Fixed unmarked non-uniform resource access while rendering particles. Other minor fixes and polish.

* Disabled the groupshared optimization for `LightLinkedListStats.cs.hlsl` on all GPUs rather than just Intel. Saw issues with it on AMD as well, need to investigate more.
* Switched to a more typical B8G8R8A8_UNORM swapchain, the R16G16B16A16_FLOAT caused issues on my laptop. (It seemingly can't decide whether to present it as sRGB or linear.)
* Fixed the velocity direction bias getting clamped to 0 in the particle system editor and added the missing label for spawn point variance.

Author: PathogenDavid

README.md

@@ -34,7 +34,7 @@ Various debug visualizations, settings, and tools can be accessed using the UI.
 
 Building should be as simple as opening `ThreeL.sln` in Visual Studio 2022 and pressing F5.
 
- 
+### Build Configurations
 
 ThreeL has three build configrations:
 

ThreeL/ResourceManager.cpp

@@ -32,8 +32,10 @@ ResourceManager::ResourceManager(GraphicsCore& graphics)
     ShaderBlobs lightLinkedListDebugPs = hlslCompiler.CompileShader(L"Shaders/LightLinkedListDebug.ps.hlsl", L"PsMain", L"ps_6_0");
 
     std::vector<std::wstring> lightLinkedListStatsCsDefines;
-    if (Graphics.IsIntel())
-        lightLinkedListStatsCsDefines.push_back(L"NO_GROUPSHARED"); // My Intel UHD 620 is choking on the groupshared optimization in this shader.
+    // My Intel UHD 620 is choking on the groupshared optimization in this shader.
+    // I've also seen a AMD RX 6700 XT choking on this in a different way (light count is randomly corrupted), so let's just disable the optimization for now.
+    //if (Graphics.IsIntel())
+    lightLinkedListStatsCsDefines.push_back(L"NO_GROUPSHARED");
     ShaderBlobs lightLinkedListStatsCs = hlslCompiler.CompileShader(L"Shaders/LightLinkedListStats.cs.hlsl", L"Main", L"cs_6_0", lightLinkedListStatsCsDefines);
 
     ShaderBlobs lightSpritesVs = hlslCompiler.CompileShader(L"Shaders/LightSprites.hlsl", L"VsMain", L"vs_6_0");

ThreeL/Shaders/Pbr.hlsl

@@ -195,7 +195,7 @@ struct Brdf
         // attenuation is approaching zero at that point. Basically this shows dim solid light for areas covered by the light linked list
         // and bright in areas actually covered by the light. It also indirectly shows light checks lost due to depth errors.
         // In other words, this shows that RangeExtension in LightLinkedListFill.hlsl is being calculated correctly.
-#if DEBUG_LIGHT_BOUNDARIES
+#ifdef DEBUG_LIGHT_BOUNDARIES
         lightAttenuation = distanceSquared < rangeSquared ? 1.f : 0.25f;
         Diffuse += light.Color * lightAttenuation;
 #else
@@ -208,6 +208,16 @@ struct Brdf
     }
 };
 
+float4 SampleBindlessTexture(uint textureIndex, uint samplerIndex, float2 uv)
+{
+    // Particles are instanced, which means differen pixel shader invocations get different material IDs which means potentially non-uniform resource indicies
+#ifdef PBR_IS_PARTICLE
+    return g_Textures[NonUniformResourceIndex(textureIndex)].Sample(g_Samplers[NonUniformResourceIndex(samplerIndex)], uv);
+#else
+    return g_Textures[textureIndex].Sample(g_Samplers[samplerIndex], uv);
+#endif
+}
+
 [RootSignature(PBR_ROOT_SIGNATURE)]
 float4 PsMain(PsInput input, bool isFrontFace: SV_IsFrontFace) : SV_Target
 {
@@ -224,7 +234,7 @@ float4 PsMain(PsInput input, bool isFrontFace: SV_IsFrontFace) : SV_Target
     float4 baseColor = input.Color * material.BaseColorFactor;
 
     if (material.BaseColorTexture != DISABLED_BUFFER)
-    { baseColor *= g_Textures[material.BaseColorTexture].Sample(g_Samplers[material.BaseColorTextureSampler], input.Uv0); }
+    { baseColor *= SampleBindlessTexture(material.BaseColorTexture, material.BaseColorTextureSampler, input.Uv0); }
 
     // Only base color affects alpha so alpha cutoff can be applied at this point
     if (baseColor.a < material.AlphaCutoff)
@@ -236,7 +246,7 @@ float4 PsMain(PsInput input, bool isFrontFace: SV_IsFrontFace) : SV_Target
 
     if (material.MealicRoughnessTexture != DISABLED_BUFFER)
     {
-        float4 mr = g_Textures[material.MealicRoughnessTexture].Sample(g_Samplers[material.MetalicRoughnessTextureSampler], input.Uv0);
+        float4 mr = SampleBindlessTexture(material.MealicRoughnessTexture, material.MetalicRoughnessTextureSampler, input.Uv0);
         metalness *= mr.b;
         roughness *= mr.g;
     }
@@ -260,7 +270,7 @@ float4 PsMain(PsInput input, bool isFrontFace: SV_IsFrontFace) : SV_Target
 
         float3x3 tangentFrame = float3x3(tangent, bitangent, normal);
 
-        float3 textureNormal = g_Textures[material.NormalTexture].Sample(g_Samplers[material.NormalTextureSampler], input.Uv0).rgb;
+        float3 textureNormal = SampleBindlessTexture(material.NormalTexture, material.NormalTextureSampler, input.Uv0).rgb;
         textureNormal = textureNormal * 2.f - 1.f;
         textureNormal *= float3(material.NormalTextureScale.xx, 1.f);
         textureNormal = normalize(textureNormal);
@@ -271,7 +281,7 @@ float4 PsMain(PsInput input, bool isFrontFace: SV_IsFrontFace) : SV_Target
     float3 emissive = material.EmissiveFactor;
 
     if (material.EmissiveTexture != DISABLED_BUFFER)
-    { emissive *= g_Textures[material.EmissiveTexture].Sample(g_Samplers[material.EmissiveTextureSampler], input.Uv0).rgb; }
+    { emissive *= SampleBindlessTexture(material.EmissiveTexture, material.EmissiveTextureSampler, input.Uv0).rgb; }
 
     //=================================================================================================================
     // PBR calculations

ThreeL/SwapChain.cpp

@@ -93,7 +93,7 @@ SwapChain::SwapChain(GraphicsCore& graphicsCore, Window& window)
     InitializeBackBuffers();
 
     // Register WndProc to handle resizing
-    m_WndProcHandle = window.AddWndProc([&](HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+    m_WndProcHandle = window.AddWndProc([&](HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) -> std::optional<LRESULT>
         {
             if (message == WM_WINDOWPOSCHANGED)
             {
@@ -106,10 +106,10 @@ SwapChain::SwapChain(GraphicsCore& graphicsCore, Window& window)
                     Resize(newSize);
                 }
 
-                return std::optional<LRESULT>(0);
+                return 0;
             }
 
-            return std::optional<LRESULT>();
+            return { };
         });
 }
 
@@ -161,7 +161,6 @@ void SwapChain::Present(PresentMode mode)
     m_SyncPoints[m_CurrentBackBufferIndex].Wait();
 }
 
-
 void SwapChain::Resize(uint2 size)
 {
     Assert((size > uint2::Zero).All() && "The swap chain size must be positive and non-zero!");

ThreeL/SwapChain.h

@@ -17,7 +17,13 @@ enum class PresentMode
 class SwapChain
 {
 public:
-    static const DXGI_FORMAT BACK_BUFFER_FORMAT = DXGI_FORMAT_R16G16B16A16_FLOAT;
+    // My laptop misbehaves when DXGI_FORMAT_R16G16B16A16_FLOAT
+    // Documentation on using this format for swapchains is scant, so it's unclear if this is due to
+    // something we're doing wrong or something maybe Intel's drivers are doing wrong.
+    // Regardless, we weren't really taking advantage of the increased precision anyway.
+    // In the future I might implement proper HDR support (either for rendering or presenting), but first I probably need to acquire a decent HDR monitor.
+    //static const DXGI_FORMAT BACK_BUFFER_FORMAT = DXGI_FORMAT_R16G16B16A16_FLOAT;
+    static const DXGI_FORMAT BACK_BUFFER_FORMAT = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
     static const uint32_t BACK_BUFFER_COUNT = 3;
 
 private:

ThreeL/Ui.cpp

@@ -160,15 +160,16 @@ void Ui::SubmitParticleSystemEditor(ComputeContext& context, ParticleSystem& par
         ImGui::DragFloat("Y##VelocityDirectionVariance", &particleSystemDefinition.VelocityDirectionVariance.y, 0.01f, 0.f, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
         ImGui::DragFloat("Z##VelocityDirectionVariance", &particleSystemDefinition.VelocityDirectionVariance.z, 0.01f, 0.f, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
         ImGui::Text("Velocity direction bias");
-        ImGui::DragFloat("X##VelocityDirectionBias", &particleSystemDefinition.VelocityDirectionBias.x, 0.01f, 0.f, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
-        ImGui::DragFloat("Y##VelocityDirectionBias", &particleSystemDefinition.VelocityDirectionBias.y, 0.01f, 0.f, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
-        ImGui::DragFloat("Z##VelocityDirectionBias", &particleSystemDefinition.VelocityDirectionBias.z, 0.01f, 0.f, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
+        ImGui::DragFloat("X##VelocityDirectionBias", &particleSystemDefinition.VelocityDirectionBias.x, 0.01f, -FLT_MAX, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
+        ImGui::DragFloat("Y##VelocityDirectionBias", &particleSystemDefinition.VelocityDirectionBias.y, 0.01f, -FLT_MAX, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
+        ImGui::DragFloat("Z##VelocityDirectionBias", &particleSystemDefinition.VelocityDirectionBias.z, 0.01f, -FLT_MAX, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
         ImGui::Text("Velocity magnitude");
         ImGui::DragFloatRange2("Linear", &particleSystemDefinition.VelocityMagnitudeMin, &particleSystemDefinition.VelocityMagnitudeMax, 0.01f);
         ImGui::DragFloatRange2("Angular", &particleSystemDefinition.AngularVelocityMin, &particleSystemDefinition.AngularVelocityMax, 0.01f, 0.f, 0.f, "%.3f rad/s");
 
         ImGui::SeparatorText("Spawn point");
         ImGui::Checkbox("Show spawn point gizmo", &ShowParticleSystemGizmo);
+        ImGui::Text("Spawn point variance");
         ImGui::DragFloat("X##SpawnPointVariance", &particleSystemDefinition.SpawnPointVariance.x, 0.01f, 0.f, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
         ImGui::DragFloat("Y##SpawnPointVariance", &particleSystemDefinition.SpawnPointVariance.y, 0.01f, 0.f, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);
         ImGui::DragFloat("Z##SpawnPointVariance", &particleSystemDefinition.SpawnPointVariance.z, 0.01f, 0.f, FLT_MAX, "%.3f", ImGuiSliderFlags_AlwaysClamp);