DtDiGuyCharacterModel.h

Go to the documentation of this file.

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


#pragma once

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

#include <matrix/topoCoord.h>

#include <boost/unordered_map.hpp>

//#define VISUALIZE_DIGUY_VELOCITY

class diguyCharacter;
class diguyCharacterGuide;
class diguyGraphicsLink;

namespace osg
{
   class Group;
}

namespace makVrv
{
   class DtDeadReckonUpdater;

   class DtDiGuyOsgGraphicsLink;
   class DtDiGuyScenario;
   class DtDiGuyMotionModel;

   class DtOsgSceneConnector;
   class DtSceneObject;
   class DtSceneObjectAgent;
   class DtSceneObjectUpdater;
   class DtOsgGizmoRenderer;
   struct DtDiguyLightConfig;


   struct DtLastForceActionParams
   {
      DtLastForceActionParams()
         : myName()
         , mySpeed( 0 )
         , myUsePositioning( false )
         , myOffset( 0, 0, 0 )
         , myAutoTransition( 0 )
         , myTransitionSpeed( 0 )
      {
      }

      std::string myName;
      float mySpeed;
      bool myUsePositioning;
      DtVector myOffset;
      int myAutoTransition;
      float myTransitionSpeed;

   };


// for debugging
    struct DtDiGuyDebugEventStream
    {
        std::string m_action;
        double m_time;
    };

   struct DT_DLL_VRVDIGUY DtDiGuyLightRtInfo
   {
      DtDiGuyLightRtInfo()
         : myDesc( nullptr )
         , myLink( nullptr )
         , myIndex( -1 )
         , myActive( false )
         , myConnectionPoint( false )
      {
      }

      const DtDiguyLightConfig* myDesc;

      // runtime data

      diguyGraphicsLink* myLink;
      osg::Matrix myOffsetMat;
      int myIndex;
      bool myActive;
      bool myConnectionPoint;
   };
   
   
   class DT_DLL_VRVDIGUY DtDiGuyCharacterModel : public DtCharacterModel
   {
   public:

      DtDiGuyCharacterModel(DtDe& de, DtUniqueID id);

      virtual ~DtDiGuyCharacterModel();

   private:
      DtDiGuyCharacterModel(const DtDiGuyCharacterModel&) = delete;
      DtDiGuyCharacterModel& operator=(const DtDiGuyCharacterModel&) = delete;

   public:

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

      virtual void discoverDynamicRegions(const DtModelDefinition* definition);

      diguyCharacter* character();

      DtDiGuyScenario& getScenario();

      virtual const std::string& className() const;

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

      virtual void removeFromScene();

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

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

      virtual void setPositionOffset(const DtVector& position);

      virtual void setOrientation(int vtx, const DtTaitBryan& orientation);
      const DtTaitBryan& getOrientation() { return myWorldOrientation; }

      virtual void setOrientationOffset(const DtTaitBryan& orientationOffset);

      virtual void setPositionAndOrientation(int vtx, const DtVector& position, const DtTaitBryan& orientation);


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


      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 setCharacterEquipment( const std::string& appearanceName );

      virtual void setUnit( unsigned short country, unsigned char service, unsigned short patch, bool setPersonal ) override;
      virtual void setPersonalUnit( unsigned short country, unsigned char service, unsigned short patch ) override;
      virtual void setRank( unsigned short country, unsigned char service, unsigned short patch ) override;
      virtual void setCharacterName( const std::string& name ) override;


      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 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 setEnableAnimationSmoothing(bool);

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

      virtual void fireWeapon();

      virtual void forceAction( const std::string& action, float speed, bool usePositioning,
         const DtVector& offset, int autoChooseTransitionBehavior, float transitionSpeedScale );

      virtual int currentArcChangeCb(diguyCharacter* character);

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

      virtual void unforceAction();

      virtual void setSpeed(float speed);

      virtual void setPosture(int posture);

      virtual bool weaponDeployed() const override;

      virtual EntityStateListener::WeaponState weaponState() const override;

      virtual void setWeaponState(EntityStateListener::WeaponState deployed) override;


      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;

      virtual  bool getVRForcesEntity() { return myVRForcesEntity; }

      bool autoGenerateActions() const;

      bool autoGenerateActionSpeed() const;

      virtual void setModelScalingEnabled(bool b);

      virtual void setIsSupportModel(bool isSupport);

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

      virtual void setStationName(int name);
      virtual int getStationName() const;

      virtual void setStationNumber(DtU16 number);

      virtual void setScale(const DtVector& scale);
      virtual void setWeight(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 setLinkRotationOverride(const std::string& linkName, const DtTaitBryan& rotation,
         float rampTime);

      virtual void setLinkTranslationOverride(const std::string& linkName, const DtVector& offsets,
         float rampTime);

      virtual void setPartVisibility(int partNumber, bool visible);
      void updateAimingAndGaze();

      void setupGuides();
      virtual diguyCharacterGuide* getGuide();
      virtual void setGuide(diguyCharacterGuide* guide);
      
      virtual void setupCoordSystem(const DtVector& vrvLoc, bool overrideEmbarked = false);

      virtual bool getAndResetTerrainHasChangedBit();

      virtual void setTerrainHasChanged();

      // 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; }

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

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

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

      virtual DtVector positionOffsetWorld();

      virtual bool hasPositionOffset();

      virtual DtTaitBryan orientationOffsetWithBase(const DtTaitBryan& baseOri);

      virtual bool hasOrientationOffset();

      virtual void setUseTransitions(bool use);

      virtual bool useTransitions();

      virtual void setEnabled(bool enabled);

      virtual bool enabled();

      virtual void setIsOccupant(bool occupant);

      virtual bool occupant();

      virtual DtSceneObject* sceneObject() { return mySceneObject; }

      virtual bool isPostureTransitioning();

      virtual bool usingActionPositioningFlag();

      virtual void updateLights();

      virtual void resetLightsWithLink(DtDiGuyOsgGraphicsLink* link);

      virtual void draw_character_skeleton(DtOsgGizmoRenderer* renderer);

      virtual void draw_movement_info(DtOsgGizmoRenderer* renderer);

      std::vector<DtDiGuyLightRtInfo>& lights();

      // not active yet
      const std::list< DtDiGuyDebugEventStream>& recentActions() { return myRecentActions; }
      const std::list< DtDiGuyDebugEventStream>& recentHandItems() { return myRecentHandItems; }
   
   public:
      static void setDiGuyAttachGroup(osg::Group* diguy_attach_pt) { DiguyAttachGroup = diguy_attach_pt; }

   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();

      virtual void setMotionModelByName(const std::string& modelName);

      virtual void updateVisibility();

      virtual void createLights(int id);


   protected:

      DtDiGuyScenario* myDtScenario;

      DtTaitBryan myWorldOrientation;
      DtVector myWorldPosition;

      diguyCharacter* myCharacter;
      diguyCharacterGuide* myGuide;

      int myStationName;

      bool myUsingActionPositioningFlag;
      bool myGenerateAutomaticActionFlag;
      bool myGenerateActionSpeedFlag;
      EntityStateListener::WeaponState myWeaponState;
      bool myFullUpdateFlag;
      bool myEmbarkedFlag;
      bool myVRForcesEntity;
      bool m_turreted_vehicle;
      bool m_vehicle;
      DtUniqueID mySceneObjectId;
      DtLastForceActionParams myLastForceAction;

      // For positionOffset so that it can
      // get a good initial orientation
      DtSceneObject* mySceneObject;

      float m_aim_az; // azimuth
      float m_aim_el; // elevation
      float m_gaze_az;
      float m_gaze_el;
      bool m_character_can_aim;

      bool myEnableAnimationSmoothing;
      bool myTerrainHasChanged;

      // Perform transitions and ramp downs
      // between animations (for occupants / drivers)
      bool myUseTransitions;

      // Is this DI-Guy an occupant / driver
      bool myIsOccupant;

      bool myEnabled;
      //bool myUseGeocentricCoords;
      bool mySelected;

      bool myCouldBePostureTransitioning;

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

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

      std::list< DtDiGuyDebugEventStream> myRecentActions;
      std::list< DtDiGuyDebugEventStream> myRecentHandItems;

#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

      std::list<std::string> myAliveStateDynamicRegions;
      std::list<std::string> myWeaponFireDynamicRegions;

   protected:
      static osg::Group* DiguyAttachGroup;

   };

}