abstractturtle.h

Go to the documentation of this file.

#ifndef ABSTRACTTURTLE_H_
#define ABSTRACTTURTLE_H_

#include "utils.h"
#include "lsgeode.h"
#include "randomizer.h"

namespace AP_LSystem {

enum InterpretErrorCodes
{
    LS_OK,                                  
    LS_NOTIMPLEMENTED,                      
    LS_ERR_PAR_BADTYPE,                     
    LS_ERR_PAR_INVALIDCOUNT,                
    LS_ERR_DRAWFORWARD_NEGATIVEDISTANCE,    
    LS_ERR_STACK_UNKNOWN_TURTLE_TYPE,       
    LS_ERR_STACK_NULL_LSGEODE,              
};

const osg::Vec3d HeadVec(0.0,1.0,0.0);      
const osg::Vec3d UpVec(1.0,0.0,0.0);        
const osg::Vec3d LeftVec(0.0,0.0,1.0);      
const osg::Vec3d Center(0.0,0.0,0.0);       

const osg::Vec4d White(1.0,1.0,1.0,1.0);    

class AbstractTurtle
{
protected:
    TurtleProperties properties;    
    LSGeode * geode;                

public:
//****************************************************************
//**                        OTHER                               **
//****************************************************************
    virtual int initialize()    { return 0;}            
    
    virtual int finalize()      { return 0;}

    virtual int resetValues() { return 0;}          // TODO

    inline TurtleProperties & getProperties()
    {
        return properties;
    }

    virtual void setProperties( TurtleProperties p )
    {
        properties = p;
    }

    virtual void inheritProperties( TurtleProperties p ) 
    {
        // inherit matrix
        properties.matrix = p.matrix;
    }

    inline void bindGeode( LSGeode * geode )    
    {
        this->geode = geode;
    }

    inline LSGeode * getGeode( )
    {
        return geode;
    }

    inline osg::Matrixd getMatrix()
    {
        return properties.matrix;
    }

//****************************************************************
//**                        DEBUG                               **
//****************************************************************

    virtual void drawFrame( osg::Matrixd & matrix, osg::Vec4d * color = NULL )              = 0;
    
    virtual void drawVector( const osg::Vec3d & vector, osg::Matrixd & matrix, osg::Vec4d & color)
    {
        double s = properties.debugGeometryScale;
        double l = vector.length();
        osg::Cylinder * cylinder = new osg::Cylinder(vector * s * (l/2.0f) * matrix,s * 0.01f,s * l);
        osg::Cone * cone = new osg::Cone(vector * s * ( l + 0.03f ) * matrix, s * 0.03f,s * 0.15f);

        osg::Matrixd m = osg::Matrixd::rotate( LeftVec, vector ) * matrix;
        cylinder->setRotation( m.getRotate() );
        cone->setRotation( m.getRotate() );

        osg::ShapeDrawable * shape;
        shape = new osg::ShapeDrawable(cylinder);
        shape->setColor( color );
        geode->addDrawable( shape );
    
        shape = new osg::ShapeDrawable(cone);
//      shape->setColor( color );
        geode->addDrawable( shape );
    }

//****************************************************************
//**                        ROTATION                            **
//****************************************************************
    inline double toRad( double angle )
    {
        if( properties.flags & TurtleProperties::DEGREES_TO_RADIANS )
            return osg::DegreesToRadians( angle );
        else
            return angle;
    }

    inline double rand( double angle )
    {
        if( properties.angleVariance )
            angle *= Randomizer::get( properties.angleVariance );
        return angle;
    }

    virtual int turnLeft(std::vector<Parameter> & p)        = 0;

    virtual int turnRight(std::vector<Parameter> & p)       = 0;

    virtual int pitchDown(std::vector<Parameter> & p)       = 0;

    virtual int pitchUp(std::vector<Parameter> & p)         = 0;

    virtual int rollLeft(std::vector<Parameter> & p)        = 0;

    virtual int rollRight(std::vector<Parameter> & p)       = 0;

    virtual int turnArround()                               = 0;

    virtual int rollArround()                               = 0;

    virtual int rollUntilHorizontal()                       = 0;

    virtual int randomTurnPitchRoll(std::vector<Parameter>& p)= 0;

//****************************************************************
//**                    CHANGE PROPERTIES                       **
//****************************************************************
    virtual int multiplyLength(std::vector<Parameter> & p)  = 0;

    virtual int multiplyRadius(std::vector<Parameter> & p)  = 0;

    virtual int multiplyAngle(std::vector<Parameter> & p)       = 0;

    virtual int multiplyTropismElasticity(std::vector<Parameter> & p)= 0;

    virtual int multiplyGravitropismElasticity(std::vector<Parameter> & p)= 0;

//****************************************************************
//**                        MOVEMENT                            **
//****************************************************************
    virtual int drawForward(std::vector<Parameter> & p)     = 0;

    virtual int drawForwardHalf()                           = 0;

    virtual int moveForward(std::vector<Parameter> & p)     = 0;
    
    virtual int moveForwardHalf()                           = 0;
    
};
}

#endif