I am building a 3d renderer in C++ using Vulkan.hpp. I am in the process of implementing…
- User
I am building a 3d renderer in C++ using Vulkan.hpp. I am in the process of implementing SSAO into the rendering pipeline. I have grabbed some code for the shader as a starting point, but I don't think it's written in a way that best suites my needs. The output does not look right. I believe the shader code is written for world space ambient occlusion, while my renderer utilises deferred shading and will apply the SSAO in screen space. Can you look at the shader code and let me know whether this is likely the issue and, if so, make the necessary changes to the shader code? It is worth noting that there is a subsequent step that handles the blurring of the SSAO output, which seems to be working correctly.
Here is the shader code for the SSAO fragment shader:
#version 450
layout(location = 0) out vec4 FragColor;
layout(location = 0) in vec2 TexCoords;
layout(set = 0, binding = 0) uniform sampler2D gPosition; layout(set = 0, binding = 1) uniform sampler2D gNormal; layout(set = 0, binding = 2) uniform sampler2D texNoise;
layout(binding = 3) buffer SamplesBufferObject { vec3 samples[]; } samplesUBO;
layout(binding = 4) uniform InputsBufferObject { //vec3 samples[]; int kernelSize; float radius; float bias; vec2 noiseScale; } inputsUBO;
layout(binding = 5) uniform ProjBufferObject { mat4 proj; } projUBO;
void main() { // get input for SSAO algorithm vec3 fragPos = texture(gPosition, TexCoords).xyz; vec3 normal = normalize(texture(gNormal, TexCoords).rgb); vec3 randomVec = normalize(texture(texNoise, TexCoords * inputsUBO.noiseScale).xyz); // create TBN change-of-basis matrix: from tangent-space to view-space vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal)); vec3 bitangent = cross(normal, tangent); mat3 TBN = mat3(tangent, bitangent, normal); // iterate over the sample kernel and calculate occlusion factor float occlusion = 0.0; for(int i = 0; i < inputsUBO.kernelSize; ++i) { // get sample position vec3 samplePos = TBN * samplesUBO.samples[i]; // from tangent to view-space samplePos = fragPos + samplePos * inputsUBO.radius;
// project sample position (to sample texture) (to get position on screen/texture) vec4 offset = vec4(samplePos, 1.0); offset = projUBO.proj * offset; // from view to clip-space offset.xyz /= offset.w; // perspective divide offset.xyz = offset.xyz * 0.5 + 0.5; // transform to range 0.0 - 1.0 // get sample depth float sampleDepth = texture(gPosition, offset.xy).z; // get depth value of kernel sample // range check & accumulate float rangeCheck = smoothstep(0.0, 1.0, inputsUBO.radius / abs(fragPos.z - sampleDepth)); occlusion += (sampleDepth >= samplePos.z + inputsUBO.bias ? 1.0 : 0.0) * rangeCheck; } occlusion = 1.0 - (occlusion / inputsUBO.kernelSize); FragColor = vec4(occlusion,occlusion,occlusion, 1.0);}
- Assistant
Your current SSAO fragment shader seems to be oriented towards view or world space, as it uses the
gPositiontexture to get world space positions, a method that is more typical of world-space ambient occlusion calculations. However, in a typical deferred shading pipeline utilizing screen space ambient occlusion (SSAO), you should leverage the depth buffer to work solely in screen space. Here's a revision toward a more screen-space-oriented method, often referred to as screen space normals and view-space depth from the depth buffer:Revised Shader for Screen Space Ambient Occlusion
#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 TexCoords; layout(set = 0, binding = 0) uniform sampler2D gNormal; layout(set = 0, binding = 1) uniform sampler2D texNoise; layout(binding = 2) uniform sampler2D depthSampler; layout(binding = 3) buffer SamplesBufferObject { vec3 samples[]; } samplesUBO; layout(binding = 4) uniform InputsBufferObject { int kernelSize; float radius; float bias; vec2 noiseScale; } inputsUBO; layout(binding = 5) uniform ProjBufferObject { mat4 proj; } projUBO; vec3 getViewPos(vec2 texCoords, float depth) { // Reconstruct view-space position from screen-space data (position and depth) vec4 clipSpacePos = vec4(texCoords * 2.0 - 1.0, depth, 1.0); vec4 viewSpacePos = inverse(projUBO.proj) * clipSpacePos; return viewSpacePos.xyz / viewSpacePos.w; } void main() { float depth = texture(depthSampler, TexCoords).r; vec3 currentPosition = getViewPos(TexCoords, depth); vec3 normal = normalize(texture(gNormal, TexCoords).rgb); vec3 randomVec = normalize(texture(texNoise, TexCoords * inputsUBO.noiseScale).xyz); vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal)); vec3 bitangent = cross(normal, tangent); mat3 TBN = mat3(tangent, bitangent, normal); float occlusion = 0.0; for(int i = 0; i < inputsUBO.kernelSize; ++i) { vec3 samplePos = TBN * samplesUBO.samples[i]; samplePos = currentPosition + samplePos * inputsUBO.radius; vec4 offset = projUBO.proj * vec4(samplePos, 1.0); offset.xyz /= offset.w; // Perspective divide offset.xyz = offset.xyz * 0.5 + 0.5; // To NDC space: [0, 1] float sampleDepth = texture(depthSampler, offset.xy).r; vec3 samplePosition = getViewPos(offset.xy, sampleDepth); float rangeCheck = smoothstep(0.0, 1.0, inputsUBO.radius / abs(currentPosition.z - samplePosition.z)); occlusion += (sampleDepth >= samplePos.z + inputsUBO.bias ? 1.0 : 0.0) * rangeCheck; } occlusion = 1.0 - (occlusion / inputsUBO.kernelSize); FragColor = vec4(occlusion, occlusion, occlusion, 1.0); }Key Changes & Considerations:
-
Depth Sampling: Instead of obtaining the position from a g-buffer, depth values for the current fragment are fetched from
depthSampler, and view space positions are reconstructed using the inverse projection matrix. -
Position Reconstruction: Implemented a helper function
getViewPosthat reconstructs the view space position from the depth value and screen coordinates, enhancing screen-space calculations. -
Projection Matrix: Confirm the right adjustment for reconstructing positions, validating this method fits your projection matrix setup, especially how the inverse projection matrix is applied.
-
Normals: Use screen space derived normals
gNormal, typical in SSAO for deferred renders.
Compile and test the modified shader, and adapt further if necessary to refine self-shadow artifacts or bias. Adjust buffer/unit bindings and shader properties as per your pipeline's specific architecture.
-
- User
Can you explain to me what the depthSampler is? This appears to be a new texture that is being passed to the shader and will need to be generated.
- Assistant
Certainly! In a deferred rendering pipeline used for techniques like SSAO, the
depthSampleris a texture that stores the depth information of your scene. It's essentially a depth buffer that you render to during the geometry pass of your deferred rendering process. This depth information is crucial for reconstructing the view-space positions or for calculating the distances between the fragments in screen space.Purpose of DepthSampler:
-
Reconstructing View-Space Positions: By fetching the depth value of a fragment from this texture, you can reconstruct the fragment's position in view space. This is useful for SSAO computations because it allows for sampling neighboring positions to evaluate occlusion.
-
Sampling Nearby Depth Values: During SSAO computations, you often sample multiple nearby pixels to determine how much occlusion should be applied to a particular fragment.
How to Generate the Depth Texture:
-
Render Pass Setup: During your scene's geometry pass, attach a texture that allows for depth storage as a render target. This is often done in a framebuffer object (FBO) in OpenGL or as part of a render pass in Vulkan.
-
Format and Allocation:
- Format: Use a depth format like
VK_FORMAT_D32_SFLOATor similar in Vulkan that matches the precision you need. - Allocation: Allocate a 2D texture with the same dimensions as your framebuffer/window size.
- Format: Use a depth format like
-
Attachment: Bind this depth texture as a depth attachment in your render pass. In Vulkan, this means it's part of the attachment descriptions for your render pass creation.
-
Rendering: When rendering your geometry, ensure the depth buffer is being written to this texture. This happens naturally when a depth attachment is part of your active framebuffer.
-
Reading in SSAO Shader: Once you have the depth buffer populated, pass it as a
sampler2Dto your SSAO fragment shader. This is what thedepthSamplerin the shader code refers to asuniform sampler2D.
Here's a brief pseudocode outline of what setting up the depth texture would look like (in Vulkan):
VkImage depthImage; VkDeviceMemory depthImageMemory; createImage(width, height, VK_FORMAT_D32_SFLOAT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, depthImage, depthImageMemory); VkImageView depthImageView; depthImageView = createImageView(depthImage, VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT); // Attach this depthImageView in your framebuffer setup for the geometry passAccessing the Depth in Shaders:
Ensure the
depthSampleris appropriately bound in your descriptor sets within Vulkan. You'll need to configure your application to pass this depth buffer to the SSAO shader pipeline step.This depth information is crucial because it enables accurate SSAO computations based on the geometric relationships between fragments, improving the quality and realism of shadowing effects.
-
- User
I am trying to setup the depth texture to feed into the depthSampler for SSAO. However, the image output from the previous geometry stage is still multisampled, which I wish to retain into later stages. I have code I have used previously for the normal image that will resolve the multisampled image and I am trying to modify it to resolve the depth image, but I am encountering an error:
VUID-vkCmdResolveImage-dstImage-02003(ERROR / SPEC): msgNum: 983975111 - Validation Error: [ VUID-vkCmdResolveImage-dstImage-02003 ] Object 0: handle = 0x2b965efa7a0, type = VK_OBJECT_TYPE_COMMAND_BUFFER; Object 1: handle = 0xcfcda0000000001e, type = VK_OBJECT_TYPE_IMAGE; | MessageID = 0x3aa644c7 | In vkCmdResolveImage, VkFormatFeatureFlags (0x40020001de01) does not support required feature VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT for format 126 used by VkImage 0xcfcda0000000001e[] with tiling VK_IMAGE_TILING_OPTIMAL. The Vulkan spec states: The format features of dstImage must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT (https://vulkan.lunarg.com/doc/view/1.3.239.0/windows/1.3-extensions/vkspec.html#VUID-vkCmdResolveImage-dstImage-02003) Objects: 2 [0] 0x2b965efa7a0, type: 6, name: NULL [1] 0xcfcda0000000001e, type: 10, name: NULL
Can you look a the code for the depth image resolve function and see where this error may be occurring? Here is the code:
void Renderer::ResolveDepthImage(vk::Device device, vk::CommandPool commandPool, vk::Queue graphicsQueue, vk::Image srcImage, vk::Image dstImage, vk::ImageResolve* pRegions, uint32_t regionCount, uint32_t mipLevels) {
// Allocate a one-time-use command buffer vk::CommandBufferAllocateInfo allocInfo{}; allocInfo.level = vk::CommandBufferLevel::ePrimary; allocInfo.commandPool = commandPool; allocInfo.commandBufferCount = 1; vk::CommandBuffer commandBuffer = device.allocateCommandBuffers(allocInfo).front(); // Begin command buffer recording vk::CommandBufferBeginInfo beginInfo{}; beginInfo.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit; commandBuffer.begin(beginInfo); // Transition source image from ShaderReadOnlyOptimal to TransferSrcOptimal vk::ImageMemoryBarrier barrierToSrc{}; barrierToSrc.oldLayout = vk::ImageLayout::eDepthAttachmentOptimal; barrierToSrc.newLayout = vk::ImageLayout::eTransferSrcOptimal; barrierToSrc.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrierToSrc.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrierToSrc.image = srcImage; barrierToSrc.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eDepth; barrierToSrc.subresourceRange.baseMipLevel = 0; barrierToSrc.subresourceRange.levelCount = mipLevels; barrierToSrc.subresourceRange.baseArrayLayer = 0; barrierToSrc.subresourceRange.layerCount = 1; barrierToSrc.srcAccessMask = vk::AccessFlagBits::eShaderRead; barrierToSrc.dstAccessMask = vk::AccessFlagBits::eTransferRead; // Transition destination image from ShaderReadOnlyOptimal to TransferDstOptimal vk::ImageMemoryBarrier barrierToDst{}; barrierToDst.oldLayout = vk::ImageLayout::eUndefined; barrierToDst.newLayout = vk::ImageLayout::eTransferDstOptimal; barrierToDst.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrierToDst.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrierToDst.image = dstImage; barrierToDst.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eDepth; barrierToDst.subresourceRange.baseMipLevel = 0; barrierToDst.subresourceRange.levelCount = mipLevels; barrierToDst.subresourceRange.baseArrayLayer = 0; barrierToDst.subresourceRange.layerCount = 1; barrierToDst.srcAccessMask = {};// vk::AccessFlagBits::eShaderRead; barrierToDst.dstAccessMask = vk::AccessFlagBits::eTransferWrite; // Insert pipeline barriers for the layout transitions commandBuffer.pipelineBarrier( vk::PipelineStageFlagBits::eFragmentShader, vk::PipelineStageFlagBits::eTransfer, {}, 0, nullptr, 0, nullptr, 1, &barrierToSrc ); commandBuffer.pipelineBarrier( vk::PipelineStageFlagBits::eFragmentShader, vk::PipelineStageFlagBits::eTransfer, {}, 0, nullptr, 0, nullptr, 1, &barrierToDst ); // Resolve the multisampled image to a single-sampled image commandBuffer.resolveImage( srcImage, vk::ImageLayout::eTransferSrcOptimal, dstImage, vk::ImageLayout::eTransferDstOptimal, regionCount, pRegions ); // Transition source image back to ShaderReadOnlyOptimal barrierToSrc.oldLayout = vk::ImageLayout::eTransferSrcOptimal; barrierToSrc.newLayout = vk::ImageLayout::eShaderReadOnlyOptimal; barrierToSrc.srcAccessMask = vk::AccessFlagBits::eTransferRead; barrierToSrc.dstAccessMask = vk::AccessFlagBits::eShaderRead; // Transition destination image back to ShaderReadOnlyOptimal barrierToDst.oldLayout = vk::ImageLayout::eTransferDstOptimal; barrierToDst.newLayout = vk::ImageLayout::eShaderReadOnlyOptimal; barrierToDst.srcAccessMask = vk::AccessFlagBits::eTransferWrite; barrierToDst.dstAccessMask = vk::AccessFlagBits::eShaderRead; // Insert pipeline barriers to revert the layouts commandBuffer.pipelineBarrier( vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eFragmentShader, {}, 0, nullptr, 0, nullptr, 1, &barrierToSrc ); commandBuffer.pipelineBarrier( vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eFragmentShader, {}, 0, nullptr, 0, nullptr, 1, &barrierToDst ); // End command buffer recording commandBuffer.end(); // Submit the command buffer and wait for its execution to complete vk::SubmitInfo submitInfo{}; submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = &commandBuffer; graphicsQueue.submit(1, &submitInfo, nullptr); graphicsQueue.waitIdle(); // Free the command buffer device.freeCommandBuffers(commandPool, commandBuffer);}
- Assistant
The error you're encountering highlights an issue with attempting to resolve a multisampled image into a single-sampled image. Specifically, Vulkan's
vkCmdResolveImagefunction requires that the destination image has specific format features, particularlyVK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, which doesn't apply to depth or depth/stencil formats. Here's the main takeaway and suggested fixes:Problem
vkCmdResolveImageis designed for color attachment formats only. As per the Vulkan specification, it doesn't support resolving depth or depth/stencil formats directly.- The error message indicates that your destination image does not have the required format feature for resolving, specifically for depth attachments.
Solution
You will need to use an alternate approach for resolving depth images compared to color images. Instead of
vkCmdResolveImage, you'll have to manually resolve the depth by adding an additional render pass step or doing a full-screen quad copy.Here is an outline of how you can perform this:
-
Custom Shader Resolve:
- Render to a non-multisampled depth image using your depth resolve in a shader. You will use a fragment shader that reads from the multisample depth buffer and writes to a regular depth buffer.
-
Rendering to Resolved Depth Image:
- Perform the resolve operation in a separate render pass, using a fragment shader that samples from the multisampled image and writes to a single sample depth image.
Steps:
-
Create a Single-Sampled Depth Image:
- Similar to creating your multisampled depth image but without the multisample bit.
-
Setup New Render Pass:
- Create a render pass where you can draw a full-screen rectangle or quad.
- Attach the destination depth image (single-sampled) as the depth/stencil attachment.
-
Fragment Shader:
- Write a simple shader that takes the multisampled depth texture and outputs the resolved depth to the single-sampled texture.
-
Pipeline and Drawing:
- Use a graphics pipeline to perform this step.
- Draw a quad that spans the entire screen, executing the fragment shader that resolves depth.
This process will essentially mimic what
vkCmdResolveImagedoes for color attachments, but you'll be handling the resolve in your shader as Vulkan does not provide an automatic resolve for depth attachments.Additional Considerations:
- Performance: Ensure this is done efficiently. This added render pass should be as lightweight as possible.
- Precision and Format: Ensure your resolved depth format matches what you'll need for later phases in your pipeline, like SSAO.
Example for Depth Resolve Shader:
#version 450 layout(location = 0) out float FragDepth; layout(set = 0, binding = 0) uniform sampler2DMS depthMS; void main() { // Sample the depth values from the MS texture - the sample count here should match your multisampling setup float depthValue = 0.0; const int sampleCount = 4; // example for 4x MSAA for (int i = 0; i < sampleCount; ++i) { depthValue += texelFetch(depthMS, ivec2(gl_FragCoord.xy), i).r; } FragDepth = depthValue / sampleCount; // average samples }By resolving in the shader pipeline, you gain flexibility and conform to Vulkan's requirements for depth images. Remember to ensure that your multisampled depth image is accessible in your render pipeline settings.
- User
I'm assuming this would require at least two functions to setup: One for setting up the resources and another for executing the resolve. Can you show me code that would achieve this?
- Assistant
Certainly! Let's cover both functions with pseudo-code and Vulkan-centric details for setting up the multisampled depth resolve process. We'll need:
-
Setup Function: Create resources such as a single-sampled depth image, its image view, a framebuffer, and a render pass.
-
Execute Resolve Function: Use the created resources to perform the resolve using a fullscreen quad.
Setup Function
This function creates a single-sampled depth image, a render pass, a framebuffer, and necessary attachments.
void SetupDepthResolveResources(vk::Device device, vk::Extent2D extent, vk::Format depthFormat, vk::RenderPass* renderPass, vk::Framebuffer* framebuffer, vk::Image* singleSampledDepthImage, vk::ImageView* singleSampledDepthImageView) { // Create single-sampled depth image createImage(device, extent.width, extent.height, depthFormat, vk::ImageTiling::eOptimal, vk::ImageUsageFlagBits::eDepthStencilAttachment | vk::ImageUsageFlagBits::eSampled, vk::MemoryPropertyFlagBits::eDeviceLocal, *singleSampledDepthImage, *singleSampledDepthImageMemory); // Create an image view for the single-sampled depth image createImageView(device, *singleSampledDepthImage, depthFormat, vk::ImageAspectFlagBits::eDepth, *singleSampledDepthImageView); // Create a render pass vk::AttachmentDescription depthAttachment{}; depthAttachment.format = depthFormat; depthAttachment.samples = vk::SampleCountFlagBits::e1; depthAttachment.loadOp = vk::AttachmentLoadOp::eDontCare; depthAttachment.storeOp = vk::AttachmentStoreOp::eStore; depthAttachment.stencilLoadOp = vk::AttachmentLoadOp::eDontCare; depthAttachment.stencilStoreOp = vk::AttachmentStoreOp::eDontCare; depthAttachment.initialLayout = vk::ImageLayout::eUndefined; depthAttachment.finalLayout = vk::ImageLayout::eDepthStencilReadOnlyOptimal; vk::AttachmentReference depthAttachmentRef{}; depthAttachmentRef.attachment = 0; depthAttachmentRef.layout = vk::ImageLayout::eDepthStencilAttachmentOptimal; vk::SubpassDescription subpass{}; subpass.pipelineBindPoint = vk::PipelineBindPoint::eGraphics; subpass.pDepthStencilAttachment = &depthAttachmentRef; vk::RenderPassCreateInfo renderPassInfo{}; renderPassInfo.attachmentCount = 1; renderPassInfo.pAttachments = &depthAttachment; renderPassInfo.subpassCount = 1; renderPassInfo.pSubpasses = &subpass; *renderPass = device.createRenderPass(renderPassInfo); // Create a framebuffer vk::FramebufferCreateInfo framebufferInfo{}; framebufferInfo.renderPass = *renderPass; framebufferInfo.attachmentCount = 1; framebufferInfo.pAttachments = singleSampledDepthImageView; framebufferInfo.width = extent.width; framebufferInfo.height = extent.height; framebufferInfo.layers = 1; *framebuffer = device.createFramebuffer(framebufferInfo); }Execute Resolve Function
This function records and submits a command buffer that performs rendering using the previously set render pass and framebuffer.
void ExecuteDepthResolve(vk::Device device, vk::CommandBuffer commandBuffer, vk::RenderPass renderPass, vk::Framebuffer framebuffer, vk::Extent2D extent) { // Begin render pass vk::RenderPassBeginInfo renderPassInfo{}; renderPassInfo.renderPass = renderPass; renderPassInfo.framebuffer = framebuffer; renderPassInfo.renderArea.offset = vk::Offset2D{ 0, 0 }; renderPassInfo.renderArea.extent = extent; vk::ClearValue clearValue{}; renderPassInfo.clearValueCount = 1; renderPassInfo.pClearValues = &clearValue; commandBuffer.beginRenderPass(renderPassInfo, vk::SubpassContents::eInline); // Bind pipeline and draw fullscreen quad commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, yourGraphicsPipeline); // Assuming you have a pipeline setup that does the depth resolve with the shader example provided commandBuffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, yourPipelineLayout, 0, 1, &yourDescriptorSet, 0, nullptr); commandBuffer.draw(3, 1, 0, 0); // Draw a fullscreen triangle/quad commandBuffer.endRenderPass(); }Required Resources and Assumptions
- Device: Your logical Vulkan device.
- Formats and Misc: Proper formats, including
depthFormat, consistent with your rendering setup. - Command Buffers: Using
commandBufferto record commands (ensure it’s set up for the render pass). - Pipeline and Shaders: You need a graphics pipeline (
yourGraphicsPipeline) with a shader that performs the actual resolve based on input data. - Descriptor Set: Contains descriptors for the resources your resolve fragment shader reads, like the multisampled depth image.
- Pipeline Layout: Required to bind descriptor sets.
Notes
- The execute function currently uses a simple draw call to render a full-screen quad allowing you to write the depth resolve logic in a shader. Ensure any necessary resources are bound accordingly.
- Depending on your rasterization setup, you might use vertex buffers or other methods to construct the full-screen quad.
- Adjust any validation and error handling as needed to align with your application's error management strategy.
-
- User
Before I delve any further into resolving the depth image, is it possible to modify the SSAO shader achieve the desired outcomes using the position and normal images, without bringing in the depth image?
- Assistant
Yes, it is indeed possible to implement Screen-Space Ambient Occlusion (SSAO) using position and normal images without directly using a separate depth image. In a deferred rendering setup, you typically have a g-buffer containing at least position and normal data. These can be sufficient to implement SSAO, as you can deduce depth information from the position data.
Here's how to structure your SSAO shader using the position and normal images:
Approach Using Position and Normal Images
-
Position Image: This texture contains the view-space position of each fragment. You can directly calculate depth variations and sample occlusion using this data without needing separate depth fetching.
-
Normal Image: Contains the normal vectors in view space, which are essential for computing the occlusion factor using the SSAO algorithm.
SSAO Shader Without Depth Image
Here is a revision of your SSAO shader utilizing only the position and normal images. This approach relies on the position buffer already being in view space.
#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 TexCoords; layout(set = 0, binding = 0) uniform sampler2D gPosition; // View Space Positions layout(set = 0, binding = 1) uniform sampler2D gNormal; // Normals layout(set = 0, binding = 2) uniform sampler2D texNoise; layout(binding = 3) buffer SamplesBufferObject { vec3 samples[]; } samplesUBO; layout(binding = 4) uniform InputsBufferObject { int kernelSize; float radius; float bias; vec2 noiseScale; } inputsUBO; layout(binding = 5) uniform ProjBufferObject { mat4 proj; } projUBO; void main() { // Fetch position and normal from the g-buffers vec3 fragPos = texture(gPosition, TexCoords).xyz; vec3 normal = normalize(texture(gNormal, TexCoords).rgb); vec3 randomVec = normalize(texture(texNoise, TexCoords * inputsUBO.noiseScale).xyz); // Create TBN matrix for transforming samples to view space vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal)); vec3 bitangent = cross(normal, tangent); mat3 TBN = mat3(tangent, bitangent, normal); // Calculate the SSAO factor float occlusion = 0.0; for (int i = 0; i < inputsUBO.kernelSize; ++i) { vec3 samplePos = TBN * samplesUBO.samples[i]; samplePos = fragPos + samplePos * inputsUBO.radius; // Project the sample position and fetch corresponding depth vec4 offset = vec4(samplePos, 1.0); // Convert to homogeneous coordinates offset = projUBO.proj * offset; // View space to clip space offset.xyz /= offset.w; // Clip space to NDC offset.xyz = offset.xyz * 0.5 + 0.5; // NDC to [0, 1] vec3 sampleViewPos = texture(gPosition, offset.xy).xyz; // Check occlusion float rangeCheck = smoothstep(0.0, 1.0, inputsUBO.radius / abs(fragPos.z - sampleViewPos.z)); occlusion += (sampleViewPos.z >= samplePos.z + inputsUBO.bias ? 1.0 : 0.0) * rangeCheck; } occlusion = 1.0 - (occlusion / inputsUBO.kernelSize); FragColor = vec4(occlusion, occlusion, occlusion, 1.0); }Key Considerations
-
Position Precision: Ensure the gPosition texture holds positions with sufficient precision for view-space calculations.
-
Projection Matrix: Your
projmatrix should be correctly set and used to convert view-space positions to clip-space coordinates for proper SSAO sampling. -
Offsets and Sampling:
TexCoords * inputsUBO.noiseScaleis used for jittering with the noise texture to avoid banding artifacts. -
Bias: The
biashelps reduce self-occlusion where samples might inaccurately classify parts of a surface as occluded. Tuning is necessary based on your typical scene depth and proximity.
This method effectively leverages existing g-buffer information to facilitate SSAO, simplifying your pipeline by reducing dependencies on additional depth-specific resources.
-
- User
This looks very similar to my original code. Can you confirm that it will produce SSAO in the screen space setup I have with my deferred shading? Here is my original code again for reference:
#version 450
layout(location = 0) out vec4 FragColor;
layout(location = 0) in vec2 TexCoords;
layout(set = 0, binding = 0) uniform sampler2D gNormal; layout(set = 0, binding = 1) uniform sampler2D texNoise;
layout(binding = 2) uniform sampler2D depthSampler;
layout(binding = 3) buffer SamplesBufferObject { vec3 samples[]; } samplesUBO;
layout(binding = 4) uniform InputsBufferObject { int kernelSize; float radius; float bias; vec2 noiseScale; } inputsUBO;
layout(binding = 5) uniform ProjBufferObject { mat4 proj; } projUBO;
vec3 getViewPos(vec2 texCoords, float depth) { // Reconstruct view-space position from screen-space data (position and depth) vec4 clipSpacePos = vec4(texCoords * 2.0 - 1.0, depth, 1.0); vec4 viewSpacePos = inverse(projUBO.proj) * clipSpacePos; return viewSpacePos.xyz / viewSpacePos.w; }
void main() { float depth = texture(depthSampler, TexCoords).r; vec3 currentPosition = getViewPos(TexCoords, depth); vec3 normal = normalize(texture(gNormal, TexCoords).rgb); vec3 randomVec = normalize(texture(texNoise, TexCoords * inputsUBO.noiseScale).xyz);
vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal)); vec3 bitangent = cross(normal, tangent); mat3 TBN = mat3(tangent, bitangent, normal); float occlusion = 0.0; for(int i = 0; i < inputsUBO.kernelSize; ++i) { vec3 samplePos = TBN * samplesUBO.samples[i]; samplePos = currentPosition + samplePos * inputsUBO.radius; vec4 offset = projUBO.proj * vec4(samplePos, 1.0); offset.xyz /= offset.w; // Perspective divide offset.xyz = offset.xyz * 0.5 + 0.5; // To NDC space: [0, 1] float sampleDepth = texture(depthSampler, offset.xy).r; vec3 samplePosition = getViewPos(offset.xy, sampleDepth); float rangeCheck = smoothstep(0.0, 1.0, inputsUBO.radius / abs(currentPosition.z - samplePosition.z)); occlusion += (sampleDepth >= samplePos.z + inputsUBO.bias ? 1.0 : 0.0) * rangeCheck; } occlusion = 1.0 - (occlusion / inputsUBO.kernelSize); FragColor = vec4(occlusion, occlusion, occlusion, 1.0);}
- Assistant
The original shader you provided is set up to reconstruct view-space positions using depth values, a common approach for screen space ambient occlusion (SSAO) in deferred shading. Let’s examine whether it can indeed produce screen space SSAO, and how it compares to using position and normal images without a depthSampler.
Analysis of Original Shader
-
View-Space Position Reconstruction:
getViewPos: This function reconstructs the view-space position from screen space and the depth value using the projection matrix. This is a typical approach for SSAO when a depth buffer (depth texture) is used.
-
TBN Matrix:
- The shader generates tangent, bitangent, and normal (
TBNmatrix) to transform sample vectors into view space, ensuring sample directions align with surface orientations.
- The shader generates tangent, bitangent, and normal (
-
Occlusion Sampling:
- Sample positions are calculated by transforming sample vectors through the TBN matrix and offsetting by the radius in the view space.
- Depth comparison is used to determine occlusion amounts for fragments, checking differences between current fragment position and sample positions.
Moving Away from Depth Texture
To adapt your shader to only use gPosition (from a typical g-buffer containing view space positions and normals), replace the reliance on
depthSamplerwithgPosition.Here's a suggested adaptation that ensures screen space SSAO purely based on
gPositionandgNormal:#version 450 layout(location = 0) out vec4 FragColor; layout(location = 0) in vec2 TexCoords; layout(set = 0, binding = 0) uniform sampler2D gPosition; // View Space Positions layout(set = 1, binding = 0) uniform sampler2D gNormal; // Normals layout(set = 2, binding = 0) uniform sampler2D texNoise; layout(binding = 3) buffer SamplesBufferObject { vec3 samples[]; } samplesUBO; layout(binding = 4) uniform InputsBufferObject { int kernelSize; float radius; float bias; vec2 noiseScale; } inputsUBO; layout(binding = 5) uniform ProjBufferObject { mat4 proj; } projUBO; void main() { vec3 currentPosition = texture(gPosition, TexCoords).xyz; vec3 normal = normalize(texture(gNormal, TexCoords).rgb); vec3 randomVec = normalize(texture(texNoise, TexCoords * inputsUBO.noiseScale).xyz); vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal)); vec3 bitangent = cross(normal, tangent); mat3 TBN = mat3(tangent, bitangent, normal); float occlusion = 0.0; for (int i = 0; i < inputsUBO.kernelSize; ++i) { vec3 samplePos = TBN * samplesUBO.samples[i]; // in view-space samplePos = currentPosition + samplePos * inputsUBO.radius; // Project the view-space sample back to screen space (NDC coordinates) vec4 offset = projUBO.proj * vec4(samplePos, 1.0); offset.xyz /= offset.w; // Perspective divide offset.xyz = offset.xyz * 0.5 + 0.5; // To NDC space: [0, 1] vec3 samplePosition = texture(gPosition, offset.xy).xyz; float rangeCheck = smoothstep(0.0, 1.0, inputsUBO.radius / abs(currentPosition.z - samplePosition.z)); occlusion += (samplePosition.z >= samplePos.z + inputsUBO.bias ? 1.0 : 0.0) * rangeCheck; } occlusion = 1.0 - (occlusion / inputsUBO.kernelSize); FragColor = vec4(occlusion, occlusion, occlusion, 1.0); }Key Considerations
-
Use of Position Data: The shader relies purely on position data from
gPositionwithout needing to reconstruct from depth. This assumesgPositioncontains view-space positions. -
Projection Matrix: Ensure that your
projmatrix is properly set up within the vertex pipeline, as discrepancies here can cause inaccurate sampling. -
Range Check: This provides a smooth fall-off for occlusion based on the sample's distance from the current fragment position, intended to simulate occlusion subtly.
Using this setup in a screen-space manner aligns with deferred shading architectures, where detailed world-space information like repositioned positions enables SSAO computations, avoiding the need to maintain separate depth buffer complexities. This shader should create SSAO effects using the resources already derived from your deferred rendering pass.
-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.