---

RadMesh.h

Go to the documentation of this file.

/*
    File:       RadMesh.h

    Function:   Defines a basic mesh of radiosity elements. These can be either
                quads (parallelograms), or triangles. 
                    
    Author(s):  Andrew Willmott

    Copyright:  (c) 1995-2000, Andrew Willmott
 */

#ifndef __RadMesh__
#define __RadMesh__

#include "gcl/Geometry.h"
#include "gcl/Renderer.h"
#include "RadControl.h"
#include "gcl/Texture.h"
#include "cl/PtrArray.h"
#include "cl/NArray.h"

class RadElem;

class RadProps
{
public:
    RadProps();

    Colour              reflectance;    
    Colour              emittance;

    PointList           *points;        
    ColourList          *colours;       
    PointList           *normals;       
    CoordList           *texCoords;     

    Texture             *texture;
    Int                 id;

    Void                InterpolateIndexes(
                            RadElem *srcElt, 
                            Int     srcVtx1, 
                            Int     srcVtx2, 
                            RadElem *dstElt, 
                            Int     dstVtx,
                            GCLReal m = 0.5
                        );

};

struct CompareStats
{
    GCLReal areaSum;
    Colour  cSum;
    Colour  cSqrSum;
    Colour  refSum;
};

class PatchStats
{
public:
    Void            Init();
    Void            Update(RadElem *patch);
    Void            Report(ostream &s);
    
    GCLReal         minArea;
    GCLReal         maxArea;    
    Reflectance     minRefl;
    Reflectance     maxRefl;
    Colour          maxPower;
    Colour          totalPower;
};


typedef RadElem             *RadElemPtr;
typedef PtrArray<RadElem>   PatchList;
typedef Array<RadElem>      RadElemList;

class RadElem
{
public:
                    RadElem();
    virtual         ~RadElem(); 
    
    Int             index[4];           
    Int             clrIdx[4];          
    Int             normIdx[4];         
    Int             texIdx[4];          
    RadProps        *props;             

    Point           centre;             
    Vector          normal;             
    Colour          colour;             
    GCLReal         area;               
#ifdef RAD_TEXTURE
    Colour          localRefl;
#endif
#ifdef RAD_VIS
    Byte            highlight;          
#endif

    virtual Void    Draw(Renderer &r);              
                    // Draw this element

    //  Sampling methods

    Void            Compare(RadElem *to, GCLReal edgeLen, CompareStats &stats);
    virtual Colour  Sample(Coord c);

    Coord           FindCoord(Point &p);
    virtual RadElem *FindContainer(Coord &coord);
    virtual Colour  SampleLeaf(Coord c);

    //  Form factor-calculation methods

    GCLReal         EstPatchFactor(const Point &p, const Vector &n);
    GCLReal         PatchFactor(const Point &p, const Vector &n);
    GCLReal         ApproxPatchFactor(const Point &p, const Vector &np);
    GCLReal         EstFormFactor(RadElem *to);
    GCLReal         EdgeArea(const Vector &p, const Vector &q, 
                        const Vector &n);
    GCLReal         SampledFormFactor(Int n, RadElem *to, GCLReal &error);
    Int             OrientInfo(RadElem *to);

    //  Visibility methods

    GCLReal         Visibility(RadElem *to);

    GCLReal         CentreVis(const Point &p, const Vector &n);
    GCLReal         Visibility16(const Point &p, const Vector &n);
    Bool            PotentiallyVis(RadElem *to);
    Bool            PotentiallyVisAndTouching(RadElem *to, Bool &touching);
    GCLReal         Visibility44(RadElem *to);

    Void            SetVisPoints(Point p[]);
    GCLReal         RadVis4x4(RadElem *to);
    GCLReal         RadVis16x1(const Point &p, const Vector &n);
    
    //  Radiosity methods....
    
    virtual Void    ColourVertices(Int weights[]);  
    virtual Void    CreatePatches(PatchList &patches);
    //  Utility
    
    virtual Void    Print(ostream &s);
    virtual Void    Parse(istream &s);
    virtual Void    Reanimate(RadElem *parent);
    virtual StrConst Name();

    Void            SetProps(RadProps *props);
    Void            SetHighlight(Int h);
    Void            DrawHighlight(Renderer &r);
    Void            RaiseVertex(Renderer &r, Int i);
    Void            SetColour(const Colour &c)
                    { colour = c; };

    // Property accessor methods

    Vector          &Vertex(Int i)  {return((*props->points)[index[i]]);};
    Colour          &VtxClr(Int i)  {return((*props->colours)[clrIdx[i]]);};
    Vector          &Normal(Int i)  {return((*props->normals)[normIdx[i]]);};
    Coord           &TexCoord(Int i) {return((*props->texCoords)[texIdx[i]]);};

    Void            SetIndexes(
                        Int         dstIdx,       
                        RadElem     *src,       
                        Int         srcIdx
                    );

    Void            SetAllIndexes(
                        RadElem     *s0,       
                        Int         i0,       
                        RadElem     *s1,       
                        Int         i1,       
                        RadElem     *s2,       
                        Int         i2,
                        RadElem     *s3,       
                        Int         i3
                    );

    Vector          &Normal()       {return(normal);};
    Vector          &Centre()       {return(centre);};
    Colour          &Emittance()    {return(props->emittance);};
#ifdef RAD_TEXTURE
    Colour          &Reflectance()  {return(localRefl);};
#else
    Colour          &Reflectance()  {return(props->reflectance);};
#endif
    Int             Sides()         {return((index[3] < 0) ? 3 : 4);};

    Bool            IsTri()         {return(index[3] < 0);};
    Bool            IsQuad()        {return(index[3] >= 0);};
    Bool            IsTextured()    {return(props->texCoords != 0);};
    Bool            HasNormals()    {return(props->normals != 0);};
    Void            SendPoints(Renderer &r)
                    { r.P(Vertex(0)).P(Vertex(1)).P(Vertex(2));
                      if (IsQuad()) r.P(Vertex(3)); };

    virtual GCLReal 
                    MemoryUse();

    static Int      sGridMem;
    static Int      sGridChildMem;
};

ostream &operator << (ostream &s, RadElem &rq);
istream &operator >> (istream &s, RadElem &rq);

// --- An elem with neighbour info --------------------------------------------

class NbRadElem : public RadElem
{
public:
    NbRadElem();
    
    NbRadElem       *nbFace[4];     
    Byte            nbEdge[4];
    GCLReal         MemoryUse();
};


// --- An elem that can be gridded --------------------------------------------


class GridBase : public NbRadElem
{
public:
    Void                Mesh(GCLReal density);

    virtual RadElemPtr  AddChild(RadElem &elem, Int i, Int j, Int in, Int jn) = 0;
    Int                 FindChildIndex(Coord &coord);
                                                        
    Int                 rows, cols;
};

class RadGrid : public GridBase
{
public:
    Void                CreatePatches(PatchList &patches);
    Void                Draw(Renderer &r);
    Void                ColourVertices(Int weights[]);
    RadElem             *FindContainer(Coord &coord);   
    Void                Reanimate(RadElem *parent);

    Void                Print(ostream &s);
    Void                Parse(istream &s);
    StrConst            Name();

    GCLReal             MemoryUse();

    RadElemPtr          AddChild(RadElem &elem, Int i, Int j, Int in, Int jn);  
    RadElemList         children;
};

const GCLReal kRaySurfEps = 1e-6;   // amount to offset vis testing from
                                    // surfaces to aVoid self-intersection.

#endif

---