6cec098132bb3e88766f9b694c18f4f22874a9d1
[blender.git] / intern / elbeem / intern / ntl_world.h
1 /** \file elbeem/intern/ntl_world.h
2  *  \ingroup elbeem
3  */
4 /******************************************************************************
5  *
6  * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
7  * Copyright 2003-2006 Nils Thuerey
8  *
9  * Main renderer class
10  *
11  *****************************************************************************/
12 #ifndef NTL_RAYTRACER_HH
13 #define NTL_RAYTRACER_HH
14
15 #include "ntl_vector3dim.h"
16 #include "ntl_ray.h"
17 #include "ntl_lighting.h"
18 #include "ntl_geometryobject.h"
19 #include "simulation_object.h"
20 #include "elbeem.h"
21 class ntlOpenGLRenderer;
22 class ntlScene;
23 class SimulationObject;
24 class ntlRandomStream;
25
26 class ntlWorld
27 {
28         public:
29                 /*! Constructor for API init */
30                 ntlWorld();
31                 /*! Constructor */
32                 ntlWorld(string filename, bool commandlineMode);
33                 /*! Destructor */
34                 virtual ~ntlWorld( void );
35                 /*! default init for all contructors */
36                 void initDefaults();
37                 /*! common world contruction stuff once the scene is set up */
38                 void finishWorldInit();
39                 /*! add domain for API init */
40                 int addDomain(elbeemSimulationSettings *simSettings);
41
42                 /*! render a whole animation (command line mode) */
43                 int renderAnimation( void );
44                 /*! render a whole animation (visualization mode) */
45                 int renderVisualization( bool );
46                 /*! render a single step for viz mode */
47                 int singleStepVisualization( void );
48                 /*! advance simulations by time frame time */
49                 int advanceSims(int framenum);
50                 /*! advance simulations by a single step */
51                 void singleStepSims(double targetTime);
52
53                 /*! set stop rend viz flag */
54                 void setStopRenderVisualization(bool set) { mStopRenderVisualization = set; }
55                 /*! should the rendering viz thread be stopped? */
56                 bool getStopRenderVisualization() { return mStopRenderVisualization; }
57
58                 /*! render scene (a single pictures) */
59                 virtual int renderScene( void );
60
61                 /*! set single frame rendering to filename */
62                 void setSingleFrameOut( string singleframeFilename );
63
64                 /* access functions */
65
66                 /*! set&get render globals */
67                 inline void setRenderGlobals( ntlRenderGlobals *set) { mpGlob = set; }
68                 inline ntlRenderGlobals *getRenderGlobals( void )    { return mpGlob; }
69
70                 /*! set&get render globals */
71                 inline void setSimulationTime( double set) { mSimulationTime = set; }
72                 inline double getSimulationTime( void ) { return mSimulationTime; }
73
74                 /*! set&get single step debug mode */
75                 inline void setSingleStepDebug( bool set) { mSingleStepDebug = set; }
76                 inline bool getSingleStepDebug( void ) { return mSingleStepDebug; }
77
78                 /*! &get simulation object vector (debugging) */
79                 inline vector<SimulationObject*> *getSimulations( void ) { return mpSims; }
80
81                 /*! get opengl renderer */
82                 inline ntlOpenGLRenderer *getOpenGLRenderer() { return mpOpenGLRenderer; }
83
84         private:
85
86         protected:
87
88                 /*! global render settings needed almost everywhere */
89                 ntlRenderGlobals        *mpGlob;
90
91                 /*! a list of lights in the scene (geometry is store in ntl_scene) */
92                 vector<ntlLightObject*> *mpLightList;
93                 /*! surface materials */
94                 vector<ntlMaterial*>    *mpPropList;
95                 /*! sims list */
96                 vector<SimulationObject*> *mpSims;
97
98                 /*! opengl display */
99                 ntlOpenGLRenderer *mpOpenGLRenderer;
100
101                 /*! stop rend viz? */
102                 bool mStopRenderVisualization;
103
104                 /*! rend viz thread currently running? */
105                 bool mThreadRunning;
106
107                 /*! remember the current simulation time */
108                 double mSimulationTime;
109
110                 /*! first simulation that is valid */
111                 int mFirstSim;
112
113                 /*! single step mode for debugging */
114                 bool mSingleStepDebug;
115
116                 /*! count no. of frame for viz render */
117                 int mFrameCnt;
118
119                 /*! count no. of frame for correct sim time */
120                 int mSimFrameCnt;
121                 vector<int> mSimFrameValue;
122 };
123
124
125 //! Class that handles global rendering parameters
126 class ntlRenderGlobals
127 {
128         public:
129                 //! Standard constructor
130                 ntlRenderGlobals();
131                 //! Destructor
132                 ~ntlRenderGlobals();
133
134                 //! Returns the renderscene manager (scene changes for each frame)
135                 inline ntlScene *getRenderScene(void) { return mpRenderScene; }
136                 //! Set the renderscene manager
137                 inline void setRenderScene(ntlScene *set) { mpRenderScene = set;} 
138
139                 //! Returns the simulation scene manager (static scene with sim objects)
140                 inline ntlScene *getSimScene(void) { return mpSimScene; }
141                 //! Set the simulation scene manager
142                 inline void setSimScene(ntlScene *set) { mpSimScene = set;} 
143
144                 //! Returns the light object list
145                 inline vector<ntlLightObject*> *getLightList(void) { return mpLightList; }
146                 //! Set the light list
147                 inline void setLightList(vector<ntlLightObject*> *set) { mpLightList = set;} 
148
149                 //! Returns the property object list
150                 inline vector<ntlMaterial*> *getMaterials(void) { return mpMaterials; }
151                 //! Set the property list
152                 inline void setMaterials(vector<ntlMaterial*> *set) { mpMaterials = set;} 
153
154                 //! Returns the list of simulations
155                 inline vector<SimulationObject*> *getSims(void) { return mpSims; }
156                 //! Set the pointer to the list of simulations
157                 inline void setSims(vector<SimulationObject*> *set) { mpSims = set;} 
158
159                 //! Set the x resolution
160                 inline void setResX(unsigned int set) { mResX = set; }
161                 //! Set the y resolution
162                 inline void setResY(unsigned int set) { mResY = set; }
163                 //! Set the anti-aliasing depth
164                 inline void setAADepth(int set) { mAADepth = set; }
165                 //! Set the max color value
166                 inline void setMaxColVal(unsigned int set) { mMaxColVal = set; }
167                 //! Set the maximum ray recursion
168                 inline void setRayMaxDepth(unsigned int set) { mRayMaxDepth = set; }
169                 //! Set the eye point
170                 inline void setEye(ntlVec3Gfx set) { mvEye = set; }
171                 //! Set the look at vector
172                 inline void setLookat(ntlVec3Gfx set) { mvLookat = set; }
173                 //! Set the up vector
174                 inline void setUpVec(ntlVec3Gfx set) { mvUpvec = set; }
175                 //! Set the image aspect
176                 inline void setAspect(float set) { mAspect = set; }
177                 //! Set the field of view
178                 inline void setFovy(float set) { mFovy = set; }
179                 //! Set the background color
180                 inline void setBackgroundCol(ntlColor set) { mcBackgr = set; }
181                 //! Set the ambient lighting color
182                 inline void setAmbientLight(ntlColor set) { mcAmbientLight = set; }
183                 //! Set the debug output var 
184                 inline void setDebugOut(int  set) { mDebugOut = set; }
185
186                 //! Set the animation start time
187                 inline void setAniStart(int set) { mAniStart = set; }
188                 //! Set the animation number of frames
189                 inline void setAniFrames(int set) { mAniFrames = set; }
190                 //! Set the animation
191                 inline void setAniCount(int set) { mAniCount = set; }
192                 //! Set the ray counter
193                 inline void setCounterRays(int set) { mCounterRays = set; }
194                 //! Set the ray shades counter
195                 inline void setCounterShades(int set) { mCounterShades = set; }
196                 //! Set the scenen intersection counter
197                 inline void setCounterSceneInter(int set) { mCounterSceneInter = set; }
198                 //! Set if existing frames should be skipped
199                 inline void setFrameSkip(int set) { mFrameSkip = set; }
200
201                 //! Set the outfilename
202                 inline void setOutFilename(string set) { mOutFilename = set; }
203
204                 //! get Maximum depth for BSP tree
205                 inline void setTreeMaxDepth( int set ) { mTreeMaxDepth = set; }
206                 //! get Maxmimum nr of triangles per BSP tree node
207                 inline void setTreeMaxTriangles( int set ) { mTreeMaxTriangles = set; }
208
209                 //! set the enable flag of the test sphere
210                 inline void setTestSphereEnabled( bool set ) { mTestSphereEnabled = set; }
211                 //! set the center of the test sphere
212                 inline void setTestSphereCenter( ntlVec3Gfx set ) { mTestSphereCenter = set; }
213                 //! set the radius of the test sphere
214                 inline void setTestSphereRadius( gfxReal set ) { mTestSphereRadius = set; }
215                 //! set the material name of the test sphere
216                 inline void setTestSphereMaterialName( char* set ) { mTestSphereMaterialName = set; }
217                 //! set debugging pixel coordinates
218                 inline void setDebugPixel( int setx, int sety ) { mDebugPixelX = setx; mDebugPixelY = sety; }
219                 //! set test mode flag
220                 inline void setTestMode( bool set ) { mTestMode = set; }
221                 //! set single frame mode flag
222                 inline void setSingleFrameMode(bool set) {mSingleFrameMode = set; };
223                 //! set single frame mode filename
224                 inline void setSingleFrameFilename(string set) {mSingleFrameFilename = set; };
225                 
226
227                 //! Return the x resolution
228                 inline unsigned int getResX(void) { return mResX; }
229                 //! Return the y resolution
230                 inline unsigned int getResY(void) { return mResY; }
231                 //! Return the anti-aliasing depth
232                 inline int getAADepth(void) { return mAADepth; }
233                 //! Return the max color value for ppm
234                 inline unsigned int getMaxColVal(void) { return mMaxColVal; }
235                 //! Return the maximum ray recursion
236                 inline unsigned int getRayMaxDepth(void) { return mRayMaxDepth; }
237                 //! Return the eye point
238                 inline ntlVec3Gfx getEye(void) { return mvEye; }
239                 //! Return the look at vector
240                 inline ntlVec3Gfx getLookat(void) { return mvLookat; }
241                 //! Return the up vector
242                 inline ntlVec3Gfx getUpVec(void) { return mvUpvec; }
243                 //! Return the image aspect 
244                 inline float getAspect(void) { return mAspect; }
245                 //! Return the field of view
246                 inline float getFovy(void) { return mFovy; }
247                 //! Return the background color
248                 inline ntlColor getBackgroundCol(void) { return mcBackgr; }
249                 //! Return the ambient color
250                 inline ntlColor getAmbientLight(void) { return mcAmbientLight; }
251                 //! Return the debug mode setting
252                 inline int getDebugOut(void) { return mDebugOut; }
253
254                 //! Return the animation start time
255                 inline int getAniStart(void) { return mAniStart; }
256                 //! Return the animation frame number
257                 inline int getAniFrames(void) { return mAniFrames; }
258                 //! Return the animation counter
259                 inline int getAniCount(void) { return mAniCount; }
260                 //! Return the ray counter
261                 inline int getCounterRays(void) { return mCounterRays; }
262                 //! Return the ray shades counter
263                 inline int getCounterShades(void) { return mCounterShades; }
264                 //! Return the scene intersection counter 
265                 inline int getCounterSceneInter(void) { return mCounterSceneInter; }
266                 //! Check if existing frames should be skipped
267                 inline int getFrameSkip( void ) { return mFrameSkip; }
268
269
270                 //! Return the outfilename
271                 inline string getOutFilename(void) { return mOutFilename; }
272
273                 //! get Maximum depth for BSP tree
274                 inline int getTreeMaxDepth( void ) { return mTreeMaxDepth; }
275                 //! get Maxmimum nr of triangles per BSP tree node
276                 inline int getTreeMaxTriangles( void ) { return mTreeMaxTriangles; }
277                 
278                 //! get open gl attribute list
279                 inline AttributeList* getOpenGlAttributes( void ) { return mpOpenGlAttr; }
280                 //! get blender output attribute list
281                 inline AttributeList* getBlenderAttributes( void ) { return mpBlenderAttr; }
282                 
283                 //! is the test sphere enabled? 
284                 inline bool getTestSphereEnabled( void ) { return mTestSphereEnabled; }
285                 //! get the center of the test sphere
286                 inline ntlVec3Gfx getTestSphereCenter( void ) { return mTestSphereCenter; }
287                 //! get the radius of the test sphere
288                 inline gfxReal getTestSphereRadius( void) { return mTestSphereRadius; }
289                 //! get the materialname of the test sphere
290                 inline char *getTestSphereMaterialName( void) { return mTestSphereMaterialName; }
291                 //! get the debug pixel coordinate
292                 inline int getDebugPixelX( void ) { return mDebugPixelX; }
293                 //! get the debug pixel coordinate
294                 inline int getDebugPixelY( void ) { return mDebugPixelY; }
295                 //! get test mode flag
296                 inline bool getTestMode( void ) { return mTestMode; }
297                 //! set single frame mode flag
298                 inline bool getSingleFrameMode() { return mSingleFrameMode; };
299                 //! set single frame mode filename
300                 inline string getSingleFrameFilename() { return mSingleFrameFilename; };
301
302   
303 private:
304
305         /*! Scene storage (dynamic rendering scene) */
306         ntlScene *mpRenderScene;
307         /*! Scene storage (static sim scene, inited only once) */
308         ntlScene *mpSimScene;
309
310   //! List of light objects
311   vector<ntlLightObject*> *mpLightList;
312   //! List of surface properties
313   vector<ntlMaterial*> *mpMaterials;
314         /*! storage for simulations */
315         vector<SimulationObject*> *mpSims;
316
317   //! resolution of the picture
318   unsigned int mResX, mResY;
319   //! Anti-Aliasing depth
320   int mAADepth;
321   //! max color value for ppm
322   unsigned int mMaxColVal;
323   /* Maximal ray recursion depth */
324   int mRayMaxDepth;
325   //! The eye point
326   ntlVec3Gfx  mvEye;
327   //! The look at point
328   ntlVec3Gfx  mvLookat;
329   //! The up vector
330   ntlVec3Gfx  mvUpvec;
331   //! The image aspect = Xres/Yres
332   float  mAspect;
333   //! The horizontal field of view
334   float  mFovy;
335   //! The background color
336   ntlColor  mcBackgr;
337   //! The ambient color
338   ntlColor  mcAmbientLight;
339   //! how much debug output is needed? off by default
340   char mDebugOut;
341
342
343   //! animation properties, start time
344   int mAniStart;
345   //! animation properties, number of frames to render
346   int mAniFrames;
347   //! animation status, current frame number
348   int mAniCount;
349         /*! Should existing picture frames be skipped? */
350         int mFrameSkip;
351
352
353   //! count the total number of rays created (also used for ray ID's)
354   int  mCounterRays;
355   //! count the total number of rays shaded
356   int  mCounterShades;
357   //! count the total number of scene intersections
358   int  mCounterSceneInter;
359
360         /*! filename of output pictures (without suffix or numbers) */
361   string mOutFilename;
362
363         //! get Maximum depth for BSP tree
364         int mTreeMaxDepth;
365         //! get Maxmimum nr of triangles per BSP tree node
366         int mTreeMaxTriangles; 
367
368         //! attribute list for opengl renderer
369         AttributeList *mpOpenGlAttr;
370         //! attribute list for blender output 
371         AttributeList *mpBlenderAttr;
372
373
374         //! Enable test sphere?
375         bool mTestSphereEnabled;
376         //! Center of the test sphere
377         ntlVec3Gfx mTestSphereCenter;
378         //! Radius of the test sphere
379         gfxReal mTestSphereRadius;
380         //! Materialname of the test sphere
381         char *mTestSphereMaterialName;
382         //! coordinates of the debugging pixel
383         int mDebugPixelX, mDebugPixelY;
384
385         //! test mode for quick rendering activated?, inited in ntl_scene::buildScene
386         bool mTestMode;
387
388         //! single frame flag
389         bool mSingleFrameMode;
390         //! filename for single frame mode
391         string mSingleFrameFilename;
392 };
393
394
395
396 #endif