DtCigiCharacterEntity.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCigi/DtCigiBaseEntity.h>

#include <makCigiExtensions/DtCigiDiGuyCtrl.h>
#include <makCigiExtensions/DtCigiDiGuyCtrlExt.h>

#include <vrvCore/DtCharacterModel.h>

#include <boost/unordered_map.hpp>

namespace makVrv
{

   class DtCharacterModelAgent;
   class DtCharacterModel;
   class DtSceneObjectAgent;
   class DtSurfaceClampingUpdaterAgent;
   class DtWaterClampingUpdaterAgent;

   namespace EntityStateListener
   {
      enum class WeaponState;
   }

   class DT_DLL_VRVCIGI DtCigiCharacterEntity : public DtCigiBaseEntity
   {
   public:

      DtCigiCharacterEntity(DtCigiConnection& connection,
         DtAgentManagerInterface& sceneInterface, int entityId, int entityType);

      virtual ~DtCigiCharacterEntity();

      virtual void init();

      virtual void uninit();

      virtual void restart();

      virtual void setPosition(const DtGeodeticCoord& pos, bool force=false);

      virtual void setOrientation(const DtTaitBryan& orientation, bool force=false);

      virtual void setCharacterPaused( bool paused );

      virtual void setCharacterActionSpeed( float speed );

      virtual void unforceAction();

      virtual void setCharacterAction( const std::string& action );

      virtual void setCharacterAction( const std::string& action, bool paused,
         double speed, bool usePositioning, const DtVector& offset );

      virtual void setCharacterPosture( DtCharacterModel::Posture posture );

      virtual void setWeaponState( EntityStateListener::WeaponState state );

      virtual EntityStateListener::WeaponState weaponState() const;

      virtual void setAlive( bool alive );

      virtual bool alive() const;

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

      virtual void endGesture(const std::string& gestureName, float rampDown);

      virtual void setItemAppearance( const std::string& itemAppearance );

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

      virtual void setHeadAppearance( const std::string& headAppearance );

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

      virtual void setCharacterScale( const DtVector& scale );

      // Get the character scale
      virtual const DtVector& characterScale() const;

      virtual void setCharacterWeight( float characterWeight );

      virtual float characterWeight() const;

      virtual void setWaterlineOriginOffset( float offset );

      virtual void startEmbarked();

      virtual void endEmbarked();

      virtual void setArtPartTranslation(int partId, float xOffset, float yOffset,
         float zOffset, bool xEnable, bool yEnable, bool zEnable);

      virtual void setArtPartOrientation(int partId, float yaw, float pitch, float roll,
         bool yawEnable, bool pitchEnable, bool rollEnable);

      virtual void setArtPartLinearRate(int partId, float xRate, float yRate,
         float zRate);

      virtual void setArtPartAngularRate(int partId, float yawRate, float pitchRate,
         float rollRate);

      virtual void setArtPartEnable(int partId, bool trueFalse);

      virtual void setIsAmphibious(bool isAmphibious);
      virtual bool isAmphibious() const;

      virtual bool gestureInitialRepetitions(const std::string& gestureName, int& reps) const;

      virtual bool gestureInitialDuration(const std::string& gestureName, float& duration) const;

      virtual bool gestureChannelAWeight(const std::string& gestureName, float& weight) const;


   protected:
      virtual void startDeadReckoning();

      virtual void endDeadReckoning();

      virtual void startGroundClamping();

      virtual void endGroundClamping();

   protected:
      DtCharacterModelAgent* myCharacterModel;
      EntityStateListener::WeaponState myWeaponState;
      bool myAlive;

      std::string myCharacterAction;
      bool myCharacterPaused;
      float myCharacterActionSpeed;
      bool myCharacterActionUsesPositioning;
      DtVector myCharacterActionOffset;

      DtCharacterModel::Posture myPosture;
      float myWaterlineOriginOffset;
      std::string myItemAppearance;
      std::string myHeadAppearance;
      DtVector myCharacterScale;
      float myCharacterWeight;
      bool myIsAmphibious;

      typedef struct gestureData
      {
         int repetitions;  // Note the character interface doesn't give us a way to know how many repetitions
                           // might have already happened (or for what duration).  The best a connection 'restart'
                           // can do is restart a current gesture with it's initial values
         float duration;
         float channelAWeight;
      } GestureData;

      typedef boost::unordered_map<std::string, GestureData> GestureDataMap;

      GestureDataMap myGestureDataMap;

      DtSurfaceClampingUpdaterAgent* mySurfaceClampingUpdaterAgent;
      DtWaterClampingUpdaterAgent* myWaterClampingUpdaterAgent;
   };

   typedef DtCigiObjectCreatorTemplate<DtCigiCharacterEntity>
      DtCigiCharacterEntityCreator;
}