removed class Attribute and use BaseGeometry::Attribute to reduce del…

…ta between opengl and scenegraph

src/rendergraph/common/rendergraph/attributeinit.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "rendergraph/types.h"
+
+namespace rendergraph {
+struct AttributeInit;
+}
+
+struct rendergraph::AttributeInit {
+    int m_tupleSize;
+    PrimitiveType m_primitiveType;
+
+    template<typename T>
+    static AttributeInit create() {
+        return AttributeInit{tupleSizeOf<T>(), primitiveTypeOf<T>()};
+    }
+};

src/rendergraph/common/rendergraph/attributeset.h

@@ -1,20 +1,20 @@
 #pragma once
 
 #include "backend/baseattributeset.h"
+#include "rendergraph/attributeinit.h"
 
 namespace rendergraph {
 class AttributeSet;
 }
 
 class rendergraph::AttributeSet : public rendergraph::BaseAttributeSet {
   public:
-    AttributeSet(std::initializer_list<Attribute> list, const std::vector<QString>& names);
-    const std::vector<Attribute>& attributes() const;
+    AttributeSet(std::initializer_list<AttributeInit> list, const std::vector<QString>& names);
 };
 
 namespace rendergraph {
 template<typename... T>
 AttributeSet makeAttributeSet(const std::vector<QString>& names) {
-    return AttributeSet({(Attribute::create<T>())...}, names);
+    return AttributeSet({(AttributeInit::create<T>())...}, names);
 }
 } // namespace rendergraph

src/rendergraph/common/rendergraph/geometry.h

@@ -52,19 +52,34 @@ class rendergraph::Geometry : public rendergraph::BaseGeometry {
     };
 
     Geometry(const rendergraph::AttributeSet& attributeSet, int vertexCount);
-    ~Geometry();
 
-    void allocate(int vertexCount);
+    const Attribute* attributes() const {
+        return BaseGeometry::attributes();
+    }
 
     void setAttributeValues(int attributePosition, const float* data, int numTuples);
 
-    float* vertexData();
+    int attributeCount() const {
+        return BaseGeometry::attributeCount();
+    }
+
+    void allocate(int vertexCount) {
+        BaseGeometry::allocate(vertexCount);
+    }
+
+    int sizeOfVertex() const {
+        return BaseGeometry::sizeOfVertex();
+    }
+    int vertexCount() const {
+        return BaseGeometry::vertexCount();
+    }
 
     template<typename T>
     T* vertexDataAs() {
         return reinterpret_cast<T*>(vertexData());
     }
 
     DrawingMode drawingMode() const;
+
     void setDrawingMode(DrawingMode mode);
 };

src/rendergraph/opengl/CMakeLists.txt

@@ -1,9 +1,8 @@
 add_library(rendergraph_gl
-../common/attributeset.cpp
 ../common/treenode.cpp
 ../common/node.cpp
 ../common/opacitynode.cpp
-../common/rendergraph/attribute.h
+../common/rendergraph/attributeinit.h
 ../common/rendergraph/attributeset.h
 ../common/rendergraph/treenode.h
 ../common/rendergraph/geometry.h
@@ -49,6 +48,7 @@ backend/baseopenglnode.cpp
 backend/baseopenglnode.h
 backend/shadercache.h
 backend/basetexture.h
+attributeset.cpp
 treenode.cpp
 engine.cpp
 geometry.cpp

src/rendergraph/opengl/attributeset.cpp

@@ -0,0 +1,8 @@
+#include "rendergraph/attributeset.h"
+
+using namespace rendergraph;
+
+AttributeSet::AttributeSet(std::initializer_list<AttributeInit> list,
+        const std::vector<QString>& names)
+        : BaseAttributeSet(list, names) {
+}

src/rendergraph/opengl/backend/baseattributeset.cpp

@@ -3,12 +3,16 @@
 
 using namespace rendergraph;
 
-BaseAttributeSet::BaseAttributeSet(std::initializer_list<Attribute> list,
+BaseAttributeSet::BaseAttributeSet(std::initializer_list<AttributeInit> list,
         const std::vector<QString>& names) {
     DEBUG_ASSERT(list.size() == names.size());
     int i = 0;
+    int offset = 0;
     m_attributes.reserve(list.size());
     for (auto item : list) {
-        m_attributes.push_back(Attribute{item.m_tupleSize, item.m_primitiveType, names[i++]});
+        m_attributes.push_back(BaseGeometry::Attribute{
+                offset, item.m_tupleSize, item.m_primitiveType, names[i++]});
+        offset += item.m_tupleSize * sizeOf(item.m_primitiveType);
     }
+    m_sizeOfVertex = offset;
 }

src/rendergraph/opengl/backend/baseattributeset.h

@@ -3,14 +3,26 @@
 #include <initializer_list>
 #include <vector>
 
-#include "rendergraph/attribute.h"
+#include "backend/basegeometry.h"
+#include "rendergraph/attributeinit.h"
 
 namespace rendergraph {
 class BaseAttributeSet;
 }
 
 class rendergraph::BaseAttributeSet {
   protected:
-    BaseAttributeSet(std::initializer_list<Attribute> list, const std::vector<QString>& names);
-    std::vector<Attribute> m_attributes;
+    BaseAttributeSet(std::initializer_list<AttributeInit> list, const std::vector<QString>& names);
+
+  public:
+    const std::vector<BaseGeometry::Attribute>& attributes() const {
+        return m_attributes;
+    }
+    int sizeOfVertex() const {
+        return m_sizeOfVertex;
+    }
+
+  protected:
+    std::vector<BaseGeometry::Attribute> m_attributes;
+    int m_sizeOfVertex;
 };

src/rendergraph/opengl/backend/basegeometry.cpp

@@ -1,41 +1,21 @@
 #include "backend/basegeometry.h"
 
+#include "backend/baseattributeset.h"
 #include "rendergraph/geometry.h"
 
 using namespace rendergraph;
 
-BaseGeometry::BaseGeometry(
-        const AttributeSet& attributeSet, int vertexCount)
-        : m_drawingMode(static_cast<int>(Geometry::DrawingMode::
-                          TriangleStrip)) // to mimic sg default
-          ,
-          m_vertexCount(vertexCount) {
-    int offset = 0;
-    for (const auto& attribute : attributeSet.attributes()) {
-        m_offsets.push_back(offset);
-        offset += attribute.m_tupleSize;
-        m_tupleSizes.push_back(attribute.m_tupleSize);
-    }
-    m_stride = offset * sizeof(float);
-    m_data.resize(offset * vertexCount);
-}
-
-int BaseGeometry::attributeCount() const {
-    return m_tupleSizes.size();
-}
-
-int BaseGeometry::vertexCount() const {
-    return m_vertexCount;
-}
+namespace {
+// to mimic sg default
+constexpr int defaultDrawingMode = static_cast<int>(Geometry::DrawingMode::TriangleStrip);
+} // namespace
 
-int BaseGeometry::offset(int attributeIndex) const {
-    return m_offsets[attributeIndex];
-}
-
-int BaseGeometry::tupleSize(int attributeIndex) const {
-    return m_tupleSizes[attributeIndex];
-}
-
-int BaseGeometry::stride() const {
-    return m_stride;
+BaseGeometry::BaseGeometry(
+        const BaseAttributeSet& attributeSet, int vertexCount)
+        : m_pAttributes(attributeSet.attributes().data()),
+          m_attributeCount(attributeSet.attributes().size()),
+          m_sizeOfVertex(attributeSet.sizeOfVertex()),
+          m_drawingMode(defaultDrawingMode),
+          m_vertexCount(vertexCount),
+          m_vertexData(m_vertexCount * m_sizeOfVertex / sizeof(float)) {
 }

src/rendergraph/opengl/backend/basegeometry.h

@@ -1,29 +1,56 @@
 #pragma once
 
+#include <QString>
 #include <vector>
 
-#include "rendergraph/attributeset.h"
+#include "rendergraph/types.h"
 
 namespace rendergraph {
+class BaseAttributeSet; // fwd decl to avoid circular dependency
 class BaseGeometry;
 }
 
+// TODO this assumes all vertices consist of floats
 class rendergraph::BaseGeometry {
   protected:
-    BaseGeometry(const AttributeSet& attributeSet, int vertexCount);
+    BaseGeometry(const BaseAttributeSet& attributeSet, int vertexCount);
 
   public:
-    int attributeCount() const;
-    int vertexCount() const;
-    int offset(int attributeIndex) const;
-    int tupleSize(int attributeIndex) const;
-    int stride() const;
+    struct Attribute {
+        const int m_offset;
+        const int m_tupleSize;
+        const PrimitiveType m_primitiveType;
+        const QString m_name;
+    };
+
+    float* vertexData() {
+        return m_vertexData.data();
+    }
+    const float* vertexData() const {
+        return m_vertexData.data();
+    }
+    const Attribute* attributes() const {
+        return m_pAttributes;
+    }
+    int attributeCount() const {
+        return m_attributeCount;
+    }
+    int vertexCount() const {
+        return m_vertexCount;
+    }
+    int sizeOfVertex() const { // in bytes
+        return m_sizeOfVertex;
+    }
+    void allocate(int vertexCount) {
+        m_vertexCount = vertexCount;
+        m_vertexData.resize(m_vertexCount * sizeOfVertex() / sizeof(float));
+    }
 
   protected:
+    const Attribute* m_pAttributes;
+    const int m_attributeCount;
+    const int m_sizeOfVertex;
     int m_drawingMode;
     int m_vertexCount;
-    std::vector<int> m_tupleSizes;
-    std::vector<int> m_offsets;
-    int m_stride;
-    std::vector<float> m_data;
+    std::vector<float> m_vertexData;
 };

src/rendergraph/opengl/backend/basegeometrynode.cpp

@@ -70,13 +70,17 @@ void BaseGeometryNode::renderBackend() {
         }
     }
 
+    // TODO this code assumes all vertices are floats
+    int vertexOffset = 0;
     for (int i = 0; i < geometry.attributeCount(); i++) {
+        const Geometry::Attribute& attribute = geometry.attributes()[i];
         int location = material.attributeLocation(i);
         shader.enableAttributeArray(location);
         shader.setAttributeArray(location,
-                geometry.vertexData() + geometry.offset(i),
-                geometry.tupleSize(i),
-                geometry.stride());
+                geometry.vertexDataAs<float>() + vertexOffset,
+                attribute.m_tupleSize,
+                geometry.sizeOfVertex());
+        vertexOffset += attribute.m_tupleSize;
     }
 
     // TODO multiple textures

src/rendergraph/opengl/geometry.cpp

@@ -9,41 +9,33 @@ Geometry::Geometry(const AttributeSet& attributeSet, int vertexCount)
         : BaseGeometry(attributeSet, vertexCount) {
 }
 
-Geometry::~Geometry() = default;
-
 void Geometry::setAttributeValues(int attributePosition, const float* from, int numTuples) {
-    const int offset = m_offsets[attributePosition];
-    const int tupleSize = m_tupleSizes[attributePosition];
-    const int strideNumberOfFloats = m_stride / sizeof(float);
-    const int skip = strideNumberOfFloats - tupleSize;
+    // TODO this code assumes all vertices are floats
+    VERIFY_OR_DEBUG_ASSERT(attributePosition < attributeCount()) {
+        return;
+    }
+    const int vertexOffset = attributes()[attributePosition].m_offset / sizeof(float);
+    const int tupleSize = attributes()[attributePosition].m_tupleSize;
+    const int vertexStride = sizeOfVertex() / sizeof(float);
+    const int vertexSkip = vertexStride - tupleSize;
 
-    VERIFY_OR_DEBUG_ASSERT(offset + numTuples * strideNumberOfFloats - skip <=
-            static_cast<int>(m_data.size())) {
+    VERIFY_OR_DEBUG_ASSERT(vertexOffset + numTuples * vertexStride - vertexSkip <=
+            static_cast<int>(m_vertexData.size())) {
         return;
     }
 
-    float* to = m_data.data();
-    to += offset;
+    float* to = m_vertexData.data();
+    to += vertexOffset;
 
     while (numTuples--) {
         int k = tupleSize;
         while (k--) {
             *to++ = *from++;
         }
-        to += skip;
+        to += vertexSkip;
     }
 }
 
-float* Geometry::vertexData() {
-    return m_data.data();
-}
-
-void Geometry::allocate(int vertexCount) {
-    const int strideNumberOfFloats = m_stride / sizeof(float);
-    m_vertexCount = vertexCount;
-    m_data.resize(strideNumberOfFloats * m_vertexCount);
-}
-
 void Geometry::setDrawingMode(Geometry::DrawingMode mode) {
     m_drawingMode = static_cast<int>(mode);
 }