celisej567/Nuake
1
0
Fork 0
mirror of https://github.com/antopilo/Nuake.git synced 2026-01-01 05:48:14 +03:00
Code Issues Packages Projects Releases Wiki Activity

Volumetric upscaling + support for other types of lights + CSM

Browse Source
This commit is contained in:
antopilo
2025-04-24 23:18:14 -04:00
parent 4f24372a2f
commit 30b5ccc339
10 changed files with 408 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
Data/Shaders/Vulkan/depth_aware_blur.frag Normal file
View File

@@ -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;
}

109
Data/Shaders/Vulkan/depth_aware_blur.vert Normal file
View File

@@ -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;
}

90
Data/Shaders/Vulkan/volumetric.frag
View File

@@ -103,6 +103,7 @@ struct VolumetricConstant
float NoiseSpeed;
float NoiseScale;
float NoiseStrength;
float CSMSplits[4];
};
[[vk::push_constant]]
@@ -214,8 +215,28 @@ float snoise(float3 v)
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;
@@ -246,31 +267,66 @@ 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;
float3 noiseOffset = float3(pushConstants.NoiseSpeed * pushConstants.Time, pushConstants.NoiseSpeed * pushConstants.Time, pushConstants.NoiseSpeed * pushConstants.Time);
float3 noiseSamplePos = (currentPosition + noiseOffset) * pushConstants.NoiseScale;
if(closestDepth < currentDepth)
else if(light.type == 1)
{
accumFog += (ComputeScattering(dot(rayDirection, light.direction)).rrr * light.color) * pushConstants.Exponant * ((snoise(noiseSamplePos.xyz) + 1.0) / 2.0);
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 * ((snoise(noiseSamplePos.xyz) + 1.0) / 2.0);
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 ;
}

1
Data/Shaders/Vulkan/volumetric.vert
View File

@@ -93,6 +93,7 @@ struct VolumetricConstant
float NoiseSpeed;
float NoiseScale;
float NoiseStrength;
float CSMSplits[4];
};
[[vk::push_constant]]

55
Nuake/Source/Nuake/Rendering/Vulkan/SceneRenderPipeline.cpp
View File

@@ -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)
@@ -281,8 +283,8 @@ void SceneRenderPipeline::Render(PassRenderContext& ctx)
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;
@@ -296,6 +298,7 @@ void SceneRenderPipeline::Render(PassRenderContext& ctx)
{ ShadingOutput }, // Shading
{ TonemappedOutput }, // Tonemap
{ VolumetricOutput },
{ VolumetricBlurOutput },
{ VolumetricCombineOutput },
{ GizmoOutput, GBufferEntityID, GBufferDepth }, // Reusing depth from gBuffer
{ GizmoCombineOutput },
@@ -640,6 +643,11 @@ 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;
@@ -657,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"));
@@ -679,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);
@@ -690,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);

3
Nuake/Source/Nuake/Rendering/Vulkan/SceneRenderPipeline.h
View File

@@ -102,6 +102,7 @@ namespace Nuake
float NoiseSpeed;
float NoiseScale;
float NoiseStrength;
float CSMSplits[4];
};
struct CopyConstant
@@ -175,6 +176,7 @@ namespace Nuake
Ref<VulkanImage> TonemappedOutput;
Ref<VulkanImage> VolumetricOutput;
Ref<VulkanImage> VolumetricBlurOutput;
Ref<VulkanImage> VolumetricCombineOutput;
Ref<VulkanImage> OutlineOutput;
@@ -203,6 +205,7 @@ namespace Nuake
BloomConstant bloomConstant;
VolumetricConstant volumetricConstant;
RenderPipeline GBufferPipeline;
// Delegates

2
Nuake/Source/Nuake/Rendering/Vulkan/ShaderCompiler.cpp
View File

@@ -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
{

7
Nuake/Source/Nuake/Rendering/Vulkan/VulkanRenderer.cpp
View File

@@ -37,8 +37,11 @@
#include <mutex>
#include <algorithm>
bool NKUseValidationLayer = true;
#ifdef NK_DEBUG
bool NKUseValidationLayer = true;
#else
bool NKUseValidationLayer = false;
#endif
using namespace Nuake;
VkRenderer::~VkRenderer()

2
Nuake/Source/Nuake/Rendering/Vulkan/VulkanResources.cpp
View File

@@ -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 = {};

2
Nuake/Source/Nuake/Rendering/Vulkan/VulkanSceneRenderer.cpp
View File

@@ -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)