feat: attempt to address rendering problems with radv mesa

Signed-off-by: Michael Pollind <[email protected]>

HPL2/include/graphics/ForgeRenderer.h

@@ -11,6 +11,7 @@
 
 #include <engine/RTTI.h>
 
+#include "Common_3/Utilities/RingBuffer.h"
 #include "graphics/ForgeHandles.h"
 #include "windowing/NativeWindow.h"
 #include "engine/QueuedEventLoopHandler.h"
@@ -54,13 +55,12 @@ namespace hpl {
             CopyPipelineCount = 2
         };
 
+
         static constexpr uint32_t MaxCopyFrames = 32;
         static constexpr uint32_t SwapChainLength = 2; // double buffered
         static constexpr uint32_t ResourcePoolSize = 4; // double buffered
 
         void InitializeRenderer(window::NativeWindowWrapper* window);
-        void InitializeResource();
-        //RendererApi GetApi();
 
         struct SamplerPoolKey {
             union {
@@ -104,9 +104,13 @@ namespace hpl {
         * tracks the resources used by a single command buffer
         */
         struct Frame {
+        public:
             uint32_t m_currentFrame = 0;
             uint32_t m_frameIndex = 0;
-            uint32_t m_swapChainIndex = 0;
+            GpuCmdRingElement m_cmdRingElement;
+            bool m_isFinished = true;
+            //FrameState m_state = FrameState::Unitialize;
+
             ForgeRenderer* m_renderer = nullptr;
             SwapChain* m_swapChain = nullptr;
             Cmd* m_cmd = nullptr;
@@ -115,26 +119,37 @@ namespace hpl {
             Semaphore* m_renderCompleteSemaphore = nullptr;
             CommandResourcePool* m_resourcePool = nullptr;
             RenderTarget* m_finalRenderTarget = nullptr;
-            std::vector<Semaphore*>* m_waitSemaphores;
-        };
 
 
-        const inline Frame GetFrame() {
-            Frame frame;
-            frame.m_currentFrame = FrameCount();
-            frame.m_frameIndex = CurrentFrameIndex();
-            frame.m_swapChainIndex = SwapChainIndex();
-            frame.m_renderer = this;
-            frame.m_swapChain = m_swapChain.m_handle;
-
-            frame.m_cmd = m_cmds[CurrentFrameIndex()];
-            frame.m_cmdPool = m_cmdPools[CurrentFrameIndex()];
-            frame.m_renderCompleteFence = m_renderCompleteFences[CurrentFrameIndex()];
-            frame.m_renderCompleteSemaphore = m_renderCompleteSemaphores[CurrentFrameIndex()];
-            frame.m_resourcePool = &m_resourcePool[CurrentFrameIndex()];
-            frame.m_finalRenderTarget = m_finalRenderTarget[CurrentFrameIndex()].m_handle;
-            frame.m_waitSemaphores = &m_waitSemaphores[CurrentFrameIndex()];
-            return frame;
+            template<typename T>
+            inline void pushResource(const T& ele) {
+                m_resourcePool->Push(ele);
+            }
+            inline uint32_t index() {
+                return m_frameIndex;
+            }
+
+            inline Cmd*& cmd() {
+                return m_cmdRingElement.pCmds[0];
+            }
+
+            inline RenderTarget* finalTarget() {
+                return m_finalRenderTarget;
+            }
+
+           // inline RenderTarget* swapChainTarget() {
+           //     return m_swapChainTarget;
+           // }
+
+            inline GpuCmdRingElement& RingElement() {
+                return m_cmdRingElement;
+            }
+
+            friend class ForgeRenderer;
+        };
+
+        inline Frame& GetFrame() {
+            return m_frame;
         }
         // void BeginFrame() {}
 
@@ -147,10 +162,6 @@ namespace hpl {
         }
         RootSignature* PipelineSignature() { return m_pipelineSignature; }
 
-        size_t SwapChainIndex() { return m_swapChainIndex; }
-        size_t CurrentFrameIndex() { return m_currentFrameCount % SwapChainLength; }
-        size_t FrameCount() { return m_currentFrameCount; }
-        inline SwapChain* GetSwapChain() { return m_swapChain.m_handle; }
         inline Queue* GetGraphicsQueue() { return m_graphicsQueue; }
 
         void cmdCopyTexture(Cmd* cmd, Texture* srcTexture, RenderTarget* dstTexture);
@@ -160,20 +171,15 @@ namespace hpl {
     private:
         std::array<Sampler*, SamplerPoolKey::NumOfVariants> m_samplerPool;
         std::array<CommandResourcePool, SwapChainLength> m_resourcePool;
-        std::array<Fence*, SwapChainLength> m_renderCompleteFences;
-        std::array<Semaphore*, SwapChainLength> m_renderCompleteSemaphores;
         std::array<CmdPool*, SwapChainLength> m_cmdPools;
         std::array<Cmd*, SwapChainLength> m_cmds;
         std::array<SharedRenderTarget, SwapChainLength> m_finalRenderTarget;
 
-        std::array<std::vector<Semaphore*>, SwapChainLength> m_waitSemaphores;
-
-
-        float m_gamma = 1.0f;
-
         window::WindowEvent::QueuedEventHandler m_windowEventHandler;
         window::NativeWindowWrapper* m_window = nullptr;
 
+        GpuCmdRing m_graphicsCmdRing;
+
         Renderer* m_renderer = nullptr;
         RootSignature* m_pipelineSignature = nullptr;
         SharedSwapChain m_swapChain;
@@ -192,11 +198,14 @@ namespace hpl {
         SharedSampler m_pointSampler ;
 
         RootSignature* m_copyPostProcessingRootSignature = nullptr;
-        DescriptorSet* m_copyPostProcessingDescriptorSet = nullptr;
+        std::array<DescriptorSet*, SwapChainLength> m_copyPostProcessingDescriptorSet ;
         uint32_t m_copyRegionDescriptorIndex = 0;
+        float m_gamma = 1.0f;
+        uint32_t m_swapChainCount;
+
+
+        Frame m_frame;
 
-        uint32_t m_currentFrameCount = 0;
-        uint32_t m_swapChainIndex = 0;
     };
 
 } // namespace hpl

HPL2/include/graphics/Renderer.h

@@ -29,6 +29,7 @@
 #include "math/MathTypes.h"
 #include "scene/SceneTypes.h"
 
+#include "graphics/ScopedBarrier.h"
 #include "graphics/RenderFunctions.h"
 #include "scene/Viewport.h"
 #include <cstdint>
@@ -155,7 +156,8 @@ namespace hpl {
             cFrustum* apFrustum,
             cWorld* apWorld,
             cRenderSettings* apSettings,
-            bool abSendFrameBufferToPostEffects) = 0;
+            RenderTargetScopedBarrier& output
+            ) = 0;
 
         void Update(float afTimeStep);
 

HPL2/include/graphics/RendererDeferred.h

@@ -21,6 +21,7 @@
 #include "engine/RTTI.h"
 
 #include "graphics/SceneResource.h"
+#include "graphics/ScopedBarrier.h"
 #include "scene/Viewport.h"
 #include "scene/World.h"
 #include "windowing/NativeWindow.h"
@@ -362,7 +363,7 @@ namespace hpl {
             cFrustum* apFrustum,
             cWorld* apWorld,
             cRenderSettings* apSettings,
-            bool abSendFrameBufferToPostEffects) override;
+            RenderTargetScopedBarrier& output) override;
 
     private:
         iVertexBuffer* GetLightShape(iLight* apLight, eDeferredShapeQuality aQuality) const;

HPL2/include/graphics/RendererDeferred2.h

@@ -24,6 +24,7 @@
 #include "graphics/GraphicsTypes.h"
 #include "graphics/ImageBindlessPool.h"
 #include "graphics/SceneResource.h"
+#include "graphics/ScopedBarrier.h"
 #include "graphics/ShadowCache.h"
 #include "graphics/BindlessDescriptorPool.h"
 #include "scene/Viewport.h"
@@ -120,8 +121,8 @@ namespace hpl {
             ViewportData() = default;
             ViewportData(const ViewportData&) = delete;
             ViewportData(ViewportData&& buffer)= default;
-            ViewportData& operator=(const ViewportData&) = delete;
             ViewportData& operator=(ViewportData&& buffer) = default;
+            ViewportData& operator=(const ViewportData&) = delete;
 
             uint2 m_size = uint2(0, 0);
             std::array<SharedRenderTarget, ForgeRenderer::SwapChainLength> m_outputBuffer;
@@ -154,7 +155,7 @@ namespace hpl {
             cFrustum* apFrustum,
             cWorld* apWorld,
             cRenderSettings* apSettings,
-            bool abSendFrameBufferToPostEffects) override;
+            RenderTargetScopedBarrier& output) override;
 
     private:
         void setIndirectDrawArg(const ForgeRenderer::Frame& frame, uint32_t drawArgIndex, uint32_t slot, DrawPacket& packet);

HPL2/include/graphics/RendererWireFrame.h

@@ -92,7 +92,7 @@ namespace hpl {
             cFrustum* apFrustum,
             cWorld* apWorld,
             cRenderSettings* apSettings,
-            bool abSendFrameBufferToPostEffects) override;
+        RenderTargetScopedBarrier& output) override;
 
         std::array<SharedBuffer, NumberOfPerFrameUniforms> m_frameBufferUniform;
         uint32_t m_perFrameIndex = 0;

HPL2/include/graphics/ScopedBarrier.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "Common_3/Graphics/Interfaces/IGraphics.h"
+#include <span>
+
+namespace hpl {
+    class RenderTargetScopedBarrier;
+    struct RenderTargetTransition {
+        RenderTargetScopedBarrier* m_resource;
+        ResourceState m_newState;
+    };
+
+    namespace ScopedBarrier {
+        void End(
+            Cmd* cmd,
+            std::span<RenderTargetScopedBarrier*>
+        );
+
+        void Transition(
+            Cmd* cmd,
+            std::span<RenderTargetTransition>
+        );
+    };
+
+    class RenderTargetScopedBarrier {
+    public:
+        RenderTargetScopedBarrier();
+        RenderTargetScopedBarrier(RenderTarget* target, ResourceState start, ResourceState end);
+        RenderTargetScopedBarrier(RenderTargetScopedBarrier&) = delete;
+        RenderTargetScopedBarrier(RenderTargetScopedBarrier&&);
+
+        void Set(RenderTarget* target, ResourceState start, ResourceState end);
+        void operator=(RenderTargetBarrier&) = delete;
+        void operator=(RenderTargetScopedBarrier&&);
+
+        ~RenderTargetScopedBarrier() {
+            // scope hasn't been closed
+            ASSERT(m_target == nullptr);
+        }
+
+        inline bool IsValid() {
+            return m_target != nullptr;
+        }
+
+        inline RenderTarget* Target() {
+            return m_target;
+        }
+
+    private:
+        ResourceState m_startState;
+        ResourceState m_currentState;
+        ResourceState m_endState;
+        RenderTarget* m_target = nullptr;
+
+        friend void ScopedBarrier::End(Cmd*, std::span<RenderTargetScopedBarrier*>);
+        friend void ScopedBarrier::Transition(Cmd*, std::span<RenderTargetTransition>);
+
+    };
+
+
+}

HPL2/include/scene/Scene.h

@@ -66,7 +66,7 @@ namespace hpl {
 		 * Called by cEngine
 		 */
 		void Render(float afFrameTime, tFlag alFlags) {} //TODO MP: this needs to be replaced
-		void Render(const ForgeRenderer::Frame&, float afFrameTime, tFlag alFlags);
+		void Render(ForgeRenderer::Frame&, float afFrameTime, tFlag alFlags);
 
 		void Update(float timeStep);
 

HPL2/resource/parallax_bindless.h.fsl

@@ -4,16 +4,10 @@
 #ifndef _PARALLAX_BINDLESS_H
 #define _PARALLAX_BINDLESS_H
 
-float GetNormalizedDepth(SamplerState sh, uint heightIdx, float startDepth, float stopDepth, float inverseDepthRange, float2 uv, bool isHeightMapSingleChannel) {
-    float currentSample = 0.0;
-    float4 value;
-    if(SampleSceneTextureFloat4(heightIdx, sh, uv, value)) {
-      if(isHeightMapSingleChannel) {
-        currentSample = value.r;
-      } else {
-        currentSample = value.a;
-      }
-    }
+INLINE float GetNormalizedDepth(float currentSample, float startDepth, float stopDepth, float inverseDepthRange) {
+    //float currentSample = 0.0;
+   //   BeginNonUniformResourceIndex(heightIdx);
+    //  EndNonUniformResourceIndex(); 
 
     float normalizedDepth = 0.0;
     if(stopDepth - startDepth > 0.0001)
@@ -33,8 +27,7 @@ float2 ParallaxAdvance(
     float3 normal,
     float3 tangent,
     float3 bitangent,
-    uint heightIdx, 
-    SamplerState sh,
+    uint heightTextureIndex, 
     bool isHeightMapSingleChannel) {
 
     float3 dirToCameraTS = normalize(WorldSpaceToTangent(dir, normal, tangent, bitangent));
@@ -54,24 +47,25 @@ float2 ParallaxAdvance(
     // It is adjusted according to the depthOffset, raising or lowering the whole surface by depthOffset units.
     float3 parallaxOffset = -dirToCameraTS.xyz * dirToCameraZInverse * depthOffset;
 
-    float currentSample;
-    float4 value;
-    if(SampleSceneTextureFloat4(heightIdx, sh, uv.xy + parallaxOffset.xy, value)) {
-      if(isHeightMapSingleChannel) {
-        currentSample = value.r;
-      } else {
-        currentSample = value.a;
-      }
-    }
-    float prevSample;
+    float currentSample = 0.0;
+    uint index2 = heightTextureIndex;
+    BeginNonUniformResourceIndex(index2);
+      currentSample =  isHeightMapSingleChannel ? SampleTex2D(Get(sceneTextures)[index2], Get(sceneSampler),  uv.xy + parallaxOffset.xy).r : SampleTex2D(Get(sceneTextures)[index2], Get(sceneSampler),  uv.xy + parallaxOffset.xy).a;
+    EndNonUniformResourceIndex(); 
+    float prevSample = 0.0;
 
     // Do a basic search for the intersect step
     while(currentSample > currentStep) {
         currentStep += step;
         parallaxOffset += delta;
 
         prevSample = currentSample;
-        currentSample = GetNormalizedDepth(sh, heightIdx, depthSearchStart, depthSearchEnd, inverseDepthFactor, uv.xy + parallaxOffset.xy, isHeightMapSingleChannel);
+        float newSample;
+        uint index = heightTextureIndex;
+        BeginNonUniformResourceIndex(index);
+            newSample =  isHeightMapSingleChannel ? SampleTex2D(Get(sceneTextures)[index], Get(sceneSampler),  uv.xy + parallaxOffset.xy).r : SampleTex2D(Get(sceneTextures)[index], Get(sceneSampler),  uv.xy + parallaxOffset.xy).a;
+        EndNonUniformResourceIndex(); 
+        currentSample = GetNormalizedDepth(newSample, depthSearchStart, depthSearchEnd, inverseDepthFactor);
     }
 
     if(currentStep > 0.0)
@@ -95,7 +89,12 @@ float2 ParallaxAdvance(
             parallaxOffset += adjustedDelta;
             prevSample = currentSample;
 
-            currentSample = GetNormalizedDepth(sh, heightIdx, depthSearchStart, depthSearchEnd, inverseDepthFactor, uv.xy + parallaxOffset.xy, isHeightMapSingleChannel);
+            float newSample;
+            uint index = heightTextureIndex;
+            BeginNonUniformResourceIndex(index);
+                newSample =  isHeightMapSingleChannel ? SampleTex2D(Get(sceneTextures)[index], Get(sceneSampler),  uv.xy + parallaxOffset.xy).r : SampleTex2D(Get(sceneTextures)[index], Get(sceneSampler),  uv.xy + parallaxOffset.xy).a;
+            EndNonUniformResourceIndex(); 
+            currentSample = GetNormalizedDepth(newSample, depthSearchStart, depthSearchEnd, inverseDepthFactor);
         }
     }
     if(parallaxOffset.z > 0.0)

HPL2/resource/scene_defs.h.fsl

@@ -1,6 +1,8 @@
 #ifndef _SCENE_RESOURCE_DEFS_H_
 #define _SCENE_RESOURCE_DEFS_H_
 
+#define VK_EXT_DESCRIPTOR_INDEXING_ENABLED 1
+
 #define PARALLAX_MULTIPLIER 0.7
 
 #define POINT_LIGHT_MAX_COUNT  (256)