instrumentPanelManagerStructs.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file instrumentPanelManagerStructs.h
//! \brief Defines structures used by the instrument panel manager in VR-Engage
//!
//! This file contains the DtCameraStruct, DtPanelStruct, and DtTextureIndexDrawCallback
//! classes which are used by the instrument panel manager to manage camera views,
//! panels, and render-to-texture operations for instrument displays. These structures
//! handle the configuration and rendering of instrument panel elements in 3D cockpits.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include <vrvOsg/DtCameraNode.h>
 
#include <osg/Object>
#include <osg/ref_ptr>
#include <osg/Texture2D>
 
namespace makVrv
{
//! \brief Forward declaration of the entity facade class
class DtEntityFacade;
 
//! \brief Forward declaration of the observer class
class DtObserver;
 
//! \brief Forward declaration of the scene object class
class DtSceneObject;
 
//! \brief Forward declaration of the input driver class
class DtInputDriver;
 
//! \brief Forward declaration of the channel configuration class
class DtChannelConfiguration;
 
//! \brief Forward declaration of the OSG channel class
class DtOsgChannel;
 
//! \brief Forward declaration of the model definition class
class DtModelDefinition;
}; // namespace makVrv
 
namespace osg
{
//! \brief Forward declaration of the render info class
class RenderInfo;
} // namespace osg
 
namespace makVre
{
//! \brief Forward declaration of the interpolator class
class DtInterpolator;
 
//! \brief Forward declaration of the window operation message class
class WindowOperationMessage;
 
//! \brief Forward declaration of the entity resolver class
class DtEntityResolver;
 
//! \brief Forward declaration of the initialization table class
class DtInitTable;
 
//! \brief Forward declaration of the texture index draw callback class
class DtTextureIndexDrawCallback;
 
//! \brief Enumeration of camera types used in instrument panels
//!
//! Defines the different types of cameras that can be used to render
//! instrument panel views. Each type has different behaviors and rendering
//! characteristics appropriate for different instrument display needs.
enum DtCameraType
{
   Uninitialized = 0, //!< Camera is not yet initialized
   Gimbal,            //!< Camera with gimbal-like movement behavior
   Stealth,           //!< Camera that follows but doesn't affect the scene
   PlanView,          //!< Top-down map-like view camera
   Panel              //!< Instrument panel-specific camera
};
 
//! \brief Structure that manages camera and render-to-texture for instrument panels
//!
//! DtCameraStruct manages a camera view used for rendering to texture for
//! an instrument panel display. It holds the configuration for a specific
//! instrument panel camera, including render target settings, texture properties,
//! and the associated OSG cameras. This struct maintains the relationships between
//! the camera view, its output texture, and the display parameters.
struct PLAYERSTATION_DLL DtCameraStruct
{
   //! \brief Constructor
   //! \param de Reference to the display engine
   //!
   //! Creates a new camera structure with default settings. Initializes all
   //! camera properties to their default values and associates the structure
   //! with the specified display engine.
   DtCameraStruct(makVrv::DtDe& de)
      : myDe(de)
      , cameraType(Uninitialized)
      , ownshipId(DtEntityIdentifier::nullId())
      , windowName("")
      , observerName("")
      , channelName("")
      , useCount(0)
      , textureIndex(-1)
      , textureOffsetX(0)
      , textureOffsetY(0)
      , textureWidth(512)
      , textureHeight(512)
      , rttCamera(0)
      , overlayCamera(0)
      , modelDef(NULL)
      , mipRtt(false)
      , rttIsHud(false)
      , outputTexture()
      , postDrawCallback(0)
   {
   }
 
   //! \brief Handles viewport size or position changes
   //! \param x New x-coordinate of the viewport
   //! \param y New y-coordinate of the viewport
   //! \param w New width of the viewport
   //! \param h New height of the viewport
   //!
   //! Updates the camera and render-to-texture configuration when the viewport
   //! dimensions or position change. This ensures the rendered output matches
   //! the new viewport specifications.
   void viewportChanged(int x, int y, int w, int h);
 
   //! \brief Handles changes to the render texture
   //!
   //! Updates the camera and associated objects when the render texture
   //! properties change. This ensures all components are properly synchronized
   //! to use the updated texture.
   void renderTextureChanged();
 
   //! \brief Callback executed during the rendering process
   //! \param renderInfo Rendering information from OSG
   //!
   //! This callback is executed during the OSG rendering process. It handles
   //! any custom rendering operations needed for this camera, such as setting
   //! up texture indices or applying post-processing effects.
   void drawCallback(osg::RenderInfo& renderInfo);
 
   //! \brief Entity identifier of the ownship associated with this camera
   DtEntityIdentifier ownshipId;
 
   //! \brief Name of this camera
   std::string name;
 
   //! \brief Type of camera (Gimbal, Stealth, PlanView, Panel)
   DtCameraType cameraType;
 
   //! \brief Name of the window this camera renders to
   std::string windowName;
 
   //! \brief Name of the observer associated with this camera
   std::string observerName;
 
   //! \brief Name of the channel this camera renders to
   std::string channelName;
 
   //! \brief Reference count for this camera
   //!
   //! Tracks how many panel displays are using this camera view.
   int useCount;
 
   //! \brief Index of the texture in the texture array
   int textureIndex;
 
   //! \brief X-coordinate offset within the texture
   int textureOffsetX;
 
   //! \brief Y-coordinate offset within the texture
   int textureOffsetY;
 
   //! \brief Width of the render texture in pixels
   int textureWidth;
 
   //! \brief Height of the render texture in pixels
   int textureHeight;
 
   //! \brief Camera node used for render-to-texture operations
   makVrv::DtCameraNode* rttCamera;
 
   //! \brief Camera node used for rendering overlays on top of the main view
   makVrv::DtCameraNode* overlayCamera;
 
   //! \brief Reference to the output texture where the camera renders
   osg::ref_ptr<osg::Texture2D> outputTexture;
 
   //! \brief Name of the texture this RTT replaces in the model
   std::string rttReplaces;
 
   //! \brief Pointer to model definition associated with this camera
   const makVrv::DtModelDefinition* modelDef;
 
   //! \brief Flag indicating whether to generate mipmaps for the render texture
   bool mipRtt;
 
   //! \brief Flag indicating whether this render texture is for a HUD display
   bool rttIsHud;
 
   //! \brief Callback executed after drawing to handle post-render operations
   makVre::DtTextureIndexDrawCallback* postDrawCallback;
 
   //! \brief Reference to the display engine
   makVrv::DtDe& myDe;
};
 
//! \brief Structure that manages a collection of instrument panels
//!
//! DtPanelStruct represents a group of related instrument panels associated
//! with a specific entity. It manages the relationship between panel displays,
//! their windows, and the cameras that render content to them. This struct forms
//! the organizational structure for instrument panels in a cockpit or vehicle.
struct PLAYERSTATION_DLL DtPanelStruct
{
   //! \brief Constructor
   //!
   //! Creates a new panel structure with default settings. Initializes entity
   //! identifiers to null and creates empty collections for windows and cameras.
   DtPanelStruct()
      : ownshipId(DtEntityIdentifier::nullId())
      , panelHostId(DtEntityIdentifier::nullId())
      , windows()
      , cameras()
   {
   }
 
   //! \brief Entity identifier of the ownship associated with these panels
   DtEntityIdentifier ownshipId;
 
   //! \brief Entity identifier of the host entity containing these panels
   DtEntityIdentifier panelHostId;
 
   //! \brief Type definition for mapping window names to model definition names
   using WindowNameModelDefMap = std::map<std::string, std::string>;
 
   //! \brief Map of window names to their associated model definition names
   WindowNameModelDefMap windows;
 
   //! \brief Type definition for mapping camera names to camera structures
   using CameraMap = std::map<std::string, DtCameraStruct*>;
 
   //! \brief Map of camera names to their associated camera structures
   CameraMap cameras;
};
 
//! \brief Draw callback that sets the correct texture index for instrument panel displays
//!
//! DtTextureIndexDrawCallback is an OSG draw callback that ensures the correct
//! texture index is used when rendering to an instrument panel display. This is
//! particularly important for GLStudio widgets, which need specific texture indices
//! to properly display rendered content. The callback executes during the rendering
//! process to maintain proper texture synchronization.
class PLAYERSTATION_DLL DtTextureIndexDrawCallback : public osg::Camera::DrawCallback
{
public:
   //! \brief OSG meta object declaration for proper type handling
   META_Object(osg, DtTextureIndexDrawCallback);
 
   //! \brief Default constructor
   //!
   //! Creates a new texture index draw callback with no associated camera structure.
   DtTextureIndexDrawCallback()
      : osg::Camera::DrawCallback()
      , myCameraStruct(0)
   {
   }
 
   //! \brief Constructor with camera structure
   //! \param cs Pointer to the camera structure this callback is associated with
   //!
   //! Creates a new texture index draw callback associated with the specified
   //! camera structure. The callback will use the camera structure's texture index
   //! and other properties during rendering.
   DtTextureIndexDrawCallback(makVre::DtCameraStruct* cs)
      : osg::Camera::DrawCallback()
      , myCameraStruct(cs)
   {
   }
 
   //! \brief Copy constructor
   //! \param cb Draw callback to copy from
   //! \param co Copy operation to use
   //!
   //! Creates a new texture index draw callback by copying from an existing
   //! draw callback. This constructor is required by the OSG object system
   //! for proper cloning and copying of objects.
   DtTextureIndexDrawCallback(const DrawCallback& cb, const osg::CopyOp& co)
      : osg::Camera::DrawCallback(cb, co)
      , myCameraStruct(0)
   {
   }
 
   //! \brief Destructor
   //!
   //! Cleans up resources used by the texture index draw callback.
   virtual ~DtTextureIndexDrawCallback() override {}
 
   //! \brief Functor method called by the rendering thread
   //! \param renderInfo Rendering information from OSG
   //!
   //! This method is called by the OSG rendering thread during the rendering
   //! process. It delegates to the camera structure's drawCallback method to
   //! handle the actual texture index updating and any other rendering operations.
   virtual void operator()(osg::RenderInfo& renderInfo) const override { myCameraStruct->drawCallback(renderInfo); }
 
   //! \brief Backwards compatibility functor method
   //! \param camera Camera being rendered
   //!
   //! This method is provided for backwards compatibility with older OSG
   //! versions. It is called by the operator()(osg::RenderInfo&) method
   //! in those versions. This implementation is intentionally empty as
   //! the actual work is done in the other operator() method.
   virtual void operator()(const osg::Camera& /*camera*/) const override {}
 
protected:
   //! \brief Pointer to the camera structure this callback is associated with
   makVre::DtCameraStruct* myCameraStruct;
 
private:
   //! \brief Copy constructor (deleted)
   //!
   //! Copy construction is not supported for this class.
   DtTextureIndexDrawCallback(const DtTextureIndexDrawCallback&);
 
   //! \brief Assignment operator (deleted)
   //!
   //! Assignment is not supported for this class.
   DtTextureIndexDrawCallback& operator=(const DtTextureIndexDrawCallback& orig);
};
} // namespace makVre