[renderer] fixed shutdown assert and blurry image due to 0.990 resolution scale

Author: PanosK92

data/shaders/auto_exposure.hlsl

@@ -77,19 +77,18 @@ void main_cs(uint3 thread_id : SV_DispatchThreadID)
         avg_nits = exp2(weighted_log_sum / max(weight_sum, 0.000001f));
     }
 
-    // 2. auto exposure works on top of the manual camera exposure, so the target is in post-camera scene-linear space
+    // 2. keep the existing camera-relative metering so artistic exposure choices remain intact
     float camera_exposure   = max(buffer_frame.camera_exposure, 0.000001f);
     float current_brightness = avg_nits * camera_exposure;
 
-    // 3. target middle gray so auto exposure refines the camera settings
-    // instead of pushing every scene toward a bright daytime look.
+    // 3. target middle gray using the final exposure value that the renderer applies.
+    // storing the resolved exposure keeps temporal upscalers in sync with output.
     const float target_luminance = 0.18f;
 
-    // 4. compute the ae multiplier needed to bring the current average toward middle gray
+    // 4. compute the camera-relative auto exposure trim
     float desired_exposure = target_luminance / max(current_brightness, 0.000001f);
 
-    // 5. keep auto exposure as a trim around the physical camera settings.
-    // this preserves intentionally dark scenes such as night shots.
+    // 5. clamp the auto exposure trim to a practical range
     const float min_ev = -4.0f; 
     const float max_ev =  3.0f;
 
@@ -98,19 +97,20 @@ void main_cs(uint3 thread_id : SV_DispatchThreadID)
 
     desired_exposure = clamp(desired_exposure, min_exposure, max_exposure);
 
-    // 6. temporal adaptation in ev space so large changes remain stable
+    // 6. resolve the final exposure and adapt it in ev space so large changes remain stable
+    float desired_total_exposure = camera_exposure * desired_exposure;
     float prev_exposure = tex2.Load(int3(0, 0, 0)).r;
     float adaptation_speed = pass_get_f3_value().x;
 
     // start from the current target to avoid a first-frame flash
     if (isnan(prev_exposure) || prev_exposure <= 0.0f)
     {
-        prev_exposure = desired_exposure;
+        prev_exposure = desired_total_exposure;
     }
 
     // higher values should adapt faster, so the response scales with the user-controlled speed directly
     float prev_ev          = log2(max(prev_exposure, 0.000001f));
-    float desired_ev       = log2(max(desired_exposure, 0.000001f));
+    float desired_ev       = log2(max(desired_total_exposure, 0.000001f));
     float adaptation_alpha = 1.0f - exp(-max(adaptation_speed, 0.0f) * 4.0f * buffer_frame.delta_time);
     float exposure         = exp2(lerp(prev_ev, desired_ev, adaptation_alpha));
 

data/shaders/output.hlsl

@@ -392,10 +392,10 @@ void main_cs(uint3 thread_id : SV_DispatchThreadID)
     const float luminous_efficacy = 683.0f;
     color.rgb *= luminous_efficacy; 
 
-    // apply exposure (camera and auto-exposure)
-    // applied in nits domain, so physical camera units work correctly
-    float exposure = is_auto_exposure ? tex2.Load(int3(0, 0, 0)).r : 1.0f;
-    color.rgb     *= buffer_frame.camera_exposure * exposure;
+    // apply exposure
+    // auto exposure stores the resolved final scale, while manual mode falls back to the camera settings
+    float exposure = is_auto_exposure ? tex2.Load(int3(0, 0, 0)).r : buffer_frame.camera_exposure;
+    color.rgb     *= exposure;
 
     // check hdr state
     bool is_hdr    = buffer_frame.hdr_enabled != 0.0f;

source/editor/WorldPreviews.cpp

@@ -11,6 +11,7 @@
 #include "FileSystem/FileSystem.h"
 #include "Rendering/Renderer.h"
 #include "Resource/ResourceCache.h"
+#include "RHI/RHI_Device.h"
 #include "RHI/RHI_Texture.h"
 #include "World/World.h"
 
@@ -320,6 +321,16 @@ void WorldPreviews::Tick()
 void WorldPreviews::Shutdown()
 {
     clear_request();
+
+    spartan::RHI_Device::QueueWaitAll();
+    for (auto& [path, texture] : preview_textures)
+    {
+        if (texture)
+        {
+            texture->DestroyResourceImmediate();
+        }
+    }
+
     preview_textures.clear();
 }
 

source/runtime/Core/Settings.cpp

@@ -72,7 +72,14 @@ namespace spartan
                 {
                     if (name.size() >= 2 && name[0] == 'r' && name[1] == '.')
                     {
-                        root.append_child(cvar_name_to_xml(string(name).c_str()).c_str()).text().set(get<float>(*cvar.m_value_ptr));
+                        float value = get<float>(*cvar.m_value_ptr);
+
+                        if (name == "r.resolution_scale" && cvar_dynamic_resolution.GetValueAs<bool>())
+                        {
+                            value = 1.0f;
+                        }
+
+                        root.append_child(cvar_name_to_xml(string(name).c_str()).c_str()).text().set(value);
                     }
                 }
 
@@ -106,6 +113,7 @@ namespace spartan
 
                 Renderer::SetResolutionRender(root.child("ResolutionRenderWidth").text().as_int(), root.child("ResolutionRenderHeight").text().as_int());
                 Renderer::SetResolutionOutput(root.child("ResolutionOutputWidth").text().as_int(), root.child("ResolutionOutputHeight").text().as_int());
+                bool dynamic_resolution = root.child("r_dynamic_resolution").text().as_bool();
 
                 // load render options from xml
                 for (const auto& [name, cvar] : ConsoleRegistry::Get().GetAll())
@@ -115,7 +123,14 @@ namespace spartan
                         pugi::xml_node child = root.child(cvar_name_to_xml(string(name).c_str()).c_str());
                         if (child)
                         {
-                            ConsoleRegistry::Get().SetValueFromString(string(name).c_str(), child.text().as_string());
+                            if (name == "r.resolution_scale" && dynamic_resolution)
+                            {
+                                ConsoleRegistry::Get().SetValueFromString(string(name).c_str(), "1.0");
+                            }
+                            else
+                            {
+                                ConsoleRegistry::Get().SetValueFromString(string(name).c_str(), child.text().as_string());
+                            }
                         }
                     }
                 }

source/runtime/Profiling/Profiler.cpp

@@ -543,7 +543,7 @@ namespace spartan
                 static_cast<uint32_t>(Display::GetLuminanceMax()),
                 static_cast<uint32_t>(res_render.x),
                 static_cast<uint32_t>(res_render.y),
-                cvar_resolution_scale.GetValue() * 100.0f,
+                Renderer::GetResolutionScale() * 100.0f,
                 static_cast<uint32_t>(res_output.x),
                 static_cast<uint32_t>(res_output.y),
                 static_cast<uint32_t>(vp.width),

source/runtime/RHI/D3D12/D3D12_Texture.cpp

@@ -420,4 +420,9 @@ namespace spartan
 
         m_rhi_srv = nullptr;
     }
+
+    void RHI_Texture::DestroyResourceImmediate()
+    {
+        RHI_DestroyResource();
+    }
 }

source/runtime/RHI/RHI_CommandList.cpp

@@ -23,6 +23,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "pch.h"
 #include "RHI_CommandList.h"
 #include "RHI_Texture.h"
+#include "../Rendering/Renderer.h"
 //============================
 
 //= NAMESPACES ========
@@ -33,15 +34,12 @@ namespace spartan
 {
     void RHI_CommandList::Dispatch(RHI_Texture* texture, float resolution_scale /*= 1.0f*/)
     {
-        // clamp scale
-        resolution_scale = clamp(resolution_scale, 0.5f, 1.0f);
-
         const uint32_t thread_group_size = 8;
 
-        // scaled dimensions (round up to ensure coverage)
-        const uint32_t scaled_width  = static_cast<uint32_t>(ceil(texture->GetWidth() * resolution_scale));
-        const uint32_t scaled_height = static_cast<uint32_t>(ceil(texture->GetHeight() * resolution_scale));
-        const uint32_t scaled_depth  = (texture->GetType() == RHI_Texture_Type::Type3D) ? static_cast<uint32_t>(ceil(texture->GetDepth() * resolution_scale)): 1;
+        // scaled dimensions
+        const uint32_t scaled_width  = Renderer::GetScaledDimension(texture->GetWidth(), resolution_scale);
+        const uint32_t scaled_height = Renderer::GetScaledDimension(texture->GetHeight(), resolution_scale);
+        const uint32_t scaled_depth  = (texture->GetType() == RHI_Texture_Type::Type3D) ? Renderer::GetScaledDimension(texture->GetDepth(), resolution_scale) : 1;
 
         // conservative dispatch counts
         const uint32_t dispatch_x = (scaled_width + thread_group_size - 1) / thread_group_size;

source/runtime/RHI/RHI_PipelineState.cpp

@@ -168,9 +168,8 @@ namespace spartan
 
             if (pso.resolution_scale)
             { 
-                float resolution_scale = cvar_resolution_scale.GetValue();
-                *width                 = static_cast<uint32_t>(*width * resolution_scale);
-                *height                = static_cast<uint32_t>(*height * resolution_scale);
+                *width  = Renderer::GetScaledDimension(*width);
+                *height = Renderer::GetScaledDimension(*height);
             }
         }
     }

source/runtime/RHI/RHI_Texture.h

@@ -114,6 +114,7 @@ namespace spartan
         // misc
         void ClearData();
         void PrepareForGpu();
+        void DestroyResourceImmediate();
         static size_t CalculateMipSize(uint32_t width, uint32_t height, uint32_t depth, RHI_Format format, uint32_t bits_per_channel, uint32_t channel_count);
 
         // data

source/runtime/RHI/Vulkan/Vulkan_CommandList.cpp

@@ -1296,7 +1296,7 @@ namespace spartan
         if (m_pso.render_target_depth_texture != nullptr)
         {
             RHI_Texture* rt = m_pso.render_target_depth_texture;
-            if (cvar_resolution_scale.GetValue() == 1.0f)
+            if (Renderer::GetResolutionScale() == 1.0f)
             { 
                 SP_ASSERT_MSG(rt->GetWidth() == rendering_info.renderArea.extent.width, "The depth buffer doesn't match the output resolution");
             }
@@ -1634,8 +1634,8 @@ namespace spartan
         for (uint32_t mip_index = 0; mip_index < blit_region_count; mip_index++)
         {
             VkOffset3D& source_blit_size = blit_offsets_source[mip_index];
-            source_blit_size.x           = static_cast<int32_t>(source->GetWidth()  * source_scaling) >> mip_index;
-            source_blit_size.y           = static_cast<int32_t>(source->GetHeight() * source_scaling) >> mip_index;
+            source_blit_size.x           = static_cast<int32_t>(Renderer::GetScaledDimension(source->GetWidth(), source_scaling)) >> mip_index;
+            source_blit_size.y           = static_cast<int32_t>(Renderer::GetScaledDimension(source->GetHeight(), source_scaling)) >> mip_index;
             source_blit_size.z           = 1;
 
             VkOffset3D& destination_blit_size = blit_offsets_destination[mip_index];