particletracer.h

Go to the documentation of this file.

/******************************************************************************
 *
 * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
 * Copyright 2003-2006 Nils Thuerey
 *
 * Particle Viewer/Tracer
 *
 *****************************************************************************/
#ifndef NTL_PARTICLETRACER_H

#include "ntl_geometryobject.h"
template<class Scalar> class ntlMatrix4x4;

// particle types
#define PART_BUBBLE (1<< 1)
#define PART_DROP   (1<< 2)
#define PART_INTER  (1<< 3)
#define PART_FLOAT  (1<< 4)
#define PART_TRACER (1<< 5)

// particle state
#define PART_IN     (1<< 8)
#define PART_OUT    (1<< 9)
#define PART_INACTIVE (1<<10)
#define PART_OUTFLUID  (1<<11)

// defines for particle movement
#define MOVE_FLOATS 1
#define FLOAT_JITTER 0.03
//#define FLOAT_JITTER 0.0

extern int ParticleObjectIdCnt;

class ParticleObject
{
        public:
        inline ParticleObject(ntlVec3Gfx mp) :
                        mPos(mp),mVel(0.0), mSize(1.0), mStatus(0),mLifeTime(0),mpNext(NULL) 
                                { mId = ParticleObjectIdCnt++; };
        inline ParticleObject(const ParticleObject &a) :
                        mPos(a.mPos), mVel(a.mVel), mSize(a.mSize), 
                        mStatus(a.mStatus),
                        mLifeTime(a.mLifeTime), mpNext(NULL) 
                                { mId = ParticleObjectIdCnt++; };
        inline ~ParticleObject() { /* empty */ };

                inline void advance(float vx, float vy, float vz) {
                        mPos[0] += vx; mPos[1] += vy; mPos[2] += vz; }
                inline void advanceVec(ntlVec3Gfx v) {
                        mPos[0] += v[0]; mPos[1] += v[1]; mPos[2] += v[2]; }
                inline void advanceVel() { mPos += mVel; }
                inline void addToVel(ntlVec3Gfx acc) { mVel += acc; }

                inline ntlVec3Gfx getPos() { return mPos; }
                inline void setPos(ntlVec3Gfx set) { mPos=set; }
                inline void setVel(ntlVec3Gfx set) { mVel = set; }
                inline void setVel(gfxReal x, gfxReal y, gfxReal z) { mVel = ntlVec3Gfx(x,y,z); }
                inline ntlVec3Gfx getVel() { return mVel; }

                inline gfxReal getSize() { return mSize; }
                inline void setSize(gfxReal set) { mSize=set; }

                inline ParticleObject* getNext() { return mpNext; }
                inline void setNext(ParticleObject* set) { mpNext=set; }

                inline int getFlags() const { return mStatus; }
                inline int getStatus() const { return (mStatus&0xFF00); }
                inline void setStatus(int set) { mStatus = set|(mStatus&0x00FF); }
                inline int getType() const { return (mStatus&0x00FF); }
                inline void setType(int set) { mStatus = set|(mStatus&0xFF00); }
                inline bool getActive() const { return ((mStatus&PART_INACTIVE)==0); }
                inline void setActive(bool set) { 
                        if(set) mStatus &= (~PART_INACTIVE);    
                        else mStatus |= PART_INACTIVE;
                }
                inline bool getInFluid() const { return ((mStatus&PART_OUTFLUID)==0); }
                inline void setInFluid(bool set) { 
                        if(set) mStatus &= (~PART_OUTFLUID);    
                        else mStatus |= PART_OUTFLUID;
                }
                inline float getLifeTime() const { return mLifeTime; }
                inline void setLifeTime(float set) { mLifeTime = set; }
                
                inline int getId() const { return mId; }

                static inline float getMass(float size) { 
                        return 4.0/3.0 * M_PI* (size)*(size)*(size); // mass: 4/3 pi r^3 rho
                }

        protected:

                int mId;
                ntlVec3Gfx mPos;
                ntlVec3Gfx mVel;
                gfxReal mSize;
                int mStatus;
                float mLifeTime;

                /* for list constructions */
                ParticleObject *mpNext;
};


class ParticleTracer :
        public ntlGeometryObject
{
        public:
        ParticleTracer();
        ~ParticleTracer();

                void addParticle(float x, float y, float z);
                void addFullParticle(ParticleObject &np);

                void draw();
                
                void parseAttrList( AttributeList *att );

                void adaptPartTimestep(float factor);

                // access funcs
                
                inline int  getNumParticles()                           { return mParts.size(); }
                inline void setNumInitialParticles(int set) { mNumInitialParts=set; }
                inline int  getNumInitialParticles()          { return mNumInitialParts; }

                inline vector<ParticleObject>::iterator getParticlesBegin() { return mParts.begin(); }
                inline vector<ParticleObject>::iterator getParticlesEnd() { return mParts.end(); }
                inline ParticleObject* getLast() { return &(mParts[ mParts.size()-1 ]); }
                
                inline void setStart(ntlVec3Gfx set) { mStart = set; initTrafoMatrix(); }
                inline void setEnd(ntlVec3Gfx set) { mEnd = set; initTrafoMatrix(); }
                inline ntlVec3Gfx getStart() { return mStart; }
                inline ntlVec3Gfx getEnd() { return mEnd; }
                
                inline void setSimStart(ntlVec3Gfx set) { mSimStart = set; initTrafoMatrix(); }
                inline void setSimEnd(ntlVec3Gfx set) { mSimEnd = set; initTrafoMatrix(); }
                
                inline void setDumpParts(bool set) { mDumpParts = set; }
                inline bool getDumpParts()         { return mDumpParts; }
                inline void setDumpTextFile(string set) { mDumpTextFile = set; }
                inline string getDumpTextFile()         { return mDumpTextFile; }
                inline void setDumpTextInterval(float set) { mDumpTextInterval = set; }
                inline float getDumpTextInterval()         { return mDumpTextInterval; }
                inline void setInitStart(float set) { mInitStart = set; }
                inline float getInitStart()         { return mInitStart; }
                inline void setInitEnd(float set)   { mInitEnd = set; }
                inline float getInitEnd()           { return mInitEnd; }
                
                inline void setPartScale(float set) { mPartScale = set; }

                void checkDumpTextPositions(double simtime);

                // NTL geometry implementation
                virtual void getTriangles(double t, vector<ntlTriangle> *triangles, 
                                vector<ntlVec3Gfx> *vertices, 
                                vector<ntlVec3Gfx> *normals, int objectId );

                virtual void notifyOfDump(int dumptype, int frameNr,char *frameNrStr,string outfilename,double simtime);

                // notify of next step for trails
                void checkTrails(double time);
                // free deleted particles
                void cleanup();

        protected:

                vector<ParticleObject> mParts;

                float mPartSize;

                ntlVec3Gfx mStart, mEnd;

                ntlVec3Gfx mSimStart, mSimEnd;

                float mPartScale;
                float mPartHeadDist, mPartTailDist;
                int mPartSegments;
                int mValueScale;
                float mValueCutoffTop;
                float mValueCutoffBottom;

                int mDumpParts;
                string mDumpTextFile;
                float mDumpTextInterval;
                float mDumpTextLastTime;
                int mDumpTextCount;
                int mShowOnly;
                int mNumInitialParts;

                ntlMatrix4x4<gfxReal> *mpTrafo;
                void initTrafoMatrix();

                float mInitStart, mInitEnd;

                vector< vector<ParticleObject> > mPrevs;
                /* prev pos save interval */
                float mTrailTimeLast, mTrailInterval;
                int mTrailLength;
};

#define NTL_PARTICLETRACER_H
#endif