humanRenderUpdater.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*****************************************************************************/
//! \file humanRenderUpdater.h
//! \brief Defines DtHumanRenderUpdater for managing human-specific rendering and visual effects
//! \ingroup vreHumanFrontend
 
#pragma once
 
#include "vreHumanFrontend/export.h"
 
#include "vrePlayerStation/playerComponent.h"
#include "vreUtil/coordConverter.h"
 
#include "vreCommonComponents/stateDefines.h"
 
#include "vreMessageManager/vreMessage.h"
 
#include <vrvCore/DtUniqueID.h>
 
class diguyCharacter;
 
namespace makVrv
{
//! \brief Forward declaration of the display element class
class DtDe;
 
//! \brief Forward declaration of the character model agent class
class DtCharacterModelAgent;
 
//! \brief Forward declaration of the scene object agent class
class DtSceneObjectAgent;
 
//! \brief Forward declaration of the scene object class
class DtSceneObject;
 
//! \brief Forward declaration of the dead reckon updater agent class
class DtDeadReckonUpdaterAgent;
 
//! \brief Forward declaration of the dead reckon updater class
class DtDeadReckonUpdater;
 
//! \brief Forward declaration of the terrain scaling updater class
class DtTerrainScalingUpdater;
 
//! \brief Forward declaration of the OSG channel class
class DtOsgChannel;
}; // namespace makVrv
 
namespace HumanRenderUpdaterConfig
{
//! \ingroup RoleConfigParams
//! \defgroup HumanRenderUpdaterRoleParams Human Render Updater Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for human render updater role.
//! @{
 
//! \vreRoleParamRequired{firstPersonModelMap,DtInitTable,humanRenderUpdater,"Table",Mapping between weapons and model definitions for first-person view.}
constexpr const char* firstPersonModelMap = "firstPersonModelMap";
 
//! \vreRoleParam{healthEffectHealthMaximum,double,0.85,humanRenderUpdater,Maximum health value for health effect visibility.}
constexpr const char* healthEffectHealthMaximum = "healthEffectHealthMaximum";
 
//! \vreRoleParam{healthEffectHealthMinimum,double,0.15,humanRenderUpdater,Minimum health value for health effect visibility to prevent screen from going completely opaque.}
constexpr const char* healthEffectHealthMinimum = "healthEffectHealthMinimum";
 
//! \vreRoleParam{healthEffectOpacityMaximum,double,0.4,humanRenderUpdater,Maximum opacity value for health effects overlay.}
constexpr const char* healthEffectOpacityMaximum = "healthEffectOpacityMaximum";
 
//! \vreRoleParam{hideFirstPersonModelWhileAiming,bool,false,humanRenderUpdater,Whether to hide the first-person player model when aiming. Not applicable in VR mode.}
constexpr const char* hideFirstPersonModelWhileAiming = "hideFirstPersonModelWhileAiming";
 
//! \vreRoleParam{hitEffectDuration,double,4.0,humanRenderUpdater,Duration of hit effects in seconds.}
constexpr const char* hitEffectDuration = "hitEffectDuration";
 
//! @}
} // namespace HumanRenderUpdaterConfig
 
namespace makVre
{
//! \brief Forward declaration of the first-person updater agent class
class DtFpsFirstPersonUpdaterAgent;
 
//! \brief Forward declaration of the orientation updater agent class
class DtFpsOrientationUpdaterAgent;
 
//! \brief Type identifier constant for DtHumanRenderUpdater components
//!
//! This constant defines the string identifier used to identify DtHumanRenderUpdater
//! component types within the VR-Engage framework. It is used for component
//! registration, type checking, and serialization operations.
constexpr const char* DtHumanRenderUpdaterType = "DtHumanRenderUpdater";
 
//! \brief DtHumanRenderUpdater manages model and visual effects for Human role player.
//!
//! The primary function of this class is management of first person arms and gun model.
//! This class owns the first person model agent and first person mimic model updater,
//! and is responsible for selecting the appropriate first person model depending on
//! active gun and/or equipment, hiding or showing the model based on 1st/3rd person
//! view mode or other condition such as death, (re)positioning model relative to camera
//! based on posture, and setting aiming and firing state of first person model when
//! necessary. This class also manages overlay effects such as sniper rifle sights and
//! blood overlay effects that indicate when and from where the player is taking hits.
class HUMAN_DLL DtHumanRenderUpdater : public makVre::DtPlayerComponent
{
public:
   //! \brief Default constructor
   DtHumanRenderUpdater();
 
   //! \brief Virtual destructor
   virtual ~DtHumanRenderUpdater() override;
 
   //! \brief Initializes the render updater component
   //! \param player Pointer to the player station
   //! \param config Configuration settings for initialization
   //! \return True if initialization was successful, false otherwise
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
 
   //! \brief Updates rendering elements for the current frame
   //! \param dt Delta time since the last frame in seconds
   virtual void tick(double dt) override;
 
   //! \brief Cleans up resources when the component is being shut down
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return String identifier for this component type
   //!
   //! Returns the type identifier string for this component, which is used
   //! by the VR-Engage framework for component identification and management.
   //! The returned value matches DtHumanRenderUpdaterType.
   virtual const char* type() const override;
 
   //! \brief Shows the first-person model
   void showFirstPerson();
 
   //! \brief Hides the first-person model
   void hideFirstPerson();
 
   //! \brief Shows the third-person model
   void showThirdPerson();
 
   //! \brief Sets the visibility of the third-person model
   //! \param visible True to show the model, false to hide it
   void setThirdPersonVisible(bool visible);
 
   //! \brief Sets the offset of the first-person model
   //! \param translation Translation offset vector
   //! \param rotation Rotation offset in Tait-Bryan angles
   void setFirstPersonModelOffset(DtVector translation, DtTaitBryan rotation = DtTaitBryan());
 
   //! \brief Finds the appropriate first-person model offset for the given state
   //! \param posture Current human posture
   //! \param aiming True if the player is currently aiming
   //! \param usingVr True if VR mode is active
   //! \param translation [out] Pointer to receive the translation offset, can be nullptr
   //! \param rotation [out] Pointer to receive the rotation offset, can be nullptr
   //! \return True if offsets were found, false otherwise
   bool findFirstPersonModelOffset(HumanPosture posture, bool aiming, bool usingVr, DtVector* translation = nullptr,
      DtTaitBryan* rotation = nullptr);
 
protected:
   //! \brief Enumeration of hit effect positions
   //!
   //! Used to track the timers for each hit effect location
   using HitEffectEnum = enum {
      HIT_EFFECT_LEFT_SIDE,     //!< Hit effect on the left side of the screen
      HIT_EFFECT_RIGHT_SIDE,    //!< Hit effect on the right side of the screen
      HIT_EFFECT_ALL_SIDES,     //!< Hit effect on all sides of the screen
      HIT_EFFECT_NUMBER_EFFECTS //!< Total number of hit effect types (must be last)
   };
 
 
   //! \brief Initializes render objects like models and effects
   //! \return True if initialization was successful, false otherwise
   bool initializeRenderObjects();
 
   //! \brief Clears any active scene selections
   void clearSceneSelection();
 
   //! \brief Configures dead reckoning and movement smoothing
   void configureDeadReckoningAndSmoothing();
 
   //! \brief Updates blood sight (damage) overlay effects
   void updateBloodSightEffects();
 
   //! \brief Updates the first-person model state and position
   //! \param dt Delta time since the last frame in seconds
   void updateFirstPersonModel(double dt);
 
   //! \brief Updates the third-person model state and position
   //! \param dt Delta time since the last frame in seconds
   void updateThirdPersonModel(double dt);
 
   //! \brief Updates aiming-related visual effects
   void updateAimingEffects();
 
   //! \brief Updates equipment-related visual effects
   void updateEquipmentEffects();
   //! \brief Updates health-related visual effects
   //!
   //! Updates the effect that shows when the human's damage state is slight or moderate
   void updateHealthEffects();
 
   //! \brief Updates hit-related visual effects
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Updates the hit effect when the human is hit by a munition. It shows effects on
   //! the right, left, or all corners of the GUI.
   void updateHitEffects(double dt);
 
   //! \brief Starts a hit effect timer
   //! \param hitEffect The hit effect type to start
   virtual void startHitEffect(HitEffectEnum hitEffect);
 
   //! \brief Stops a hit effect timer
   //! \param hitEffect The hit effect type to stop
   virtual void stopHitEffect(HitEffectEnum hitEffect);
 
   //! \brief Handles fire messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   virtual makVre::DtVreMessageResult handleFireMessage(makVre::DtVreMessage* msg);
 
   //! \brief Handles detonation location messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   virtual makVre::DtVreMessageResult handleReportDetonationLocationMessage(makVre::DtVreMessage* msg);
 
   //! \brief Handles changes in player health
   //! \param val New health value
   void onHealthChanged(double val);
 
   //! \brief Looks up the dead reckoning updater for a scene object
   //! \param myDisSceneObject Pointer to the scene object
   //! \return Pointer to the dead reckoning updater, or nullptr if not found
   const makVrv::DtDeadReckonUpdater* lookupDeadReckonUpdater(makVrv::DtSceneObject* myDisSceneObject);
 
   //! \brief Handles scene object deletion notifications
   //! \param id Unique ID of the scene object being deleted
   virtual void slot_disSceneObjectToBeDeleted(const makVrv::DtUniqueID& id);
 
   //! \brief Duration of hit effects in seconds
   double myHitEffectDuration;
 
   //! \brief Minimum health value for health effect visibility
   //!
   //! The minimum health that the health effect will change. Don't want the screen to go completely opaque
   double myHealthEffectHealthMinimum;
 
   //! \brief Maximum health value for health effect visibility
   //!
   //! The maximum health that the health effect will change
   double myHealthEffectHealthMaximum;
 
   //! \brief Maximum opacity value for health effects
   double myHealthEffectOpacityMaximum;
 
   //! \brief Mapping between weapons and model definitions
   DtInitTable myFirstPersonModelMap;
 
   //! \brief Configuration table for first-person models
   DtInitTable myFirstPersonModelTable;
 
   //! \brief Agent managing the first-person character model
   makVrv::DtCharacterModelAgent* myFirstPersonModelAgent;
 
   //! \brief Agent managing the first-person scene object
   makVrv::DtSceneObjectAgent* myFirstPersonSceneObjectAgent;
 
   //! \brief Agent managing first-person model updates
   DtFpsFirstPersonUpdaterAgent* myFirstPersonUpdaterAgent;
 
   //! \brief Agent managing orientation updates
   DtFpsOrientationUpdaterAgent* myOrientationUpdaterAgent;
 
   //! \brief Main scene object for the player entity
   makVrv::DtSceneObject* myDisSceneObject;
 
   //! \brief Current weapon identifier
   std::string myDisGun;
 
   //! \brief Current appearance identifier
   std::string myDisAppearance;
 
   //! \brief Finds the appropriate first-person model definition
   //! \param gun Current weapon identifier
   //! \param appearance Current appearance identifier
   //! \return Model definition identifier string
   std::string findFirstPersonModelDef(const std::string& gun, const std::string& appearance);
 
   //! \brief Finds the DI-Guy character for the player
   //! \return Pointer to the DI-Guy character, or nullptr if not found
   diguyCharacter* findDisDiguyCharacter();
 
   //! \brief Flag indicating if first-person view is currently shown
   bool myShowingFirstPerson;
 
   //! \brief Current posture of the arms model
   int myArmsPosture;
 
   //! \brief Flag indicating if weapon is in the down position
   bool myWeaponDown;
 
   //! \brief Last known aiming state
   bool myLastKnownAiming;
 
   //! \brief Flag indicating if render objects have been initialized
   bool myRenderObjectsInitialized;
 
   //! \brief Flag indicating if first-person objects have been initialized
   bool myFirstPersonObjectsInitialized;
 
   //! \brief Pointer to the main rendering channel
   makVrv::DtOsgChannel* myChannel;
 
   //! \brief Time when the sight effect should end
   double myEndSightEffect;
 
   //! \brief Last known equipment state
   Equipment myLastKnownEquipment;
 
   //! \brief Delay before switching models in seconds
   double myModelSwitchDelay;
 
   //! \brief Delay before showing models in seconds
   double myModelShowDelay;
 
   //! \brief Current pitch angle of the arms model
   double myArmsPitch;
 
   //! \brief Additional pitch angle for arc aiming
   double myArcPitchAddition;
 
   //! \brief Pitch offset for the first-person model
   double myFirstPersonModelPitchOffset;
 
   //! \brief Heading (yaw) offset for the first-person model
   double myFirstPersonModelHeadingOffset;
 
   //! \brief Flag indicating if VR mode is active
   bool myUsingVr;
 
   //! \brief Flag indicating whether to hide the first-person player model while aiming (not applicable in VR)
   DtAttributeHandleType<bool> myHideFirstPersonModelWhileAiming;
 
   //! \brief Tracks whether first-person model was visible before entering aiming mode
   bool myFirstPersonVisibleBeforeAiming;
 
   //! \brief Enumeration of hit effect states
   //!
   //! These states are necessary to have interruptible hit effects
   using HitEffectState = enum {
      HIT_EFFECT_STATE_OFF,      //!< Hit effect is disabled
      HIT_EFFECT_STATE_ON,       //!< Hit effect is enabled
      HIT_EFFECT_STATE_INTERRUPT //!< Hit effect is being interrupted
                                 //!< This state is used to give the Post Processor state to run once when
                                 //!< the post processor effect is disabled. This allows its state machine
                                 //!< to reset and the effect to play correctly when interrupted.
   };
 
   //! \brief Structure containing hit effect information
   struct HitEffectInfo
   {
      //! \brief Default constructor
      HitEffectInfo()
         : hitEffectState(HIT_EFFECT_STATE_OFF)
         , timer(0.0)
      {
      }
 
      std::string effectName;        //!< The Post Processor name. Used to enable/disable the effect.
      double timer;                  //!< The timer to determine when the effect should be removed.
                                     //!< This timer needs to be coordinated with any front-end timers.
      HitEffectState hitEffectState; //!< Current state of this hit effect
   };
 
   //! \brief Collection of hit effects and their information
   //!
   //! Timer used to control the hit effect which appears in the corners of the GUI
   std::vector<std::pair<HitEffectEnum, HitEffectInfo>> myHitEffect;
};
}; // namespace makVre