CarExecutionUnit.h

Go to the documentation of this file.

#ifndef CAR_EXECUTION_UNIT
#define CAR_EXECUTION_UNIT

#include <vrecko/Ability.h>
#include <vrecko/IOPins.h>
#include <vrecko/Message.h>
#include <osg/MatrixTransform>
#include "CarState.h"
#include "CCUStructs.h"

// typy svetel:
#define FRONT_LIGHT 1
#define BRAKE_LIGHT 2
#define BLINK_LIGHT 3

// cas v s od zacatku bliknuti do zacatku pristiho bliknuti blinkeru
#define BLINK_LENGTH 1.0

namespace CarSim {
    // zde budou ulozeny ukazatele na transformace svetel
    struct Lights {
        osg::MatrixTransform* pFrontLightMT;
        osg::MatrixTransform* pBrakeLightMT;
        osg::MatrixTransform* pLeftBlinkerLightMT;
        osg::MatrixTransform* pRightBlinkerLightMT;
    };

    // pro ulozeni cest k souborum s casmi geometrie auta (bude mit vyznam
    // pouze u negenerovanych aut)
    struct GeometryPartsPath {
        std::string carWithoutWheelsPath;
        std::vector<std::string> leftWheelsPathVec;
        std::string frontLightsPath;
        std::string brakeLightsPath;
        std::string leftBlinkerPath;
        std::string rightBlinkerPath;
    };

    class CarExecutionUnit: public vrecko::Ability {
        public:
            CarExecutionUnit();
            // tento konstruktor bude slouzit k nastaveni generovanych aut
            CarExecutionUnit(const CarSize &carSize,
                const float maxSpeed,const float minSpeed, const float maxAcc,
                const float minAcc,const float maxDispWheelAngle,std::vector<osg::MatrixTransform*> *const pWheelsVec,
                const float wheelR,Lights *const pLights,const osg::Vec3 &carDirection,const osg::Vec3 &carNormal,
                const osg::Vec3 &carPositionOnRoad,vrecko::EnvironmentObject *const pFutureCarEOownerToSet);
            ~CarExecutionUnit();

            void preInitialize(void);
            void update(void);

            bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);
        protected:
            CarState carState;
            float vPrevious;    

            float maxSpeed;
            float minSpeed;
            // maximalni uhel zobrazovaneho zatoceni kol
            float maxDispWheelAngle;

            // aby zobrazene natoceni kol melo vetsi setrvacnost a nesekalo se tolik,
            // budou se zobrazena kola natacet (kolem normaly auta) o uhel,
            // ktery je vazenym prumerem skutecneho
            // natoceni kol v tomto snimku a dosavadniho natoceni kol pro zobrazeni;
            // natoceni kol pro zobrazeni bude mit (0.25/lastFrameLength)*vetsi vahu nez skutecne natoceni kol;
            // kde t je cas, ktery trval posledni snimek, takze cim pomalejsi
            // simulace bude, tim mensi bude setrvacnost
            
            // jestlize je vetsi nez maxDispWheelAngle, bude maxDispWheelAngle
            // jestlize je mensi nez -maxDispWheelAngle, bude -maxDispWheelAngle
            // (velke uhly by nepusobily prirozene);
            float wheelDisplayAngleAroundNormal;

            // uhel natoceni kol podle osy normala^smer auta, bude vzdy v rozmezi [0,2PI)
            float wheelRotateAngle;

            // polomer kola, pro jednoduchost bude uvazovat, ze ji budou mit vsechna kola stejnou
            float wheelR;

            // v tomto odkazovanem vektoru budou ukazatele na transformace s koly auta
            // (postupuje se zleva doprava a odpredu dozadu)
            std::vector<osg::MatrixTransform*> *const pWheelsVec;
            // matice kol, ktera urcuji jejich pocatecni rozestaveni
            // (v ramci lokalniho souradneho systemu auta)
            std::vector<osg::Matrix> wheelsInitMatrixVec;

            // zde jsou ukazatale na transforamce svetel auta, prvni jsou predni svetla,
            // pak brzdova svetla a nakonec blinkry - nejdriv levy, pak pravy
            Lights *const pLights;

            // stavy svetel
            unsigned int frontLightState;
            unsigned int brakeLightState;

            // faze blinkeru;
            // uplynuly cas od zacatku posledniho bliknuti blinkru;
            // jestlize jsou blinkry ve stavu LIGHT_TURNED_OFF, muze obsahovat
            // hodnotu z drivejsi doby, kdy byl jeste nejaky blinkr zapnuty
            float timeFromLastBlinkStart;

            // zda vzniklo auto pomoci generatoru
            const bool isGenCar;

            // zde budou ulozeny cesty k souborum s castmi geometrie auta (bude mit
            // vyznam jen u negenerovanych aut)
            GeometryPartsPath *const pGeometryPartsPath;

            // pozice levych kol relativne vzhledem ke stredu auta (odpredu dozadu,
            // ma vyznam pouze u generovanych aut)
            std::vector<osg::Vec3> *const pLeftWheelsPosVec;

            // tato metoda otestuje korektnost vstupnich parametru
            // z XML souboru
            void checkXMLparameters();

            // metoda nastavi smer auta, natoci podle nej EO auta a urci docasnou
            // normalu auta (metoda pocita s tim, ze pocatecni spravna normala
            // jeste nebyla urcena)
            void initDirection(const osg::Vec3 &dir);

            // metoda nastavi normalu auta, natoci podle ni EO auta 
            // (metoda pocita s tim, ze pocatecni smer auta uz byl urcen)
            void initNormal(const osg::Vec3 &normal);
            
            // vypocita novy stav auta (aktualizuje hodnoty v carState a hodnoty
            // s tim spojene)
            void computeCarState(const float lastFrameLength);

            // metoda prepne svetlo (predni, brzdove nebo blinkry) do pozadovaneho stavu
            void switchLight(const unsigned int lightType,const unsigned int lightState);

            // metoda, ktera zjisti, v jake fazi se nachazi zapnuty blinkr (levy nebo pravy
            // nebo oboje); jestlize ma nejaky blinkr svitit a doposud byl zhasnuty,
            // rozsviti ho a naopak jestlize ma byt nejaky blinkr zhasnuty a doposud svitil,
            // zhasne ho; blinkry by nemely byt ve stavu LIGHT_TURNED_OFF, sice metoda nic
            // zavazneho neudela, ale neni to prilis optimalni;
            // faze blinkeru jsou dve - zapnuto (timeFromLastBlinkStart in [0,0.5*BLINK_LENGTH],
            // vypnuto (timeFromLastBlinkStart in (0.5*BLINK_LENGTH,BLINK_LENGTH) )
            void blink(const float lastFrameLength);

            // jestlize auto nevzniklo generovanim, nacte tato metoda geometrie casti auta
            // ze souboru (auto bez kol, kolo, svetla)
            void loadGeometryParts();


            DECLARE_INPUT(InAcc, vrecko::MessageFloat);
            DECLARE_INPUT(InWheelAngle, vrecko::MessageFloat);
            DECLARE_INPUT(InStop, vrecko::MessageVoid);
            DECLARE_INPUT(InUpdate, vrecko::MessageFloat);
            DECLARE_INPUT(InInitNormal, vrecko::MessageVec3);
            DECLARE_INPUT(InInitDirection, vrecko::MessageVec3);
            DECLARE_INPUT(InInitPosition, vrecko::MessageVec3);
            DECLARE_INPUT(InSetCarNormal, vrecko::MessageVec3);
            DECLARE_INPUT(InPushCarInNormalDir, vrecko::MessageFloat);
            DECLARE_INPUT(InPushCarInDirectionCrossNormalDir, vrecko::MessageFloat);
            DECLARE_INPUT(InSetBlinker, vrecko::MessageUnsignedInt);
            DECLARE_INPUT(InShow, vrecko::MessageVoid);
            DECLARE_INPUT(InHide, vrecko::MessageVoid);


            DECLARE_REQUEST_INPUT(InGetCarState, vrecko::MessageVoid, MessageCarStatePtr);
            DECLARE_REQUEST_INPUT(InGetCarLength, vrecko::MessageVoid, vrecko::MessageFloat);

    };

}

#endif