---

RT_Prim.cc

Go to the documentation of this file.

/*
    File:       RT_Prim.cc

    Function:   Implements various ray-trace primitives

    Author:     Andrew Willmott

    Notes:      
*/

#include "RT_Prim.h"
#include "gcl/VecUtil.h"

// --- Triangle methods -------------------------------------------------------


Int RT_Prim::gStamp = 1;
Int RT_Object::gStamp = 1;

Void RT_Tri::Init(Int v1, Int v2, Int v3, RT_Object *obj, Int triID)
{
    v[0] = v1;
    v[1] = v2;
    v[2] = v3;
    flags = 0;
    stamp = 0;
    primType = rt_triangle;
    object = obj;
    id = triID;
}

#define CROSS_X_3(a, b, c)  ((a[1] - b[1]) * (c[2] - b[2]) \
                             - (a[2] - b[2]) * (c[1] - b[1]))
//  returns (a - b) x (c - a) . (1, 0, 0)
#define CROSS_Y_3(a, b, c)  ((a[2] - b[2]) * (c[0] - b[0]) \
                             - (a[0] - b[0]) * (c[2] - b[2]))
//  returns (a - b) x (c - a) . (0, 1, 0)
#define CROSS_Z_3(a, b, c)  ((a[0] - b[0]) * (c[1] - b[1]) \
                             - (a[1] - b[1]) * (c[0] - b[0]))
//  returns (a - b) x (c - a) . (0, 0, 1)

static const GCLReal kEdgeFuzz = 0.0;   
static const GCLReal kNegEdgeFuzz = -kEdgeFuzz; 

Bool RT_Tri::PointIsInside(Point& point)
{
    Point*  points = object->points;
    Int     i0 = v[0],  i1 = v[1], i2 = v[2];
    GCLReal temp, a, b;
    
#ifdef RT_TRI_CACHE 
    // Time stamp object so we can reuse this intersection test if necessary.

    Stamp();
#endif

    flags &= ~TRI_HIT;
    
    //  Given a point lying in the plane of the triangle, we return false
    //  if it lies outside the triangle, and its barycentric coordinates if it
    //  lies inside.

    temp = normal[normMajorAxis];
    
    switch(normMajorAxis)
    {
    case 0:
        a = CROSS_X_3(points[i2], points[i1], point) / temp;
        if (a < kEdgeFuzz)  return(false);

        b = CROSS_X_3(points[i0], points[i2], point) / temp;
        if (b < kEdgeFuzz)  return(false);

        a = 1.0 - a - b;
        if (a < kEdgeFuzz)  return(false);
        
        flags |= TRI_HIT;
        return(true);

    case 1:
        a = CROSS_Y_3(points[i2], points[i1], point) / temp;    
        if (a < kEdgeFuzz)  return(false);

        b = CROSS_Y_3(points[i0], points[i2], point) / temp;        
        if (b < kEdgeFuzz)  return(false);

        a = 1.0 - a - b;
        if (a < kEdgeFuzz)  return(false);

        flags |= TRI_HIT;
        return(true);

    case 2:
        a = CROSS_Z_3(points[i2], points[i1], point) / temp;
        if (a < kEdgeFuzz)  return(false);

        b = CROSS_Z_3(points[i0], points[i2], point) / temp;
        if (b < kEdgeFuzz)  return(false);

        a = 1.0 - a - b;
        if (a < kEdgeFuzz)  return(false);
        
        flags |= TRI_HIT;
        return(true);
    }
    
    return(true);   // to keep the compiler happy.
}

Void RT_Tri::FindBaryCoords(Point& point, Vector &coords)
{
    Point*  points = object->points;
    Int     i0 = v[0],  i1 = v[1], i2 = v[2];
    GCLReal temp;
    
#ifdef RT_TRI_CACHE 
    // Time stamp object so we can reuse this intersection test if necessary.

    Stamp();
#endif

    flags &= ~TRI_HIT;
    
    //  Given a point lying in the plane of the triangle, we return false
    //  if it lies outside the triangle, and its barycentric coordinates if it
    //  lies inside.

    temp = normal[normMajorAxis];

    switch(normMajorAxis)
    {
    case 0:
        coords[0] = CROSS_X_3(points[i2], points[i1], point) / temp;
        coords[1] = CROSS_X_3(points[i0], points[i2], point) / temp;
        coords[2] = 1.0 - coords[0] - coords[1];
        return;

    case 1:
        coords[0] = CROSS_Y_3(points[i2], points[i1], point) / temp;    
        coords[1] = CROSS_Y_3(points[i0], points[i2], point) / temp;        
        coords[2] = 1.0 - coords[0] - coords[1];
        return;

    case 2:
        coords[0] = CROSS_Z_3(points[i2], points[i1], point) / temp;        
        coords[1] = CROSS_Z_3(points[i0], points[i2], point) / temp;        
        coords[2] = 1.0 - coords[0] - coords[1];
        return;
    }
}


Void RT_Tri::UpdateBounds(Point& min, Point& max)
// Use the tri's vertices to update the given min & max bounds.
{
    Int     i;
    Point   *points = object->points;
        
    for (i = 0; i < 3; i++)
        ::UpdateBounds(points[v[i]], min, max);
}

Void RT_Tri::MakeNormal()
{
    GCLReal xf,  yf,  zf;
    Point*  points = object->points;
        
    // Calculate face normal & other info
    
    CalcTriAreaNormal(points[v[0]], points[v[1]], points[v[2]], normal);
    
    d = -dot(normal, points[v[2]]);
 
    xf = abs(normal[0]);
    yf = abs(normal[1]);
    zf = abs(normal[2]);

    if (xf > yf)
    {
        if (xf > zf)
            normMajorAxis = 0;
        else
            normMajorAxis = 2;
    }
    else 
    {
        if (yf > zf)
            normMajorAxis = 1;
        else
            normMajorAxis = 2;
    }
    
    area = 0.5 * len(normal);
}


// --- RT_Sphere methods ------------------------------------------------------

Void RT_Sphere::Init(const Point &c, GCLReal r, RT_Object *obj, Int genID)
{
    centre = c;
    radius = r;
    sqrRad = sqr(r);
    area = vl_pi * sqrRad;
    primType = rt_gen;
    object = obj;
    id = genID;
}


Bool RT_Sphere::Intersect(Point &start, Vector &dir, GCLReal tMin, GCLReal tMax)
// Assumes dir is normalised.
{
    Vector  v = centre - start;
    GCLReal b = dot(v, dir);
    GCLReal disc = sqr(b) - sqrlen(v) + sqrRad;
    GCLReal t0;
    
    flags &= ~TRI_HIT;

    //  Root must be smaller than current value of t...
    //  and larger than tMin
    
    if (disc <= 0.0)
        return(false);      // no intersection

    disc = sqrt(disc);
    t0 = b - disc;          // 1st root
    
    if (t0 >= tMin && t0 < tMax)
    {
        hitT = t0;
        flags |= TRI_HIT;
        return(true);
    }
    
    t0 = b + disc;          // 2nd root

    if (t0 >= tMin && t0 < tMax)
    {
        hitT = t0;
        flags |= TRI_HIT;
        return(true);
    }
    
    return(false);          // intersection is behind
}

Void RT_Sphere::UpdateBounds(Point &min, Point &max)
{
    Point   sMin, sMax;

    FindBounds(sMin, sMax);
    FindMinElts(sMin, min, min);    
    FindMaxElts(sMax, max, max);    
}

Void RT_Sphere::FindBounds(Point &min, Point &max)
{
    max.MakeBlock(radius);
    min = centre - max;
    max += centre;
}


// --- RT_Object methods -------------------------------------------------------


Void RT_Object::Init(Int numTris, Int numGens)
{
    SELF.numTris = numTris;
    SELF.numGens = numGens;
    if (numTris == 0)
        tris = 0;
    else
        tris = new RT_Tri[numTris];
    if (numGens == 0)
        gens = 0;
    else
        gens = new RT_GenPtr[numGens];

    points = 0;
    numPoints = 0;
    normals = 0;
    numNormals = 0;

    tag = 1;
    id = 0;
}

Void RT_Object::Setup()
{
    Int     i;

    for (i = 0; i < numTris; i++)
    {
        tris[i].object = this;
        tris[i].MakeNormal();
    }
}

Void RT_Object::Free()
{
    Int i;

    for (i = 0; i < numGens; i++)
        delete gens[i];

    delete[] tris;
    delete[] gens;
    delete[] points;
    delete[] normals;
}

---