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