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