vreQtQuickFileData.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*********************************************************************************/
 
#pragma once
 
//! \file vreQtQuickFileData.h
//! \ingroup vreQtQuickRenderer
//! \brief Class for storing information about QML files in the render pipeline
//!
//! This class maintains data about QML files that are currently being rendered or
//! are scheduled to be rendered. It tracks file paths, owners, target windows,
//! render textures, and callback functions for QML loading.
 
#include "vreQtQuickRenderer/export.h"
 
#include <functional>
#include <string>
 
#include <osg/Texture2D>
 
class QObject;
class QQuickItem;
 
namespace makVre
{
class DtPerWindowQtQuickData;
 
//! \brief Container for QML file rendering data
//!
//! This class stores all the necessary information about a QML file to be rendered,
//! including its target window, initialization function, file path, root item,
//! and render-to-texture settings.
class QTQUICKRENDERER_DLL DtQtQuickFileData
{
public:
   //! \brief Default constructor
   DtQtQuickFileData();
 
   //! \brief Destructor
   ~DtQtQuickFileData();
 
   //! \brief Sets the target window name for rendering
   //! \param windowName Name of the target window
   virtual void setTargetWindow(const std::string& windowName);
 
   //! \brief Gets the target window name
   //! \return Reference to the target window name
   virtual const std::string& getTargetWindow();
 
   //! \brief Sets the document initialization function
   //! \param func Callback function to be called when the QML file is loaded
   virtual void setDocInitFunction(const std::function<void(QQuickItem*)>& func);
 
   //! \brief Gets the document initialization function
   //! \return Reference to the initialization function
   virtual const std::function<void(QQuickItem*)>& getDocInitFunction();
 
   //! \brief Sets the path of the QML file to load
   //! \param filePath Path to the QML file
   virtual void setFileToLoad(const std::string& filePath);
 
   //! \brief Gets the path of the QML file to load
   //! \return Reference to the file path
   virtual const std::string& getFileToLoad();
 
   //! \brief Sets the root QML item
   //! \param root Pointer to the root QML item
   virtual void setRoot(QQuickItem* root);
 
   //! \brief Gets the root QML item
   //! \return Pointer to the root QML item
   virtual QQuickItem* getRoot();
 
   //! \brief Sets the owner object
   //! \param owner Pointer to the owner object
   virtual void setOwner(QObject* owner);
 
   //! \brief Gets the owner object
   //! \return Pointer to the owner object
   virtual QObject* getOwner();
 
   //! \brief Sets the render-to-texture data
   //! \param data Pointer to the per-window Qt Quick data
   virtual void setRTTdata(DtPerWindowQtQuickData* data);
 
   //! \brief Gets the render-to-texture data
   //! \return Pointer to the per-window Qt Quick data
   virtual DtPerWindowQtQuickData* getRTTdata();
 
   //! \brief Sets whether this is a render-to-texture target
   //! \param isRTT True if this is a render-to-texture target, false otherwise
   virtual void setRTTtarget(bool isRTT);
 
   //! \brief Checks if this is a render-to-texture target
   //! \return True if this is a render-to-texture target, false otherwise
   virtual bool getRTTtarget();
 
   //! \brief Sets the framebuffer size
   //! \param w Width of the framebuffer in pixels
   //! \param h Height of the framebuffer in pixels
   virtual void setFboSize(int w, int h);
 
   //! \brief Gets the framebuffer size
   //! \param w Output parameter for the framebuffer width
   //! \param h Output parameter for the framebuffer height
   virtual void getFboSize(int& w, int& h);
 
   //! \brief Gets the framebuffer width
   //! \return Width of the framebuffer in pixels
   virtual int getFboWidth();
 
   //! \brief Gets the framebuffer height
   //! \return Height of the framebuffer in pixels
   virtual int getFboHeight();
 
   //! \brief Sets the number of framebuffer samples for multisampling
   //! \param samples Number of samples
   virtual void setFboSamples(int samples);
 
   //! \brief Gets the number of framebuffer samples
   //! \return Number of samples for multisampling
   virtual int getFboSamples();
 
   //! \brief Sets the OSG render texture
   //! \param texture Pointer to the OSG texture for rendering
   virtual void setOsgRenderTexture(osg::Texture2D* texture);
 
   //! \brief Gets the OSG render texture
   //! \return Pointer to the OSG texture for rendering
   virtual osg::Texture2D* getOsgRenderTexture();
 
protected:
   //! \brief Render-to-texture data for this file
   DtPerWindowQtQuickData* myRTTdata;
   //! \brief Owner object for this QML file
   QObject* myOwner;
   //! \brief Root QML item
   QQuickItem* myRoot;
   //! \brief Flag indicating if this is a render-to-texture target
   bool myRTTtarget;
   //! \brief Number of samples for framebuffer multisampling
   int myFboSamples;
   //! \brief Width of the framebuffer in pixels
   int myFboWidth;
   //! \brief Height of the framebuffer in pixels
   int myFboHeight;
   //! \brief OSG texture for rendering
   osg::ref_ptr<osg::Texture2D> myOsgTarget;
   //! \brief Document initialization function
   std::function<void(QQuickItem*)> myDocInitFunction;
 
   //! \brief Current warning messages
   std::string myCurrentWarnings;
   //! \brief Path to the QML file to load
   std::string myFileToLoad;
   //! \brief Name of the target window
   std::string myTargetWindow;
};
 
} // namespace makVre