outline some ideas about dealing with indexing schemes

devsh · devsh · commit fd87ce74a943 · 2025-05-29T19:25:10.000+02:00
diff --git a/include/nbl/asset/ICPUPolygonGeometry.h b/include/nbl/asset/ICPUPolygonGeometry.h
@@ -46,8 +46,6 @@ class NBL_API2 ICPUPolygonGeometry final : public IAsset, public IPolygonGeometr
                 retval->m_auxAttributeViews.push_back(view.clone(nextDepth));
             retval->m_normalView = m_normalView.clone(nextDepth);
             retval->m_jointCount = m_jointCount;
-            retval->m_verticesForFirst = m_verticesForFirst;
-            retval->m_verticesPerSupplementary = m_verticesPerSupplementary;
             return retval;
         }
 
@@ -92,27 +90,15 @@ class NBL_API2 ICPUPolygonGeometry final : public IAsset, public IPolygonGeometr
         }
 
         //
-        inline bool setVerticesForFirst(const uint16_t count)
+        inline bool setIndexing(const IIndexingCallback* indexing)
         {
             if (isMutable())
             {
-                m_verticesForFirst = count;
+                m_indexing = indexing;
                 return true;
             }
             return false;
         }
-
-        //
-        inline bool setVerticesPerSupplementary(const uint16_t count)
-        {
-            if (isMutable())
-            {
-                m_verticesPerSupplementary = count;
-                return true;
-            }
-            return false;
-        }
-
         //
         inline bool setNormalView(SDataView&& view)
         {
@@ -155,7 +141,17 @@ class NBL_API2 ICPUPolygonGeometry final : public IAsset, public IPolygonGeometr
         template<typename Out, typename Index=uint32_t> requires (hlsl::concepts::UnsignedIntegralScalar<Out> && hlsl::concepts::UnsignedIntegralScalar<Index>)
         inline bool getPrimitiveIndices(Out* out, const Index primitiveID) const
         {
-            // TODO: rename `m_verticesForFirst` to `m_verticesPerPrimitive` or `m_degree`
+            if (!m_indexing)
+                return false;
+            if (m_indexView)
+            {
+            }
+            else
+            {
+            }
+            IIndexingCallback::SContext ctx = {
+                .indexSizeLog2 = m_indexView
+            };
             for (auto i=0; i<m_verticesForFirst; i++)
             {
                 assert(false);
diff --git a/include/nbl/asset/IPolygonGeometry.h b/include/nbl/asset/IPolygonGeometry.h
@@ -11,30 +11,134 @@
 
 namespace nbl::asset
 {
+//
+class NBL_API2 IPolygonGeometryBase : public virtual core::IReferenceCounted
+{
+    public:
+        //
+        class NBL_API2 IIndexingCallback
+        {
+            public:
+                // how many vertices per polygon
+                inline uint8_t degree() const
+                {
+                    const auto retval = degree_impl();
+                    assert(retval>0);
+                    return retval;
+                }
+                //
+                inline uint8_t reuseCount() const
+                {
+                    const auto retval = reuseCount_impl();
+                    assert(retval<degree());
+                    return retval;
+                }
+
+                struct SContext
+                {
+                    template<typename Index> requires std::is_integral_v<Index>
+                    inline Index indexSize() const {return Index(1)<<indexSizeLog2;}
+
+                    template<typename Index> requires std::is_integral_v<Index>
+                    inline void setOutput(const Index value) const
+                    {
+                        switch (indexSizeLog2)
+                        {
+                            case 0:
+                                *reinterpret_cast<uint8_t*>(out) = value;
+                                break;
+                            case 1:
+                                *reinterpret_cast<uint16_t*>(out) = value;
+                                break;
+                            case 2:
+                                *reinterpret_cast<uint32_t*>(out) = value;
+                                break;
+                            case 3:
+                                *reinterpret_cast<uint64_t*>(out) = value;
+                                break;
+                            default:
+                                assert(false);
+                                break;
+                        }
+                    }
+
+                    const uint8_t* const indexBuffer;
+                    // no point making them smaller cause of padding
+                    const uint32_t inSizeLog2;
+                    const uint32_t outSizeLog2;
+                    uint8_t* out;
+                    uint32_t newIndexID;
+                    // if `reuseCount()==0` then should be ignored
+                    uint32_t restartValue = ~0ull;
+                };
+                inline void operator()(SContext& ctx) const
+                {
+                    const auto deg = degree();
+                    if (ctx.newIndexID<deg || primitiveRestart)
+                    {
+// straight up copy
+                    }
+                    operator_impl(ctx);
+                    ctx.newIndexID += reuseCount();
+                    ctx.out += deg<<ctx.outSizeLog2;
+                }
+
+                // default is unknown
+                virtual inline E_PRIMITIVE_TOPOLOGY knownTopology() const {return static_cast<E_PRIMITIVE_TOPOLOGY>(~0);}
+
+            protected:
+                virtual uint8_t degree_impl() const = 0;
+                virtual uint8_t reuseCount_impl() const = 0;
+                // needs to deal with being handed `!ctx.indexBuffer`
+                virtual void operator_impl(const SContext& ctx) const = 0;
+        };
+        //
+        static IIndexingCallback* PointList();
+        static IIndexingCallback* LineList();
+        static IIndexingCallback* TriangleList();
+        static IIndexingCallback* QuadList();
+        //
+        static IIndexingCallback* TriangleStrip();
+        static IIndexingCallback* TriangleFan();
+
+        //
+        inline const IIndexingCallback* getIndexingCallback() const {return m_indexing;}
+
+    protected:
+        virtual ~IPolygonGeometryBase() = default;
+
+        //
+        const IIndexingCallback* m_indexing = nullptr;
+};
+
 // Don't want to overengineer, support for variable vertex count (order) polgyon meshes is not encouraged or planned.
 // If you want different polygon types in same model, bucket the polgyons into separate geometries and reunite in a single collection.
 template<class BufferType>
-class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>
+class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>, public IPolygonGeometryBase
 {
         using base_t = IIndexableGeometry<BufferType>;
 
     protected:
         using EPrimitiveType = base_t::EPrimitiveType;
-        using BLASTriangles = IBottomLevelAccelerationStructure::Triangles<std::remove_const<BufferType>>;
+        using SDataView = base_t::SDataView;
+        using BLASTriangles = IBottomLevelAccelerationStructure::Triangles<std::remove_const_t<BufferType>>;
 
     public:
         //
         virtual inline bool valid() const override
         {
             if (!base_t::valid())
                 return false;
+            if (!m_indexing)
+                return false;
             // things that make no sense
             if (m_verticesPerSupplementary==0 || m_verticesPerSupplementary>m_verticesForFirst)
                 return false;
             // there needs to be at least one vertex to reference (it also needs to be formatted)
-            if (m_positionView.getElementCount()==0)
+            const auto& positionBase = base_t::m_positionView.composed;
+            const auto vertexCount = positionBase.getElementCount();
+            if (vertexCount==0 || !positionBase.isFormatted())
                 return false;
-            const auto vertexCount = m_positionView.getElementCount();
             if (m_normalView && m_normalView.getElementCount()<vertexCount)
                 return false;
             // the variable length vectors must be filled with valid views
@@ -52,18 +156,21 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>
         inline EPrimitiveType getPrimitiveType() const override final {return PrimitiveType;}
 
         //
-        inline const auto& getAABB() const override final {return m_positionView.encodedDataRange;}
+        inline const IGeometryBase::SAABBStorage& getAABB() const override final {return base_t::m_positionView.encodedDataRange;}
 
         //
-        inline uint64_t getVertexReferenceCount() const {return getIndexView() ? getIndexCount():m_positionView.getElementCount();}
+        inline uint64_t getVertexReferenceCount() const {return base_t::getIndexView() ? base_t::getIndexCount():base_t::m_positionView.getElementCount();}
 
         //
         inline uint64_t getPrimitiveCount() const override final
         {
+            if (!m_indexing)
+                return 0;
             const auto vertexReferenceCount = getVertexReferenceCount();
-            if (vertexReferenceCount<m_verticesForFirst)
+            const auto verticesForFirst = m_indexing->degree();
+            if (vertexReferenceCount<verticesForFirst)
                 return 0;
-            return (vertexReferenceCount-m_verticesForFirst)/m_verticesPerSupplementary;
+            return (vertexReferenceCount-verticesForFirst)/(verticesForFirst-m_indexing->reuseCount());
         }
 
         // For when the geometric normal of the patch isn't enough and you want interpolated custom normals
@@ -92,11 +199,6 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>
         // For User defined semantics
         inline const core::vector<SDataView>& getAuxAttributeViews() const {return m_auxAttributeViews;}
 
-        // Simple geometries like point, line, triangle and patch have `m_verticesForFirst==m_verticesPerSupplementary`
-        // Note that this is also true for adjacency lists, but they're the reason `m_verticesForFirst` is not named `m_order` or `m_n`
-        // While strips and fans have `m_verticesForFirst>m_verticesPerSupplementary`
-        inline uint16_t getVerticesForFirst() const {return m_verticesForFirst;}
-        inline uint16_t getVerticesPerSupplementary() const {return m_verticesPerSupplementary;}
 
         // Does not set the `transform` or `geometryFlags` fields, because it doesn't care about it.
         // Also won't set second set of vertex data, opacity mipmaps, etc.
@@ -108,9 +210,9 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>
             {
                 auto indexType = EIT_UNKNOWN;
                 // disallowed index format
-                if (m_indexView)
+                if (base_t::m_indexView)
                 {
-                    switch (m_indexView.format)
+                    switch (base_t::m_indexView.format)
                     {
                         case EF_R16_UINT:
                             indexType = EIT_16BIT;
@@ -124,11 +226,11 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>
                     if (indexType==EIT_UNKNOWN)
                         return retval;
                 }
-                retval.vertexData[0] = m_positionView;
-                retval.indexData = m_indexView;
-                retval.maxVertex = m_positionView.getElementCount();
-                retval.vertexStride = m_positionView.getStride();
-                retval.vertexFormat = m_positionView.format;
+                retval.vertexData[0] = base_t::m_positionView;
+                retval.indexData = base_t::m_indexView;
+                retval.maxVertex = base_t::m_positionView.getElementCount();
+                retval.vertexStride = base_t::m_positionView.getStride();
+                retval.vertexFormat = base_t::m_positionView.format;
                 retval.indexType = indexType;
             }
             return retval;
@@ -137,6 +239,17 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>
     protected:
         virtual ~IPolygonGeometry() = default;
 
+        //
+        inline bool setIndexView(SDataView&& view)
+        {
+            if (!view || view.isFormattedScalarInteger())
+            {
+                m_indexView = std::move(view);
+                return true;
+            }
+            return false;
+        }
+
         //
         core::vector<SJointWeight> m_jointWeightViews = {};
         //
@@ -145,9 +258,6 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>
         SDataView m_normalView = {};
         //
         uint32_t m_jointCount = 0;
-        //
-        uint16_t m_verticesForFirst = 1;
-        uint16_t m_verticesPerSupplementary = 0;
 };
 
 }
diff --git a/src/nbl/asset/ICPUPolygonGeometry.cpp b/src/nbl/asset/ICPUPolygonGeometry.cpp
@@ -0,0 +1,84 @@
+#include "nbl/asset/ICPUPolygonGeometry.h"
+
+using namespace nbl;
+using namespace asset;
+
+
+template<uint8_t Order> requires (Order>0)
+class CListIndexingCB final : public IPolygonGeometryBase::IIndexingCallback
+{
+    inline uint8_t degree_impl() const override {return Order;}
+    inline uint8_t reuseCount_impl() const override {return 0;}
+    inline void operator_impl(const SContext& ctx) const override
+    {
+        if (ctx.indexBuffer)
+            memcpy(ctx.out,ctx.indexBuffer+(ctx.newIndexID<<ctx.indexSizeLog2),Order<<ctx.indexSizeLog2);
+        else
+        for (auto i=0u; i<Order; i++)
+        {
+            ctx.setOutput(ctx.newIndexID+i);
+            ctx.out += ctx.indexSize();
+        }
+    }
+};
+auto IPolygonGeometryBase::PointList() -> IIndexingCallback*
+{
+    static CListIndexingCB<1> singleton;
+    return &singleton;
+}
+auto IPolygonGeometryBase::LineList() -> IIndexingCallback*
+{
+    static CListIndexingCB<2> singleton;
+    return &singleton;
+}
+auto IPolygonGeometryBase::TriangleList() -> IIndexingCallback*
+{
+    static CListIndexingCB<3> singleton;
+    return &singleton;
+}
+auto IPolygonGeometryBase::QuadList() -> IIndexingCallback*
+{
+    static CListIndexingCB<4> singleton;
+    return &singleton;
+}
+
+class CTriangleStripIndexingCB final : public IIndexingCallback
+{
+    inline uint8_t degree_impl() const override {return 3;}
+    inline uint8_t reuseCount_impl() const override {return 2;}
+    inline void operator_impl(const SContext& ctx) const override
+    {
+        // two immediately previous and current
+        memcpy(out,indexBuffer+(newIndexID-2)*indexSize,indexSize*3);
+    }
+};
+auto IPolygonGeometryBase::TriangleStrip() -> IIndexingCallback*
+{
+    static CTriangleStripIndexingCB singleton;
+    return &singleton;
+}
+
+class CTriangleFanIndexingCB final : public IIndexingCallback
+{
+    inline uint8_t degree_impl() const override {return 3;}
+    inline uint8_t reuseCount_impl() const override {return 2;}
+    inline void operator_impl(const SContext& ctx) const override
+    {
+        // first index is always 0
+        memset(ctx.out,0,ctx.indexSize());
+        ctx.out += ctx.indexSize();
+        // immediately previous and current
+        if (ctx.indexBuffer)
+            memcpy(ctx.out,ctx.indexBuffer+((ctx.newIndexID-1)<<ctx.indexSizeLog2),2u<<ctx.indexSizeLog2);
+        else
+        {
+            ctx.setOutput(ctx.newIndexID-1);
+            ctx.setOutput(ctx.newIndexID);
+        }
+    }
+};
+auto IPolygonGeometryBase::TriangleFan() -> IIndexingCallback*
+{
+    static CTriangleFanIndexingCB singleton;
+    return &singleton;
+}
