PerlinLines.h

Go to the documentation of this file.

#ifndef _PERLINELINES_H
#define _PERLINELINES_H

#include "Controller.h"
#include "poa.h"
#include <osg/LineWidth>


using namespace vrecko;

namespace APDYNAMICART
{



typedef std::vector<osg::ref_ptr<osg::Sphere> >  Spheres;


class PerlinLines : public PoA
{
public:
    PerlinLines(Controller* contr, int numberOfLines, double x, double y, double z);
    ~PerlinLines();

    int load(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* PoANode) { return 0; }

    void save(XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* Document, XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* poaNode) {}
    
    virtual void createMenuStructure( osg::ref_ptr<vreckoUtils::MenuBase> parentMenu ) const;
    
    void GUIItemClicked(const char* itemID);
    
    void GUISliderChanged(const char* sliderID, float sliderPos);
    
    void pointed(bool pointed);
    
    void setColor(osg::Vec4 newColour) {}
    
    void update();
    
    void draw();
    
    void setLineParameters(int count);
    
    void setLinesParameters();  

    double perlinNoise(osg::Vec3 temp);
    
    double smooth(osg::Vec3 temp, double sx, double sy, double sz);
    
    double interpolate(double a, double b, double c);
    
    void interpolateVec3(osg::Vec3Array* controlPoints, osg::Vec3Array* interpolatedPoints, int p_steps);
    
    osg::Vec3 interpolatePoint(double t, osg::Vec3 point1, osg::Vec3 point2, osg::Vec3 point0 = osg::Vec3(0.0, 0.0, 0.0), osg::Vec3 point3  = osg::Vec3(0.0, 0.0, 0.0));
    
    double random(double min,double max) { return min + (max-min)*(double)rand()/(double)RAND_MAX;}


    void setMagnet(osg::Vec3 coordinates, float magnetSize){_magnetUsed = true; _magnetCoords = coordinates; this->_magnetSize = magnetSize;};

    void createMagnet(EnvironmentObject* daarea, bool first){daarea->addEOChild(magnetEO); daarea->addEOChild(particlesEO);if (first) _magnetCreated = true; else _magnetCreated = false;};

    void updateMagnetPosition(osg::Vec3 vektor, float size) ;

    void unsetMagnet() {_magnetUsed = false; _magnetON = false;};


    void setBounding(float boundingSize, bool first) {_boundingUsed = true; this->_boundingSize = boundingSize;if (first) _boundingCreated = true; else _boundingCreated = false;};

    void setBoundingVisible() {if(_boundingVisible) _boundingVisible = false; else _boundingVisible = true;};

    void unsetBounding() {_boundingUsed = false;};


    void recalculateColorInterpolation();

    void setColor(osg::Vec3 color){_red = color.x(); _green = color.y(); _blue = color.z();};


    void setSpeed(int speed) {changedSpeed = 101-speed;};

    int getSpeed(){return this->_speed;};

    void setInterpolationCount(int interpolationCount) {changedInterpolation = 5 + interpolationCount; _somethingChaned = true;};

    int getInterpolationCount() {return this->_interpolationCount;};

    void setLength(int length) {changedLength = 4 + length; _somethingChaned = true;};

    void setColor(float r, float g, float b) {_red = r; _green = g; _blue = b; _somethingChaned = true;}


    void setController(osg::Vec3 vektor);

    void unsetController(){_controllerUsed = false;};

    void updateControllerPosition(osg::Vec3 vektor) {if (_request) _controllerCoords = vektor;};

    int getLength(){return this->_length;};

    void pause(){if (_paused) _paused = false; else _paused = true;};




protected:     
    typedef osg::ref_ptr<osg::Vec3Array> Vec3Ptr;

    osg::ref_ptr<osg::Geode>                    _lineGeode, _boxGeode;  
    std::vector<osg::ref_ptr<osg::Geometry>>    _lineGeometry;
    osg::ref_ptr<osg::Vec4Array>                _linesColorArray, _boxColorArray;
    osg::ref_ptr<osg::Vec4Array>                _newLinesColorArray;
    osg::ref_ptr<osg::StateSet>                 _OSGState, _boxOSGState;
    osg::ref_ptr<osg::LineWidth>                _linewidth;
    osg::ref_ptr<osg::Material>                 _linesMaterial, _boxMaterial;
    std::vector<Vec3Ptr>                        _lines;
    std::vector<Vec3Ptr>                        _interpolatedLines;
    Vec3Ptr                                     gradient;
    int                                         _p[512];
    float                                       _magnetSize, _boundingSize;
    u_int                                       _speed, _trigger, _interpolationCount, _length;
    osg::Vec3                                   _magnetCoords, _unusedMagnetCoords, _controllerCoords;
    bool                                        _somethingChaned, _request, _pointed, _paused, _magnetUsed, _magnetON, _controllerUsed, _boundingUsed, _boundingVisible;
    bool                                        _magnetCreated, _boundingCreated;
    u_int                                       changedSpeed, changedInterpolation, changedLength;
    float                                       _red, _green, _blue, _changedRed, _changedGreen, _changedBlue;
    EnvironmentObject*                          magnetEO;
    EnvironmentObject*                          particlesEO;
    EnvironmentObject*                          _daArea;
    bool                                        firstTimeUpdate;

    osg::ref_ptr<osg::Geode> magnetGeode; 
    osg::ref_ptr<osg::StateSet> magnetStateSet;
    osg::ref_ptr<osg::Material> magnetMaterial;
};

}
#endif