OpenSceneGraph/src/osgPlugins/geo/osgGeoAnimation.h

// animation features of the CarbonGraphics .geo format
// require access to the internal Vars & External Vars.
#ifndef _GEO_ANIM_H_
#define _GEO_ANIM_H_

#include <osg/Timer>
#include <osg/PositionAttitudeTransform>

class georecord; // You don't need to know how I read a geo record, 
//    but objects of this class are passed to some of the parsing routines.
// The values are defined in osgGeoStructs.h which is distributed with OSG.

class geoValue {
public:
    geoValue() {
        token=0; fid=0; val.d=0; name="";
        vmin=0; vmax=0;
        constrained=false;
    }
    geoValue(const unsigned int tok, const unsigned int fident) {
        token=tok; fid=fident; val.d=0; name="";
        vmin=0; vmax=0;
        constrained=false;
    }
    ~geoValue() {}
    inline unsigned int getToken() const { return token;}
    inline unsigned int getFID() const { return fid;}
    inline double *getValue() { return &(val.d);}
    void setVal(double v) { val.d=v;
    if (constrained) {
        if (v>vmax) val.d=vmax;
        if (v<vmin) val.d=vmin;
    }
    }
    const std::string getName(void) const { return name;}
    void setName(const char *nm) { name=nm;    }
    void setMinRange(const float f) { vmin=f;}
    void setMaxRange(const float f) { vmax=f; }
    void setConstrained(bool onoff=true) {    constrained=onoff;}
private:
    union {
        double d;
        float f;
        int i;
        unsigned int ui;
    } val;
    unsigned int token; // type of field
    unsigned int fid; // field identifier
    float vmin, vmax;
    std::string name;
    bool constrained; // are values limited by min,max
}; // a numerical value, may be one of several types
class internalVars { // holds internal variables for whole model
public:
    internalVars() {   }
    ~internalVars() { 
        }
    void addInternalVars(const georecord &gr);
    void update(osg::Timer  &_timer,osg::FrameStamp &_frameStamp);
    double *getVar(const unsigned fid) { 
        int iord=0;
        for (std::vector<geoValue>::iterator itr=vars.begin();
        itr!=vars.end();
        ++itr, iord++)
        {// for each field
            if ((*itr).getFID() == fid) {
                return ((*itr).getValue());
            }
        }
        return NULL;
    }

private:
    std::vector<geoValue> vars; // these fields define internal vars
};

class userVars {
public:
    userVars() {}
    ~userVars() {}
    unsigned int number() { return vars.size();}
    std::vector<geoValue> *getvars() { return &vars;}
    double *getVar(const unsigned fid)  { 
        for (std::vector<geoValue>::iterator itr=vars.begin(); itr<vars.end(); itr++) {
            if (itr->getFID() == fid) return (itr->getValue());
        }
        return NULL;
    }
    void addUserVar(const georecord &gr);
    void update() {
        for (std::vector<geoValue>::iterator itr=vars.begin();
            itr!=vars.end();
            ++itr)
        {// for each user var
            //    itr->setVal((*itr->getValue())+0.01);
        }
    }
private:
    std::vector<geoValue> vars;
};

class geoHeader: public osg::PositionAttitudeTransform {
    // structure for header of .geo file
    // adds position attitude orientation for not Z up models,
    // plus animation variables.
public:
    geoHeader() { intVars=new internalVars; useVars=new userVars;
        extVars=new userVars;
        _frameStamp.setFrameNumber(0);  //  vars=NULL;
        tstart=_frameStamp.getReferenceTime();_initialTick = _timer.tick();
        ucb=NULL;
    };
    void setUserUpdate(void (*ufn)(const double time, userVars *locVars,userVars *extVars) )
    { // pass the address of a user written function in the App process.
        ucb=ufn;
    }
    void addInternalVars(const georecord &gr) { intVars->addInternalVars(gr);}
    internalVars *getInternalVars(void) const { return intVars;}
    double *getVar(const unsigned fid) { 
        double *dv=NULL;
        dv=intVars->getVar(fid);
        if (!dv) {
            dv=useVars->getVar(fid);
            if (!dv) {
                dv=extVars->getVar(fid);
            }
        }
        return dv;
    }
    void addUserVar(const georecord &gr)
    { // this georecord defines a single variable of type<>
        useVars->addUserVar(gr);
    }
    void update() {
        osg::Timer_t _frameTick = _timer.tick();;
        _lastFrameTick=_frameTick;
        
        _frameStamp.setFrameNumber(_frameStamp.getFrameNumber()+1);
        _frameStamp.setReferenceTime(_timer.delta_s(_initialTick,_frameTick));
        double time = _frameStamp.getReferenceTime();
        intVars->update(_timer, _frameStamp);
        useVars->update();
        extVars->update();
        if (ucb) ucb(time,useVars, extVars);
    }
    userVars *getLocalVars() const { return useVars;}
    userVars *getExternalVars() const { return extVars;}

protected:

    virtual ~geoHeader() {}

    osg::Timer_t _lastFrameTick,_initialTick;
    osg::Timer   _timer;
    double tstart; // start time
    osg::FrameStamp _frameStamp ; // time utilities
    internalVars *intVars;
    userVars *useVars;
    userVars *extVars;
    void (* ucb)(const double t, userVars *l,userVars *e); // called when variables are updated, you write this!
};

#endif