DLSS: fix dispatch error

Author: PanosK92

data/shaders/common_structs.hlsl

@@ -102,6 +102,11 @@ struct Surface
         depth                 = sample_depth;
         normal                = sample_normal.xyz;
         flags                 = material.flags;
+        // velocity.w is packed at gbuffer time so composition can find skids if the material index misses
+        if (tex_velocity.SampleLevel(samplers[sampler_point_clamp], uv, 0).a > 0.5f)
+        {
+            flags |= uint(1U << 20);
+        }
         albedo                = replace_color_with_one ? 1.0f : sample_albedo.rgb;
         alpha                 = sample_albedo.a;
         roughness             = sample_material.r;

data/shaders/g_buffer.hlsl

@@ -373,7 +373,8 @@ gbuffer main_ps(gbuffer_vertex vertex, bool is_front_face : SV_IsFrontFace)
     albedo.a = lerp(albedo.a, 1.0f, step(albedo_sample.a, 1.0f) * pass_is_opaque());
     if (surface.is_skid_mark())
     {
-        albedo.a *= saturate(vertex.uv_misc.z);
+        // stain mask is texture alpha times vertex fade, color.a is only the transparent pass ticket
+        albedo.a = saturate(albedo_sample.a) * saturate(vertex.uv_misc.z);
     }
 
     // emission
@@ -522,6 +523,6 @@ gbuffer main_ps(gbuffer_vertex vertex, bool is_front_face : SV_IsFrontFace)
     g_buffer.albedo   = albedo;
     g_buffer.normal   = float4(normal, pass_get_material_index());
     g_buffer.material = float4(roughness, metalness, emission, occlusion);
-    g_buffer.velocity = float4(velocity, material.is_motion_blur_radial() ? 1.0f : 0.0f, 0.0f);
+    g_buffer.velocity = float4(velocity, material.is_motion_blur_radial() ? 1.0f : 0.0f, surface.is_skid_mark() ? 1.0f : 0.0f);
     return g_buffer;
 }

data/shaders/light_composition.hlsl

@@ -76,20 +76,20 @@ void main_cs(uint3 thread_id : SV_DispatchThreadID)
     Surface surface;
     surface.Build(thread_id.xy, resolution_out, true, false);
 
-    // skip non transparent pixels during the transparent pass, the opaque pass already wrote them
-    if (pass_is_transparent() && !surface.is_transparent())
-        return;
-
-    // rubber stain, multiply the lit ground, glass overwrite is the wrong operator
+    // rubber stain, multiply the lit ground from the opaque blit, glass overwrite is the wrong operator
     if (pass_is_transparent() && surface.is_skid_mark())
     {
-        float coverage = saturate(surface.alpha);
-        float3 dest    = tex_uav[thread_id.xy].rgb;
-        float3 stain   = dest * lerp(float3(1.0f, 1.0f, 1.0f), surface.albedo, coverage);
+        float mask   = saturate(surface.alpha);
+        float3 dest  = tex[thread_id.xy].rgb;
+        float3 stain = dest * lerp(float3(1.0f, 1.0f, 1.0f), surface.albedo, mask);
         tex_uav[thread_id.xy] = validate_output(float4(stain, 1.0f));
         return;
     }
 
+    // skip non transparent pixels during the transparent pass, the opaque pass already wrote them
+    if (pass_is_transparent() && !surface.is_transparent())
+        return;
+
     float3 light_diffuse       = 0.0f;
     float3 light_specular      = 0.0f;
     float3 light_emissive      = 0.0f;

data/shaders/reflections_apply.hlsl

@@ -245,7 +245,8 @@ void main_cs(uint3 thread_id : SV_DispatchThreadID)
     float4 sample_material = tex_material.SampleLevel(samplers[sampler_point_clamp], uv, 0);
     MaterialParameters mat = material_parameters[uint(sample_normal.a)];
     bool is_water_pixel    = (mat.flags & uint(1U << 13)) != 0;
-    bool is_skid_pixel     = (mat.flags & uint(1U << 20)) != 0;
+    bool is_skid_pixel     = (mat.flags & uint(1U << 20)) != 0
+        || tex_velocity.SampleLevel(samplers[sampler_point_clamp], uv, 0).a > 0.5f;
     bool is_glass_pixel    = alpha > 0.0f && alpha < 1.0f && !is_skid_pixel;
 
     // stain already multiplied into the frame, skip glass refraction and extra specular

data/shaders/skid_marks.hlsl

@@ -603,7 +603,12 @@ namespace spartan
             if (texture_color && !texture_color->IsCompressedFormat())
             {
                 texture_color->SetFlag(RHI_Texture_Compress);
-                texture_color->SetCompressionFormat(texture_color->IsSemiTransparent() ? RHI_Format::BC3_Unorm : RHI_Format::BC1_Unorm);
+                const bool has_alpha = texture_color->HasAlphaPixels();
+                texture_color->SetCompressionFormat(has_alpha ? RHI_Format::BC3_Unorm : RHI_Format::BC1_Unorm);
+                if (has_alpha)
+                {
+                    texture_color->SetFlag(RHI_Texture_Transparent, true);
+                }
             }
 
             if (texture_normal && !texture_normal->IsCompressedFormat())
@@ -1363,6 +1368,12 @@ namespace spartan
     bool Material::IsAlphaTested()
     {
         // hot path for draw sort and shadow passes, read slots directly
+        // skids keep texture alpha for a multiply mask, clipping would punch holes in the ribbon
+        if (GetProperty(MaterialProperty::IsSkidMark) != 0.0f)
+        {
+            return false;
+        }
+
         RHI_Texture* color = m_textures[static_cast<uint32_t>(MaterialTextureType::Color) * slots_per_texture];
         const bool albedo_mask = color && color->IsSemiTransparent();
         return HasTextureOfType(MaterialTextureType::AlphaMask) || albedo_mask;

source/rendering/Material.cpp

@@ -3239,13 +3239,10 @@ namespace spartan
                 continue;
             }
 
-            const bool is_skid_mark = material->GetProperty(MaterialProperty::IsSkidMark) != 0.0f;
-            const bool skip_deferred = render->HasFlag(RenderFlags::SkipDeferred) || is_skid_mark;
-
             // off-screen geometry is only kept when classic shadow maps need the caster
             if (!render->IsVisible())
             {
-                if (material->IsTransparent() && !skip_deferred)
+                if (material->IsTransparent())
                 {
                     m_transparents_present = true;
                 }
@@ -3259,7 +3256,7 @@ namespace spartan
                 }
             }
 
-            if (material->IsTransparent() && !skip_deferred)
+            if (material->IsTransparent())
             {
                 m_transparents_present = true;
             }
@@ -3358,7 +3355,7 @@ namespace spartan
             Render* render              = dc.render;
             Material* material          = render->GetMaterial();
 
-            if (!material || material->IsTransparent() || render->HasFlag(RenderFlags::SkipDeferred))
+            if (!material || material->IsTransparent())
             {
                 continue;
             }
@@ -4619,7 +4616,6 @@ namespace spartan
         Pass_Reflections_Denoise(eye_layer);
 
         Pass_Reflections_Apply(eye_layer);
-        Pass_SkidMarks(eye_layer);
         Pass_LightFlares(eye_layer);
         if (clouds_prepared)
         {

source/rendering/Renderer.cpp

@@ -363,7 +363,6 @@ namespace spartan
         void Pass_GBuffer(const bool is_transparent_pass);
         void Pass_GBuffer_Indirect();
         void Pass_GBuffer_TessellatedAndTransparent(const bool is_transparent_pass);
-        bool Pass_SkidMarks(uint32_t eye_layer = rhi_all_mips);
         void Pass_MeshletVisualize();
         void Pass_ScreenSpaceAmbientOcclusion();
         void Pass_Reflections_Trace(uint32_t eye_layer = rhi_all_mips);

source/rendering/Renderer.h

@@ -365,8 +365,6 @@ namespace spartan
         outline_v,
         outline_p,
         outline_c,
-        skid_marks_v,
-        skid_marks_p,
         font_v,
         font_p,
         ssao_c,

source/rendering/Renderer_Definitions.h

@@ -1024,10 +1024,6 @@ namespace spartan
             }
 
             const bool is_tessellated = material->GetProperty(MaterialProperty::Tessellation) > 0.0f;
-            if (render->HasFlag(RenderFlags::SkipDeferred) || material->GetProperty(MaterialProperty::IsSkidMark) != 0.0f)
-            {
-                continue;
-            }
             if (is_transparent_pass)
             {
                 if (!material->IsTransparent())
@@ -1081,99 +1077,6 @@ namespace spartan
         RHI_CommandList::EndTimeblock();
     }
 
-    bool Renderer::Pass_SkidMarks(uint32_t eye_layer)
-    {
-        (void)eye_layer;
-
-        RHI_Shader* shader_v = GetShader(Renderer_Shader::skid_marks_v);
-        RHI_Shader* shader_p = GetShader(Renderer_Shader::skid_marks_p);
-        if (!shader_v || !shader_p || !shader_v->IsCompiled() || !shader_p->IsCompiled())
-        {
-            return false;
-        }
-
-        RHI_Texture* tex_out     = GetRenderTarget(Renderer_RenderTarget::frame_render);
-        RHI_Texture* tex_lit     = GetRenderTarget(Renderer_RenderTarget::frame_render_opaque);
-        RHI_Texture* tex_depth   = GetRenderTarget(Renderer_RenderTarget::gbuffer_depth);
-        if (!tex_out || !tex_lit || !tex_depth)
-        {
-            return false;
-        }
-
-        bool has_skid = false;
-        for (uint32_t i = 0; i < m_draw_call_count; i++)
-        {
-            Render* render = m_draw_calls[i].render;
-            if (render && render->HasFlag(RenderFlags::SkipDeferred) && m_draw_calls[i].camera_visible)
-            {
-                has_skid = true;
-                break;
-            }
-        }
-        if (!has_skid)
-        {
-            return false;
-        }
-
-        RHI_CommandList::Blit(tex_out, tex_lit, false);
-
-        RHI_PipelineState pso;
-        pso.name                             = "skid_marks";
-        pso.shaders[RHI_Shader_Type::Vertex] = shader_v;
-        pso.shaders[RHI_Shader_Type::Pixel]  = shader_p;
-        pso.blend_state                      = GetBlendState(Renderer_BlendState::Off);
-        pso.rasterizer_state                 = GetRasterizerState(Renderer_RasterizerState::Solid);
-        pso.primitive_topology               = RHI_PrimitiveTopology::TriangleList;
-        pso.depth_stencil_state              = GetDepthStencilState(Renderer_DepthStencilState::ReadGreaterEqual);
-        pso.resolution_scale                 = true;
-        pso.render_target_color_textures[0]  = tex_out;
-        pso.render_target_depth_texture      = tex_depth;
-        pso.clear_color[0]                   = rhi_color_load;
-        pso.cull_mode                        = RHI_CullMode::None;
-
-        RHI_CommandList::BeginTimeblock("skid_marks");
-        RHI_CommandList::SetPipelineState(pso);
-        RHI_CommandList::SetCullMode(RHI_CullMode::None);
-        RHI_CommandList::SetTexture(static_cast<uint32_t>(Renderer_BindingsSrv::tex), tex_lit);
-
-        RHI_Buffer* instance_buffer = GeometryBuffer::GetInstanceBuffer()
-            ? GeometryBuffer::GetInstanceBuffer()
-            : GetBuffer(Renderer_Buffer::DummyInstance);
-
-        for (uint32_t i = 0; i < m_draw_call_count; i++)
-        {
-            const Renderer_DrawCall& draw_call = m_draw_calls[i];
-            Render* render                     = draw_call.render;
-            if (!render || !draw_call.camera_visible || !render->HasFlag(RenderFlags::SkipDeferred))
-            {
-                continue;
-            }
-
-            Material* material = render->GetMaterial();
-            if (!material)
-            {
-                continue;
-            }
-
-            m_pcb_pass_cpu.draw_index     = draw_call.draw_data_index;
-            m_pcb_pass_cpu.material_index = material->GetIndex();
-            RHI_CommandList::PushConstants(m_pcb_pass_cpu);
-
-            RHI_CommandList::SetBufferVertex(render->GetVertexBuffer(), instance_buffer);
-            RHI_CommandList::SetBufferIndex(render->GetIndexBuffer());
-            RHI_CommandList::DrawIndexed(
-                render->GetIndexCount(draw_call.lod_index),
-                render->GetIndexOffset(draw_call.lod_index),
-                render->GetVertexOffset(draw_call.lod_index),
-                render->GetGlobalInstanceOffset() + draw_call.instance_index,
-                draw_call.instance_count
-            );
-        }
-
-        RHI_CommandList::EndTimeblock();
-        return true;
-    }
-
     void Renderer::Pass_GBuffer(const bool is_transparent_pass)
     {
         RHI_CommandList::BeginTimeblock(is_transparent_pass ? "g_buffer_transparent" : "g_buffer");