ntl_geometryobject.h

Go to the documentation of this file.

/******************************************************************************
 *
 * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
 * Copyright 2003-2006 Nils Thuerey
 *
 * a geometry object
 * all other geometry objects are derived from this one
 *
 *****************************************************************************/
#ifndef NTL_GEOMETRYOBJECT_H
#define NTL_GEOMETRYOBJECT_H

#include "ntl_geometryclass.h"
#include "ntl_lighting.h"
#include "ntl_ray.h"
class ntlRenderGlobals;
class ntlTriangle;

#define DUMP_FULLGEOMETRY 1
#define DUMP_PARTIAL      2

#define VOLUMEINIT_VOLUME 1
#define VOLUMEINIT_SHELL  2
#define VOLUMEINIT_BOTH   (VOLUMEINIT_SHELL|VOLUMEINIT_VOLUME)

class ntlGeometryObject : public ntlGeometryClass
{

        public:
                ntlGeometryObject();
                virtual ~ntlGeometryObject();

                virtual int getTypeId() { return GEOCLASSTID_OBJECT; }

                virtual void initialize(ntlRenderGlobals *glob);

                virtual void getTriangles(double t, vector<ntlTriangle> *triangles, 
                                vector<ntlVec3Gfx> *vertices, 
                                vector<ntlVec3Gfx> *normals, int objectId ) = 0;
                
                virtual void notifyOfDump(int dumptype, int frameNr,char *frameNrStr,string outfilename, double simtime);

                void searchMaterial(vector<ntlMaterial *> *mat);

                /* Acces methods */
                inline void setMaterial(ntlMaterial *p) { mpMaterial = p; }
                inline ntlMaterial *getMaterial( void ) { return mpMaterial; }
                inline void setMaterialName(string set) { mMaterialName = set; }
                inline string getMaterialName( void ) { return mMaterialName; }

                inline void setReceiveShadows(int set) { mReceiveShadows=set; }
                inline int getReceiveShadows() const { return mReceiveShadows; }

                inline void setCastShadows(int set) { mCastShadows=set; }
                inline int getCastShadows() const { return mCastShadows; }

                inline void setGeoInitType(int set) { mGeoInitType=set; }
                inline int getGeoInitType() const { return mGeoInitType; }

                inline bool getGeoInitIntersect() const { return mGeoInitIntersect; }
                inline void setGeoInitIntersect(bool set) { mGeoInitIntersect=set; }

                inline float getGeoPartSlipValue() const { return mGeoPartSlipValue; }
                inline void setGeoPartSlipValue(float set) { mGeoPartSlipValue=set; }

                inline float getGeoImpactFactor(double t) { return mcGeoImpactFactor.get(t); }
                inline void setGeoImpactFactor(float set) { mcGeoImpactFactor = AnimChannel<float>(set); }

                inline int getVolumeInit() const { return mVolumeInit; }
                inline void setVolumeInit(int set) { mVolumeInit=set; }

                void setInitialVelocity(ntlVec3Gfx set);
                ntlVec3Gfx getInitialVelocity(double t);

                inline bool getLocalCoordInivel() const { return mLocalCoordInivel; }
                inline void setLocalCoordInivel(bool set) { mLocalCoordInivel=set; }
                
                /****************************************/
                /* fluid control features */
                /****************************************/
                inline float getCpsTimeStart() const { return mCpsTimeStart; }
                inline void setCpsTimeStart(float set) { mCpsTimeStart=set; }
                
                inline float getCpsTimeEnd() const { return mCpsTimeEnd; }
                inline void setCpsTimeEnd(float set) { mCpsTimeEnd=set; }
                
                inline float getCpsQuality() const { return mCpsQuality; }
                inline void setCpsQuality(float set) { mCpsQuality=set; }
                
                inline AnimChannel<float> getCpsAttrFStr() const { return mcAttrFStr; }
                inline AnimChannel<float> getCpsAttrFRad() const { return mcAttrFRad; }
                inline AnimChannel<float> getCpsVelFStr() const { return mcVelFStr; }
                inline AnimChannel<float> getCpsVelFRad() const { return mcVelFRad; }
                
                /****************************************/
                
                void initChannels(
                                int nTrans, float *trans, int nRot, float *rot, int nScale, float *scale,
                                int nAct, float *act, int nIvel, float *ivel,
                                int nAttrFStr, float *attrFStr,
                                int nAttrFRad, float *attrFRad,
                                int nVelFStr, float *velFStr,
                                int nVelFRad, float *velFRad
                                );

                inline bool getIsAnimated() const { return mIsAnimated; }
                bool checkIsAnimated();
                virtual bool getMeshAnimated();
                virtual void calcTriangleDivs(vector<ntlVec3Gfx> &verts, vector<ntlTriangle> &tris, gfxReal fsTri);

                void applyTransformation(double t, vector<ntlVec3Gfx> *verts, vector<ntlVec3Gfx> *norms, int vstart, int vend, int forceTrafo);

                void initMovingPoints(double time, gfxReal featureSize);
                void initMovingPointsAnim(
                 double srctime, vector<ntlVec3Gfx> &srcpoints,
                 double dsttime, vector<ntlVec3Gfx> &dstpoints,
                 vector<ntlVec3Gfx> *dstnormals,
                 gfxReal featureSize, ntlVec3Gfx geostart, ntlVec3Gfx geoend );
                void getMovingPoints(vector<ntlVec3Gfx> &ret, vector<ntlVec3Gfx> *norms = NULL);
                ntlVec3Gfx calculateMaxVel(double t1, double t2);
                ntlVec3Gfx getTranslation(double t);
                float getGeoActive(double t);

                //  helper function for getTriangles
                void sceneAddTriangle(
                                ntlVec3Gfx  p1,ntlVec3Gfx  p2,ntlVec3Gfx  p3,
                                ntlVec3Gfx pn1,ntlVec3Gfx pn2,ntlVec3Gfx pn3,
                                ntlVec3Gfx trin, bool smooth,
                                vector<ntlTriangle> *triangles,
                                vector<ntlVec3Gfx>  *vertices,
                                vector<ntlVec3Gfx>  *vertNormals);
                void sceneAddTriangleNoVert(int *trips,
                                ntlVec3Gfx trin, bool smooth,
                                vector<ntlTriangle> *triangles);

        protected:

                /* initialized for scene? */
                bool mIsInitialized; 

                ntlMaterial *mpMaterial;

                string mMaterialName;

                int mCastShadows;
                int mReceiveShadows;

                /* fluid init data */
                int mGeoInitType;
                ntlVec3Gfx mInitialVelocity;
                AnimChannel<ntlVec3Gfx> mcInitialVelocity;
                bool mLocalCoordInivel;
                bool mGeoInitIntersect;
                float mGeoPartSlipValue;
                AnimChannel<float> mcGeoImpactFactor;
                int mVolumeInit;

                ntlVec3Gfx mInitialPos;
                AnimChannel<ntlVec3Gfx> mcTrans, mcRot, mcScale;
                bool mIsAnimated;
                
                vector<ntlVec3Gfx> mMovPoints;
                vector<ntlVec3Gfx> mMovNormals;
                bool mHaveCachedMov;
                vector<ntlVec3Gfx> mCachedMovPoints;
                vector<ntlVec3Gfx> mCachedMovNormals;
                vector<int> mTriangleDivs1,mTriangleDivs2,mTriangleDivs3;
                float mMovPntsInited;
                int mMaxMovPnt;

                AnimChannel<float> mcGeoActive;
                
                /* fluid control settings */
                float mCpsTimeStart;
                float mCpsTimeEnd;
                float mCpsQuality;
                AnimChannel<float> mcAttrFStr, mcAttrFRad, mcVelFStr, mcVelFRad;

        public:

};

#endif