DtDiGuyCharacterModel.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2019 VT MAK
 * 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;

namespace osg
{
   class Group;
}

namespace makVrv
{
   class DtSceneObjectAgent;
   class DtDiGuyScenario;
   class DtOsgSceneConnector;
   class DtSceneObject;
   class DtSceneObjectUpdater;
   class DtDiGuyMotionModel;
   class DtDeadReckonUpdater;

   DtTaitBryan vrvToDiGuyOrientationChar(const DtTaitBryan& hpr);

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

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

   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, 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 const 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, bool usePositioning,
         const DtVector& offset, int autoChooseTransitionBehavior);

      virtual int currentArcChangeCb(diguyCharacter* character);

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

      virtual void setLinkRotationOverride(const std::string& linkName, const DtTaitBryan& rotation,
         float rampTime);

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

      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);
      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 setPartVisibility(int partNumber, bool visible);
      void updateAimingAndGaze();

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

      bool getVRForcesEntity() { return myVRForcesEntity; }

      virtual void setupCoordSystem(const DtVector& vrvLoc, bool overrideEmbarked = false);

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

      virtual DtVector positionOffsetWorld();

      virtual bool hasPositionOffset();

      virtual DtTaitBryan orientationOffsetWithBase(const DtTaitBryan& baseOri);

      virtual bool hasOrientationOffset();

      virtual void setUseTransitions(bool use);

      bool useTransitions();

      virtual void setEnabled(bool enabled);

      bool enabled();

      virtual void setIsOccupant(bool occupant);

      bool occupant();

      //virtual bool useGeocentricCoords() { return myUseGeocentricCoords; }

      virtual DtSceneObject* sceneObject() { return mySceneObject; }

      virtual bool isPostureTransitioning();

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


   protected:

      static osg::Group* DiguyAttachGroup;
      DtDiGuyScenario* myDtScenario;

      DtTaitBryan myWorldOrientation;
      DtVector myWorldPosition;

      diguyCharacter* myCharacter;
      diguyCharacterGuide* myGuide;

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

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

      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 m_character_can_aim;

      bool myEnableAnimationSmoothing;

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

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

      bool myCouldBePostureTransitioning;

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

}