---

RT_Prim.h

Go to the documentation of this file.

/*
    File:           RT_Prim.h
    
    Function:       Defines raytracing primitives
    
    Author(s):      Andrew Willmott

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

#ifndef __RT_Prim__
#define __RT_Prim__

#include "RT_Defs.h"

// Tri flags...

const Byte TRI_HIT      = 0x0001;
const Byte GEN_HIT      = 0x0001;
const Byte TRI_INACTIVE = 0x0002;
const Byte TRI_2SIDED_R = 0x0004;   // two-sided for rendering purposes
const Byte TRI_2SIDED_V = 0x0008;   // two-sided for visibility purposes

class RT_Tri;
class RT_Gen;
typedef RT_Gen *RT_GenPtr;

// An object is a collection of primitives which share a list of (world space)
// points and normals.
class RT_Object
{
public:
    Void        Init(Int numTris, Int numGens = 0);
                // call this, then fill in point & tri data
    Void        Setup();
                // call once tri & gen data has been filled in
    Void        Free();

    Point*      points;
    Int         numPoints;
    Vector*     normals;
    Int         numNormals;

    RT_Tri*     tris;
    Int         numTris;
    RT_GenPtr*  gens;
    Int         numGens;
    Void*       data;           // extra info we might need.

    Int         id;             // per-object id.
    Int         tag;            // groups this object belongs to

    Int         stamp;          // local time stamp;
    static Int  gStamp;         // global time stamp;

    static Void IncTime()       { gStamp++; };
    Void        Stamp()         { stamp = gStamp; };
    Bool        IsStamped()     { return(stamp == gStamp); };
};


// --- RT primitives ----------------------------------------------------------


enum RT_PrimTag 
{
    rt_triangle, 
    rt_gen,
    rt_grid
};

class RT_Prim
{
protected:
    Int         stamp;          // local time stamp;
    static Int  gStamp;         // global time stamp;

public:
    RT_Object*  object;
    Byte        primType;
    Byte        flags;          // See values above
    Int         id;
    Float       area;           // surface area
#ifdef RT_OPAC
    Int         cells;          // number of grid cells covered
#endif

    Bool        IsTrue(Int i)   { return(flags & i); };
    static Void IncTime()       { gStamp++; };
    Void        Stamp()         { stamp = gStamp; };
    Bool        IsStamped()     { return(stamp == gStamp); };
};

class RT_Tri : public RT_Prim
{
public:
    Int         v[3];           // vertex indices
#ifdef RT_NORM
    Int         n[3];           // normal indices
#endif

    Vector      normal;         // face normal
    Float       d;              // completes the plane equation
    Byte        normMajorAxis;  // largest component of normal
    
    //  Methods

    Void        Init(Int v1, Int v2, Int v3, RT_Object *obj, Int triID);

    Bool        PointIsInside(Point &p);
    Void        FindBaryCoords(Point &p, Vector &coords);
    Void        UpdateBounds(Point &min, Point &max);
    Void        MakeNormal();
        
    Void        Draw();
    
    Point&      Vertex(Int i)   { return(object->points[v[i]]); };
#ifdef RT_NORM
    Point&      Normal(Int i)   { return(object->normals[n[i]]); }; 
#endif
};  

class RT_Gen : public RT_Prim
// generic RT object.
{
public:
    GCLReal             hitT;
        
    Void                Init(const Point &centre, GCLReal radius,
                             RT_Object *obj, Int genID);
        
    virtual Bool        Intersect(Point &start, Vector &dir, GCLReal tMin, 
                          GCLReal tMax) = 0; 

    virtual Void        UpdateBounds(Point &min, Point &max) = 0;
    virtual Void        FindBounds(Point &min, Point &max) = 0;
};

class RT_Sphere : public RT_Gen
{
public:
    Point       centre;
    GCLReal     radius;
    GCLReal     sqrRad;
        
    Void        Init(const Point &centre, GCLReal radius, RT_Object *obj,
                     Int genID);
        
    Bool        Intersect(Point &start, Vector &dir, GCLReal tMin, 
                          GCLReal tMax); 

    Void        UpdateBounds(Point &min, Point &max);
    Void        FindBounds(Point &min, Point &max);
};

#endif

---