Incremental Improvements

Author: TheCurle

projs/shadow/shadow-engine/core/src/core/job/Job.cpp

@@ -108,7 +108,7 @@ namespace SH::Jobs {
 
         TaskGroup group { task, &context, 0, 0, 1, 0 };
 
-        if (queue.nThreads <= 1) {
+        if (queue.nThreads < 1) {
             group.Execute();
             return;
         }
@@ -135,7 +135,7 @@ namespace SH::Jobs {
             group.groupIdx = grp * groups;
             group.groupEnd = std::min(group.groupIdx + groups, jobs);
 
-            if (queue.nThreads <= 1)
+            if (queue.nThreads < 1)
                 group.Execute();
             else
                 queue.queues[queue.nextQueue.fetch_add(1) % queue.nThreads].Push(group);

projs/shadow/shadow-engine/renderer/base/inc/renderer/GraphicsDefine.h

@@ -402,6 +402,7 @@ namespace rx {
             CARTOON,
             UNLIT,
             WATER,
+            INTERIOR,
             SIZE
         };
 
@@ -1948,6 +1949,19 @@ namespace rx {
         metaHolder(RaytracingPipelineMeta)
     };
 
+    descriptor PipelineHash {
+        const PipelineState* pso = {};
+        size_t hash = {};
+
+        constexpr bool operator==(const PipelineHash& other) const {
+            return pso == other.pso && hash == other.hash;
+        }
+
+        constexpr size_t GetHash() const {
+            return ((size_t) pso & (hash << 1)) >> 1;
+        }
+    };
+
     /**
      * An easy way to reference entries in tables output by the Ray Tracing shaders.
      */
@@ -2521,3 +2535,10 @@ template<>
 struct enable_bitmask_operators<rx::RenderPassFlags> {
     static const bool enable = true;
 };
+
+template <>
+struct hash<rx::PipelineHash> {
+    inline size_t operator()(const rx::PipelineHash& hash) const {
+        return hash.GetHash();
+    }
+};

projs/shadow/shadow-engine/renderer/base/inc/renderer/Renderer.h

@@ -236,10 +236,8 @@ namespace rx {
         static void DownsampleDepthBuffer(const Texture& dest, ThreadCommands cmd);
 
         struct TiledLightResources {
-            DirectX::XMUINT3 tileCount = {};
-            GPUBuffer tileFrustums;
-            GPUBuffer tilesOpaque;
-            GPUBuffer tilesTransparent;
+            DirectX::XMUINT2 tileCount = {};
+            GPUBuffer entityTiles;
         };
 
         static void CreateTiledLightResources(TiledLightResources& res, DirectX::XMUINT2 resolution);

projs/shadow/shadow-engine/renderer/base/inc/renderer/interfaces/VulkanInterface.h

@@ -4,7 +4,6 @@
 #include <vulkan/vulkan.h>
 #include "vk_mem_alloc.h"
 #include "shadow/util/Synchronization.h"
-#include <atomic>
 #include <deque>
 #include <mutex>
 
@@ -48,6 +47,8 @@ namespace rx {
         VkPhysicalDeviceMeshShaderPropertiesEXT meshShaderProps = {};                           // Properties of the physical device's support for mesh shaders.
         VkPhysicalDeviceMemoryProperties2 memoryProps = {};                                     // Properties of the physical device's graphics memory
         VkPhysicalDeviceDepthStencilResolveProperties depthStencilResolveProps = {};            // Properties of the physical device's support for depth stenciling.
+        VkPhysicalDeviceConservativeRasterizationPropertiesEXT conservativeRasterProps = {};    // Properties of the physical device's support for conservative
+        bool useConservativeRasterization = false;                                              // Whether Conservative Rasterization is used in the currently active physical device.
         VkPhysicalDeviceFeatures2 deviceFeatures2 = {};                                         // Optional Vulkan features that the physical device supports.
         VkPhysicalDeviceVulkan11Features deviceFeatures11 = {};                                 // Optional Vulkan 1.1 features that the physical device supports.
         VkPhysicalDeviceVulkan12Features deviceFeatures12 = {};                                 // Optional Vulkan 1.2 features that the physical device supports.
@@ -301,12 +302,13 @@ namespace rx {
             DescriptorPool bindPools[frameBuffers];                                               // The DescriptorBindPools for this thread, for each frame
             GPULinearAllocator frameAllocators[frameBuffers];                                     // The linear allocators for each frame
 
-            std::vector<std::pair<size_t, VkPipeline>> pipelines;                                 // A vectorized map of pipeline hash to PSO
+
+            std::vector<std::pair<PipelineHash, VkPipeline>> pipelines;                           // A vectorized map of pipeline hash to PSO
             const PipelineState* activePSO = nullptr;                                             // The active PSO
             const Shader* activeShader = nullptr;                                                 // The active (bound) shader - render or compute.
             const RaytracingPipeline* activeRT = nullptr;                                         // The active RayTracing acceleration structure (bounding volume hierarchy)
 
-            size_t prevPipelineHash = 0;                                                          // The hash of the pipeline that was previously bound to the current thread - for use with the vectorized map
+            PipelineHash prevPipelineHash = {};                                                   // The hash of the pipeline that was previously bound to the current thread - for use with the vectorized map
             ShadingRate prevShadeRate = {};                                                       // The Shading Rate that was previously bound to the current thread - for easy comparison
             std::vector<SwapChain> prevSwapchains;                                                // All Swap-Chains that were previously bound to the current thread.
             bool PSODirty = false;                                                                // Whether the Pipeline State Object has changed in a way that requires some form of re-initialization
@@ -334,7 +336,7 @@ namespace rx {
                 bindPools[bufIdx].Reset();
                 binds.Reset();
                 frameAllocators[bufIdx].Reset();
-                prevPipelineHash = 0;
+                prevPipelineHash = {};
                 activePSO = nullptr;
                 activeShader = nullptr;
                 activeRT = nullptr;
@@ -361,8 +363,8 @@ namespace rx {
             }
         };
 
-        std::vector<std::unique_ptr<VulkanThreadCommands>> cmds;                                // A list of all active and inactive Thread Commands, for all threads managed by the engine.
-        uint32_t cmdCount = 0;                                                                  // The number of active Thread Commands. Should always be == cmds.size(), unless a thread is currently initializing one.
+        std::vector<std::unique_ptr<VulkanThreadCommands>> cmds;                      // A list of all active and inactive Thread Commands, for all threads managed by the engine.
+        uint32_t cmdCount = 0;                                                        // The number of active Thread Commands. Should always be == cmds.size(), unless a thread is currently initializing one.
         SH::SpinLock cmdLock;                                                         // A lock to prevent more than one thread submitting the commands at a time.
 
         /**
@@ -384,11 +386,11 @@ namespace rx {
             uint32_t firstBindless = 0;
         };
 
-        mutable std::unordered_map<size_t, PSOLayout> PSOcache;                                 // A cache of all created Pipeline State Objects indexed by hash, for easy switching.
+        mutable std::unordered_map<PipelineHash, PSOLayout> PSOcache;                           // A cache of all created Pipeline State Objects indexed by hash, for easy switching.
         mutable std::mutex PSOcacheMutex;                                                       // A lock to prevent the PSO cache being modified during access.
 
         VkPipelineCache pipelineCache = VK_NULL_HANDLE;                                         // A Vulkan Pipeline Cache. Saves to disk for reuse, preventing long initialization times every startup.
-        std::unordered_map<size_t, VkPipeline> pipelines;                                       // A cache of VkPipeline objects (not Pipeline State Objects, see PSOcache for that)
+        std::unordered_map<PipelineHash, VkPipeline> pipelines;                                 // A cache of VkPipeline objects (not Pipeline State Objects, see PSOcache for that)
 
         /**
          * @brief Verify that all PSOs in the cache are valid.
@@ -440,7 +442,7 @@ namespace rx {
                 std::vector<int> freeList;
                 std::mutex lock;
 
-                void Init(VkDevice device, VkDescriptorType type, uint32_t descriptors) {
+                void Init(VulkanInterface* device, VkDescriptorType type, uint32_t descriptors) {
                     descriptors = std::min(descriptors, 500'000u);
 
                     VkDescriptorPoolSize size = {
@@ -456,7 +458,7 @@ namespace rx {
                         .pPoolSizes = &size,
                     };
 
-                    VkResult res = vkCreateDescriptorPool(device, &create, nullptr, &pool);
+                    VkResult res = vkCreateDescriptorPool(device->device, &create, nullptr, &pool);
                     assert(res == VK_SUCCESS);
 
                     VkDescriptorSetLayoutBinding binding = {
@@ -484,7 +486,7 @@ namespace rx {
                         .pBindings = &binding,
                     };
 
-                    res = vkCreateDescriptorSetLayout(device, &layoutCreate, nullptr, &setLayout);
+                    res = vkCreateDescriptorSetLayout(device->device, &layoutCreate, nullptr, &setLayout);
                     assert(res == VK_SUCCESS);
 
                     VkDescriptorSetAllocateInfo allocateInfo = {
@@ -494,11 +496,56 @@ namespace rx {
                         .pSetLayouts = &setLayout
                     };
 
-                    res = vkAllocateDescriptorSets(device, &allocateInfo, &set);
+                    res = vkAllocateDescriptorSets(device->device, &allocateInfo, &set);
                     assert(res == VK_SUCCESS);
 
                     for (int i = 0; i < (int)descriptors; i++)
                         freeList.push_back((int)descriptors - i - 1);
+
+                    if (type != VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR) {
+                        // We do a little memory leaking
+                        // Shader compiler might be dodgy, so we add safety buffers to prevent null pointers in all possible edge cases
+                        int idx = Allocate();
+                        VkWriteDescriptorSet write = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
+                        write.descriptorType = type;
+                        write.dstBinding = 0;
+                        write.dstArrayElement = idx;
+                        write.descriptorCount = 1;
+                        write.dstSet = set;
+
+                        VkDescriptorImageInfo imageInfo = {};
+                        VkDescriptorBufferInfo bufferInfo = {};
+
+                        switch (type) {
+                            case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+                                imageInfo.imageView = device->nullImageView2;
+                                imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+                                write.pImageInfo = &imageInfo;
+                                break;
+                            case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+                            case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+                                write.pTexelBufferView = &device->nullBufferView;
+                                break;
+                            case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+                                bufferInfo = { device->nullBuffer, VK_WHOLE_SIZE };
+                                write.pBufferInfo = &bufferInfo;
+                                break;
+                            case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+                                imageInfo.imageView = device->nullImageView2;
+                                imageInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
+                                write.pImageInfo = &imageInfo;
+                                break;
+                            case VK_DESCRIPTOR_TYPE_SAMPLER:
+                                imageInfo.sampler = device->nullSampler;
+                                write.pImageInfo = &imageInfo;
+                                break;
+                            default:
+                                assert("Descriptor error in bindless heap: non acceleration structure descriptor type with non zero index");
+                                break;
+                        }
+
+                        vkUpdateDescriptorSets(device->device, 1, &write, 0, nullptr);
+                    }
                 }
 
                 void Destroy(VkDevice device) {
@@ -917,12 +964,19 @@ y;                                        \
 
         RenderPassMeta GetRenderPassMeta(ThreadCommands cmd) override {
             return GetThreadCommands(cmd).passMeta;
-        };
+        }
 
         // Get the allocator to be used for the current frame.
         GPULinearAllocator& GetAllocator(ThreadCommands cmd) override {
             return GetThreadCommands(cmd).frameAllocators[GetBufferIndex()];
-        };
+        }
+
+        VkDevice GetDevice();
+        VkPhysicalDevice GetPhysicalDevice();
+        VkInstance GetInstance();
+        VkQueue GetGraphicsQueue();
+        uint32_t GetGraphicsIndex();
+        VkImage GetTextureInternal(const rx::Texture* tex);
 
     };
 }

projs/shadow/shadow-engine/renderer/base/src/renderer/Renderer.cpp

@@ -123,34 +123,31 @@ namespace rx::internal {
 
     std::vector<uint8_t> debugTexts;                                                                                    // A buffer of texts used to send data to the console from the renderer.
 
-    SH::SpinLock mipperLock;                                                                                  // A lock used by the dynamic mipmap generator.
+    SH::SpinLock mipperLock;                                                                                            // A lock used by the dynamic mipmap generator.
     std::vector<std::pair<Texture, bool>> mipperList;                                                                   // A list of textures for the dynamic mipmap generator to process. pair<Texture, whether it has been processed yet>
     std::vector<std::pair<Texture, Texture>> decompressorList;                                                          // A list of textures for the decompressor to work on. pair<compressed texture, decompressed texture>
 
-    GPUBuffer luminanceBuffer;                                                                                          // A buffer for dynamic luminance compensation. Required by some shaders to exist. NVIDIA 10xx GPUs will error without such.
-
-    SH::Jobs::ExecutionContext pipelineJobContext[ENUMSIZE(defs::RenderPass)];                                              // Job contexts for processing PSOs.
+    SH::Jobs::ExecutionContext pipelineJobContext[ENUMSIZE(defs::RenderPass)];                                          // Job contexts for processing PSOs.
 
     PipelineState PSOOcclusion;                                                                                         // PSO for Occlusion Queries
-    PipelineState PSOBillboard[ENUMSIZE(defs::RenderPass)];                                                                 // PSO for billboard rendering, per render pass
+    PipelineState PSOBillboard[ENUMSIZE(defs::RenderPass)];                                                             // PSO for billboard rendering, per render pass
     PipelineState PSOBillboardWire;                                                                                     // PSO for billboard rendering of wires and lines.
     PipelineState PSOGatherBillboard;                                                                                   // PSO for capturing billboard-rendered pixels into a buffer
-    PipelineState PSOLightVisual[ENUMSIZE(defs::LightType)];                                                                // PSO for visualizing light-affected pixels into a buffer
-    PipelineState PSOLightVolumetric[ENUMSIZE(defs::LightType)];                                                            // PSO for rendering volumetric lights
+    PipelineState PSOLightVisual[ENUMSIZE(defs::LightType)];                                                            // PSO for visualizing light-affected pixels into a buffer
+    PipelineState PSOLightVolumetric[ENUMSIZE(defs::LightType)];                                                        // PSO for rendering volumetric lights
     PipelineState PSOLightmap;                                                                                          // PSO for rendering light maps
     PipelineState PSOLensFlare;                                                                                         // PSO for rendering lens flares
     PipelineState PSODownsampleDepth;                                                                                   // PSO for downsampling depth buffers
     PipelineState PSOUpsample;                                                                                          // PSO for bilateral upsampling
     PipelineState PSOUpsampleClouds;                                                                                    // PSO for upsampling volumetric clouds
     PipelineState PSOOutline;                                                                                           // PSO for rendering outlines of objects
-    PipelineState PSOSky[ENUMSIZE(defs::SkyRenderType)];                                                                    // PSO for sky rendering, per type
-    PipelineState PSODebug[ENUMSIZE(defs::DebugRenderType)];                                                                // PSO for debug rendering, per mode
+    PipelineState PSOSky[ENUMSIZE(defs::SkyRenderType)];                                                                // PSO for sky rendering, per type
+    PipelineState PSODebug[ENUMSIZE(defs::DebugRenderType)];                                                            // PSO for debug rendering, per mode
     PipelineState PSOWire;                                                                                              // PSO for wire (thin strips of pixels) rendering
     PipelineState PSOWireTess;                                                                                          // PSO for wire (thin strips of pixels) rendering, with tesselation
 
     RaytracingPipeline PSORTReflect;                                                                                    // PSO for ray-traced reflections
 
-
     /**
      * An instance of a mesh, with associated distance to the camera.
      * Can be sorted back-to-front or front-to-back depending on need.
@@ -247,13 +244,13 @@ namespace rx::internal {
      * Use as an index into the array of pipeline state objects.
      */
     union RenderVariants {
-        struct __attribute__((packed)) { uint8_t pass : 4; uint8_t shader; uint8_t blend : 4; uint8_t cull : 2; uint8_t tesselation : 1; uint8_t alpha : 1; uint32_t sample : 4; } parts;
+        struct __attribute__((packed)) { uint8_t pass : 4; uint8_t shader; uint8_t blend : 4; uint8_t cull : 2; uint8_t tesselation : 1; uint8_t alpha : 1; uint32_t sample : 4; uint8_t mesh : 1;} parts;
         uint32_t data;
     };
 
-    std::unordered_map<uint32_t, PipelineState> PSOByVariant[ENUMSIZE(defs::RenderPass)][ENUMSIZE(defs::MaterialShaderType)]; // TODO: Material Component types
+    std::unordered_map<uint32_t, PipelineState> PSOByVariant[ENUMSIZE(defs::RenderPass)][ENUMSIZE(defs::MaterialShaderType)][2];
     inline PipelineState* GetPipelineForVariants(RenderVariants var) {
-        return &PSOByVariant[var.parts.pass][var.parts.shader][var.data];
+        return &PSOByVariant[var.parts.pass][var.parts.shader][var.parts.mesh][var.data];
     }
 
     defs::ShaderType VertexShaderFor(defs::RenderPass pass, bool tesselation, bool alpha, bool transparent) {