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