ntl_world.h

Go to the documentation of this file.

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

#include "ntl_vector3dim.h"
#include "ntl_ray.h"
#include "ntl_lighting.h"
#include "ntl_geometryobject.h"
#include "simulation_object.h"
#include "elbeem.h"
class ntlOpenGLRenderer;
class ntlScene;
class SimulationObject;
class ntlRandomStream;

class ntlWorld
{
    public:
        ntlWorld();
        ntlWorld(string filename, bool commandlineMode);
        virtual ~ntlWorld( void );
        void initDefaults();
        void finishWorldInit();
        int addDomain(elbeemSimulationSettings *simSettings);

        int renderAnimation( void );
        int renderVisualization( bool );
        int singleStepVisualization( void );
        int advanceSims(int framenum);
        void singleStepSims(double targetTime);

        void setStopRenderVisualization(bool set) { mStopRenderVisualization = set; }
        bool getStopRenderVisualization() { return mStopRenderVisualization; }

        virtual int renderScene( void );

        void setSingleFrameOut( string singleframeFilename );

        /* access functions */

        inline void setRenderGlobals( ntlRenderGlobals *set) { mpGlob = set; }
        inline ntlRenderGlobals *getRenderGlobals( void )    { return mpGlob; }

        inline void setSimulationTime( double set) { mSimulationTime = set; }
        inline double getSimulationTime( void ) { return mSimulationTime; }

        inline void setSingleStepDebug( bool set) { mSingleStepDebug = set; }
        inline bool getSingleStepDebug( void ) { return mSingleStepDebug; }

        inline vector<SimulationObject*> *getSimulations( void ) { return mpSims; }

        inline ntlOpenGLRenderer *getOpenGLRenderer() { return mpOpenGLRenderer; }

    private:

    protected:

        ntlRenderGlobals        *mpGlob;

        vector<ntlLightObject*> *mpLightList;
        vector<ntlMaterial*>    *mpPropList;
        vector<SimulationObject*> *mpSims;

        ntlOpenGLRenderer *mpOpenGLRenderer;

        bool mStopRenderVisualization;

        bool mThreadRunning;

        double mSimulationTime;

        int mFirstSim;

        bool mSingleStepDebug;

        int mFrameCnt;
};


class ntlRenderGlobals
{
    public:
        ntlRenderGlobals();
        ~ntlRenderGlobals();

        inline ntlScene *getRenderScene(void) { return mpRenderScene; }
        inline void setRenderScene(ntlScene *set) { mpRenderScene = set;} 

        inline ntlScene *getSimScene(void) { return mpSimScene; }
        inline void setSimScene(ntlScene *set) { mpSimScene = set;} 

        inline vector<ntlLightObject*> *getLightList(void) { return mpLightList; }
        inline void setLightList(vector<ntlLightObject*> *set) { mpLightList = set;} 

        inline vector<ntlMaterial*> *getMaterials(void) { return mpMaterials; }
        inline void setMaterials(vector<ntlMaterial*> *set) { mpMaterials = set;} 

        inline vector<SimulationObject*> *getSims(void) { return mpSims; }
        inline void setSims(vector<SimulationObject*> *set) { mpSims = set;} 

        inline void setResX(unsigned int set) { mResX = set; }
        inline void setResY(unsigned int set) { mResY = set; }
        inline void setAADepth(int set) { mAADepth = set; }
        inline void setMaxColVal(unsigned int set) { mMaxColVal = set; }
        inline void setRayMaxDepth(unsigned int set) { mRayMaxDepth = set; }
        inline void setEye(ntlVec3Gfx set) { mvEye = set; }
        inline void setLookat(ntlVec3Gfx set) { mvLookat = set; }
        inline void setUpVec(ntlVec3Gfx set) { mvUpvec = set; }
        inline void setAspect(float set) { mAspect = set; }
        inline void setFovy(float set) { mFovy = set; }
        inline void setBackgroundCol(ntlColor set) { mcBackgr = set; }
        inline void setAmbientLight(ntlColor set) { mcAmbientLight = set; }
        inline void setDebugOut(int  set) { mDebugOut = set; }

        inline void setAniStart(int set) { mAniStart = set; }
        inline void setAniFrames(int set) { mAniFrames = set; }
        inline void setAniCount(int set) { mAniCount = set; }
        inline void setCounterRays(int set) { mCounterRays = set; }
        inline void setCounterShades(int set) { mCounterShades = set; }
        inline void setCounterSceneInter(int set) { mCounterSceneInter = set; }
        inline void setFrameSkip(int set) { mFrameSkip = set; }

        inline void setOutFilename(string set) { mOutFilename = set; }

        inline void setTreeMaxDepth( int set ) { mTreeMaxDepth = set; }
        inline void setTreeMaxTriangles( int set ) { mTreeMaxTriangles = set; }

        inline void setTestSphereEnabled( bool set ) { mTestSphereEnabled = set; }
        inline void setTestSphereCenter( ntlVec3Gfx set ) { mTestSphereCenter = set; }
        inline void setTestSphereRadius( gfxReal set ) { mTestSphereRadius = set; }
        inline void setTestSphereMaterialName( char* set ) { mTestSphereMaterialName = set; }
        inline void setDebugPixel( int setx, int sety ) { mDebugPixelX = setx; mDebugPixelY = sety; }
        inline void setTestMode( bool set ) { mTestMode = set; }
        inline void setSingleFrameMode(bool set) {mSingleFrameMode = set; };
        inline void setSingleFrameFilename(string set) {mSingleFrameFilename = set; };
        

        inline unsigned int getResX(void) { return mResX; }
        inline unsigned int getResY(void) { return mResY; }
        inline int getAADepth(void) { return mAADepth; }
        inline unsigned int getMaxColVal(void) { return mMaxColVal; }
        inline unsigned int getRayMaxDepth(void) { return mRayMaxDepth; }
        inline ntlVec3Gfx getEye(void) { return mvEye; }
        inline ntlVec3Gfx getLookat(void) { return mvLookat; }
        inline ntlVec3Gfx getUpVec(void) { return mvUpvec; }
        inline float getAspect(void) { return mAspect; }
        inline float getFovy(void) { return mFovy; }
        inline ntlColor getBackgroundCol(void) { return mcBackgr; }
        inline ntlColor getAmbientLight(void) { return mcAmbientLight; }
        inline int getDebugOut(void) { return mDebugOut; }

        inline int getAniStart(void) { return mAniStart; }
        inline int getAniFrames(void) { return mAniFrames; }
        inline int getAniCount(void) { return mAniCount; }
        inline int getCounterRays(void) { return mCounterRays; }
        inline int getCounterShades(void) { return mCounterShades; }
        inline int getCounterSceneInter(void) { return mCounterSceneInter; }
        inline int getFrameSkip( void ) { return mFrameSkip; }


        inline string getOutFilename(void) { return mOutFilename; }

        inline int getTreeMaxDepth( void ) { return mTreeMaxDepth; }
        inline int getTreeMaxTriangles( void ) { return mTreeMaxTriangles; }
        
        inline AttributeList* getOpenGlAttributes( void ) { return mpOpenGlAttr; }
        inline AttributeList* getBlenderAttributes( void ) { return mpBlenderAttr; }
        
        inline bool getTestSphereEnabled( void ) { return mTestSphereEnabled; }
        inline ntlVec3Gfx getTestSphereCenter( void ) { return mTestSphereCenter; }
        inline gfxReal getTestSphereRadius( void) { return mTestSphereRadius; }
        inline char *getTestSphereMaterialName( void) { return mTestSphereMaterialName; }
        inline int getDebugPixelX( void ) { return mDebugPixelX; }
        inline int getDebugPixelY( void ) { return mDebugPixelY; }
        inline bool getTestMode( void ) { return mTestMode; }
        inline bool getSingleFrameMode() { return mSingleFrameMode; };
        inline string getSingleFrameFilename() { return mSingleFrameFilename; };

  
private:

    ntlScene *mpRenderScene;
    ntlScene *mpSimScene;

  vector<ntlLightObject*> *mpLightList;
  vector<ntlMaterial*> *mpMaterials;
    vector<SimulationObject*> *mpSims;

  unsigned int mResX, mResY;
  int mAADepth;
  unsigned int mMaxColVal;
  /* Maximal ray recursion depth */
  int mRayMaxDepth;
  ntlVec3Gfx  mvEye;
  ntlVec3Gfx  mvLookat;
  ntlVec3Gfx  mvUpvec;
  float  mAspect;
  float  mFovy;
  ntlColor  mcBackgr;
  ntlColor  mcAmbientLight;
  char mDebugOut;


  int mAniStart;
  int mAniFrames;
  int mAniCount;
    int mFrameSkip;


  int  mCounterRays;
  int  mCounterShades;
  int  mCounterSceneInter;

  string mOutFilename;

    int mTreeMaxDepth;
    int mTreeMaxTriangles; 

    AttributeList *mpOpenGlAttr;
    AttributeList *mpBlenderAttr;


    bool mTestSphereEnabled;
    ntlVec3Gfx mTestSphereCenter;
    gfxReal mTestSphereRadius;
    char *mTestSphereMaterialName;
    int mDebugPixelX, mDebugPixelY;

    bool mTestMode;

    bool mSingleFrameMode;
    string mSingleFrameFilename;
};



#endif