DtDiGuyCharacterModel.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2016 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once

#include <vrvDiGuy/vrvDiGuy.h>
#include <vrvCore/DtCharacterModel.h>
#include <osg/ref_ptr>
#include <osg/Geometry>

#include <matrix/topoCoord.h>

#include <boost/unordered_map.hpp>

//#define VISUALIZE_DIGUY_VELOCITY

class diguyCharacter;
class diguyCharacterGuide;

namespace osg
{
    class Group;
}

namespace makVrv
{
    class DtParticleSystemModelAgent;
    class DtSceneObjectAgent;
    class DtDiGuyScenario;
    
    DtTaitBryan vrvToDiGuyOrientationChar(const DtTaitBryan& hpr);

    struct DtLastForceActionParams
    {
       DtLastForceActionParams() :
          mySpeed(0)
          , myAutoTransition(0)
       {
          ; 
       }
        float mySpeed;
        int myAutoTransition;
        std::string myName;
    };

    class DtOsgSceneConnector;
    class DtSceneObject;

    class DT_DLL_VRVDIGUY DtDiGuyCharacterModel : public DtCharacterModel
    {
    public:
        DtDiGuyCharacterModel(DtDe& de, DtUniqueID id);

        virtual ~DtDiGuyCharacterModel();

        virtual void setModelDefinition(const std::string& modelDefinition);

        virtual void addToScene( const DtUniqueID& sceneObjectId, int modelSet,
            int visualizerType );

        virtual void removeFromScene();

        void setPositionAndVelocityState(const DtVector& vrvLoc, const DtTaitBryan& vrvOri, DtVector32 vrvVel, DtVector32 vrvAngularVel, bool needsTopoUpdate);

        virtual void setPosition( int vtx, const DtVector& position );
        const DtVector& getPosition(){ return myPosition; }

        virtual void setOrientation( int vtx, const DtTaitBryan& orientation );

        virtual std::string className() const;

        virtual void setCharacterModel(const std::string& characterType);

        virtual void setEnableAnimationSmoothing(bool);

        virtual bool enableAnimationSmoothing() const;


        virtual void setDefaultAppearance(const std::string& appearanceName);
        virtual void setAppearance(const std::string&  appearanceName);

        virtual void setHeadAppearance(const std::string&  appearanceName);
        virtual void setItemAppearance(const std::string&  appearanceName); 

        virtual void setFlamesPresent(bool val);
        virtual void setEnginePlume(bool val);
        virtual void setEngineSmoke(bool val);
        virtual void setTrailState(bool val);
        virtual void setLightState(unsigned int light, unsigned int lightState);

        virtual void fireWeapon();

        virtual void beginAppearanceEffect(const std::string& effect,const std::string& overrideLink,
            float overrideScale,const DtVector& overrideOffset,float overrideDuration );
        virtual void endAppearanceEffect(int instant, const std::string& effect,const std::string& overrideLink);

        virtual void executeGesture(const std::string& gestureName, int reps, 
            float overallDuration, float channelAWeight);
        virtual void endGesture(const std::string& gestureName,float rampDown);

        virtual void setDesiredAction(const std::string& action,float speed);

        virtual void forceAction(const std::string& action, float speed, int autoChooseTransitionBehavior);

        virtual void forceTemporaryAction(const std::string& action, double duration);

        virtual void unforceAction();

        virtual void setSpeed(float speed);

        virtual bool weaponDeployed() const;

        virtual void setWeaponDeployed(bool deployed);

        void setFullUpdateNeeded(bool updated);

        bool fullUpdateNeeded() const;

        virtual void die(const std::string& deathAction);

        virtual void revive(const std::string& aliveAction);

        virtual void setPaused(bool paused);

        bool paused() const;

        diguyCharacter* character();

        virtual void setPosture(int posture);

        bool autoGenerateActions() const;

        bool autoGenerateActionSpeed() const;

        virtual void setModelScalingEnabled( bool b );

        virtual void setIsSupportModel(bool isSupport);

        static void setDiGuyAttachGroup(osg::Group* diguy_attach_pt) {DiguyAttachGroup = diguy_attach_pt;}

        virtual void setEmbarked( bool embarkedState );
        virtual bool embarked() const;

        virtual void setScale(const DtVector & scale, float weightScale);
        virtual void setPartOrientation(int partNumber, 
            const DtTaitBryan& orientation, const DtVector& rotationalVelocity);
        virtual void setPartTranslation(int partNumber, 
            const DtVector& translation, const DtVector& velocity);
        virtual void setPartVisibility(int partNumber, bool visible);
        void updateAimingAndGaze();

        void setupGuides();
        diguyCharacterGuide * getGuide(){return myGuide;}
        void setGuide(diguyCharacterGuide * guide){myGuide = guide;}

        bool getVRForcesEntity(){return myVRForcesEntity;}

        void setupTopoConversion( const DtVector& location );
        // If coordinate system is geocentric, will output orientation and velocity values
        // That make sense in NED paradigm. Otherwise, output values will be the same
        // as input ones.
        void convertToLocalFrame(
            const DtVector32 & velocity, const DtTaitBryan& orientation, 
            DtVector32 &outVelocity, DtTaitBryan & outOrientation );

        bool getIsVehicle(){return m_vehicle;}

        DtDiGuyScenario & getScenario();

      virtual void setSelected(bool value);
      virtual void setTextureVariations(std::vector<DtCharacterTextureVariationInfo> & varationInfoArray, int force);

      virtual void setDynamicSensorRegion( const std::string& region, bool state );

      virtual bool dynamicSensorRegion( const std::string& region );

    protected:

        virtual void setSceneObjectIdOnCollisionBoxes();

        void slot_modelInstanceToBeDestroyed(DtModelInstance*, DtModel*);

        void slot_modelInstanceCreated(DtModelInstance*, DtModel*);            

        //helper function to update model instance when appearance/model changes
        virtual void updateModelInstance();


    protected:

        //void updateParticleSystem(const std::string& appearanceName);

        static osg::Group* DiguyAttachGroup;
        DtTaitBryan myOrientation;
        DtVector myPosition;

        diguyCharacter* myCharacter;
        diguyCharacterGuide * myGuide;

        bool myGenerateAutomaticActionFlag;
        bool myGenerateActionSpeedFlag;
        bool myWeaponDeployedFlag;
        bool myFullUpdateFlag;
        bool myEmbarkedFlag;
        bool myVRForcesEntity;
        bool myNeedsGuideInstalled;
        DtUniqueID mySceneObjectId;
        DtLastForceActionParams myLastForceAction;

        bool m_turreted_vehicle;
        bool m_vehicle;
        float m_aim_az; // azimuth
        float m_aim_el; // elevation
        float m_gaze_az;
        float m_gaze_el;

        bool myEnableAnimationSmoothing;

        //particle support
        DtParticleSystemModelAgent * myParticleAgent;
        DtSceneObjectAgent * mySceneObjectParticle;

        typedef boost::unordered_map<std::string, bool> SensorRegionStateMap;
        SensorRegionStateMap mySensorRegionMap;

    public:
        // For converting from geocentric frame of reference to topographic one
        DtCoordTransform m_geocToTopo;
        DtCoordTransform m_topoToGeoc;

#ifdef VISUALIZE_DIGUY_VELOCITY
        osg::ref_ptr<osg::Geometry> myDesiredPositionLine;
        osg::ref_ptr<osg::Geometry> myDesiredVelocityLine;
        osg::ref_ptr<osg::Geometry> myVelocityLine;
        osg::ref_ptr<osg::Geometry> myCordSys;
        osg::ref_ptr<osg::Geometry> myCurrentDesiredPositionLine;
        osg::ref_ptr<osg::Geode>    myVizualizers;
        osg::ref_ptr<osg::MatrixTransform>    myVizualizersTransform;
#endif
    };
}