pilotRenderUpdater.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file pilotRenderUpdater.h
//! \brief Defines render components for the pilot role including instrument displays
//! \ingroup vrePilotFrontend
 
#pragma once
 
#include <vrePlayerStation/playerComponent.h>
#include "vreUtil/attribute.h"
 
#include <vreMessageManager/vreMessage.h>
#include <vreMessages/sensorData.h>
 
#include <vrvOsg/DtChannelSpecificGroup.h>
#include <vrvUtil/DtChannelConfiguration.h>
 
#include <osg/Node>
#include <osg/NodeVisitor>
#include <osg/Texture2D>
#include <osg/BoundingBox>
 
#include <vrePilotFrontend/export.h>
 
namespace makVre
{
 
namespace PilotRenderUpdaterConfig
{
//! \ingroup RoleConfigParams
//! \defgroup PilotRenderUpdaterRoleParams Pilot Render Updater Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for pilot render updater component.
//! @{
 
//! \vreRoleParam{liveTextures,table,{},pilotRenderUpdater,Configuration table for live texture definitions used in cockpit displays and instruments.}
constexpr const char* liveTextures = "liveTextures";
 
//! \vreRoleParam{renderCockpitGeometryOnly,bool,false,pilotRenderUpdater,Whether to render only the cockpit geometry without other scene elements.}
constexpr const char* renderCockpitGeometryOnly = "renderCockpitGeometryOnly";
 
//! @}
} // namespace PilotRenderUpdaterConfig
 
} // namespace makVre
 
namespace makVrv
{
//! \brief Forward declaration of the display element class
class DtDe;
 
//! \brief Forward declaration of the model definition class
class DtModelDefinition;
 
//! \brief Forward declaration of the model instance class
class DtModelInstance;
 
//! \brief Forward declaration of the scene object class
class DtSceneObject;
 
//! \brief Forward declaration of the scene object agent class
class DtSceneObjectAgent;
 
//! \brief Forward declaration of the articulated model agent class
class DtArticulatedModelAgent;
 
//! \brief Forward declaration of the OSG observer object class
class DtOsgObserverObject;
 
//! \brief Forward declaration of the observer class
class DtObserver;
 
//! \brief Forward declaration of the channel-specific group class
class DtChannelSpecificGroup;
 
//! \brief Forward declaration of the channel class
class DtChannel;
}; // namespace makVrv
 
namespace makVre
{
//! \brief Forward declaration of the entity resolver class
class DtEntityResolver;
 
//! \brief Forward declaration of the instrument panel manager class
class DtInstrumentPanelManager;
 
//! \brief Forward declaration of the scene object mimic updater agent class
class DtSceneObjectMimicUpdaterAgent;
 
//! \brief Forward declaration of the camera structure
struct DtCameraStruct;
 
//! \brief Node visitor for replacing instrument textures in cockpit models
//!
//! DtInstrumentTextureReplacer traverses a scene graph to find and replace
//! specific textures with render-to-texture (RTT) displays for aircraft instruments.
//! It can also collect geometry information about the textures for proper positioning.
class PILOT_DLL DtInstrumentTextureReplacer : public osg::NodeVisitor
{
public:
   //! \brief Constructor
   //! \param targetTextureName Name of the texture to replace
   //! \param replacementTexture Reference to the replacement texture
   //! \param isHud Flag indicating if this is a HUD texture
   //! \param findPosition Flag indicating whether to collect geometry information
   //! \param overrideNormal Optional normal vector to override the calculated normal
   DtInstrumentTextureReplacer(const std::string& targetTextureName, osg::ref_ptr<osg::Texture2D> replacementTexture,
      bool isHud = false, bool findPosition = false, const osg::Vec3* overrideNormal = NULL);
 
   //! \brief Virtual destructor
   virtual ~DtInstrumentTextureReplacer() override;
 
   //! \brief The visitor apply method used to traverse the scene-graph
   //! \param node The osg::Node being visited
   //!
   //! Called during scene-graph traversal. Do not directly call this function.
   virtual void apply(osg::Node& node) override;
 
   //! \brief The visitor apply method for geodes
   //! \param geode The osg::Geode being visited
   //!
   //! Called during scene-graph traversal. Do not directly call this function.
   //! Currently commented out and not used.
   //       virtual void apply(osg::Geode& geode);
 
   //! \brief Checks if the target texture was found
   //! \return True if the target texture was found, false otherwise
   bool foundTarget() const;
 
   //! \brief Gets the normal vector of the target geometry
   //! \return Normal vector of the target geometry
   osg::Vec3 targetNormal() const;
 
   //! \brief Gets the minimum bounds of the target geometry
   //! \return Minimum bounds vector
   osg::Vec3 targetBoundsMin() const;
 
   //! \brief Gets the maximum bounds of the target geometry
   //! \return Maximum bounds vector
   osg::Vec3 targetBoundsMax() const;
 
protected:
   //! \brief Replaces a texture in the given state set
   //! \param ss State set containing the texture to replace
   //! \param node Node associated with the state set
   //! \return True if the texture was replaced, false otherwise
   virtual bool replaceTexture(osg::StateSet& ss, osg::Node& node);
 
   //! \brief Collects geometry information for the target texture
   //! \param node Node containing the geometry
   //! \param nodePath Path to the node in the scene graph
   //! \return True if geometry was collected, false otherwise
   virtual bool collectGeometry(const osg::Node& node, const osg::NodePath& nodePath);
 
   //! \brief Name of the texture to replace
   std::string myTargetTextureName;
 
   //! \brief Reference to the replacement texture
   osg::ref_ptr<osg::Texture2D> myReplacementTexture;
 
   //! \brief Flag indicating if this is a HUD texture
   bool myIsHud;
 
   //! \brief Flag indicating if the target texture was found
   bool myFoundTarget;
 
   //! \brief Flag indicating if geometry information should be collected
   bool myWantsGeometry;
 
   //! \brief Flag indicating whether to continue traversal after finding the target
   bool myTraverseOnTarget;
 
   //! \brief Structure containing geometry information for the target texture
   struct Geometry
   {
      osg::Vec3 normal;     //!< Average normal of RTT geometry
      osg::Plane plane;     //!< Plane on farthest point along average normal
      osg::BoundingBox box; //!< Box holding geometry bounds in model space
      osg::Vec3 min;        //!< Minimum RTT geometry bounds projected on plane
      osg::Vec3 max;        //!< Maximum RTT geometry bounds projected on plane
   };
 
   //! \brief Collected geometry information for the target texture
   Geometry myGeometry;
 
   //! \brief Flag indicating whether to use the provided override normal
   bool myUseOverrideNormal;
};
 
//! \brief Type identifier constant for DtPilotRenderUpdater components
//!
//! This constant defines the string identifier used to identify DtPilotRenderUpdater
//! component types within the VR-Engage framework. It is used for component
//! registration, type checking, and serialization operations.
constexpr const char* DtPilotRenderUpdaterType = "DtPilotRenderUpdater";
 
//! \brief Render updater component for the pilot role
//!
//! DtPilotRenderUpdater handles render-to-texture (RTT) channels and channel
//! configurations for aircraft cockpit displays and instruments. It manages
//! cockpit model initialization, instrument panel updates, and HUD elements.
class PILOT_DLL DtPilotRenderUpdater : public DtPlayerComponent
{
public:
   //! \brief Default constructor
   DtPilotRenderUpdater();
 
   //! \brief Virtual destructor
   virtual ~DtPilotRenderUpdater() 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(DtPlayerStation* player, DtInitTable& config) override;
 
   //! \brief Performs post-initialization setup
   //! \return True if post-initialization was successful, false otherwise
   virtual bool postInitialize() 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 DtPilotRenderUpdaterType.
   virtual const char* type() const override;
 
   //! \brief Handles render texture initialized messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   virtual DtVreMessageResult handleRenderTextureInitialized(DtVreMessage* msg);
 
   //! \brief Handles sensor data messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Caches sensor contacts, so tick can convert to screen coordinates for the HUD.
   virtual DtVreMessageResult handleSensorData(DtVreMessage* msg);
 
   //! \brief Overrides the camera mask for a channel
   //! \param channel Pointer to the channel to override
   //! \param mask New camera mask to apply
   //! \return The original camera mask
   static unsigned int overrideChannelCameraMask(makVrv::DtChannel* channel, unsigned int mask);
 
protected:
   //! \brief Initializes render textures for a model instance
   //! \param modelInstance Pointer to the model instance
   //! \return Number of render textures initialized
   virtual int initRenderTexturesFor(makVrv::DtModelInstance* modelInstance);
 
   //! \brief Replaces RTT textures on a scene object
   //! \param so Pointer to the scene object
   //! \param cameraStruct Pointer to the camera structure
   //! \return True if textures were replaced successfully, false otherwise
   virtual bool replaceRttTexturesOn(makVrv::DtSceneObject* so, DtCameraStruct* cameraStruct);
 
   //! \brief Enables RTT effect texture for texture swapping
   //! \param cameraStruct Pointer to the camera structure
   //! \param addToList Flag indicating whether to add the texture to the effect textures list
   //! \return True if the texture was enabled successfully, false otherwise
   virtual bool enableRttEffectTexture(DtCameraStruct* cameraStruct, bool addToList = true);
 
   //! \brief Turns off the RTT effect textures and restores the original textures
   virtual void disableRttEffectTextures();
 
   //! \brief Initializes cockpit objects
   //! \return True if initialization was successful, false otherwise
   //!
   //! Called during tick. Maps RTT texture indices to elements in the 3D model.
   virtual bool initCockpitObjects();
 
   //! \brief Destroys cockpit objects and releases resources
   virtual void destroyCockpitObjects();
 
   //! \brief Initializes ownship-only rendering mode
   //! \return True if initialization was successful, false otherwise
   virtual bool initOwnshipOnlyRender();
 
   //! \brief Reverts the ownship-only rendering mode
   virtual void undoOwnshipOnlyRender();
 
   //! \brief Updates vision block observers for cockpit views
   virtual void updateVisionBlockObservers();
 
   //! \brief Handles changes in VR state
   //! \param enabled True if VR is enabled, false otherwise
   virtual void onVrStateChanged(bool enabled);
 
   //! \brief Handles channel modification events
   //! \param deName Name of the display element
   //! \param winName Name of the window
   //! \param channelName Name of the modified channel
   //! \param config New channel configuration
   virtual void slot_channelModified(const std::string& deName, const std::string& winName,
      const std::string& channelName, const makVrv::DtChannelConfiguration& config);
 
   //! \brief Initializes a 3D cockpit model with instruments
   //!
   //! Initialization to be done when using a "real" 3D cockpit model.
   //! Sets up render-to-texture elements for instruments.
   virtual void initRealCockpit();
 
   //! \brief Updates HUD contact positions
   //!
   //! Updates HUD contact positions based on contact locations and
   //! current position and orientation of ownship.
   virtual void updateHudContacts();
 
   //! \brief Pointer to the instrument panel manager
   DtInstrumentPanelManager* myInstrumentPanelManager;
 
   //! \brief Aircraft marking text
   std::string myMarkingText;
 
   //! \brief Pointer to the cockpit model definition
   const makVrv::DtModelDefinition* myCockpitModelDef;
 
   //! \brief Agent for the cockpit articulated model
   makVrv::DtArticulatedModelAgent* myCockpitModelAgent;
 
   //! \brief Agent for the cockpit scene object
   makVrv::DtSceneObjectAgent* myCockpitSceneObjectAgent;
 
   //! \brief Agent for the cockpit updater
   DtSceneObjectMimicUpdaterAgent* myCockpitUpdaterAgent;
 
   //! \brief Flag indicating if cockpit objects are initialized
   bool myCockpitObjectsInitialized;
 
   //! \brief Flag indicating if cockpit models are initialized
   bool myCockpitModelsInitialized;
 
   //! \brief Map of RTT definitions indexed by name
   std::map<std::string, DtInitTable> myRttDefs;
 
   //! \brief Pointer to the ownship scene object
   makVrv::DtSceneObject* myOwnshipSceneObject;
 
   //! \brief Flag indicating if only the model should be rendered
   bool myRenderModelOnly;
 
   //! \brief Flag indicating if ownship-only rendering is desired
   bool myWantOwnshipOnly;
 
   //! \brief Flag indicating if ownship-only rendering is active
   bool myMadeOwnshipOnly;
 
   //! \brief Flag indicating if ownship was set up in VR mode
   bool myDidOwnshipInVR;
 
   //! \brief Reference to the ownship node group
   osg::ref_ptr<makVrv::DtChannelSpecificGroup> myOwnshipNode;
 
   //! \brief Saved sky mask for ownship-only rendering
   unsigned int mySavedSkyMask;
 
   //! \brief Saved cloud mask for ownship-only rendering
   unsigned int mySavedCloudMask;
 
   //! \brief Saved camera mask for ownship-only rendering
   unsigned int mySavedCameraMask;
 
   //! \brief Mask bit for the ownship
   unsigned int myOwnshipMaskBit;
 
   //! \brief Pointer to the OSG observer object
   makVrv::DtOsgObserverObject* myOsgObserver;
 
   //! \brief Structure containing vision block geometry information
   struct VisionBlockGeometry
   {
      osg::Quat modelSpaceCamRot; //!< Camera rotation in model space
      osg::Vec3 modelSpaceRttMin; //!< Minimum extent of RTT in model space
      osg::Vec3 modelSpaceRttMax; //!< Maximum extent of RTT in model space
      osg::Vec3 viewOffset;       //!< Offset for the view
      osg::Quat viewRotation;     //!< Rotation for the view
      float viewZoom;             //!< Zoom factor for the view
   };
 
   //! \brief List of vision blocks with their associated camera structures
   std::list<std::pair<VisionBlockGeometry, DtCameraStruct*>> myVisionBlocks;
 
   //! \brief Vector of effect texture camera structures
   std::vector<DtCameraStruct*> myEffectTextures;
 
   //! \brief Vector of sensor contacts for HUD display
   std::vector<SensorDataMessage::SensorContact> mySensorContacts;
};
}; // namespace makVre