Volumetric upscaling + support for other types of lights + CSM

# Conflicts:
#	Nuake/Source/Nuake/Modules/QuakeModule/Module.lua

Data/Shaders/Vulkan/depth_aware_blur.frag

@@ -0,0 +1,160 @@
+// Transforms
+struct ModelData
+{
+    float4x4 model;
+};
+[[vk::binding(0, 0)]]
+StructuredBuffer<ModelData> model : register(t1);
+
+// Vertex
+struct Vertex 
+{
+    float3 position;
+    float uv_x;
+    float3 normal;
+    float uv_y;
+    float3 tangent;
+    float3 bitangent;
+};
+
+[[vk::binding(0, 1)]] 
+StructuredBuffer<Vertex> vertexBuffer : register(t2);
+
+// Samplers
+[[vk::binding(0, 2)]]
+SamplerState mySampler : register(s0);
+
+// Materials
+struct Material
+{
+    bool hasAlbedo;
+    float3 albedo;
+    bool hasNormal;
+    bool hasMetalness;
+    bool hasRoughness;
+    bool hasAO;
+    float metalnessValue;
+    float roughnessValue;
+    float aoValue;
+    int albedoTextureId;
+    int normalTextureId;
+    int metalnessTextureId;
+    int roughnessTextureId;
+    int aoTextureId;
+};
+[[vk::binding(0, 3)]]
+StructuredBuffer<Material> material;
+
+// Textures
+[[vk::binding(0, 4)]]
+Texture2D textures[];
+
+// Lights
+struct Light
+{
+    float3 position;
+    int type;
+    float4 color;
+    float3 direction;
+    float outerConeAngle;
+    float innerConeAngle;
+    bool castShadow;
+    int shadowMapTextureId[4];
+    int transformId[4];
+};
+
+[[vk::binding(0, 5)]]
+StructuredBuffer<Light> lights;
+
+// Cameras
+struct CameraView {
+    float4x4 View;
+    float4x4 Projection;
+    float4x4 ViewProjection;
+    float4x4 InverseView;
+    float4x4 InverseProjection;
+    float3 Position;
+    float Near;
+    float Far;
+};
+[[vk::binding(0, 6)]]
+StructuredBuffer<CameraView> cameras;
+
+struct PSInput 
+{
+    float4 Position : SV_Position;
+    float2 UV : TEXCOORD0;
+};
+
+struct PSOutput {
+    float4 oColor0 : SV_TARGET;
+};
+
+struct DepthAwareBlurConstant
+{
+    int DepthTextureID;
+    int VolumetricTextureID;
+};
+
+[[vk::push_constant]]
+DepthAwareBlurConstant pushConstants;
+
+float2 GetTextureSize(Texture2D tex)
+{
+    uint width, height;
+    tex.GetDimensions(width, height);
+    return float2(width, height);
+}
+
+float PixelToUV(float2 uv, Texture2D tex)
+{
+    float2 texSize = GetTextureSize(tex);
+    return uv / texSize;
+}
+
+PSOutput main(PSInput input)
+{
+    int depthTexture = pushConstants.DepthTextureID;
+    float upSampledDepth = textures[depthTexture].Sample(mySampler, input.UV).r;
+    float3 upSampledColor = textures[pushConstants.VolumetricTextureID].Sample(mySampler, input.UV).rgb;
+    float3 color = 0.0f.xxx;
+	float totalWeight = 0.0f;
+	
+    int2 screenCoordinates = int2(input.Position.xy);
+    int xOffset = (screenCoordinates.x % 2 == 0) ? -1 : 1;
+    int yOffset = (screenCoordinates.y % 2 == 0) ? -1 : 1;
+
+	int2 offsets[] = {int2(0, 0),
+	int2(0, yOffset),
+	int2(xOffset, 0),
+	int2(xOffset, yOffset)};
+	
+	for (int i = 0; i < 4; i ++)
+	{
+        float2 uvOffset = float2(offsets[i].x * 4.0, offsets[i].y * 4.0) ;
+        uvOffset = PixelToUV(uvOffset, textures[pushConstants.DepthTextureID]);
+        float3 downscaledColor = textures[pushConstants.VolumetricTextureID].Sample(mySampler, input.UV + uvOffset).rgb;
+		float downscaledDepth = textures[pushConstants.DepthTextureID].Sample(mySampler, input.UV + uvOffset).r;
+		
+		float currentWeight = 1.0f;
+
+        if(abs(upSampledDepth - downscaledDepth) > 0.0001)
+        {
+            //color = float3(1, 0, 0);
+            currentWeight *= 0.0f;
+        }
+		//currentWeight *= max(0.0f, 1.0f - abs(upSampledDepth - downscaledDepth));
+		
+		color += downscaledColor * currentWeight;
+		totalWeight += currentWeight;
+	}
+	
+	float3 volumetricLight;
+	const float epsilon = 0.0001f;
+	volumetricLight.xyz = color / (totalWeight + epsilon);
+	
+    PSOutput output; 
+    output.oColor0 = float4(volumetricLight.x, volumetricLight.y, volumetricLight.z, 1.0f);
+    //output.oColor0 = float4(upSampledColor.x, upSampledColor.y, upSampledColor.z, 1.0f);
+    return output;
+}

Data/Shaders/Vulkan/depth_aware_blur.vert

@@ -0,0 +1,109 @@
+// Transforms
+struct ModelData
+{
+    float4x4 model;
+};
+[[vk::binding(0, 0)]]
+StructuredBuffer<ModelData> model : register(t1);
+
+// Vertex
+struct Vertex 
+{
+    float3 position;
+    float uv_x;
+    float3 normal;
+    float uv_y;
+    float3 tangent;
+    float3 bitangent;
+};
+
+[[vk::binding(0, 1)]] 
+StructuredBuffer<Vertex> vertexBuffer : register(t2);
+
+// Samplers
+[[vk::binding(0, 2)]]
+SamplerState mySampler : register(s0);
+
+// Materials
+struct Material
+{
+    bool hasAlbedo;
+    float3 albedo;
+    bool hasNormal;
+    bool hasMetalness;
+    bool hasRoughness;
+    bool hasAO;
+    float metalnessValue;
+    float roughnessValue;
+    float aoValue;
+    int albedoTextureId;
+    int normalTextureId;
+    int metalnessTextureId;
+    int roughnessTextureId;
+    int aoTextureId;
+};
+[[vk::binding(0, 3)]]
+StructuredBuffer<Material> material;
+
+// Textures
+[[vk::binding(0, 4)]]
+Texture2D textures[];
+
+// Lights
+struct Light
+{
+    float3 position;
+    int type;
+    float4 color;
+    float3 direction;
+    float outerConeAngle;
+    float innerConeAngle;
+    bool castShadow;
+    int shadowMapTextureId[4];
+    int transformId[4];
+};
+
+[[vk::binding(0, 5)]]
+StructuredBuffer<Light> lights;
+
+// Cameras
+struct CameraView {
+    float4x4 View;
+    float4x4 Projection;
+    float4x4 ViewProjection;
+    float4x4 InverseView;
+    float4x4 InverseProjection;
+    float3 Position;
+    float Near;
+    float Far;
+};
+[[vk::binding(0, 6)]]
+StructuredBuffer<CameraView> cameras;
+
+struct DepthAwareBlurConstant
+{
+    int DepthTextureID;
+    int VolumetricTextureID;
+};
+
+[[vk::push_constant]]
+DepthAwareBlurConstant pushConstants;
+
+// Outputs
+struct VSOutput 
+{
+    float4 Position : SV_Position;
+    float2 UV : TEXCOORD0;
+};
+
+// Main vertex shader
+VSOutput main(uint vertexIndex : SV_VertexID) 
+{
+    VSOutput output;
+
+    Vertex v = vertexBuffer[vertexIndex];
+    output.UV = float2(v.uv_x, v.uv_y);
+    output.Position = float4(v.position, 1.0f);
+    
+    return output;
+}

Data/Shaders/Vulkan/volumetric.frag

@@ -99,6 +99,11 @@ struct VolumetricConstant
     int CamViewID;
     int LightCount;
     float Ambient;
+    float Time;
+    float NoiseSpeed;
+    float NoiseScale;
+    float NoiseStrength;
+    float CSMSplits[4];
 };
 
 [[vk::push_constant]]
@@ -135,8 +140,103 @@ float3 WorldPosFromDepth(float depth, float2 uv, float4x4 invProj, float4x4 invV
     return worldSpacePosition.xyz;
 }
 
+// Simplex 3D Noise 
+float mod289(float x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+float3 mod289(float3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+float4 mod289(float4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+
+float4 permute(float4 x) { return mod289(((x*34.0)+1.0)*x); }
+
+float4 taylorInvSqrt(float4 r) { return 1.79284291400159 - 0.85373472095314 * r; }
+
+float snoise(float3 v)
+{
+    const float2  C = float2(1.0/6.0, 1.0/3.0) ;
+    const float4  D = float4(0.0, 0.5, 1.0, 2.0);
+
+    // First corner
+    float3 i  = floor(v + dot(v, C.yyy));
+    float3 x0 = v - i + dot(i, C.xxx);
+
+    // Other corners
+    float3 g = step(x0.yzx, x0.xyz);
+    float3 l = 1.0 - g;
+    float3 i1 = min(g.xyz, l.zxy);
+    float3 i2 = max(g.xyz, l.zxy);
+
+    // x0 = x0 - 0.0 + 0.0 * C.xxx;
+    float3 x1 = x0 - i1 + C.xxx;
+    float3 x2 = x0 - i2 + C.yyy;
+    float3 x3 = x0 - 1.0 + 3.0 * C.xxx;
+
+    // Permutations
+    i = mod289(i);
+    float4 p = permute(permute(permute(
+                i.z + float4(0.0, i1.z, i2.z, 1.0))
+              + i.y + float4(0.0, i1.y, i2.y, 1.0))
+              + i.x + float4(0.0, i1.x, i2.x, 1.0));
+
+    // Gradients: 7x7 points over a cube, mapped onto a unit sphere
+    float4 j = p - 49.0 * floor(p * (1.0 / 49.0));  // mod(p,7*7)
+
+    float4 x_ = floor(j * (1.0 / 7.0));
+    float4 y_ = floor(j - 7.0 * x_);  // mod(j,7)
+
+    float4 x = (x_ * 2.0 + 0.5) / 7.0 - 1.0;
+    float4 y = (y_ * 2.0 + 0.5) / 7.0 - 1.0;
+
+    float4 h = 1.0 - abs(x) - abs(y);
+
+    float4 b0 = float4(x.xy, y.xy);
+    float4 b1 = float4(x.zw, y.zw);
+
+    float4 s0 = floor(b0) * 2.0 + 1.0;
+    float4 s1 = floor(b1) * 2.0 + 1.0;
+    float4 sh = -step(h, 0.0);
+
+    float4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
+    float4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
+
+    float3 g0 = float3(a0.xy, h.x);
+    float3 g1 = float3(a0.zw, h.y);
+    float3 g2 = float3(a1.xy, h.z);
+    float3 g3 = float3(a1.zw, h.w);
+
+    // Normalize gradients
+    float4 norm = taylorInvSqrt(float4(dot(g0,g0), dot(g1,g1), dot(g2,g2), dot(g3,g3)));
+    g0 *= norm.x;
+    g1 *= norm.y;
+    g2 *= norm.z;
+    g3 *= norm.w;
+
+    // Mix final noise value
+    float4 m = max(0.6 - float4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+    m = m * m;
+    return 42.0 * dot(m*m, float4(dot(g0,x0), dot(g1,x1), dot(g2,x2), dot(g3,x3)));
+}
+
+int GetCSMSplit(float depth)
+{
+    for(int i = 0; i < 4; i++)
+    {
+        float csmSplitDepth = pushConstants.CSMSplits[i];
+
+        if(depth < csmSplitDepth + 0.000001)
+        {
+            return i;
+        }
+    }
+
+    return 0;
+}
+
 PSOutput main(PSInput input)
 {
+    float ditherPattern[4][4] = { { 0.0f, 0.5f, 0.125f, 0.625f},
+    { 0.75f, 0.22f, 0.875f, 0.375f},
+    { 0.1875f, 0.6875f, 0.0625f, 0.5625},
+    { 0.9375f, 0.4375f, 0.8125f, 0.3125} };
+
     CameraView camView = cameras[pushConstants.CamViewID];
     float3 startPosition = camView.Position;
 
@@ -167,30 +267,67 @@ PSOutput main(PSInput input)
         for(int l = 0; l < pushConstants.LightCount; l++)
         {
             Light light = lights[l];
-            if(light.type != 0) 
+            if(light.type == 0) 
             {
-                continue;
+                float lightDepth = length(worldPos - camView.Position);
+                int splitIndex = GetCSMSplit(lightDepth);
+
+                CameraView lightView = cameras[light.transformId[splitIndex]];
+                float4 fragPosLightSpace = mul(lightView.Projection, mul(lightView.View, float4(currentPosition, 1.0)));
+                float3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
+                projCoords.xy = projCoords.xy * 0.5 + 0.5;
+
+                float currentDepth = projCoords.z;
+                float closestDepth = textures[light.shadowMapTextureId[splitIndex]].Sample(mySampler, projCoords.xy).r;
+
+                float3 noiseOffset = float3(pushConstants.NoiseSpeed * pushConstants.Time, pushConstants.NoiseSpeed * pushConstants.Time, pushConstants.NoiseSpeed * pushConstants.Time);
+                float3 noiseSamplePos = (currentPosition + noiseOffset) * pushConstants.NoiseScale;
+                if(closestDepth < currentDepth)
+                {
+                    accumFog += (ComputeScattering(dot(rayDirection, light.direction)).rrr * light.color.xyz) * pushConstants.Exponant * ((snoise(noiseSamplePos.xyz) + 1.0) / 2.0);
+                }
+                else
+                {
+                    accumFog += (ComputeScattering(dot(rayDirection, light.direction)).rrr * light.color.xyz) * pushConstants.Ambient * ((snoise(noiseSamplePos.xyz) + 1.0) / 2.0);
+                }
             }
-
-            CameraView lightView = cameras[light.transformId[0]];
-            float4 fragPosLightSpace = mul(lightView.Projection, mul(lightView.View, float4(currentPosition, 1.0)));
-            float3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
-            projCoords.xy = projCoords.xy * 0.5 + 0.5;
-
-            float currentDepth = projCoords.z;
-            float closestDepth = textures[light.shadowMapTextureId[0]].Sample(mySampler, projCoords.xy).r;
-
-            if(closestDepth < currentDepth)
+            else if(light.type == 1)
             {
-                accumFog += (ComputeScattering(dot(rayDirection, light.direction)).rrr * light.color) * pushConstants.Exponant;
+                float3 lightToFrag = currentPosition - light.position;
+                float distance = length(lightToFrag);
+                float3 lightDir = normalize(-lightToFrag);
+                float attenuation = 1.0 / (distance * distance);
+                attenuation = 1.0 - smoothstep(0.0, 3.0f, distance);
+                float3 noiseOffset = float3(pushConstants.NoiseSpeed * pushConstants.Time, pushConstants.NoiseSpeed * pushConstants.Time, pushConstants.NoiseSpeed * pushConstants.Time);
+                float3 noiseSamplePos = (currentPosition + noiseOffset) * pushConstants.NoiseScale;
+                float lightScatter = (snoise(noiseSamplePos.xyz) + 1.0) * 0.5;
+
+                float3 scatterTerm = ComputeScattering(dot(rayDirection, lightDir)).rrr * light.color.xyz;
+
+                accumFog += scatterTerm * lightScatter * pushConstants.Exponant * attenuation;
             }
-            else
+            else if(light.type == 2)
             {
-                accumFog += (ComputeScattering(dot(rayDirection, light.direction)).rrr * light.color) * pushConstants.Ambient;
+                float3 lightToFrag = currentPosition - light.position;
+                float distance = length(lightToFrag);
+                float3 lightDir = normalize(-lightToFrag);
+                float attenuation = 1.0 / (distance * distance);
+                attenuation = 1.0 - smoothstep(0.0, 6.0f, distance);
+                float3 noiseOffset = float3(pushConstants.NoiseSpeed * pushConstants.Time, pushConstants.NoiseSpeed * pushConstants.Time, pushConstants.NoiseSpeed * pushConstants.Time);
+                float3 noiseSamplePos = (currentPosition + noiseOffset) * pushConstants.NoiseScale;
+                float lightScatter = (snoise(noiseSamplePos.xyz) + 1.0) * 0.5;
+
+                float theta = dot(lightDir, normalize(-light.direction));
+                float epsilon = light.innerConeAngle - light.outerConeAngle;
+                float intensity = clamp((theta - light.outerConeAngle) / epsilon, 0.0, 1.0);
+                float3 scatterTerm = ComputeScattering(dot(rayDirection, lightDir)).rrr * light.color.xyz;
+                accumFog += scatterTerm * lightScatter * pushConstants.Exponant * attenuation * intensity;
             }
         }
 
-        currentPosition += step;
+
+
+        currentPosition += step ;
         
     }
 

Data/Shaders/Vulkan/volumetric.vert

@@ -89,6 +89,11 @@ struct VolumetricConstant
     int CamViewID;
     int LightCount;
     float Ambient;
+    float Time;
+    float NoiseSpeed;
+    float NoiseScale;
+    float NoiseStrength;
+    float CSMSplits[4];    
 };
 
 [[vk::push_constant]]

Editor/Source/Editor/Windows/EditorInterface.cpp

@@ -65,7 +65,7 @@
 
 #include "../Events/EditorRequests.h"
 #include "../../../../Nuake/Thirdparty/glfw/include/GLFW/glfw3.h"
-#include "../../../AnimatedValue.h"
+#include "../misc/AnimatedValue.h"
 
 namespace Nuake {
     
@@ -2956,7 +2956,6 @@ namespace Nuake {
 
     void EditorInterface::Update(float ts)
     {
-        Logger::Log("Opacity: " + std::to_string(ts), "UPDATE");
         if (!Engine::GetCurrentScene() || Engine::IsPlayMode())
         {
             return;

Editor/Source/Editor/Windows/SceneEditor/Widgets/FileBrowserWidget.h

@@ -6,7 +6,7 @@
 
 #include "IEditorWidget.h"
 
-#include "../../../../../AnimatedValue.h"
+#include "../../../misc/AnimatedValue.h"
 
 namespace Nuake
 {

Editor/Source/Editor/Windows/SceneEditor/Widgets/SelectionPropertyWidget.cpp

@@ -946,6 +946,54 @@ void SelectionPropertyWidget::DrawFile(Ref<Nuake::File> file)
                     ImGui::PopStyleColor();
                 }
 
+                ImGui::TableNextColumn();
+                {
+                    // Title
+                    ImGui::Text("Noise Strength");
+                    ImGui::TableNextColumn();
+
+                    ImGui::DragFloat("##Noise Strength", &env->mVolumetric->mNoiseStrength, .001f, 0.f, 1.0f);
+                    ImGui::TableNextColumn();
+
+                    // Reset button
+                    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1, 1, 1, 0));
+                    std::string resetBloomThreshold = ICON_FA_UNDO + std::string("##resetBase");
+                    if (ImGui::Button(resetBloomThreshold.c_str())) env->mVolumetric->mNoiseStrength = 1.0f;
+                    ImGui::PopStyleColor();
+                }
+
+                ImGui::TableNextColumn();
+                {
+                    // Title
+                    ImGui::Text("Noise Scale");
+                    ImGui::TableNextColumn();
+
+                    ImGui::DragFloat("##Noise Scale", &env->mVolumetric->mNoiseScale, .001f, 0.f, 10.0f);
+                    ImGui::TableNextColumn();
+
+                    // Reset button
+                    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1, 1, 1, 0));
+                    std::string resetBloomThreshold = ICON_FA_UNDO + std::string("##resetBase");
+                    if (ImGui::Button(resetBloomThreshold.c_str())) env->mVolumetric->mNoiseScale = 1.0f;
+                    ImGui::PopStyleColor();
+                }
+
+                ImGui::TableNextColumn();
+                {
+                    // Title
+                    ImGui::Text("Noise Speed");
+                    ImGui::TableNextColumn();
+
+                    ImGui::DragFloat("##Noise Speed", &env->mVolumetric->mNoiseSpeed, .001f, 0.f, 10.0f);
+                    ImGui::TableNextColumn();
+
+                    // Reset button
+                    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1, 1, 1, 0));
+                    std::string resetBloomThreshold = ICON_FA_UNDO + std::string("##resetBase");
+                    if (ImGui::Button(resetBloomThreshold.c_str())) env->mVolumetric->mNoiseSpeed = 0.1f;
+                    ImGui::PopStyleColor();
+                }
+
                 ImGui::EndTable();
             }
         END_COLLAPSE_HEADER()

Editor/Source/Editor/Windows/SceneEditor/Widgets/SelectionPropertyWidget.h

@@ -2,7 +2,7 @@
 #include "IEditorWidget.h"
 #include "../../EditorSelectionPanel.h"
 
-#include "../../../../../AnimatedValue.h"
+#include "../../../misc/AnimatedValue.h"
 
 class EditorContext;
 

Editor/Source/Editor/Windows/SceneEditor/Widgets/ViewportWidget.cpp

@@ -81,7 +81,6 @@ void ViewportWidget::Draw()
 
         {
             ImGui::PushStyleVar(ImGuiStyleVar_Alpha, overlayOpacity.Value);
-            Logger::Log("Opacity: " + std::to_string(overlayOpacity.Value), "Animated");
             DrawOverlay();
             ImGui::PopStyleVar();
         }

Editor/Source/Editor/Windows/SceneEditor/Widgets/ViewportWidget.h

@@ -3,7 +3,7 @@
 #include "IEditorWidget.h"
 
 #include <imgui/ImGuizmo.h>
-#include "../../../../../AnimatedValue.h"
+#include "../../../misc/AnimatedValue.h"
 
 class EditorContext;
 

Nuake/Source/Nuake/Modules/QuakeModule/Module.lua

@@ -5,7 +5,7 @@ return {
     -- Place all your sources here
     sources = {
         "QuakeModule.cpp",
-        "QuakBaker.h",
-        "QuakBaker.cpp",
+        "QuakeBaker.h",
+        "QuakeBaker.cpp",
     }
 }

Nuake/Source/Nuake/Rendering/PostFX/Volumetric.h

@@ -17,10 +17,15 @@ namespace Nuake {
 		Texture* mDepth;
 		float mBaseAmbient = 0.1f;
 
+
+
 		Scope<FrameBuffer> mVolumetricFramebuffer;
 		Scope<FrameBuffer> mFinalFramebuffer;
 
 	public:
+		float mNoiseScale = 1.0f;
+		float mNoiseStrength = 1.0f;
+		float mNoiseSpeed = 0.1f;
 		Volumetric();
 
 		void SetDepth(Texture* depth);

Nuake/Source/Nuake/Rendering/Vulkan/Pipeline/RenderPipeline.cpp

@@ -144,7 +144,12 @@ void RenderPass::Render(PassRenderContext& ctx, PassAttachments& inputs)
 		}
 	}
 
-	VkRenderingInfo renderInfo = VulkanInit::RenderingInfo(ctx.resolution, renderAttachmentInfos, !hasDepthAttachment ? nullptr : &depthAttachmentInfo);
+	Vector2 resolution = ctx.resolution * RenderScale;
+	resolution.x = static_cast<float>(static_cast<int>(resolution.x));
+	resolution.y = static_cast<float>(static_cast<int>(resolution.y));
+	resolution = glm::clamp(resolution, Vector2(1, 1), ctx.resolution);
+
+	VkRenderingInfo renderInfo = VulkanInit::RenderingInfo(resolution, renderAttachmentInfos, !hasDepthAttachment ? nullptr : &depthAttachmentInfo);
 	renderInfo.colorAttachmentCount = std::size(renderAttachmentInfos);
 	renderInfo.pColorAttachments = renderAttachmentInfos.data();
 
@@ -152,8 +157,8 @@ void RenderPass::Render(PassRenderContext& ctx, PassAttachments& inputs)
 	cmd.BeginRendering(renderInfo);
 	{
 		cmd.BindPipeline(Pipeline);
-		cmd.SetViewport(ctx.resolution);
-		cmd.SetScissor(ctx.resolution);
+		cmd.SetViewport(resolution);
+		cmd.SetScissor(resolution);
 
 		if (RenderCb)
 		{

Nuake/Source/Nuake/Rendering/Vulkan/Pipeline/RenderPipeline.h

@@ -70,7 +70,7 @@ namespace Nuake
 		bool HasDepthTest = false;
 		Ref<VulkanShader> VertShader;
 		Ref<VulkanShader> FragShader;
-
+		float RenderScale = 1.0f;
 		std::vector<TextureAttachment> Attachments;
 		TextureAttachment DepthAttachment;
 		std::vector<std::string> InputNames;
@@ -112,6 +112,7 @@ namespace Nuake
 		TextureAttachment& AddAttachment(const std::string& name, ImageFormat format, ImageUsage usage = ImageUsage::Default, bool clearOnLoad = true);
 		TextureAttachment& GetAttachment(const std::string& name);
 		std::vector<TextureAttachment> GetAttachments();
+		void SetRenderScale(float scale) { RenderScale = scale; }
 
 		void AddInput(const std::string& name);
 		std::vector<std::string> GetInputs();

Nuake/Source/Nuake/Rendering/Vulkan/SceneRenderPipeline.cpp

@@ -178,7 +178,7 @@ SceneRenderPipeline::SceneRenderPipeline()
 	}
 
 	// Initialize render targets     
-	const Vector2 defaultSize = { 1, 1 };
+	const Vector2 defaultSize = { 4, 4 };
 	GBufferAlbedo = CreateRef<VulkanImage>(ImageFormat::RGBA16F, defaultSize);
 	GBufferAlbedo->SetDebugName("GBufferAlbedo");
 
@@ -226,6 +226,7 @@ SceneRenderPipeline::SceneRenderPipeline()
 	BloomThreshold = CreateRef<VulkanImage>(ImageFormat::RGBA16F, defaultSize);
 
 	VolumetricOutput = CreateRef<VulkanImage>(ImageFormat::RGBA8, defaultSize);
+	VolumetricBlurOutput = CreateRef<VulkanImage>(ImageFormat::RGBA8, defaultSize);
 	VolumetricCombineOutput = CreateRef<VulkanImage>(ImageFormat::RGBA8, defaultSize);
 
 	RecreatePipeline();
@@ -251,6 +252,7 @@ SceneRenderPipeline::~SceneRenderPipeline()
 	res.RemoveTexture(BloomThreshold);
 	res.RemoveTexture(VolumetricOutput);
 	res.RemoveTexture(VolumetricCombineOutput);
+	res.RemoveTexture(VolumetricBlurOutput);
 }
 
 void SceneRenderPipeline::SetCamera(UUID camera)
@@ -279,9 +281,10 @@ void SceneRenderPipeline::Render(PassRenderContext& ctx)
 	SSAOOutput = ResizeImage(ctx, SSAOOutput, ctx.resolution);
 	SSAOBlurOutput = ResizeImage(ctx, SSAOBlurOutput, ctx.resolution);
 
-	VolumetricOutput = ResizeImage(ctx, VolumetricOutput, ctx.resolution);
+	Vector2 resolution = { static_cast<int>(ctx.resolution.x * 0.25f), static_cast<int>(ctx.resolution.y * 0.25f) };
+	VolumetricOutput = ResizeImage(ctx, VolumetricOutput, glm::clamp(resolution, {1, 1}, ctx.resolution));
+	VolumetricBlurOutput = ResizeImage(ctx, VolumetricBlurOutput, ctx.resolution);
 	VolumetricCombineOutput = ResizeImage(ctx, VolumetricCombineOutput, ctx.resolution);
-
 	OutlineOutput = ResizeImage(ctx, OutlineOutput, ctx.resolution);
 
 	Color clearColor = ctx.scene->GetEnvironment()->AmbientColor;
@@ -295,6 +298,7 @@ void SceneRenderPipeline::Render(PassRenderContext& ctx)
 		{ ShadingOutput },													// Shading
 		{ TonemappedOutput },												// Tonemap
 		{ VolumetricOutput },
+		{ VolumetricBlurOutput },
 		{ VolumetricCombineOutput },
 		{ GizmoOutput, GBufferEntityID, GBufferDepth }, // Reusing depth from gBuffer
 		{ GizmoCombineOutput },
@@ -613,6 +617,7 @@ void SceneRenderPipeline::RecreatePipeline()
 	volumetricPass.SetShaders(shaderMgr.GetShader("volumetric_vert"), shaderMgr.GetShader("volumetric_frag"));
 	volumetricPass.SetPushConstant(volumetricConstant);
 	volumetricPass.AddInput("Depth");
+	volumetricPass.SetRenderScale(0.25f);
 	volumetricPass.AddAttachment("VolumetricOutput", VolumetricOutput->GetFormat());
 	volumetricPass.SetDepthTest(false);
 	volumetricPass.SetPreRender([&](PassRenderContext& ctx)
@@ -638,10 +643,19 @@ void SceneRenderPipeline::RecreatePipeline()
 		volumetricConstant.StepCount = env->mVolumetric->GetStepCount();
 		volumetricConstant.Exponant = env->mVolumetric->GetFogExponant();
 		volumetricConstant.Ambient = env->mVolumetric->GetBaseAmbient();
+		for (int i = 0; i < CSM_AMOUNT; i++)
+		{
+			volumetricConstant.CSMSplits[i] = LightComponent::mCascadeSplitDepth[i];
+		}
+
 		auto& res = GPUResources::Get();
 		volumetricConstant.DepthTextureID = res.GetBindlessTextureID(GBufferDepth->GetID());
 		volumetricConstant.CamViewID = ctx.cameraID;
 		volumetricConstant.LightCount = res.LightCount;
+		volumetricConstant.NoiseScale = env->mVolumetric->mNoiseScale;
+		volumetricConstant.NoiseSpeed = env->mVolumetric->mNoiseSpeed;
+		volumetricConstant.NoiseStrength = env->mVolumetric->mNoiseStrength;
+		volumetricConstant.Time = Engine::GetTime();
 
 		cmd.PushConstants(ctx.renderPass->PipelineLayout, sizeof(VolumetricConstant), &volumetricConstant);
 
@@ -651,6 +665,47 @@ void SceneRenderPipeline::RecreatePipeline()
 		cmd.DrawIndexed(6);
 	});
 
+
+	struct BlurConstant
+	{
+		int depthId;
+		int volumetricId;
+	};
+
+	BlurConstant blurConstantData;
+	auto& volumetricBlurPass = GBufferPipeline.AddPass("VolumetricBlur");
+	volumetricBlurPass.SetPushConstant(blurConstant);
+	volumetricBlurPass.SetShaders(shaderMgr.GetShader("depth_aware_blur_vert"), shaderMgr.GetShader("depth_aware_blur_frag"));
+	volumetricBlurPass.AddAttachment("VolumetricBlurOutput", VolumetricBlurOutput->GetFormat());
+	volumetricBlurPass.SetDepthTest(false);
+	volumetricBlurPass.SetPreRender([&](PassRenderContext& ctx)
+	{
+		Cmd& cmd = ctx.commandBuffer;
+		auto& layout = ctx.renderPass->PipelineLayout;
+		auto& res = GPUResources::Get();
+
+		cmd.BindDescriptorSet(layout, res.ModelDescriptor, 0);
+		cmd.BindDescriptorSet(layout, res.SamplerDescriptor, 2);
+		cmd.BindDescriptorSet(layout, res.MaterialDescriptor, 3);
+		cmd.BindDescriptorSet(layout, res.TexturesDescriptor, 4);
+		cmd.BindDescriptorSet(layout, res.LightsDescriptor, 5);
+		cmd.BindDescriptorSet(layout, res.CamerasDescriptor, 6);
+	});
+	volumetricBlurPass.SetRender([&](PassRenderContext& ctx)
+	{
+		auto& cmd = ctx.commandBuffer;
+
+		BlurConstant blurConstant;
+		blurConstant.depthId = GPUResources::Get().GetBindlessTextureID(GBufferDepth->GetID());
+		blurConstant.volumetricId = GPUResources::Get().GetBindlessTextureID(VolumetricOutput->GetID());
+		cmd.PushConstants(ctx.renderPass->PipelineLayout, sizeof(blurConstant), &blurConstant);
+
+		auto& quadMesh = VkSceneRenderer::QuadMesh;
+		cmd.BindDescriptorSet(ctx.renderPass->PipelineLayout, quadMesh->GetDescriptorSet(), 1);
+		cmd.BindIndexBuffer(quadMesh->GetIndexBuffer()->GetBuffer());
+		cmd.DrawIndexed(6);
+	});
+
 	auto& volumetricCombinePass = GBufferPipeline.AddPass("VolumetricCombine");
 	volumetricCombinePass.SetPushConstant(copyConstant);
 	volumetricCombinePass.SetShaders(shaderMgr.GetShader("copy_vert"), shaderMgr.GetShader("copy_frag"));
@@ -673,7 +728,7 @@ void SceneRenderPipeline::RecreatePipeline()
 	{
 		auto& cmd = ctx.commandBuffer;
 
-		copyConstant.Source2TextureID = GPUResources::Get().GetBindlessTextureID(VolumetricOutput->GetID());
+		copyConstant.Source2TextureID = GPUResources::Get().GetBindlessTextureID(VolumetricBlurOutput->GetID());
 		copyConstant.SourceTextureID = GPUResources::Get().GetBindlessTextureID(TonemappedOutput->GetID());
 		copyConstant.Mode = 1;
 		cmd.PushConstants(ctx.renderPass->PipelineLayout, sizeof(copyConstant), &copyConstant); 
@@ -684,6 +739,8 @@ void SceneRenderPipeline::RecreatePipeline()
 		cmd.DrawIndexed(6);
 	});
 
+
+
 	auto& gizmoPass = GBufferPipeline.AddPass("Gizmo");
 	gizmoPass.SetShaders(shaderMgr.GetShader("gizmo_vert"), shaderMgr.GetShader("gizmo_frag"));
 	gizmoPass.SetPushConstant<DebugConstant>(debugConstant);
@@ -870,7 +927,16 @@ Ref<VulkanImage> SceneRenderPipeline::ResizeImage(PassRenderContext& ctx, Ref<Vu
 	// Register to resource manager
 	GPUResources& gpuResources = GPUResources::Get();
 	gpuResources.AddTexture(newAttachment);
-	gpuResources.RemoveTexture(image);
+
+	using CleanUpFunc = std::function<void()>;
+	using CleanUpStack = std::stack<CleanUpFunc>;
+
+	CleanUpStack stack;
+	stack.push([image]() {
+		GPUResources& gpuResources = GPUResources::Get();
+		//gpuResources.RemoveTexture(image);
+	}); 
+	//gpuResources.QueueDeletion(std::move(stack));
 
 	// We might need to do this?
 	ctx.commandBuffer.TransitionImageLayout(newAttachment, VK_IMAGE_LAYOUT_GENERAL);

Nuake/Source/Nuake/Rendering/Vulkan/SceneRenderPipeline.h

@@ -98,6 +98,11 @@ namespace Nuake
 		int CamViewID;
 		int LightCount;
 		float Ambient;
+		float Time;
+		float NoiseSpeed;
+		float NoiseScale;
+		float NoiseStrength;
+		float CSMSplits[4];
 	};
 
 	struct CopyConstant
@@ -171,6 +176,7 @@ namespace Nuake
 
 		Ref<VulkanImage> TonemappedOutput;
 		Ref<VulkanImage> VolumetricOutput;
+		Ref<VulkanImage> VolumetricBlurOutput;
 		Ref<VulkanImage> VolumetricCombineOutput;
 
 		Ref<VulkanImage> OutlineOutput;
@@ -199,6 +205,7 @@ namespace Nuake
 		BloomConstant bloomConstant;
 		VolumetricConstant volumetricConstant;
 
+
 		RenderPipeline GBufferPipeline;
 
 		// Delegates

Nuake/Source/Nuake/Rendering/Vulkan/ShaderCompiler.cpp

@@ -127,7 +127,7 @@ Ref<VulkanShader> ShaderCompiler::CompileShader(const std::string& path)
               
             Logger::Log("Shader compilation failed: " + errorMsgStr, "DXC", CRITICAL);         
               
-            throw std::runtime_error("Shader compilation failed: " + errorMsgStr);   
+            throw std::runtime_error("Shader compilation failed: " + errorMsgStr);    
         }     
         else
         { 

Nuake/Source/Nuake/Rendering/Vulkan/VulkanRenderer.cpp

@@ -37,8 +37,11 @@
 #include <mutex>
 #include <algorithm>
 
+#ifdef NK_DEBUG
+bool NKUseValidationLayer = true; 
+#else
 bool NKUseValidationLayer = false;
-
+#endif
 using namespace Nuake;
 
 VkRenderer::~VkRenderer()
@@ -174,13 +177,19 @@ void VkRenderer::GetInstance()
 	vkb::InstanceBuilder builder;
 
 	//make the vulkan instance, with basic debug features
-	auto inst_ret = builder.set_app_name("Nuake Engine")
+	auto instRet = builder.set_app_name("Nuake Engine")
 		.request_validation_layers(NKUseValidationLayer)
 		.use_default_debug_messenger()
 		.require_api_version(1, 3, 0)
 		.build();
 
-	VkbInstance = inst_ret.value();
+	if (!instRet)
+	{
+		std::string errMsg = "Failed to create Vulkan instance. Error: " + instRet.error().message();
+		OS::ShowMessageBox("Vulkan Error", errMsg);
+	}
+
+	VkbInstance = instRet.value();
 	Instance = VkbInstance.instance;
 	VkDebugMessenger = VkbInstance.debug_messenger;
 }
@@ -218,7 +227,7 @@ void VkRenderer::SelectGPU()
 	}
 
 	vkb::PhysicalDeviceSelector selector{ VkbInstance };
-	vkb::PhysicalDevice physicalDevice = selector
+	auto physRet = selector
 		.set_minimum_version(1, 3)
 		.set_required_features_13(features)
 		.set_required_features_12(features12)
@@ -228,8 +237,15 @@ void VkRenderer::SelectGPU()
 		})
 		.set_surface(Surface)
 		.add_required_extensions(requiredExtensions)
-		.select()
-		.value();
+		.select();
+
+	if (!physRet)
+	{
+		auto message = physRet.error().message();
+		OS::ShowMessageBox("Vulkan Error", "No Physical Device supported found. \n" + message);
+	}
+
+	vkb::PhysicalDevice physicalDevice = physRet.value();
 
 	vkb::DeviceBuilder deviceBuilder{ physicalDevice };
 
@@ -258,10 +274,18 @@ void VkRenderer::SelectGPU()
 
 	// Chain pNext for Extended Dynamic State 3
 
-	VkbDevice = deviceBuilder
+	auto devRet = deviceBuilder
 		.add_pNext(&line_raster_features)
 		.add_pNext(&extendedDynamicState3Features)
-		.build().value();
+		.build();
+
+	if (!devRet)
+	{
+		auto message = devRet.error().message();
+		OS::ShowMessageBox("Vulkan Error", "No Device supported found.\n" + message);
+	}
+
+	VkbDevice = devRet.value();
 	Device = VkbDevice.device;
 	GPU = physicalDevice.physical_device;
 }

Nuake/Source/Nuake/Rendering/Vulkan/VulkanResources.cpp

@@ -295,7 +295,7 @@ void GPUResources::CreateBindlessLayout()
 	vkCreateSampler(device, &sampler, nullptr, &SamplerLinear);
 
 	VkDescriptorImageInfo textureInfo = {};
-	textureInfo.sampler = SamplerNearest;  // Your VkSampler object
+	textureInfo.sampler = SamplerLinear;  // Your VkSampler object
 	textureInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
 	VkWriteDescriptorSet samplerWrite = {};

Nuake/Source/Nuake/Rendering/Vulkan/VulkanSceneRenderer.cpp

@@ -417,6 +417,8 @@ void VkSceneRenderer::LoadShaders()
 	shaderMgr.AddShader("blur_vert", shaderCompiler.CompileShader("Resources/Shaders/Vulkan/blur.vert"));
 	shaderMgr.AddShader("volumetric_frag", shaderCompiler.CompileShader("Resources/Shaders/Vulkan/volumetric.frag"));
 	shaderMgr.AddShader("volumetric_vert", shaderCompiler.CompileShader("Resources/Shaders/Vulkan/volumetric.vert"));
+	shaderMgr.AddShader("depth_aware_blur_vert", shaderCompiler.CompileShader("Resources/Shaders/Vulkan/depth_aware_blur.vert"));
+	shaderMgr.AddShader("depth_aware_blur_frag", shaderCompiler.CompileShader("Resources/Shaders/Vulkan/depth_aware_blur.frag"));
 }
 
 void VkSceneRenderer::PrepareScenes(const std::vector<Ref<Scene>>& scenes, RenderContext inContext)
@@ -673,7 +675,10 @@ void VkSceneRenderer::DrawSceneView(RenderContext inContext)
 	passCtx.commandBuffer = inContext.CommandBuffer;
 	passCtx.scene = inContext.CurrentScene;
 	passCtx.selectedEntity = static_cast<float>(inContext.SelectedEntityID);
-	sceneRenderPipeline->Render(passCtx);
+	if (passCtx.resolution != Vector2{ 1, 1 })
+	{
+		sceneRenderPipeline->Render(passCtx);
+	}
 
 	// in case we just resized
 	inContext.CommandBuffer.TransitionImageLayout(inContext.ViewportImage, VK_IMAGE_LAYOUT_GENERAL);