finalize my indexing abstraction logic

Author: devsh

include/nbl/asset/ICPUPolygonGeometry.h

@@ -137,39 +137,32 @@ class NBL_API2 ICPUPolygonGeometry final : public IAsset, public IPolygonGeometr
             return nullptr;
         }
 
-        //
-        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
+        // We don't care about primitive restart, you need to check for it yourself.
+        // Unlike OpenGL and other APIs we don't adjust the Primitive ID because that breaks parallel processing.
+        // So a triangle strip `{ 0 1 2 3 RESTART 2 3 4 5 }` means 7 primitives, of which 3 are invalid (contain the restart index) 
+        template<typename Out> requires hlsl::concepts::UnsignedIntegralScalar<Out>
+        inline bool getPrimitiveIndices(Out* out, const uint32_t beginPrimitive, const uint32_t endPrimitive) const
         {
             if (!m_indexing)
                 return false;
-            if (m_indexView)
-            {
-            }
-            else
-            {
-            }
             IIndexingCallback::SContext ctx = {
-                .indexSizeLog2 = m_indexView
+                .indexBuffer = m_indexView.getPointer(),
+                .indexSize = getTexelOrBlockBytesize(m_indexView.composed.format),
+                .beginPrimitive = beginPrimitive,
+                .endPrimitive = endPrimitive,
+                .out = out
             };
-            for (auto i=0; i<m_verticesForFirst; i++)
-            {
-                assert(false);
-                indexID = 0xdeadbeefBADC0FFEull; // TODO: need a callback for index mapping
-                if (m_indexView)
-                {
-                    hlsl::vector<Uint,1> tmp;
-                    if (!m_indexView.decodeElement<decltype(tmp),Index>(indexID,tmp));
-                        return false;
-                    *out = tmp[0];
-                }
-                else
-                    *out = indexID;
-                out++;
-            }
+            m_indexing->operator()(ctx);
             return true;
         }
 
+        //
+        template<typename Out>
+        inline bool getPrimitiveIndices(Out* out, const uint32_t primitiveID) const
+        {
+            return getPrimitiveIndices(out,primtiveID,primtiveID+1);
+        }
+
     protected:
         //
         inline void visitDependents(std::function<bool(const IAsset*)> visit) const //override

include/nbl/asset/IPolygonGeometry.h

@@ -8,6 +8,7 @@
 #include "nbl/asset/IGeometry.h"
 #include "nbl/asset/IAccelerationStructure.h"
 
+#include <span>
 
 namespace nbl::asset
 {
@@ -26,87 +27,91 @@ class NBL_API2 IPolygonGeometryBase : public virtual core::IReferenceCounted
                     assert(retval>0);
                     return retval;
                 }
-                //
-                inline uint8_t reuseCount() const
+                // at which we consume indices for each new polygon
+                inline uint8_t rate() const
                 {
-                    const auto retval = reuseCount_impl();
-                    assert(retval<degree());
+                    const auto retval = rate_impl();
+                    assert(retval>0 && retval<=degree());
                     return retval;
                 }
 
-                struct SContext
+                template<typename OutT> requires (sizeof(OutT)<8 && hlsl::concepts::UnsignedIntegralScalar<OutT>)
+                struct SContext final
                 {
-                    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
+                    // `indexOfIndex` is somewhat of a baseIndex
+                    inline void streamOut(const uint32_t indexOfIndex, const std::span<const int32_t> permutation)
                     {
-                        switch (indexSizeLog2)
+                        auto& typedOut = reinterpret_cast<OutT*&>(out);
+                        if (indexBuffer)                  
+                        switch (indexSize)
                         {
-                            case 0:
-                                *reinterpret_cast<uint8_t*>(out) = value;
-                                break;
                             case 1:
-                                *reinterpret_cast<uint16_t*>(out) = value;
+                                for (const auto relIx : permutation)
+                                    *(typedOut++) = reinterpret_cast<const uint8_t*>(indexBuffer)[indexOfIndex+relIx];
                                 break;
                             case 2:
-                                *reinterpret_cast<uint32_t*>(out) = value;
+                                for (const auto relIx : permutation)
+                                    *(typedOut++) = reinterpret_cast<const uint16_t*>(indexBuffer)[indexOfIndex+relIx];
                                 break;
-                            case 3:
-                                *reinterpret_cast<uint64_t*>(out) = value;
+                            case 4:
+                                for (const auto relIx : permutation)
+                                    *(typedOut++) = reinterpret_cast<const uint32_t*>(indexBuffer)[indexOfIndex+relIx];
                                 break;
                             default:
                                 assert(false);
                                 break;
                         }
+                        else
+                        for (const auto relIx : permutation)
+                            *(typedOut++) = indexOfIndex+relIx;
                     }
 
-                    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;
+                    // always the base pointer, doesn't get advanced
+                    const void* const indexBuffer;
+                    const uint64_t indexSize : 3;
+                    const uint64_t beginPrimitive : 30;
+                    const uint64_t endPrimitive : 31;
+                    void* out;
                 };
-                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;
-                }
+                // could have been a static if not virtual
+                virtual void operator()(SContext<uint8_t>& ctx) const = 0;
+                virtual void operator()(SContext<uint16_t>& ctx) const = 0;
+                virtual void operator()(SContext<uint32_t>& ctx) const = 0;
 
                 // 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;
+                virtual uint8_t rate_impl() const = 0;
         };
         //
         static IIndexingCallback* PointList();
         static IIndexingCallback* LineList();
         static IIndexingCallback* TriangleList();
         static IIndexingCallback* QuadList();
-        //
+        // TODO: Adjacency, Patch, etc.
         static IIndexingCallback* TriangleStrip();
         static IIndexingCallback* TriangleFan();
 
-        //
+        // This should be a pointer to a stateless singleton (think of it more like a dynamic enum/template than anything else)
         inline const IIndexingCallback* getIndexingCallback() const {return m_indexing;}
 
     protected:
         virtual ~IPolygonGeometryBase() = default;
 
+        // indexing callback cannot be cleared
+        bool setIndexingCallback(IIndexingCallback* indexing)
+        {
+            if (!indexing)
+                return false;
+            const auto deg = m_indexing->degree();
+            if (deg==0 || m_indexing->rate()==0 || m_indexing->rate()>deg)
+                return false;
+            m_indexing = indexing;
+            return true;
+        }
+
         //
         const IIndexingCallback* m_indexing = nullptr;
 };
@@ -131,9 +136,6 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>, public
                 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)
             const auto& positionBase = base_t::m_positionView.composed;
             const auto vertexCount = positionBase.getElementCount();
@@ -170,7 +172,7 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>, public
             const auto verticesForFirst = m_indexing->degree();
             if (vertexReferenceCount<verticesForFirst)
                 return 0;
-            return (vertexReferenceCount-verticesForFirst)/(verticesForFirst-m_indexing->reuseCount());
+            return (vertexReferenceCount-verticesForFirst)/m_indexing->rate()+1;
         }
 
         // For when the geometric normal of the patch isn't enough and you want interpolated custom normals
@@ -205,8 +207,8 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>, public
         inline BLASTriangles exportForBLAS() const
         {
             BLASTriangles retval = {};
-            // must be a triangle list 
-            if (m_verticesForFirst==3 && m_verticesPerSupplementary==3)
+            // must be a triangle list, but don't want to compare pointers
+            if (m_indexing && m_indexing->knownTopology()==EPT_TRIANGLE_LIST)// && m_indexing->degree() == TriangleList()->degree() && m_indexing->rate() == TriangleList->rate())
             {
                 auto indexType = EIT_UNKNOWN;
                 // disallowed index format
@@ -239,15 +241,20 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>, public
     protected:
         virtual ~IPolygonGeometry() = default;
 
-        //
+        // 64bit indices are just too much to deal with in all the other code
+        // Also if you have more than 2G vertex references in a single geometry there's something wrong with your architecture
+        // Note that this still allows 6GB vertex attribute streams (assuming at least 3 bytes for a postion)
         inline bool setIndexView(SDataView&& view)
         {
-            if (!view || view.isFormattedScalarInteger())
+            if (view)
             {
-                m_indexView = std::move(view);
-                return true;
+                if (!view.isFormattedScalarInteger() || view.format == EF_R64_UINT || view.format == EF_R64_SINT)
+                    return false;
+                if (view.getElementCount()>(1u<<31))
+                    return false;
             }
-            return false;
+            m_indexView = std::move(view);
+            return true;
         }
 
         //

src/nbl/asset/ICPUPolygonGeometry.cpp

@@ -1,25 +1,43 @@
 #include "nbl/asset/ICPUPolygonGeometry.h"
 
+#include <ranges>
+
 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++)
+        template<typename OutT>
+        static void operator_impl(SContext<OutT>& ctx)
+        {
+            auto indexOfIndex = ctx.beginPrimitive*3;
+            for (const auto end=ctx.endPrimitive*3; indexOfIndex!=end; indexOfIndex+=3)
+                ctx.streamOut(indexOfIndex,std::ranges::iota_view{0,Order});
+        }
+
+    public:
+        uint8_t degree_impl() const override {return Order;}
+        uint8_t rate_impl() const override {return Order;}
+        void operator()(SContext<uint8_t>& ctx) const override {operator_impl(ctx);}
+        void operator()(SContext<uint16_t>& ctx) const override {operator_impl(ctx);}
+        void operator()(SContext<uint32_t>& ctx) const override {operator_impl(ctx);}
+
+        E_PRIMITIVE_TOPOLOGY knownTopology() const override
         {
-            ctx.setOutput(ctx.newIndexID+i);
-            ctx.out += ctx.indexSize();
+            switch (Order)
+            {
+                case 1:
+                    return EPT_POINT_LIST;
+                case 2:
+                    return EPT_LINE_LIST;
+                case 3:
+                    return EPT_TRIANGLE_LIST;
+                default:
+                    return EPT_PATCH_LIST;
+            }
         }
-    }
 };
 auto IPolygonGeometryBase::PointList() -> IIndexingCallback*
 {
@@ -44,13 +62,30 @@ auto IPolygonGeometryBase::QuadList() -> IIndexingCallback*
 
 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);
-    }
+        template<typename OutT>
+        static void operator_impl(SContext<OutT>& ctx)
+        {
+            auto indexOfIndex;
+            if (ctx.beginPrimitive==0)
+            {
+                ctx.streamOut(0,std::ranges::iota_view{0,3});
+                indexOfIndex = 3;
+            }
+            else
+                indexOfIndex = ctx.beginPrimitive+2;
+            const int32_t perm[] = {-1,-2,0};
+            for (const auto end=ctx.endPrimitive+2; indexOfIndex!=end; indexOfIndex++)
+                ctx.streamOut(indexOfIndex,perm);
+        }
+
+    public:
+        inline uint8_t degree_impl() const override { return 3; }
+        inline uint8_t rate_impl() const override { return 1; }
+        void operator()(SContext<uint8_t>& ctx) const override { operator_impl(ctx); }
+        void operator()(SContext<uint16_t>& ctx) const override { operator_impl(ctx); }
+        void operator()(SContext<uint32_t>& ctx) const override { operator_impl(ctx); }
+
+        E_PRIMITIVE_TOPOLOGY knownTopology() const override {return EPT_TRIANGLE_STRIP;}
 };
 auto IPolygonGeometryBase::TriangleStrip() -> IIndexingCallback*
 {
@@ -60,22 +95,34 @@ auto IPolygonGeometryBase::TriangleStrip() -> IIndexingCallback*
 
 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
+        template<typename OutT>
+        static void operator_impl(SContext<OutT>& ctx)
         {
-            ctx.setOutput(ctx.newIndexID-1);
-            ctx.setOutput(ctx.newIndexID);
+            auto indexOfIndex;
+            if (ctx.beginPrimitive==0)
+            {
+                ctx.streamOut(0,std::ranges::iota_view{0,3});
+                indexOfIndex = 3;
+            }
+            else
+                indexOfIndex = ctx.beginPrimitive+2;
+            int32_t perm[] = {0xdeadbeefu,-1,0};
+            for (const auto end=ctx.endPrimitive+2; indexOfIndex!=end; indexOfIndex++)
+            {
+                // first index is always global 0
+                perm[0] = -indexOfIndex;
+                ctx.streamOut(indexOfIndex,perm);
+            }
         }
-    }
+
+    public:
+        inline uint8_t degree_impl() const override {return 3;}
+        inline uint8_t rate_impl() const override {return 1;}
+        void operator()(SContext<uint8_t>& ctx) const override { operator_impl(ctx); }
+        void operator()(SContext<uint16_t>& ctx) const override { operator_impl(ctx); }
+        void operator()(SContext<uint32_t>& ctx) const override { operator_impl(ctx); }
+
+        E_PRIMITIVE_TOPOLOGY knownTopology() const override {return EPT_TRIANGLE_STRIP;}
 };
 auto IPolygonGeometryBase::TriangleFan() -> IIndexingCallback*
 {