Cable.h

Go to the documentation of this file.

#ifndef CABLE_H
#define CABLE_H

//VRECKO

//#include <vrecko/World.h>         //includovan ve Scene.h
#include <vrecko/Ability.h>         //incudovane v World.h
#include <vrecko/PluginManager.h>

#include <vreckoAP/EditorController/ControllableAbility.h>

#include <vrecko/EnvironmentObject.h>
#include <vrecko/Scene.h>   //chyba pri includu musi byt includovan na konci !!! jinak nelze najit EnvironmentObject

//OSG
#include <osg/Geode>
#include <osg/Geometry>
#include <osg/Drawable>
#include <osg/ShapeDrawable>


using namespace vrecko;

namespace AP_CableEditor {

    #define SPHERE_RADIUS 2.0;

    #define INTERPOLATION_CATMULL_ROM_ITERATE       1   //iterativni vyhlazovani - vzdy se puli interval (algoritmus se provede n-krat)
    #define INTERPOLATION_CATMULL_ROM_PER_SEGMENT   2   //nastaveni pevneho poctu bodu na segment (mezi 2 kontrolnimi body bude n interpolovanych)


    class Cable : public Ability {
        
        protected:

            //urcuje jestli doslo ke zmene kabelu a je potreba prekreslit obalku
            bool controlPointsChange;

            //promena urcijici, jestli se kabel nachazi v editacnim modu
            bool isUpdateState;

            //polomer kabelu
            float cableRadius;
            float controlSpheresRadiusAdjust;

            //urcuje natoceni zakladni roviny pro RMF - umoznuje otacet tvarem kabelu kolem jeho osy
            //v radianech
            float basePlaneRotation;

            //barva kabelu
            osg::Vec4f  cableColor;
            osg::Vec4f  controlSpheresColor;

            //vektor kontrolnich bodu
            //slouzi jako vstup pro interpolacni funkci
            osg::ref_ptr<osg::Vec3Array> controlPoints;

            //Tangenty, Normaly a Binormaly interpolovanych bodu
            osg::ref_ptr<osg::Vec3Array> thisTangents;
            osg::ref_ptr<osg::Vec3Array> thisNormals;
            osg::ref_ptr<osg::Vec3Array> thisBinormals;

            //vektor bodu pro vykresleni interpolovane krivky
            //slouzi jako vstup pro obalovaci funkci
            osg::ref_ptr<osg::Vec3Array> interpolatedPoints;

            //pole urcuje tvar kabelu
            osg::ref_ptr<osg::Vec3Array> shapePoints;

            //vektors kontrolnich kouli
            std::vector<vrecko::EnvironmentObject *> *controlSpheres;

            //ukazatel na editacni linku
            EnvironmentObject *cableControlLine;

            
            //Obalujici EnvironmentObject teto ability
            //sem se bude vkladat veskera geometrie (krom Kontrolnich kouli)
            EnvironmentObject   *thisEoWrapper;

            //ulozeni posledni transformace obalky kabelu - pro testovani zmeny polohy, otoceni....
            osg::ref_ptr<osg::MatrixTransform>  lastWrapperTransformation;

            osg::ref_ptr<osg::Geode> wrapperGeode;

            unsigned int interpolationsNum;
            unsigned int interpolationType;

            string cableID;

            //--------- DEBUG --------

            //ukazatel na EO kontrolnich vektoru (tangenta, normala, binormala) ke kazdemu interpolovanemu bodu
            //pro funkci visualizeVectors
            EnvironmentObject *controlVectors;
            
            //------------------------


            //_____________________________________________________ Funkce _________________________________________________________________________________

            //Upravi polohu kontrolnich kouli podle zadane matice
            void updateSpheresPosition();

            //Provede reakci na smazani kontrolni koule a na ukonceni VRECKa
            virtual int processNotification(BaseClass *sender, unsigned long notificationType,
                void *notificationData);

            //Visualizace kontrolnich bodu - Vytvori na bodech z vektoru kontrolnich bodu koule
            //podle polohy se nastavuje poloha kontrolnich bodu viz updateControlPoints()
            void createSpheres();

            //Vymaze vsechny kontrolni koule objektu ze sceny
            void clearSpheres();

            //aktualizuje kontrolni body na zaklade polohy kontrolnich kouli
            //Pozor!!!  - pokud byl pridan kontrolni bod a nebyla pro nej vytvorena koule, pak tento bod v aktualizovanych kontrolnich bodech nebude
            //          - stejne tak pokud byla smazana koule nektereho bodu, pak tento bod v poli nebude
            void updateControlPoints();


        public:
            Cable();
            virtual ~Cable();

            virtual void preInitialize();
            virtual void postInitialize();

            void setCableID( string ID) { this->cableID = ID; }
            string getCableID() {return this->cableID; }

            void setShape( osg::ref_ptr<osg::Vec3Array> points ){ shapePoints = points; }
            osg::ref_ptr<osg::Vec3Array> getShape(){ return shapePoints; }

            void setInterpolation(unsigned int type, unsigned int num) { this->interpolationType = type; this->interpolationsNum = num; }
            void getInterpolation(unsigned int *type, unsigned int *num) { *type = this->interpolationType; *num = this->interpolationsNum;  }

            void setRadius(float radius){ this->cableRadius = radius; }
            float getRadius() { return this->cableRadius; }

            //upraveni polomeru kontrolnich kouli (cableRadius + controlSpheresRadiusAdjust)
            void setControlSpheresRadiusAdjust(float radius) { this->controlSpheresRadiusAdjust = radius; }
            float getControlSpheresRadiusAdjust() { return this->controlSpheresRadiusAdjust; }

            //upravi polomer kouli podle polomeru kabelu
            void updateControlSpheresRadius();

            void setCableColor( osg::Vec4f color ) { this->cableColor = color; }
            osg::Vec4f getCableColor() { return this->cableColor; }

            void setControlSpheresColor( osg::Vec4f color ) { this->controlSpheresColor = color; }
            osg::Vec4f ControlSpheresColor() { return this->controlSpheresColor; }

            //nastavuje/ziskava uhel pootoceni obalky v radianech (otoceni normaly a binormaly zakladni roviny pro RMF)
            void setShapeRotate( float angle ) { this->basePlaneRotation = angle; }
            float getShapeRotate() { return this->basePlaneRotation; }

            //Nastaveni obalky kterou bude tato abilita spravovat - Musi byt nastaveno pri vytvareni ability !"
            void setEoWrapper (EnvironmentObject *wrapper){ if(wrapper != NULL) thisEoWrapper = wrapper; }
            EnvironmentObject *getEoWrapper() { return this->thisEoWrapper; }


            //Vrati obalku kabelu jako Geode objekt
            osg::Node *getCableWrapperNode() { return thisEoWrapper->getChild(0); }

            void setControlPoints(osg::ref_ptr<osg::Vec3Array> points) { controlPoints = points; }
            osg::ref_ptr<osg::Vec3Array> getControlPoints() { return controlPoints; }
            osg::ref_ptr<osg::Vec3Array> getIntepolatedPoints() { return interpolatedPoints; }

            void addControlPoint(osg::Vec3f position) { controlPoints->push_back(position); }

            //vlozi bod na konkretni pozici v poli - pred prvek urceny v "position"
            void addControlPoint(unsigned int position, osg::Vec3f point);

            //vlozi bod mezi 2 nejblizsi body - predpoklada ze bod lezi (alespon priblizne) na primce dane 2 kontrolnimi body
            void addControlPointBetweenLine(osg::Vec3f position);

            //Interpolacni funkce vezme 4 body (p0,p1,p2,p3) a parametr "t" [0.0f, 1.0f] urcujici polohu bodu mezi body p1 a p2
            osg::Vec3f getInterpolatedPoint(osg::Vec3 p0, osg::Vec3 p1, osg::Vec3 p2, osg::Vec3 p3, double t = 0.5) const;


            //vytvori kouli na zadanych souradnicich a vlozi ji do sceny vraci ukazatel na vytvoreny Environment object
            EnvironmentObject *createSphere(osg::Vec3f center, float radius = 0.25){
                return createSphere(center, this->cableColor, radius);
            }

            EnvironmentObject *createSphere(osg::Vec3f center, osg::Vec4f color, float radius = 0.25);

            //interpoluje kontrolni body a nastavi je abilite
            void interpolate();

            //interpoluje kontrolni body Catmull-Rom algoritmem
            //kazdy segment mezi 2 body rozdeli na pointsPerSegment interpolovanych bodu
            // neprovadi kontrolu uhlu mezi kontrolnimi body (zhustovani bodu u ostrych uhlu)
            //      pointsPerSegment - pocet interpolovanych bodu mezi 2 kontrolnimi body
            //      inputPoints     - pole bodu pro interpolaci. Musi byt >= 4
            osg::ref_ptr<osg::Vec3Array> interpolateCatPerSegment(osg::ref_ptr<osg::Vec3Array> inputPoints, unsigned int pointsPerSegment) const;

            //interpoluje zadane body pulenim intervalu
            //vraci pole interpolovanych bodu
            // inputPoints - pole kontrolnich bodu pro interpolaci. Musi byt >= 4
            // numIterations - pocet iteraci
            osg::ref_ptr<osg::Vec3Array> interpolateCatIterate(osg::ref_ptr<osg::Vec3Array> inputPoints, unsigned int numIterations) const;

            //obali interpolovane body a udela z ni kabel
            //parametr shapePoints - body urcujici tvar kabelu
            void wrapCable();

            //vypina nebo zapina aktualizaci kabelu
            void setUpdate(bool state);

            //vraci stav ve kterem se momentalne nachazi kabel (editacni rezim)
            bool getUpdate() { return isUpdateState; }

            //provadi update polohy kontrolnich bodu a obalky
            virtual void update();

            //Ke kazdemu bodu v poli ( !!krome prvniho a posledniho!! ) "points" vypocita jeho tangentu, normalu a binormalu a vrati v polich
            //v pripade uspechu vraci 0
            //jinak vraci cislo != 0 a obsah poli tangents, normals, binormals je nedefinovany
            int computeRMF(osg::Vec3Array *points, osg::Vec3Array *tangents, osg::Vec3Array *normals, osg::Vec3Array *binormals);

            //vypocita polohu bodu tvaru v danem bode
            //jako prvni parametr bere pole vektoru/bodu urcujici tvar protazeni
            //dale pak bod ve kterem se na natoceni pocitat, jeho tangentu, normalu a binormalu
            //vraci pole prepocetnych vektoru/bodu (otocenych do roviny dane normalou a binormalou)
            osg::Vec3Array *transformVectors(osg::Vec3Array *vectors, osg::Vec3f point, osg::Vec3f tangent, osg::Vec3f normal, osg::Vec3f binormal, float scale = 1);


            //Obali kabel a vrati jeho obalku jako jeden geode
            //shapeVectors -> pole vektoru/body udavajiciho tvar kabelu musi byt definovana v rovine YZ
            //points -> pole bodu pro obaleni: wrapFrom urcuje index prvniho bodu, wrapNum urcuje kolik bodu se bude obalovat - vzdy ale bez posledniho bodu v poli
            //tangents, normals, binormals -> pole tangent/normal/binormal prislusejicich k bodum v poli "points"  musi platit points->size() == tangents/normals/binormals->size() !!
            //wrapFrom -> urcuje index od ktereho bodu se bude obalovat
            //wrapNum -> urcuje kolik bodu se bude obalovat 0 znamena vsechny body v poli, pokud wrapNum < points->size() pouzije se points->size()
            // Pozn: Vzdy se obaluje o 1 bod mene nez je urceno/obsazeno poli - pokud se maji obali vsechny body je treba posledni bod zduplikovat vcetne jeho tangenty/normaly/binormaly
            osg::ref_ptr<osg::Geode> wrap(osg::Vec3Array *shapeVectors, osg::Vec3Array *points, osg::Vec3Array *tangents, osg::Vec3Array *normals, osg::Vec3Array *binormals,
                                    float scale = 1, unsigned int wrapFrom = 1, unsigned int wrapNum = 0);

            //debugovaci fce:

            void visualizeVectors(osg::Vec3Array *points, osg::Vec3Array *tangents, osg::Vec3Array *normals, osg::Vec3Array *binormals);

    };
}

#endif