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