HoopShape.h

Go to the documentation of this file.

#pragma once
#include <osg\Referenced>
#include <string>
#include <xercesc\util\XercesDefs.hpp>
#include "Spline.h"
#include "Utils.h"
#include "LinearInterpolator.h"
#include "InterpolatedSpline.h"
#include "SampledSpline.h"
#include "types.h"
#include "RegularPolygonSpline.h"
#include "CatmullRomInterpolator.h"
#include "SampledSpline.h"

namespace APDYNAMICART
{
#define META_HoopShapeObject(name, menuName) \
    name(); \
    name(const name& val); \
    virtual void createMenu( MenuPtr parent ) const; \
    virtual bool sliderChanged( const char* sliderID, float sliderPos ); \
    virtual int load( XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* PoANode ); \
    virtual void save( XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* Document, XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* poaNode ); \
    virtual osg::ref_ptr<HoopShape> clone() { return new name(*this); } \
    virtual std::string getName() { return (menuName); }

class HoopShape : public osg::Referenced
{
public:
    HoopShape() : _dirty(false), _spline(NULL) {};

    //Virtual methods
    virtual SplinePtr getLeadingSpline() { return _spline; }
    virtual void setLeadingSpline(SplinePtr val) { _spline = val; _dirty = true; }
    virtual void createMenu( MenuPtr parent ) const {};
    virtual bool itemClicked( const char* itemID ) { return false; };
    virtual bool sliderChanged( const char* sliderID, float sliderPos ) { return false; };
    virtual int load( XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* PoANode ) = 0;
    virtual void save( XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* Document, XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* poaNode ) = 0;

    //Dirty object
    virtual void dirty(bool enable = true) { _dirty = enable; }
    virtual bool isDirty() { return _dirty; }

    //Copy
    virtual osg::ref_ptr<HoopShape> clone() = 0;

    //Name
    virtual std::string getName() = 0;

protected:
    bool      _dirty;
    SplinePtr _spline;
    virtual ~HoopShape() {};
};

typedef osg::ref_ptr<HoopShape> HoopShapePtr;

class NullHoopShape : public HoopShape
{
public:
    virtual HoopShapePtr clone() { return new NullHoopShape; }
    virtual std::string getName() { return "NullHoopShape"; }
    virtual int load( XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* PoANode ) {
        err("Loading null object!"); return 1;
    }
    virtual void save( XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* Document, XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* poaNode ) {
        err("Saving null object!");
    }
};

class Rectangle : public HoopShape
{
public:
    META_HoopShapeObject(Rectangle, "Rectangle");
    
protected:
    void init();
    void updateSamplePoints();

    double       _width;
    double       _height;
    double       _scale;
    Vec3ArrayPtr _samplePoints;
};

class Ellipse : public HoopShape
{
public:
    META_HoopShapeObject(Ellipse, "Ellipse");

protected:
    void init();
    void updateSamplePoints();

    double       _a;
    double       _b;   
    Vec3ArrayPtr _samplePoints;
    unsigned int _detail;    
};

class RegularPolygon : public HoopShape
{
public:
    META_HoopShapeObject(RegularPolygon, "Regular polygon");

protected:
    RegularPolygonSplinePtr _rps;
    double _scale;

};

class Line : public HoopShape
{
public:
    META_HoopShapeObject(Line, "Rod");

protected:    
    void init();
    void updateSamplePoints();

    double           _length;
    SampledSplinePtr _sampledSpline;
    Vec3ArrayPtr     _array;
};

class ElongatedCircle : public HoopShape
{
public:
    META_HoopShapeObject(ElongatedCircle, "Elongated Circle");

protected:
    void init();
    void updateSamplePoints();
    void createCircleSide( double step);

    double       _radius;
    Vec3ArrayPtr _samplePoints;
    unsigned int _detail; 
    double _distance;
};

class Painted : public HoopShape
{
public:
    META_HoopShapeObject(Painted, "Painted");
    virtual bool itemClicked( const char* itemID );
    void setPointArray(Vec3ArrayPtr array) {
        _points = array;
        _sampledSpline->setVertexArray(_points);
    }
protected:
    Vec3ArrayPtr _points;
    SampledSplinePtr _sampledSpline;
};

class ShapeFactory
{
public:
    static std::vector<std::string> getAvaiableHoopShapes() {
        std::vector<std::string> shapes;
        shapes.push_back("Ellipse");
        shapes.push_back("Rectangle");
        shapes.push_back("Rod");
        shapes.push_back("Regular polygon");
        shapes.push_back("Elongated Circle");
        return shapes;
    }
    static HoopShapePtr getHoopShape(const std::string& name) {
        if(name == "Ellipse")
            return new Ellipse;
        else if(name == "Rectangle")
            return new Rectangle;
        else if(name == "Regular polygon")
            return new RegularPolygon;
        else if(name == "Rod")
            return new Line;
        else if(name == "Elongated Circle")
            return new ElongatedCircle;
        else if(name == "Painted")
            return new Painted;
        else
            return new NullHoopShape;
    }
};

}