Elbeem: fix memory leak and add guarded allocator directives
[blender.git] / intern / elbeem / intern / ntl_geometryobject.h
1 /** \file elbeem/intern/ntl_geometryobject.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  * a geometry object
10  * all other geometry objects are derived from this one
11  *
12  *****************************************************************************/
13 #ifndef NTL_GEOMETRYOBJECT_H
14 #define NTL_GEOMETRYOBJECT_H
15
16 #include "ntl_geometryclass.h"
17 #include "ntl_lighting.h"
18 #include "ntl_ray.h"
19
20 #ifdef WITH_CXX_GUARDEDALLOC
21 #  include "MEM_guardedalloc.h"
22 #endif
23
24 class ntlRenderGlobals;
25 class ntlTriangle;
26
27 #define DUMP_FULLGEOMETRY 1
28 #define DUMP_PARTIAL      2
29
30 #define VOLUMEINIT_VOLUME 1
31 #define VOLUMEINIT_SHELL  2
32 #define VOLUMEINIT_BOTH   (VOLUMEINIT_SHELL|VOLUMEINIT_VOLUME)
33
34 class ntlGeometryObject : public ntlGeometryClass
35 {
36
37         public:
38                 //! Default constructor
39                 ntlGeometryObject();
40                 //! Default destructor
41                 virtual ~ntlGeometryObject();
42
43                 //! Return type id
44                 virtual int getTypeId() { return GEOCLASSTID_OBJECT; }
45
46                 /*! Init attributes etc. of this object */
47                 virtual void initialize(ntlRenderGlobals *glob);
48
49                 /*! Get the triangles from this object */
50                 virtual void getTriangles(double t, vector<ntlTriangle> *triangles, 
51                                 vector<ntlVec3Gfx> *vertices, 
52                                 vector<ntlVec3Gfx> *normals, int objectId ) = 0;
53                 
54                 /*! notify object that dump is in progress (e.g. for particles) */
55                 virtual void notifyOfDump(int dumptype, int frameNr,char *frameNrStr,string outfilename, double simtime);
56
57                 /*! Search the material for this object from the material list */
58                 void searchMaterial(vector<ntlMaterial *> *mat);
59
60                 /* Acces methods */
61                 /*! Set the property of this object */
62                 inline void setMaterial(ntlMaterial *p) { mpMaterial = p; }
63                 /*! Get the surface property of this object */
64                 inline ntlMaterial *getMaterial( void ) { return mpMaterial; }
65                 /*! Set the object property name */
66                 inline void setMaterialName(string set) { mMaterialName = set; }
67                 /*! Get the object property name */
68                 inline string getMaterialName( void ) { return mMaterialName; }
69
70                 /*! Sets the receive shadows attribute */
71                 inline void setReceiveShadows(int set) { mReceiveShadows=set; }
72                 /*! Returns the receive shadows attribute */
73                 inline int getReceiveShadows() const { return mReceiveShadows; }
74
75                 /*! Sets the cast shadows attribute */
76                 inline void setCastShadows(int set) { mCastShadows=set; }
77                 /*! Returns the cast shadows attribute */
78                 inline int getCastShadows() const { return mCastShadows; }
79
80                 /*! Returns the geo init typ */
81                 inline void setGeoInitType(int set) { mGeoInitType=set; }
82                 /*! Returns the geo init typ */
83                 inline int getGeoInitType() const { return mGeoInitType; }
84
85                 /*! Set/get the intersect init flag */
86                 inline bool getGeoInitIntersect() const { return mGeoInitIntersect; }
87                 inline void setGeoInitIntersect(bool set) { mGeoInitIntersect=set; }
88
89                 /*! Set/get the part slip value*/
90                 inline float getGeoPartSlipValue() const { return mGeoPartSlipValue; }
91                 inline void setGeoPartSlipValue(float set) { mGeoPartSlipValue=set; }
92
93                 /*! Set/get the impact corr factor channel */
94                 inline float getGeoImpactFactor(double t) { return mcGeoImpactFactor.get(t); }
95                 inline void setGeoImpactFactor(float set) { mcGeoImpactFactor = AnimChannel<float>(set); }
96
97                 /*! Set/get the part slip value*/
98                 inline int getVolumeInit() const { return mVolumeInit; }
99                 inline void setVolumeInit(int set) { mVolumeInit=set; }
100
101                 /*! Set/get the cast initial veocity attribute */
102                 void setInitialVelocity(ntlVec3Gfx set);
103                 ntlVec3Gfx getInitialVelocity(double t);
104
105                 /*! Set/get the local inivel coords flag */
106                 inline bool getLocalCoordInivel() const { return mLocalCoordInivel; }
107                 inline void setLocalCoordInivel(bool set) { mLocalCoordInivel=set; }
108                 
109                 /****************************************/
110                 /* fluid control features */
111                 /****************************************/
112                 /*! Set/get the particle control set attract force strength */
113                 inline float getCpsTimeStart() const { return mCpsTimeStart; }
114                 inline void setCpsTimeStart(float set) { mCpsTimeStart=set; }
115                 
116                 /*! Set/get the particle control set attract force strength */
117                 inline float getCpsTimeEnd() const { return mCpsTimeEnd; }
118                 inline void setCpsTimeEnd(float set) { mCpsTimeEnd=set; }
119                 
120                 /*! Set/get the particle control set quality */
121                 inline float getCpsQuality() const { return mCpsQuality; }
122                 inline void setCpsQuality(float set) { mCpsQuality=set; }
123                 
124                 inline AnimChannel<float> getCpsAttrFStr() const { return mcAttrFStr; }
125                 inline AnimChannel<float> getCpsAttrFRad() const { return mcAttrFRad; }
126                 inline AnimChannel<float> getCpsVelFStr() const { return mcVelFStr; }
127                 inline AnimChannel<float> getCpsVelFRad() const { return mcVelFRad; }
128                 
129                 /****************************************/
130                 
131                 /*! Init channels from float arrays (for elbeem API) */
132                 void initChannels(
133                                 int nTrans, float *trans, int nRot, float *rot, int nScale, float *scale,
134                                 int nAct, float *act, int nIvel, float *ivel,
135                                 int nAttrFStr, float *attrFStr,
136                                 int nAttrFRad, float *attrFRad,
137                                 int nVelFStr, float *velFStr,
138                                 int nVelFRad, float *velFRad
139                                 );
140
141                 /*! is the object animated? */
142                 inline bool getIsAnimated() const { return mIsAnimated; }
143                 /*! init object anim flag */
144                 bool checkIsAnimated();
145                 /*! is the mesh animated? */
146                 virtual bool getMeshAnimated();
147                 /*! init triangle divisions */
148                 virtual void calcTriangleDivs(vector<ntlVec3Gfx> &verts, vector<ntlTriangle> &tris, gfxReal fsTri);
149
150                 /*! apply object translation at time t*/
151                 void applyTransformation(double t, vector<ntlVec3Gfx> *verts, vector<ntlVec3Gfx> *norms, int vstart, int vend, int forceTrafo);
152
153                 /*! Prepare points for moving objects */
154                 void initMovingPoints(double time, gfxReal featureSize);
155                 /*! Prepare points for animated objects */
156                 void initMovingPointsAnim(
157                  double srctime, vector<ntlVec3Gfx> &srcpoints,
158                  double dsttime, vector<ntlVec3Gfx> &dstpoints,
159                  vector<ntlVec3Gfx> *dstnormals,
160                  gfxReal featureSize, ntlVec3Gfx geostart, ntlVec3Gfx geoend );
161                 /*! Prepare points for moving objects (copy into ret) */
162                 void getMovingPoints(vector<ntlVec3Gfx> &ret, vector<ntlVec3Gfx> *norms = NULL);
163                 /*! Calculate max. velocity on object from t1 to t2 */
164                 ntlVec3Gfx calculateMaxVel(double t1, double t2);
165                 /*! get translation at time t*/
166                 ntlVec3Gfx getTranslation(double t);
167                 /*! get active flag time t*/
168                 float getGeoActive(double t);
169
170                 /*! add triangle to scene and init flags */
171                 //  helper function for getTriangles
172                 void sceneAddTriangle(
173                                 ntlVec3Gfx  p1,ntlVec3Gfx  p2,ntlVec3Gfx  p3,
174                                 ntlVec3Gfx pn1,ntlVec3Gfx pn2,ntlVec3Gfx pn3,
175                                 ntlVec3Gfx trin, bool smooth,
176                                 vector<ntlTriangle> *triangles,
177                                 vector<ntlVec3Gfx>  *vertices,
178                                 vector<ntlVec3Gfx>  *vertNormals);
179                 void sceneAddTriangleNoVert(int *trips,
180                                 ntlVec3Gfx trin, bool smooth,
181                                 vector<ntlTriangle> *triangles);
182
183         protected:
184
185                 /* initialized for scene? */
186                 bool mIsInitialized; 
187
188                 /*! Point to a property object describing the surface of this object */
189                 ntlMaterial *mpMaterial;
190
191                 /*! Name of the surcace property */
192                 string mMaterialName;
193
194                 /*! Cast shadows on/off */
195                 int mCastShadows;
196                 /*! REceive shadows on/off */
197                 int mReceiveShadows;
198
199                 /* fluid init data */
200                 /*! fluid object type (fluid, obstacle, accelerator etc.) */
201                 int mGeoInitType;
202                 /*! initial velocity for fluid objects */
203                 ntlVec3Gfx mInitialVelocity;
204                 AnimChannel<ntlVec3Gfx> mcInitialVelocity;
205                 /*! use object local inflow? */
206                 bool mLocalCoordInivel;
207                 /*! perform more accurate intersecting geo init for this object? */
208                 bool mGeoInitIntersect;
209                 /*! part slip bc value */
210                 float mGeoPartSlipValue;
211                 /*! obstacle impact correction factor */
212                 AnimChannel<float> mcGeoImpactFactor;
213                 /*! only init as thin object, dont fill? */
214                 int mVolumeInit;
215
216                 /*! initial offset for rot/scale */
217                 ntlVec3Gfx mInitialPos;
218                 /*! animated channels for postition, rotation and scale */
219                 AnimChannel<ntlVec3Gfx> mcTrans, mcRot, mcScale;
220                 /*! easy check for animation */
221                 bool mIsAnimated;
222                 
223                 /*! moving point/normal storage */
224                 vector<ntlVec3Gfx> mMovPoints;
225                 vector<ntlVec3Gfx> mMovNormals;
226                 /*! cached points for non moving objects/timeslots */
227                 bool mHaveCachedMov;
228                 vector<ntlVec3Gfx> mCachedMovPoints;
229                 vector<ntlVec3Gfx> mCachedMovNormals;
230                 /*! precomputed triangle divisions */
231                 vector<int> mTriangleDivs1,mTriangleDivs2;
232                 /*! inited? */
233                 float mMovPntsInited;
234                 /*! point with max. distance from center */
235                 int mMaxMovPnt;
236
237                 /*! animated channels for in/outflow on/off */
238                 AnimChannel<float> mcGeoActive;
239                 
240                 /* fluid control settings */
241                 float mCpsTimeStart;
242                 float mCpsTimeEnd;
243                 float mCpsQuality;
244                 AnimChannel<float> mcAttrFStr, mcAttrFRad, mcVelFStr, mcVelFRad;
245
246         public:
247
248 private:
249 #ifdef WITH_CXX_GUARDEDALLOC
250         MEM_CXX_CLASS_ALLOC_FUNCS("ELBEEM:ntlGeometryObject")
251 #endif
252 };
253
254 #endif
255