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