ntl_ray.h

Go to the documentation of this file.

/******************************************************************************
 *
 * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
 * Copyright 2003-2006 Nils Thuerey
 *
 * ray class
 *
 *****************************************************************************/
#ifndef NTL_RAY_H
#define NTL_RAY_H

#include <sstream>
#include "ntl_vector3dim.h"
#include "ntl_lighting.h"
#include "ntl_geometryobject.h"
#include "ntl_bsptree.h"

class ntlTriangle;
class ntlRay;
class ntlTree;
class ntlScene;
class ntlRenderGlobals;
class ntlGeometryObject;

// NOT YET USED
class ntlIntersection {
    public:

        ntlIntersection() :
            distance(-1.0), normal(0.0),
            ray(NULL), tri(NULL), flags(0) { };

        gfxReal distance;
        ntlVec3Gfx normal;
        ntlRay *ray; 
        ntlTriangle *tri;
        char flags;
};

class ntlRay
{
public:
  // CONSTRUCTORS
  ntlRay();
  ntlRay(const ntlRay &r);
  ntlRay(const ntlVec3Gfx &o, const ntlVec3Gfx &d, unsigned int i, gfxReal contrib, ntlRenderGlobals *glob);
  ~ntlRay();

  inline void setRefracted(unsigned char set) { mIsRefracted = set; }
  inline void setReflected(unsigned char set) { mIsReflected = set; }


  const ntlColor shade() /*const*/;

    void tracePhoton(ntlColor) const;

  void intersectFrontAABB(ntlVec3Gfx mStart, ntlVec3Gfx mEnd, gfxReal &t, ntlVec3Gfx &normal, ntlVec3Gfx &retcoord) const;
  void intersectBackAABB(ntlVec3Gfx mStart, ntlVec3Gfx mEnd, gfxReal &t, ntlVec3Gfx &normal, ntlVec3Gfx &retcoord) const;
  void intersectCompleteAABB(ntlVec3Gfx mStart, ntlVec3Gfx mEnd, gfxReal &tmin, gfxReal &tmax) const;
    // intersection routines in bsptree.cpp
  inline void intersectTriangle(vector<ntlVec3Gfx> *mpV, ntlTriangle *tri, gfxReal &t, gfxReal &u, gfxReal &v) const;
  inline void intersectTriangleX(vector<ntlVec3Gfx> *mpV, ntlTriangle *tri, gfxReal &t, gfxReal &u, gfxReal &v) const;
  inline void intersectTriangleFront(vector<ntlVec3Gfx> *mpV, ntlTriangle *tri, gfxReal &t, gfxReal &u, gfxReal &v) const;
  inline void intersectTriangleBack(vector<ntlVec3Gfx> *mpV, ntlTriangle *tri, gfxReal &t, gfxReal &u, gfxReal &v) const;

  // access methods
  inline ntlVec3Gfx getOrigin() const { return ntlVec3Gfx(mOrigin); }
  inline ntlVec3Gfx getDirection() const { return ntlVec3Gfx(mDirection); }
  inline ntlVec3Gfx getNormal() const { return ntlVec3Gfx(mvNormal); }
  inline unsigned char getRefracted() const  { return mIsRefracted; }
  inline unsigned char getReflected() const  { return mIsReflected; }
  inline ntlVec3Gfx getPositionAt(gfxReal t) const { return (mOrigin+(mDirection*t)); }
    inline ntlRenderGlobals *getRenderglobals( void ) const { return mpGlob; }
    inline int getID( void ) const { return mID; }

  inline void setOrigin(ntlVec3Gfx set) { mOrigin = set; }
  inline void setDirection(ntlVec3Gfx set) { mDirection = set; }
  inline void setNormal(ntlVec3Gfx set) { mvNormal = set; }

protected:
  /* Calulates the Lambertian and Specular color for
   * the given reflection and returns it */
  const ntlColor getShadedColor(ntlLightObject *light, const ntlRay &reflectedray, 
                                                                const ntlVec3Gfx &normal, ntlMaterial *surf) const;
  
private:
  ntlVec3Gfx     mOrigin;
  ntlVec3Gfx     mDirection;
  ntlVec3Gfx     mvNormal;
  unsigned int mDepth;
    gfxReal mContribution;

  ntlRenderGlobals *mpGlob;

  unsigned char mIsRefracted;
  unsigned char mIsReflected;

    int mID;

};


/******************************************************************************
 *
 * a single triangle
 *
 *****************************************************************************/

// triangle intersection code in bsptree.cpp
// intersectTriangle(vector<ntlVec3Gfx> *mpV, ntlTriangle *tri, gfxReal &t, gfxReal &u, gfxReal &v);

#define TRI_GEOMETRY      (1<<0)
#define TRI_CASTSHADOWS   (1<<1)


class ntlTriangle
{
public:
  /* CONSTRUCTORS */
  inline ntlTriangle( void );
  inline ntlTriangle(int *p, bool smooth, int obj, ntlVec3Gfx norm, int setflags);
  inline ntlTriangle(const ntlTriangle &tri);
  inline ~ntlTriangle() {}

    /* Access methods */

    inline int *getPoints( void ) { return mPoints; }
    inline bool getSmoothNormals( void ) const { return mSmoothNormals; }
    inline void setSmoothNormals( bool set){ mSmoothNormals = set; }
    inline int getObjectId( void ) const { return mObjectId; }
    inline void setObjectId( int set) { mObjectId = set; }
    inline ntlVec3Gfx getNormal( void ) const { return mNormal; }
    inline void setNormal( ntlVec3Gfx set ) { mNormal = set; }
    inline int getFlags( void ) const { return mFlags; }
    inline void setFlags( int set ) { mFlags = set; }
    inline int  getLastRay( void ) const { return mLastRay; }
    inline void setLastRay( int set ) { mLastRay = set; }
    inline int getBBoxId( void ) const { return mBBoxId; }
    inline void setBBoxId( int set ) { mBBoxId = set; }

    inline gfxReal getAverage( int axis ) const;

    inline friend bool operator<(const ntlTriangle &lhs, const ntlTriangle &rhs);
    inline friend bool operator>(const ntlTriangle &lhs, const ntlTriangle &rhs);

protected:

private:

    int mPoints[3];

    int mBBoxId;

    bool mSmoothNormals;

    int mObjectId;

    //int mNormalIndex; ??
    ntlVec3Gfx mNormal;

    int mFlags;

    int mLastRay;

};


    

/******************************************************************************
 * Default Constructor
 *****************************************************************************/
ntlTriangle::ntlTriangle( void ) :
    mBBoxId(-1),
    mLastRay( 0 )
{
    mPoints[0] = mPoints[1] = mPoints[2] = 0;
    mSmoothNormals = 0;
    mObjectId = 0;
    mNormal = ntlVec3Gfx(0.0);
    mFlags = 0;
}


/******************************************************************************
 * Constructor
 *****************************************************************************/
ntlTriangle::ntlTriangle(int *p, bool smooth, int obj, ntlVec3Gfx norm, int setflags) :
    mBBoxId(-1),
    mLastRay( 0 )
{
    mPoints[0] = p[0];
    mPoints[1] = p[1];
    mPoints[2] = p[2];
    mSmoothNormals = smooth;
    mObjectId = obj;
    mNormal = norm;
    mFlags = setflags;
}


/******************************************************************************
 * Copy Constructor
 *****************************************************************************/
ntlTriangle::ntlTriangle(const ntlTriangle &tri) :
    mBBoxId(-1),
    mLastRay( 0 )
{
    mPoints[0] = tri.mPoints[0];
    mPoints[1] = tri.mPoints[1];
    mPoints[2] = tri.mPoints[2];
    mSmoothNormals = tri.mSmoothNormals;
    mObjectId      = tri.mObjectId;
    mNormal        = tri.mNormal;
    mFlags         = tri.mFlags;
}




/******************************************************************************
 * Triangle sorting functions
 *****************************************************************************/

/* variables imported from ntl_bsptree.cc, necessary for using the stl sort funtion */
/* Static global variable for sorting direction */
extern int globalSortingAxis;
/* Access to points array for sorting */
extern vector<ntlVec3Gfx> *globalSortingPoints;
    

gfxReal ntlTriangle::getAverage( int axis ) const
{ 
    return ( ( (*globalSortingPoints)[ mPoints[0] ][axis] + 
                         (*globalSortingPoints)[ mPoints[1] ][axis] + 
                         (*globalSortingPoints)[ mPoints[2] ][axis] )/3.0);
}

bool operator<(const ntlTriangle &lhs,const ntlTriangle &rhs)
{
    return ( lhs.getAverage(globalSortingAxis) < 
                     rhs.getAverage(globalSortingAxis) );
}

bool operator>(const ntlTriangle &lhs,const ntlTriangle &rhs)
{
    return ( lhs.getAverage(globalSortingAxis) > 
                     rhs.getAverage(globalSortingAxis) );
}



/******************************************************************************
 *
 * Scene object, that contains and manages all geometry objects
 *
 *****************************************************************************/



class ntlScene
{
public:
  /* CONSTRUCTORS */
  ntlScene( ntlRenderGlobals *glob, bool del=true );
  ~ntlScene();

    inline void addGeoClass(ntlGeometryClass *geo) { 
        mGeos.push_back( geo ); 
        geo->setObjectId(mGeos.size());
    }
    inline void addGeoObject(ntlGeometryObject *geo) { mObjects.push_back( geo ); }

    inline ntlGeometryObject *getObject(int id) { 
        if(!mSceneBuilt) { errFatal("ntlScene::getObject","Scene not inited!", SIMWORLD_INITERROR); }
        return mObjects[id]; }

    inline vector<ntlGeometryObject*> *getObjects() { 
        if(!mSceneBuilt) { errFatal("ntlScene::getObjects[]","Scene not inited!", SIMWORLD_INITERROR); }
        return &mObjects; }

    inline vector<ntlGeometryClass*> *getGeoClasses() { 
        if(!mSceneBuilt) { errFatal("ntlScene::getGeoClasses[]","Scene not inited!", SIMWORLD_INITERROR); }
        return &mGeos; }

    //void draw();
    
    void buildScene(double time, bool firstInit);
    
    void prepareScene(double time);
    void cleanupScene( void );

    void intersectScene(const ntlRay &r, gfxReal &distance, ntlVec3Gfx &normal, ntlTriangle *&tri, int flags) const;

    ntlVec3Gfx getVertex(int index) { return mVertices[index]; } 

    // for tree generation 
    vector<ntlVec3Gfx> *getVertexPointer( void ) { return &mVertices; }
    vector<ntlVec3Gfx> *getVertexNormalPointer( void ) { return &mVertNormals; }
    vector<ntlTriangle> *getTrianglePointer( void ) { return &mTriangles; }

private:

    ntlRenderGlobals *mpGlob;

    bool mSceneDel;

  vector<ntlGeometryClass *> mGeos;

  vector<ntlGeometryObject *> mObjects;

  vector<ntlTriangle> mTriangles;
  vector<ntlVec3Gfx>  mVertices;
  vector<ntlVec3Gfx>  mVertNormals;
  vector<ntlVec3Gfx>  mTriangleNormals;

    ntlTree *mpTree;

    int mDisplayListId;

    bool mSceneBuilt;

    bool mFirstInitDone;

};


#endif