DtQtQuickRenderer.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*********************************************************************************/
 
#pragma once
 
//! \file DtQtQuickRenderer.h
//! \ingroup vreQtQuickRenderer
//! \brief Main singleton responsible for managing QML files in the VREngage system.
//!
//! This class manages QML files being rendered, QML files that need to be loaded,
//! and all associated data. It provides the interface for loading, rendering, and
//! interacting with QML-based user interfaces within the VREngage environment.
 
#include "vreQtQuickRenderer/export.h"
 
#include "vreUtil/initializer.h"
 
#include <vrvUtil/DtSignalConnectionManager.h>
 
#include <vrvOsg/DtImguiDrawable.h>
 
#include <osg/Geode>
#include <osg/Texture2D>
 
#include <QObject>
 
 
class QObject;
class QOpenGLContext;
class QWindow;
class QQuickWindow;
class QQmlEngine;
class QQmlComponent;
class QQmlContext;
class QQuickItem;
 
namespace makVrv
{
class DtDe;
class DtOsgChannel;
class DtGlRenderTexture;
class DtWindow;
} // namespace makVrv
 
namespace makVre
{
class DtQtQRenderControl;
class DtQQuickWindow;
class DtPerWindowQtQuickData;
class DtQtQuickFileData;
 
//! \brief Core renderer for QML content in the VREngage environment
//!
//! This singleton class manages the loading, rendering, and interaction with
//! QML-based user interfaces. It integrates Qt Quick with OSG rendering to provide
//! seamless UI capabilities within 3D environments.
class QTQUICKRENDERER_DLL DtQtQuickRenderer
{
public:
   //! \brief Type definition for mapping graphics contexts to Qt Quick data
   using RenderControlMap = std::map<osg::GraphicsContext*, DtPerWindowQtQuickData*>;
 
public:
   //! \brief Gets the singleton Qt Quick renderer instance
   //! \return Pointer to the singleton renderer instance
   static DtQtQuickRenderer* instance();
 
   //! \brief Installs the Qt Quick renderer system
   //! \param de Reference to the graphics engine
   static void install(makVrv::DtDe& de);
 
   //! \brief Cleans up and shuts down the Qt Quick renderer system
   //!
   //! Releases all resources and destroys loaded QML interfaces
   virtual void shutdown();
 
   //! \brief Loads a QML file and calls a function when loaded
   //! \param owner The object that owns this QML interface
   //! \param filepath Path to the QML file to load
   //! \param file_loaded_func Callback function called when the file is loaded
   virtual void loadQMLFile(
      QObject* owner, const std::string& filepath, const std::function<void(QQuickItem*)>& file_loaded_func);
 
   //! \brief Loads a QML file to a specific window and calls a function when loaded
   //! \param owner The object that owns this QML interface
   //! \param windowName Name of the window to load the QML into
   //! \param filepath Path to the QML file to load
   //! \param file_loaded_func Callback function called when the file is loaded
   virtual void loadQMLFile(QObject* owner, const std::string& windowName, const std::string& filepath,
      const std::function<void(QQuickItem*)>& file_loaded_func);
 
   //! \brief Loads a QML file for render-to-texture and calls a function when loaded
   //!
   //! Loads a QML file and renders it to a texture target. The callback function will be
   //! called with the "fbo" property set to the OpenGL texture being rendered into.
   //!
   //! \param owner The object that owns this QML interface
   //! \param filepath Path to the QML file to load
   //! \param target OpenGL texture to render the QML content into
   //! \param func Callback function called when the file is loaded
   virtual void loadQMLFileRTT(QObject* owner, const std::string& filepath, osg::Texture2D* target,
      const std::function<void(QQuickItem*)>& func);
 
   //! \brief Reloads the QML file associated with the specified owner
   //! \param owner The object that owns the QML interface to reload
   virtual void reloadQMLFile(QObject* owner);
 
   //! \brief Closes the UI associated with the specified root item
   //! \param root The root QQuickItem of the UI to close
   virtual void closeUIByRoot(QQuickItem* root);
 
   //! \brief Closes the UI associated with the specified owner
   //! \param owner The object that owns the UI to close
   virtual void closeUIByOwner(QObject* owner);
 
   //! \brief Gets the root QML context
   //!
   //! This context is needed to allow C++ to send JavaScript and QML engine objects
   //! \return Pointer to the root QML context
   virtual QQmlContext* rootContext();
 
   //! \brief Gets the render-to-texture geode
   //! \return Pointer to the OSG geode used for render-to-texture
   virtual osg::Geode* geodeRtt();
 
   //! \brief Gets the graphics engine reference
   //! \return Reference to the graphics engine
   virtual makVrv::DtDe& de() { return myDe; }
 
   //! \brief Sets the virtual reality render target
   //! \param texture Pointer to the texture to use as the VR render target
   virtual void setVirtualRealityRenderTarget(osg::Texture2D* texture);
 
   //! \brief Synchronizes the virtual reality render target with all file data
   //!
   //! Finds any file data using the virtual reality target and updates their render texture
   //! \param ctxid The context ID to synchronize
   virtual void syncVirtualRealityRenderTarget(unsigned int ctxid);
 
   //! \brief Slot called when VR running state changes
   //! \param running True if VR is running, false otherwise
   virtual void slot_vrRunningChanged(bool running);
 
   //! \brief Slot called when VR overlay settings change
   virtual void slot_vrOverlayChanged();
 
   //! \brief Adds a category to the debug map
   //! \param logCat The logging category to add
   virtual void addToDebugMap(const std::string& logCat);
 
   //! \brief Gets the number of UIs that are in queue to load
   //! \return The number of pending UI loads
   virtual const int numberOfUIsToLoad() const;
 
   //! \brief Gets a reference to a child QObject in QML
   //! \param parent The parent QObject to search in
   //! \param objectName The name of the child object to find
   //! \return Pointer to the found child object, or nullptr if not found
   static QObject* getChildObject(const QObject* parent, const QString& objectName);
 
   //! \brief Gets the dimensions of the specified window
   //! \param windowName Name of the window to get dimensions for
   //! \return Reference to a QRect containing the window dimensions
   virtual const QRect& getWindowDimensions(const std::string& windowName) const;
 
protected:
   //! Friends that need access to protected members
   friend class DtQtQuickRendererDrawable;
   friend class DtQQuickWindow;
 
protected:
   //! \brief Constructor for Qt Quick renderer
   //! \param de Reference to the graphics engine
   DtQtQuickRenderer(makVrv::DtDe& de);
 
   //! \brief Virtual destructor
   virtual ~DtQtQuickRenderer();
 
   //! \brief Initializes Qt Quick rendering components
   //! \param renderInfo Render information from OSG
   virtual void initQtQuickRenderingComponents(osg::RenderInfo& renderInfo);
   //! \brief Gets Qt Quick data for the specified graphics context
   //! \param gc The graphics context to get data for
   //! \return Pointer to the Qt Quick data for the context
   virtual DtPerWindowQtQuickData* getWindowData(osg::GraphicsContext* gc);
 
   //! \brief Installs default properties for all root QML objects
   //!
   //! Sets up properties that every root QML object should have
   virtual void installDefaultProperties();
 
   //! \brief Updates the Qt Quick rendering in OSG
   //! \param renderInfo Render information from OSG
   virtual void updateQuick(osg::RenderInfo& renderInfo);
 
   //! \brief Handles a window being destroyed
   //! \param win Pointer to the window being destroyed
   virtual void onWindowToBeDestroyed(makVrv::DtWindow* win);
 
   //! \brief Sets up the debug configuration
   virtual void setDebugConfig();
   //! \brief Callback for debug manager
   virtual void debugManagerCallback();
 
   //! \brief Reloads a QML file from file data
   //! \param data The file data to reload
   virtual void reloadQMLFile(DtQtQuickFileData* data);
   //! \brief Closes a UI from file data
   //! \param data The file data for the UI to close
   virtual void closeUI(DtQtQuickFileData* data);
   //! \brief Loads a QML file immediately
   //! \param gc The graphics context to load into
   //! \param fileData The file data to load
   //! \return Pointer to the root QML item
   virtual QQuickItem* loadFileNow(osg::GraphicsContext* gc, DtQtQuickFileData* fileData);
 
protected:
   //! \brief Singleton instance of the Qt Quick renderer
   static DtQtQuickRenderer* theQtQuickRenderer;
 
   //! \brief Reference to the graphics engine
   makVrv::DtDe& myDe;
 
   //! \brief Standard OSG geode for Qt Quick rendering
   osg::ref_ptr<osg::Geode> myGeode;
   //! \brief Standard OSG drawable for Qt Quick rendering
   osg::ref_ptr<osg::Drawable> myDrawable;
 
   //! \brief Render-to-texture OSG geode
   osg::ref_ptr<osg::Geode> myGeodeRTT;
   //! \brief Render-to-texture OSG drawable
   osg::ref_ptr<osg::Drawable> myDrawableRTT;
 
   //! \brief QML engine for loading and rendering QML
   QQmlEngine* myQmlEngine;
 
   //! \brief Default graphics context
   osg::GraphicsContext* myDefaultContext;
   //! \brief Map of graphics contexts to Qt Quick data
   RenderControlMap myRenderControlMap;
 
   //! \brief List of UIs waiting to be loaded
   std::vector<DtQtQuickFileData*> myUIsToLoadList;
   //! \brief List of UIs that have been loaded
   std::vector<DtQtQuickFileData*> myUIsLoadedList;
 
   //! \brief Signal connection manager for Qt signals
   makVrv::DtSignalConnectionManager myConnections;
 
   //! \brief Texture to synchronize for VR rendering
   osg::Texture2D* myRenderTargetToSync;
 
   //! \brief Debug map for QML event debugging
   std::map<std::string, bool> myQmlDebugMap;
};
 
} // namespace makVre