aimPointTickable.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file aimPointTickable.h
//! \brief Defines a tickable component that manages aim point visualization
//!
//! This file contains the DtAimPointTickable class which provides functionality
//! to visualize and update an aim point or targeting reticle for entities in the
//! simulation. It periodically updates the aim point position and appearance
//! based on the target entity's location and orientation.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include "vreUtil/attribute.h"
 
#include <vrvCore/DtTickable.h>
 
namespace makVrv
{
class DtSceneObjectAgent;
class DtChannelManager;
class DtChannel;
} // namespace makVrv
 
namespace makVre
{
//! \brief Tickable component that manages aim point visualization
//!
//! DtAimPointTickable is a component that updates the visualization of an aim point
//! or targeting reticle associated with a specified scene object (typically a weapon
//! or targeting system). It inherits from DtTickable, allowing it to receive regular
//! update calls from the display engine's main loop. This is used to provide visual
//! feedback for aiming and targeting in the simulation.
class PLAYERSTATION_DLL DtAimPointTickable : public makVrv::DtTickable
{
public:
   //! \brief Orientation options for the aim point
   //!
   //! Defines how the aim point should be oriented in the 3D scene.
   enum Orientation
   {
      UP,             //!< Aim point is oriented upward regardless of view direction
      TOWARD_OBSERVER //!< Aim point is oriented to face the observer/camera
   };
 
   //! \brief Screen scaling options for the aim point
   //!
   //! Defines how the aim point size should be adjusted relative to the screen.
   enum ScreenScale
   {
      SCALED,  //!< Aim point size scales with distance (appears smaller at greater distances)
      CONSTANT //!< Aim point size remains constant regardless of distance
   };
 
   //! \brief Constructor
   //! \param de Reference to the display engine
   //! \param state Reference to the attribute handle for state tracking
   //! \param ori Orientation option for the aim point
   //! \param screenScale Scaling option for the aim point
   //!
   //! Creates a new aim point tickable component associated with the specified
   //! display engine and attribute state. The orientation and screen scaling
   //! options control the appearance of the aim point.
   DtAimPointTickable(
      makVrv::DtDe& de, DtAttributeHandle& state, Orientation ori = UP, ScreenScale screenScale = SCALED);
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of resources used by derived classes.
   virtual ~DtAimPointTickable() override;
 
   //! \brief Updates the aim point
   //! \param tNow Current simulation time
   //!
   //! Called by the tickable manager to update the aim point visualization.
   //! This method updates the aim point's position, orientation, and appearance
   //! based on the target scene object's current state. If no scene object is set,
   //! this method does nothing.
   virtual void update(DtTime tNow) override;
 
   //! \brief Checks if an update is needed
   //! \param tNow Current simulation time
   //! \return True if an update should be performed, false otherwise
   //!
   //! Determines whether the aim point needs to be updated at the current time.
   //! This helps optimize performance by avoiding unnecessary updates.
   virtual bool needsUpdate(DtTime tNow) override;
 
   //! \brief Sets the target scene object
   //! \param obj Pointer to the scene object to associate with the aim point
   //!
   //! Sets the scene object that the aim point should be associated with. This can be
   //! changed at any time to switch the aim point to a different entity. Setting
   //! this to NULL disables the aim point visualization.
   virtual void setSceneObject(makVrv::DtSceneObjectAgent* obj);
 
protected:
   //! \brief Performs the actual aim point update
   //!
   //! Internal method that performs the actual work of updating the aim point
   //! visualization based on the current state of the target scene object.
   //! This handles positioning, orientation, and scaling of the aim point.
   virtual void actualUpdate();
 
   //! \brief Time of the last update
   DtTime myLastUpdatedTime;
 
   //! \brief Reference to the attribute handle for state tracking
   DtAttributeHandle myState;
 
   //! \brief Reference to the display engine
   makVrv::DtDe& myDe;
 
   //! \brief Target scene object to associate with the aim point
   makVrv::DtSceneObjectAgent* mySceneObject;
 
   //! \brief Current screen scaling option
   ScreenScale myScreenScale;
 
   //! \brief Current orientation option
   Orientation myOrientation;
 
   //! \brief Flag indicating whether model depth has been initialized
   bool myInitModelDepth;
 
   //! \brief Flag indicating whether scaling has been initialized
   bool myInitializedScaling;
};
} // namespace makVre