remove treenode

src/qml/qmlwaveformdisplay.cpp

@@ -38,7 +38,7 @@ QmlWaveformDisplay::QmlWaveformDisplay(QQuickItem* parent)
 }
 
 QmlWaveformDisplay::~QmlWaveformDisplay() {
-    // The stack contains references to Renderer that are owned and cleared by a TreeNode
+    // The stack contains references to Renderer that are owned and cleared by a BaseNode
     m_rendererStack.clear();
 }
 
@@ -107,7 +107,7 @@ QSGNode* QmlWaveformDisplay::updatePaintNode(QSGNode* node, UpdatePaintNodeData*
 
             auto renderer = pQmlRenderer->create(this);
             addRenderer(renderer.renderer);
-            m_pTopNode->appendChildNode(std::unique_ptr<rendergraph::TreeNode>(renderer.node));
+            m_pTopNode->appendChildNode(std::unique_ptr<rendergraph::BaseNode>(renderer.node));
             auto *pWaveformRenderMark =
                     dynamic_cast<allshader::WaveformRenderMark*>(
                             renderer.renderer);
@@ -122,7 +122,7 @@ QSGNode* QmlWaveformDisplay::updatePaintNode(QSGNode* node, UpdatePaintNodeData*
             }
         }
 
-        bgNode->appendChildNode(m_pTopNode->backendNode());
+        bgNode->appendChildNode(m_pTopNode);
         init();
     }
 

src/qml/qmlwaveformrenderer.h

@@ -1,17 +1,14 @@
 #pragma once
 
-#include <QQmlEngine>
 #include <QObject>
+#include <QQmlEngine>
 
+#include "rendergraph/node.h"
 #include "waveform/renderers/waveformrendererabstract.h"
 #include "waveform/renderers/waveformwidgetrenderer.h"
 
 class WaveformWidgetRenderer;
 
-namespace rendergraph {
-class TreeNode;
-} // namespace rendergraph
-
 namespace allshaders {
 class WaveformRendererEndOfTrack;
 class WaveformRendererPreroll;
@@ -28,7 +25,7 @@ class QmlWaveformRendererFactory : public QObject {
   public:
     struct Renderer {
         ::WaveformRendererAbstract* renderer{nullptr};
-        rendergraph::TreeNode* node{nullptr};
+        rendergraph::BaseNode* node{nullptr};
     };
 
     virtual Renderer create(WaveformWidgetRenderer* waveformWidget) const = 0;

src/rendergraph/common/rendergraph/geometrynode.h

@@ -3,21 +3,16 @@
 #include "backend/basegeometrynode.h"
 #include "rendergraph/geometry.h"
 #include "rendergraph/material.h"
-#include "rendergraph/treenode.h"
+#include "rendergraph/nodeinterface.h"
 
 namespace rendergraph {
 class GeometryNode;
 } // namespace rendergraph
 
-class rendergraph::GeometryNode : public rendergraph::BaseGeometryNode,
-                                  public rendergraph::TreeNode {
+class rendergraph::GeometryNode : public rendergraph::NodeInterface<rendergraph::BaseGeometryNode> {
   public:
-    using rendergraph::TreeNode::appendChildNode;
-    using rendergraph::TreeNode::firstChild;
-    using rendergraph::TreeNode::lastChild;
-    using rendergraph::TreeNode::nextSibling;
-    using rendergraph::TreeNode::removeChildNode;
     GeometryNode();
+    virtual ~GeometryNode() = default;
 
     template<class T_Material>
     void initForRectangles(int numRectangles) {
@@ -28,6 +23,7 @@ class rendergraph::GeometryNode : public rendergraph::BaseGeometryNode,
         geometry().setDrawingMode(Geometry::DrawingMode::Triangles);
     }
 
+    void setUsePreprocess(bool value);
     void setMaterial(std::unique_ptr<Material> material);
     void setGeometry(std::unique_ptr<Geometry> geometry);
 

src/rendergraph/common/rendergraph/node.h

@@ -1,18 +1,11 @@
 #pragma once
 
 #include "backend/basenode.h"
-#include "rendergraph/treenode.h"
+#include "rendergraph/nodeinterface.h"
 
 namespace rendergraph {
 class Node;
 } // namespace rendergraph
 
-class rendergraph::Node : public rendergraph::BaseNode, public rendergraph::TreeNode {
-  public:
-    using rendergraph::TreeNode::appendChildNode;
-    using rendergraph::TreeNode::firstChild;
-    using rendergraph::TreeNode::lastChild;
-    using rendergraph::TreeNode::nextSibling;
-    using rendergraph::TreeNode::removeChildNode;
-    Node();
+class rendergraph::Node : public rendergraph::NodeInterface<rendergraph::BaseNode> {
 };

src/rendergraph/common/rendergraph/nodeinterface.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "backend/basenode.h"
+
+namespace rendergraph {
+
+template<class T_Node>
+class NodeInterface : public T_Node {
+  public:
+    void appendChildNode(std::unique_ptr<BaseNode>&& pNode) {
+        T_Node::appendChildNode(pNode.release());
+    }
+    std::unique_ptr<BaseNode> detachChildNode(BaseNode* pNode) {
+        T_Node::removeChildNode(pNode);
+        return std::unique_ptr<BaseNode>(pNode);
+    }
+};
+
+} // namespace rendergraph

src/rendergraph/common/rendergraph/opacitynode.h

@@ -1,19 +1,11 @@
 #pragma once
 
 #include "backend/baseopacitynode.h"
-#include "rendergraph/treenode.h"
+#include "rendergraph/nodeinterface.h"
 
 namespace rendergraph {
 class OpacityNode;
 } // namespace rendergraph
 
-class rendergraph::OpacityNode : public rendergraph::BaseOpacityNode,
-                                 public rendergraph::TreeNode {
-  public:
-    using rendergraph::TreeNode::appendChildNode;
-    using rendergraph::TreeNode::firstChild;
-    using rendergraph::TreeNode::lastChild;
-    using rendergraph::TreeNode::nextSibling;
-    using rendergraph::TreeNode::removeChildNode;
-    OpacityNode();
+class rendergraph::OpacityNode : public rendergraph::NodeInterface<rendergraph::BaseOpacityNode> {
 };

src/rendergraph/examples/common/examplenode.cpp

@@ -16,19 +16,18 @@ using namespace rendergraph;
 
 ExampleNode::ExampleNode(rendergraph::Context* pContext) {
     {
-        TreeNode::appendChildNode(std::make_unique<GeometryNode>());
-        auto pNode = static_cast<GeometryNode*>(TreeNode::lastChild());
+        auto pNode = std::make_unique<GeometryNode>();
         pNode->initForRectangles<TextureMaterial>(1);
         auto& material = dynamic_cast<TextureMaterial&>(pNode->material());
         material.setTexture(std::make_unique<Texture>(
                 pContext, QImage(":/example/images/test.png")));
         TexturedVertexUpdater vertexUpdater{
                 pNode->geometry().vertexDataAs<Geometry::TexturedPoint2D>()};
         vertexUpdater.addRectangle({0, 0}, {100, 100}, {0.f, 0.f}, {1.f, 1.f});
+        appendChildNode(std::move(pNode));
     }
     {
-        TreeNode::appendChildNode(std::make_unique<GeometryNode>());
-        auto pNode = static_cast<GeometryNode*>(TreeNode::lastChild());
+        auto pNode = std::make_unique<GeometryNode>();
         pNode->initForRectangles<rendergraph::UniColorMaterial>(2);
         pNode->material().setUniform(1, QColor(255, 127, 0));
         pNode->geometry().setDrawingMode(Geometry::DrawingMode::Triangles);
@@ -37,16 +36,17 @@ ExampleNode::ExampleNode(rendergraph::Context* pContext) {
                         .vertexDataAs<rendergraph::Geometry::Point2D>()};
         vertexUpdater.addRectangle({100, 100}, {160, 160});
         vertexUpdater.addRectangle({200, 160}, {240, 190});
+        appendChildNode(std::move(pNode));
     }
     {
-        TreeNode::appendChildNode(std::make_unique<GeometryNode>());
-        auto pNode = static_cast<GeometryNode*>(TreeNode::lastChild());
+        auto pNode = std::make_unique<GeometryNode>();
         pNode->initForRectangles<rendergraph::RGBMaterial>(2);
         pNode->geometry().setDrawingMode(Geometry::DrawingMode::Triangles);
         rendergraph::RGBVertexUpdater vertexUpdater{
                 pNode->geometry().vertexDataAs<Geometry::RGBColoredPoint2D>()};
         vertexUpdater.addRectangle({300, 100}, {340, 140}, {1.f, 0.f, 0.5f});
         vertexUpdater.addRectangleHGradient(
                 {340, 100}, {440, 130}, {0.f, 1.f, 0.5f}, {0.5f, 0.f, 1.f});
+        appendChildNode(std::move(pNode));
     }
 }

src/rendergraph/examples/gl_example/window.cpp

@@ -17,8 +17,8 @@ void Window::closeEvent(QCloseEvent*) {
 void Window::initializeGL() {
     rendergraph::Context context;
 
-    auto node = std::make_unique<rendergraph::ExampleNode>(&context);
-    m_pEngine = std::make_unique<rendergraph::Engine>(std::move(node));
+    auto pExampleNode = std::make_unique<rendergraph::ExampleNode>(&context);
+    m_pEngine = std::make_unique<rendergraph::Engine>(std::move(pExampleNode));
 }
 
 void Window::resizeGL(int w, int h) {

src/rendergraph/examples/sg_example/CMakeLists.txt

@@ -12,7 +12,7 @@ target_include_directories(sg_example PRIVATE ../common)
 target_compile_definitions(sg_example PRIVATE rendergraph=rendergraph_sg)
 
 if(QT_VERSION VERSION_LESS "6.3.0")
- set_target_properties(sg_example PROPERTIES AUTOMOC ON)
+    set_target_properties(sg_example PROPERTIES AUTOMOC ON)
 endif()
 
 qt_add_qml_module(sg_example

src/rendergraph/examples/sg_example/customitem.cpp

@@ -44,9 +44,9 @@ QSGNode* CustomItem::updatePaintNode(QSGNode* node, UpdatePaintNodeData*) {
         material->setColor(QColor(255, 0, 0));
 
         rendergraph::Context context(window());
-        m_pExampleNode = std::make_unique<rendergraph::ExampleNode>(&context);
+        auto pExampleNode = std::make_unique<rendergraph::ExampleNode>(&context);
 
-        bgNode->appendChildNode(m_pExampleNode->backendNode());
+        bgNode->appendChildNode(pExampleNode.release());
 
         node = bgNode;
     } else {

src/rendergraph/examples/sg_example/customitem.h

@@ -4,9 +4,7 @@
 #include <QQuickItem>
 #include <memory>
 
-namespace rendergraph {
-class Node;
-}
+#include "rendergraph/node.h"
 
 class CustomItem : public QQuickItem {
     Q_OBJECT
@@ -21,9 +19,6 @@ class CustomItem : public QQuickItem {
     void geometryChange(const QRectF& newGeometry, const QRectF& oldGeometry) override;
 
     bool m_geometryChanged{};
-
-  private:
-    std::unique_ptr<rendergraph::Node> m_pExampleNode;
 };
 
 #endif // CUSTOMITEM_H