vreOsgEffectTextureController.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file vreOsgEffectTextureController.h
//! \brief Defines texture effect controllers for OSG rendering in VR-Engage
//!
//! This file contains the DtVreOsgEffectTextureController class and related
//! components which provide texture swapping effects for the VR-Engage
//! visualization system. These controllers allow for special visual effects
//! like maps, HUDs, and other texture-based overlays to be applied to the
//! rendering pipeline.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include <vrvCore/DtDe.h>
 
#include <vrvOsg/DtOsgEffectTextureController.h>
#include <vrvOsg/DtOsgRenderer.h>
#include <vrvOsg/DtEffectControllerCreatorTemplate.h>
 
namespace makVre
{
//! \brief Extension of DtEffectTextureType enumeration for VR-Engage effects
//!
//! This enumeration extends the base DtEffectTextureType with VR-Engage specific
//! effect texture types. These types are used to identify and register different
//! kinds of texture effects in the rendering system.
enum DtVreEffectTextureType
{
   VRE_ET_MAP = 1100,    //!< Map overlay effect texture type
   VRE_HUD_ET_MAP = 1101 //!< HUD (Heads-Up Display) map effect texture type
};
 
 
//! \brief Controller for texture swapping visual effects in OSG rendering
//!
//! DtVreOsgEffectTextureController manages texture swapping effects in the
//! OSG rendering pipeline. Based on VR-Vantage's exampleEffectTexturePlugin,
//! it provides the ability to dynamically apply shader-based effects to textures
//! during rendering. This enables features like map overlays, HUD elements,
//! and other specialized visual effects.
class PLAYERSTATION_DLL DtVreOsgEffectTextureController : public makVrv::DtOsgEffectTextureController
{
public:
   //! \brief Constructor
   //! \param de Reference to the display engine
   //! \param effectTextureType Type identifier for this effect texture
   //! \param typeString String identifier for this effect type
   //! \param postfix Suffix for shader uniform names
   //! \param fragFilename Filename of the fragment shader
   //! \param vertFilename Filename of the vertex shader
   //! \param fragFunction Name of the fragment shader function to call
   //! \param vertFunction Name of the vertex shader function to call
   //! \param effectUnitName Name of the texture unit for the effect
   //! \param indirectTextureMapName Name of the indirect texture map
   //! \param indirectTextureCoordName Name of the indirect texture coordinates
   //!
   //! Creates a new effect texture controller with the specified parameters.
   //! These parameters define the shaders, texture units, and naming conventions
   //! used by this effect controller.
   DtVreOsgEffectTextureController(makVrv::DtDe& de, int effectTextureType, const std::string& typeString,
      const std::string& postfix, const std::string& fragFilename, const std::string& vertFilename,
      const std::string& fragFunction, const std::string& vertFunction, const std::string& effectUnitName,
      const std::string& indirectTextureMapName, const std::string& indirectTextureCoordName);
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of effect texture controller resources.
   virtual ~DtVreOsgEffectTextureController() override;
 
   //! \brief Installs the effect shaders into a state set
   //! \param baseUnit Base texture unit index
   //! \param effectUnit Effect texture unit index
   //! \param tex Pointer to the effect texture
   //! \param stateSet State set to install the shaders into
   //! \param baseTextureName Name of the base texture sampler
   //! \return True if shaders were installed successfully, false otherwise
   //!
   //! Installs the effect shaders into the provided state set, configuring
   //! the necessary uniforms and texture units for the effect. This is called
   //! during the rendering process to apply the effect to the specified texture.
   virtual bool installShaders(int baseUnit, int effectUnit, const osg::Texture* tex, osg::StateSet* stateSet,
      const std::string& baseTextureName) const override;
 
   //! \brief Gets the uniform used for toggling effect textures
   //! \return Reference-counted pointer to the effects enabled uniform
   //!
   //! Returns the uniform that controls whether effect textures are enabled.
   //! This can be used to globally toggle all effects of this type on or off.
   static osg::ref_ptr<osg::Uniform> getEffectsEnabledUniform();
 
private:
   //! \brief Path to the fragment shader file
   std::string myFragShader;
 
   //! \brief Path to the vertex shader file
   std::string myVertShader;
 
   //! \brief Name of the fragment shader function to call
   std::string myFragFunction;
 
   //! \brief Name of the vertex shader function to call
   std::string myVertFunction;
 
   //! \brief Name of the texture unit for the effect
   std::string myEffectUnitName;
 
   //! \brief Shared uniform for enabling/disabling all effect textures
   static osg::ref_ptr<osg::Uniform> effectsEnabledUniform;
};
 
 
//! \brief Factory creator for standard effect texture controllers
//!
//! DtVreOsgEffectTextureControllerCreator is a factory class that creates
//! standard effect texture controller instances for registration with the
//! DtEffectControllerFactory. This allows the effect controllers to be
//! created on demand using the factory pattern.
class PLAYERSTATION_DLL DtVreOsgEffectTextureControllerCreator : public makVrv::DtEffectControllerCreator
{
public:
   //! \brief Creates a new effect texture controller
   //! \param de Reference to the display engine
   //! \return Pointer to a newly created effect texture controller
   //!
   //! Factory method that creates a new standard effect texture controller
   //! instance for the specified display engine.
   virtual DtVreOsgEffectTextureController* create(makVrv::DtDe& de) override;
};
 
//! \brief Factory creator for HUD-specific effect texture controllers
//!
//! DtVreOsgHudEffectTextureControllerCreator is a factory class that creates
//! HUD-specific effect texture controller instances for registration with the
//! DtEffectControllerFactory. These controllers are specially configured for
//! use with Heads-Up Display elements in the rendering pipeline.
class PLAYERSTATION_DLL DtVreOsgHudEffectTextureControllerCreator : public makVrv::DtEffectControllerCreator
{
public:
   //! \brief Creates a new HUD effect texture controller
   //! \param de Reference to the display engine
   //! \return Pointer to a newly created HUD effect texture controller
   //!
   //! Factory method that creates a new HUD-configured effect texture controller
   //! instance for the specified display engine.
   virtual DtVreOsgEffectTextureController* create(makVrv::DtDe& de) override;
};
} // namespace makVre