geoactions.cpp

最新osg包

// GEO format (carbon graphics Inc) loader for the OSG real time scene graph
// www.carbongraphics.com for more information about the Geo animation+ modeller
// 2002
// actions & behaviours for Geo loader in OSG

#include <string>

#include <stdio.h>
#include <math.h>
#include <osg/Image>
#include <osg/Group>
#include <osg/LOD>
#include <osg/Billboard>
#include <osg/Sequence>
#include <osg/Switch>
#include <osg/Geode>
#include <osg/Geometry>
#include <osg/MatrixTransform>
#include <osg/Material>
#include <osg/Notify>
#include <osg/Texture2D>
#include <osg/TexEnv>
#include <osg/StateSet>
#include <osgDB/Input>
#include <osgDB/Output>

// specific to GEO

#include "geoFormat.h"
#include "geoTypes.h"
#include "geoUnits.h"
#include "osgGeoAnimation.h"
#include "osgGeoStructs.h"
#include "osgGeoNodes.h"
#include "osgGeoAction.h"
#include <osgText/Text> // needed for text nodes
#include <osg/Timer>


void geoArithBehaviour::setType(unsigned int iop) {
    switch (iop) {
    case 1: op=addv; break; /* op=addv; addv is a function so the operation can be accessed without a switch(type)... */
    case 2: op=subv; break;
    case 3: op=mulv; break;
    case 4: op=divv; break;
    case 5: op=equa; break;
    }
}
void geoArithBehaviour::doaction(osg::Node *) { // do math operation
    if (in && out && op) {
        (*out)=op(*in,acon.get());
        //    std::cout << " math sum " << out<< " " << (*out) << " " << in <<" " << (*in) << std::endl;
    }
}
bool geoArithBehaviour::makeBehave(const georecord *grec, geoHeaderGeo *theHeader) {
    bool ok=false;
    const geoField *gfd=grec->getField(GEO_DB_ARITHMETIC_ACTION_INPUT_VAR);
    if (gfd) {
        unsigned fid= gfd->getUInt(); // field identifier
        in=theHeader->getVar(fid); // returns address of input var with fid
        //std::cout<< "Input " << fid << " : " << theHeader->getVarname(fid) ;
        if (in) {
            gfd=grec->getField(GEO_DB_ARITHMETIC_ACTION_OUTPUT_VAR);
            if (gfd) {
                fid= gfd->getUInt(); // field identifier
                out=theHeader->getVar(fid); // returns address of output var with fid
                //std::cout<< " Output " <<  fid << " : " << theHeader->getVarname(fid) << std::endl;
                gfd=grec->getField(GEO_DB_ARITHMETIC_ACTION_OP_TYPE);
                unsigned int iop=gfd?gfd->getUInt():1;
                setType(iop); // default add?
                gfd=grec->getField(GEO_DB_ARITHMETIC_ACTION_OPERAND_VALUE);
                if (gfd) {
                    acon.set(gfd->getFloat()); // field identifier
                    ok=true;
                }
                gfd=grec->getField(GEO_DB_ARITHMETIC_ACTION_OPERAND_VAR);
                if (gfd) {
                    unsigned fid= gfd->getUInt(); // field identifier
                    ok=acon.set(theHeader->getVar(fid));
                }
            }
        }
    }
    return ok;
}

void geoAr3Behaviour::setType(unsigned int iact) {
    switch (iact) {
    case DB_DSK_LINEAR_ACTION: op=linear; break; /* op=addv; */
    case DB_DSK_INVERSE_ACTION: op=lininv; break;
        //    case 3: op=linmod; break;
        //    case 4: op=linsqr; break;
    case DB_DSK_TRUNCATE_ACTION: op=trunc; break;
    case DB_DSK_PERIODIC_ACTION: op=linabs; break;
    case DB_DSK_IF_THEN_ELSE_ACTION: op=ifelse; break;
    }
}
void geoAr3Behaviour::setTrigType(int iop) {
    switch (iop) {
    case 1: op=trigsin; break; /* op=trigonometric, sine; */
    case 2: op=trigcos; break;
    case 3: op=trigtan; break;
    case 4: op=trigasin; break;
    case 5: op=trigacos; break;
    case 6: op=trigatan; break;
    case 7: op=trigatan2; break;
    case 8: op=trighypot; break;
    }
}
void geoAr3Behaviour::setPeriodicType(int iop) {
    switch (iop) {
    case 1: op=period_1; break; /* op=period type 1; */
    case 2: op=period_2; break;
    }
}

void geoAr3Behaviour::doaction(osg::Node *) { // do math operation
    if (in && out && op) {
        double var3=bcon.get();
        *out=op(*in,getconstant(),var3);
        //std::cout << " ar3 sum " << out<< " " << (*out) << " con " << getconstant() <<" b: " << bcon.get() << std::endl;
    }
}
bool geoAr3Behaviour::makeBehave(const georecord *grec, geoHeaderGeo *theHeader) {
    bool ok=false;
    const geoField *gfd=grec->getField(GEO_DB_EQUATION_ACTION_INPUT_VAR);
    const unsigned int act=grec->getType();
    if (gfd) {
        unsigned fid= gfd->getUInt(); // field identifier
        in=theHeader->getVar(fid); // returns address of input var with fid
        if (in) {
            gfd=grec->getField(GEO_DB_EQUATION_ACTION_OUTPUT_VAR);
            if (gfd) {
                fid= gfd->getUInt(); // field identifier
                out=theHeader->getVar(fid); // returns address of output var with fid
                if (act==DB_DSK_TRIG_ACTION) {
                    gfd=grec->getField(GEO_DB_TRIG_ACTION_OP);
                    int iop=gfd?gfd->getInt():1;
                    setTrigType(iop); // one of sin...
                } else if (act==DB_DSK_PERIODIC_ACTION) {
                    gfd=grec->getField(GEO_DB_PERIODIC_ACTION_TYPE);
                    int iop=gfd?gfd->getInt():1; // type 1 or 2 periodic
                    setPeriodicType(iop); // one of period 1 or 2...
                } else if (act==DB_DSK_IF_THEN_ELSE_ACTION) {
                    setType(act); // if..else if (a is in range (-1,1) =b else=c
                } else {
                    setType(act); // default linear, inverse, mod.. a.b+c
                    setConstant(1);
                    ok=true;
                }
                gfd=grec->getField(GEO_DB_EQUATION_ACTION_A_VAL);
                if (gfd) {
                    setConstant(gfd->getFloat()); // field identifier
                    ok=true;
                }
                gfd=grec->getField(GEO_DB_EQUATION_ACTION_A_VAR);
                if (gfd) {
                    unsigned fid= gfd->getUInt(); // field identifier
                    ok=setVariable(theHeader->getVar(fid));
                }
                gfd=grec->getField(GEO_DB_EQUATION_ACTION_C_VAL);
                if (gfd) {
                    bcon.set(gfd->getFloat()); // field identifier
                    ok=true;
                }
                gfd=grec->getField(GEO_DB_EQUATION_ACTION_C_VAR);
                if (gfd) {
                    unsigned fid= gfd->getUInt(); // field identifier
                    ok=bcon.set(theHeader->getVar(fid));
                }
            }
        }
    }
    return ok;
}

void geoCompareBehaviour::setType(unsigned int iop) {
    switch (iop) {
    case 1: oper=LESS;break;
    case 2: oper=LESSOREQ; break;
    case 3: oper=GREATER; break;
    case 4: oper=GREATOREQ; break;
    case 5: oper=EQUALTO; break;
    }
}

void geoCompareBehaviour::doaction(osg::Node *) { // do compare operation
    if (in && out) {
        double var2=varop? *varop : constant;
        switch (oper) {
        case 1: *out = (*in < var2) ? 1.0: -1.0; break;// Less
        case 2: *out = (*in <= var2) ? 1.0: -1.0; break;//=LessOREQ
        case 3: *out = (*in > var2) ? 1.0: -1.0; break; // greater...
        case 4: *out = (*in >= var2) ? 1.0: -1.0; break;
        case 5: *out = (*in == var2) ? 1.0: -1.0; break;
        case UNKNOWN: break;
        }
    }
}
bool geoCompareBehaviour::makeBehave(const georecord *grec, geoHeaderGeo *theHeader) {
    bool ok=false;
    const geoField *gfd=grec->getField(GEO_DB_COMPARE_ACTION_INPUT_VAR);
    if (gfd) {
        unsigned fid= gfd->getUInt(); // field identifier
        in=theHeader->getVar(fid); // returns address of input var with fid
        if (in) {
            gfd=grec->getField(GEO_DB_COMPARE_ACTION_OUTPUT_VAR);
            if (gfd) {
                fid= gfd->getUInt(); // field identifier
                out=theHeader->getVar(fid); // returns address of output var with fid
                gfd=grec->getField(GEO_DB_COMPARE_ACTION_OP_TYPE);
                unsigned int iop=gfd?gfd->getUInt():1;
                setType(iop); // default add?
                gfd=grec->getField(GEO_DB_COMPARE_ACTION_OPERAND_VALUE);
                if (gfd) {
                    constant= gfd->getFloat(); // field identifier
                    ok=true;
                }
                gfd=grec->getField(GEO_DB_COMPARE_ACTION_OPERAND_VAR);
                if (gfd) {
                    unsigned fid= gfd->getUInt(); // field identifier
                    varop=theHeader->getVar(fid);
                    ok=varop != NULL;
                }
            }
        }
    }
    return ok;
}

void geoRangeBehaviour::doaction(osg::Node *) { // do math operation
    if (in && out) {
        float v=*in;
        if (v<inmin) v=inmin;
        if (v>inmax) v=inmax;
        v=(v-inmin)/(inmax-inmin);
        *out = outmin+v*(outmax-outmin);
    }
}
bool geoRangeBehaviour::makeBehave(const georecord *grec, geoHeaderGeo *theHeader) {
    bool ok=false;
    const geoField *gfd=grec->getField(GEO_DB_RANGE_ACTION_INPUT_VAR);
    if (gfd) {
        unsigned fid= gfd->getUInt(); // field identifier
        in=theHeader->getVar(fid); // returns address of input var with fid
        if (in) {
            gfd=grec->getField(GEO_DB_RANGE_ACTION_OUTPUT_VAR);
            if (gfd) {
                fid= gfd->getUInt(); // field identifier
                out=theHeader->getVar(fid); // returns address of output var with fid
                gfd=grec->getField(GEO_DB_RANGE_ACTION_IN_MIN_VAL);
                inmin=gfd?gfd->getFloat():-1.e32;
                gfd=grec->getField(GEO_DB_RANGE_ACTION_IN_MAX_VAL);
                inmax= gfd?gfd->getFloat() : 1.e32; // field identifier
                gfd=grec->getField(GEO_DB_RANGE_ACTION_OUT_MIN_VAL);
                outmin=gfd?gfd->getFloat():-1.e32;
                gfd=grec->getField(GEO_DB_RANGE_ACTION_OUT_MAX_VAL);
                outmax= gfd?gfd->getFloat() : 1.e32; // field identifier
                ok=true;
            }
        }
    }
    return ok;
}

void geoClampBehaviour::doaction(osg::Node *) { // do math operation
    if (in && out) {
        float v=*in;
        if (v<min) v=min;
        if (v>max) v=max;
        *out = v;
    }
}
bool geoClampBehaviour::makeBehave(const georecord *grec, geoHeaderGeo *theHeader) {
    bool ok=false;
    const geoField *gfd=grec->getField(GEO_DB_CLAMP_ACTION_INPUT_VAR);
    if (gfd) {
        unsigned fid= gfd->getUInt(); // field identifier
        in=theHeader->getVar(fid); // returns address of input var with fid
        if (in) {
            gfd=grec->getField(GEO_DB_CLAMP_ACTION_OUTPUT_VAR);
            if (gfd) {
                fid= gfd->getUInt(); // field identifier
                out=theHeader->getVar(fid); // returns address of output var with fid
                gfd=grec->getField(GEO_DB_CLAMP_ACTION_MIN_VAL);
                min=gfd?gfd->getFloat():-1.e32;
                gfd=grec->getField(GEO_DB_CLAMP_ACTION_MAX_VAL);
                max= gfd?gfd->getFloat() : 1.e32; // field identifier
                ok=true;
            }
        }
    }
    return ok;
}

void geoDiscreteBehaviour::doaction(osg::Node *) { // do math operation
    if (in && out) {
        float v=*in;
        *out=rangelist.begin()->getVal();
        for (std::vector<geoRange>::const_iterator itr=rangelist.begin(); 
        itr<rangelist.end(); itr++) {
            if (v>=itr->getMin() && v<=itr->getMax()) *out=itr->getVal();
        }
    }
}
bool geoDiscreteBehaviour::makeBehave(const georecord *grec, geoHeaderGeo *theHeader) {
    bool ok=false;
    const geoField *gfd=grec->getField(GEO_DB_DISCRETE_ACTION_INPUT_VAR);
    if (gfd) {
        unsigned fid= gfd->getUInt(); // field identifier
        in=theHeader->getVar(fid); // returns address of input var with fid
        if (in) {
            gfd=grec->getField(GEO_DB_DISCRETE_ACTION_OUTPUT_VAR);
            if (gfd) {
                fid= gfd->getUInt(); // field identifier
                out=theHeader->getVar(fid); // returns address of output var with fid
                gfd=grec->getField(GEO_DB_DISCRETE_ACTION_NUM_ITEMS);
                unsigned int nr=gfd?gfd->getUInt():1;
                unsigned int i;
                for (i=0; i<nr; i++) {
                    geoRange gr;
                    rangelist.push_back(gr);
                }
                const geoField *gfdmin=grec->getField(GEO_DB_DISCRETE_ACTION_MIN_VALS);
                const geoField *gfdmax=grec->getField(GEO_DB_DISCRETE_ACTION_MAX_VALS);
                const geoField *gfdval=grec->getField(GEO_DB_DISCRETE_ACTION_MAP_VALS);
                if (gfdmin) {
                    float *fmin=gfdmin->getFloatArr();
                    float *fmax=gfdmax->getFloatArr();
                    float *fval=gfdval->getFloatArr();
                    if (fmin && fmax && fval) {
                        for (i=0; i<nr; i++) {
                            rangelist[i].setMin(fmin[i]);
                            rangelist[i].setMax(fmax[i]);
                            rangelist[i].setVal(fval[i]);
                        }
                    }
                }
                ok=true;
            }
        }
    }
    return ok;
}


void geoMoveBehaviour::doaction(osg::Node *node) {
    if (getVar()) {
        MatrixTransform *mtr=dynamic_cast<MatrixTransform *> (node);