attributes.h

Go to the documentation of this file.

/******************************************************************************
 *
 * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
 * Copyright 2003-2006 Nils Thuerey
 *
 * DEPRECATED - replaced by elbeem API, only channels are still used
 *
 *****************************************************************************/


#ifndef NTL_ATTRIBUTES_H

#include "utilities.h"
template<class T> class ntlMatrix4x4;
class ntlSetVec3f;
std::ostream& operator<<( std::ostream& os, const ntlSetVec3f& i );



template<class Scalar>
class AnimChannel
{
        public:
                // default constructor
                AnimChannel() : 
                        mValue(), mTimes() { mInited = false; debugPrintChannel(); }

                // null init constructor
                AnimChannel(Scalar null) : 
                        mValue(1), mTimes(1) { mValue[0]=null; mTimes[0]=0.0; mInited = true; debugPrintChannel(); }

                // proper init
                AnimChannel(vector<Scalar> &v, vector<double> &t) : 
                        mValue(v), mTimes(t) { mInited = true; debugPrintChannel(); }

                // desctructor, nothing to do
                ~AnimChannel() { };

                // get interpolated value at time t
                Scalar get(double t) const {
                        if(!mInited) { Scalar null; null=(Scalar)(0.0); return null; }
                        if(t<=mTimes[0])               { return mValue[0]; }
                        if(t>=mTimes[mTimes.size()-1]) { return mValue[mTimes.size()-1]; }
                        for(size_t i=0; i<mTimes.size()-1; i++) {
                                // find first time thats in between
                                if((mTimes[i]<=t)&&(mTimes[i+1]>t)) { 
                                        // interpolate
                                        double d = mTimes[i+1]-mTimes[i];
                                        double f = (t-mTimes[i])/d;
                                        //return (Scalar)(mValue[i] * (1.0-f) + mValue[i+1] * f);
                                        Scalar ret,tmp;
                                        ret = mValue[i];
                                        ret *= 1.-f;
                                        tmp = mValue[i+1];
                                        tmp *= f;
                                        ret += tmp;
                                        return ret;
                                }
                        }
                        // whats this...?
                        return mValue[0];
                };

                // get uninterpolated value at time t
                Scalar getConstant(double t) const {
                        //errMsg("DEBB","getc"<<t<<" ");
                        if(!mInited) { Scalar null; null=(Scalar)0.0; return null; }
                        if(t<=mTimes[0])               { return mValue[0]; }
                        if(t>=mTimes[mTimes.size()-1]) { return mValue[mTimes.size()-1]; }
                        for(size_t i=0; i<mTimes.size()-1; i++) {
                                //errMsg("DEBB","getc i"<<i<<" "<<mTimes[i]);
                                // find first time thats in between
                                if((mTimes[i]<=t)&&(mTimes[i+1]>t)) { return mValue[i]; }
                        }
                        // whats this...?
                        return mValue[0];
                };

                // reset to null value
                void reset(Scalar null) {
                        mValue.clear();
                        mTimes.clear();
                        mValue.push_back(null);
                        mTimes.push_back(0.0);
                }

                string printChannel();
                void debugPrintChannel();
                bool isInited() const { return mInited; }

                int getSize() const { return mValue.size(); };
                vector<Scalar> &accessValues() { return mValue; }
                vector<double> &accessTimes() { return mTimes; }
                
        protected:

                bool mInited;
                vector<Scalar> mValue;
                vector<double> mTimes;
};


// helper class (not templated) for animated meshes
class ntlSetVec3f {
        public:
                ntlSetVec3f(): mVerts() {};
                ntlSetVec3f(double v);
                ntlSetVec3f(vector<ntlVec3f> &v) { mVerts = v; };

                const ntlSetVec3f& operator=(double v );
                ntlSetVec3f& operator+=( double v );
                ntlSetVec3f& operator+=( const ntlSetVec3f &v );
                ntlSetVec3f& operator*=( double v );
                ntlSetVec3f& operator*=( const ntlSetVec3f &v );

                vector<ntlVec3f> mVerts;
};


// warning: DEPRECATED - replaced by elbeem API
class Attribute
{
        public:
        Attribute(string mn, vector<string> &value, int setline,bool channel) { 
                        mn = string(""); setline=0; channel=false; value.clear(); // remove warnings
                };
        Attribute(Attribute &a) { a.getCompleteString(); };
        ~Attribute() { };

                void setUsed(bool set){ set=false; }
                bool getUsed() { return true; }
                void setIsChannel(bool set){ set=false;  }
                bool getIsChannel() { return false; }

                string getAsString(bool debug=false);
                int getAsInt();
                bool getAsBool();
                double getAsFloat();
                ntlVec3d getAsVec3d();
                void getAsMat4Gfx(ntlMatrix4x4<gfxReal> *mat);

                AnimChannel<int> getChannelInt();
                AnimChannel<double> getChannelFloat();
                AnimChannel<ntlVec3d> getChannelVec3d();
                AnimChannel<ntlSetVec3f> getChannelSetVec3f();

                string getCompleteString();
                void print();
                
        protected:

                bool initChannel(int elemSize);
};


// warning: DEPRECATED - replaced by elbeem API
class AttributeList
{
        public:
        AttributeList(string name) { name=string(""); };
        ~AttributeList();
                void addAttr(string name, vector<string> &value, int line, bool isChannel) { 
                        name=string(""); value.clear(); line=0; isChannel=false; // remove warnings
                };
                bool exists(string name) { name=string(""); return false; }
                void setAllUsed();
                bool checkUnusedParams();
                void import(AttributeList *oal);
                int      readInt(string name, int defaultValue,         string source,string target, bool needed);
                bool     readBool(string name, bool defaultValue,       string source,string target, bool needed);
                double   readFloat(string name, double defaultValue,   string source,string target, bool needed);
                string   readString(string name, string defaultValue,   string source,string target, bool needed);
                ntlVec3d readVec3d(string name, ntlVec3d defaultValue,  string source,string target, bool needed);
                void readMat4Gfx(string name, ntlMatrix4x4<gfxReal> defaultValue,  string source,string target, bool needed, ntlMatrix4x4<gfxReal> *mat);
                AnimChannel<int>     readChannelInt(         string name, int defaultValue=0, string source=string("src"), string target=string("dst"), bool needed=false );
                AnimChannel<double>  readChannelFloat(       string name, double defaultValue=0, string source=string("src"), string target=string("dst"), bool needed=false );
                AnimChannel<ntlVec3d> readChannelVec3d(      string name, ntlVec3d defaultValue=ntlVec3d(0.), string source=string("src"), string target=string("dst"), bool needed=false );
                AnimChannel<ntlSetVec3f> readChannelSetVec3f(string name, ntlSetVec3f defaultValue=ntlSetVec3f(0.), string source=string("src"), string target=string("dst"), bool needed=false );
                AnimChannel<ntlVec3f> readChannelVec3f(           string name, ntlVec3f defaultValue=ntlVec3f(0.), string source=string("src"), string target=string("dst"), bool needed=false );
                AnimChannel<float>    readChannelSinglePrecFloat( string name, float defaultValue=0., string source=string("src"), string target=string("dst"), bool needed=false );
                bool ignoreParameter(string name, string source);
                void print();
        protected:
};

ntlVec3f channelFindMaxVf (AnimChannel<ntlVec3f> channel);
ntlVec3d channelFindMaxVd (AnimChannel<ntlVec3d> channel);
int      channelFindMaxi  (AnimChannel<int     > channel);
float    channelFindMaxf  (AnimChannel<float   > channel);
double   channelFindMaxd  (AnimChannel<double  > channel);

// unoptimized channel simplification functions, use elbeem.cpp functions
bool channelSimplifyVf (AnimChannel<ntlVec3f> &channel);
bool channelSimplifyVd (AnimChannel<ntlVec3d> &channel);
bool channelSimplifyi  (AnimChannel<int     > &channel);
bool channelSimplifyf  (AnimChannel<float   > &channel);
bool channelSimplifyd  (AnimChannel<double  > &channel);

#define DEBUG_PCHANNELS 0

template<class Scalar>
void AnimChannel<Scalar>::debugPrintChannel() { }


#define NTL_ATTRIBUTES_H
#endif