Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

I am building a 3d renderer in C++ using Vulkan.hpp. I am in the process of implementing…

  1. User

    I am building a 3d renderer in C++ using Vulkan.hpp. I am in the process of implementing a SSAO stage into the rendering pipeline. I have managed to set everything up and have a working SSAO stage. However, I just want someone to check the following code for the SSAO fragment shader and verify everything looks right.

    Inputs to the InputsBufferObject:

    kernelSize = 64 radius = 0.5 bias = 0.025 noiseScale = swapChainImage / 8

    Noise and sample generation process:

    for (unsigned int i = 0; i < ssaoSamples; ++i)
    {
        glm::vec3 sample(
            randomFloats(generator) * 2.0 - 1.0,
            randomFloats(generator) * 2.0 - 1.0,
            randomFloats(generator) * 2.0 - 1.0
        );
    
        // Use hemisphere sampling instead of full sphere
        if (sample.z < 0.0f)
            sample.z = -sample.z;
    
        sample = glm::normalize(sample);
    
        // Improved scale distribution for better sample spread
        float scale = pow((float)i / ssaoSamples, 2.0f);
        scale = 0.5f * (1.0f - cosf(scale * M_PI));  // Cosine distribution
    
        // Scale the sample and ensure proper normalization
        ssaoKernel.push_back(sample);
    }
    
    
    for (unsigned int i = 0; i < ssaoNoiseSize * ssaoNoiseSize; i++)
    {
        glm::vec4 noise(
            randomFloats(generator) * 2.0 - 1.0,
            randomFloats(generator) * 2.0 - 1.0,
            randomFloats(generator) * 2.0 - 1.0,
            1.0f
        );
    
        // Normalize and scale the noise
        noise = glm::normalize(noise)*0.1f;  // Reduced noise scale
        ssaoNoise.push_back(noise);
    }
    

    SSAO fragment shader code:

    #version 450

    layout(location = 0) out vec4 FragColor;

    layout(location = 0) in vec2 TexCoords;

    layout(set = 0, binding = 0) uniform sampler2D gDepth; 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 { int kernelSize; float radius; float bias; vec2 noiseScale; } inputsUBO;

    layout(binding = 5) uniform ProjBufferObject { mat4 proj; mat4 projInv; } projUBO;

    vec3 reconstructVSPosFromDepth(vec2 uv) { float nearPlane = 0.1; float farPlane = 100.0; float depth = texture(gDepth, uv).r; float linearSampleDepth = (2.0 * nearPlane) / (farPlane + nearPlane - depth * (farPlane - nearPlane)); linearSampleDepth = normalize(linearSampleDepth); float x = uv.x * 2.0f - 1.0f; float y = (1.0f - uv.y) * 2.0f - 1.0f; vec4 pos = vec4(x, y, linearSampleDepth, 1.0f); vec4 posVS = projUBO.projInv * pos; vec3 posNDC = posVS.xyz / posVS.w; return posNDC; }

    void main() { float nearPlane = 0.1; float farPlane = 100.0;

    float depth = texture(gDepth, TexCoords).r;
    
    vec3 posVS = reconstructVSPosFromDepth(TexCoords);
    
    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(tangent, normal);
    mat3 TBN = mat3(tangent, bitangent, normal);
    
    float occlusion = 0.0f;
    for (uint i = 0; i < inputsUBO.kernelSize; i++)
    {
    	vec3 samplePos = TBN * samplesUBO.samples[i].xyz;
    	samplePos = posVS + samplePos * inputsUBO.radius; 
    
    	vec4 offset = vec4(samplePos, 1.0f);
    	offset = projUBO.proj * offset;
    	offset.xyz /= offset.w;
    	offset.xyz = offset.xyz * 0.5f + 0.5f;
    	//offset.y = 1.0f - offset.y;
    	
    	vec3 reconstructedPos = reconstructVSPosFromDepth(offset.xy);
    
        
        // range check & accumulate
        float rangeCheck = smoothstep(0.0, 1.0, inputsUBO.radius / abs(posVS.z - reconstructedPos.z));
        occlusion += (reconstructedPos.z >= samplePos.z + inputsUBO.bias ? 1.0 : 0.0) * rangeCheck;     
    
    }
    occlusion = (occlusion / inputsUBO.kernelSize);
    
    
    FragColor = vec4(occlusion,occlusion,occlusion,1.0);
    

    }

  2. Assistant

    Your SSAO fragment shader code looks quite solid, but I'll provide a few comments and suggestions that might help you ensure it's working as intended and improve its readability or performance.

    Review Comments

    1. Uniform Buffer Objects:

      • You are using InputsBufferObject, ProjBufferObject, and SamplesBufferObject for various uniform data. Ensure that the bindings correspond correctly with the expected engine layout, as mismatches can lead to crashes or incorrect rendering.
    2. Depth Reconstruction:

      • The reconstructVSPosFromDepth function does the job of reconstructing the position from depth, but make sure the near and far planes are consistent across your entire rendering setup (e.g., depth buffer settings, projection settings). Consider using the same near and far plane values from your projection matrix rather than hardcoding them.
    3. Normal Sampling:

      • The normal is sampled directly using texture(gNormal, TexCoords).rgb. Ensure that the normal map data you are using is in the right format and that the normals are properly transformed to world space if necessary.
    4. World Position Calculation:

      • The vec3 reconstructedPos may be sourced from the depth texture. Make sure you are calculating and sampling depth values robustly to avoid inaccuracies.
    5. Distribution and Weights:

      • The random sampling and kernel generation seem to be handled well. You scale the samples, which is a good approach. Be mindful of the sampling distribution; sometimes additional functions could be used for better overall spread, depending on your visual results.
    6. Range Check:

      • The smoothstep() check for the range should consider edge cases where abs(posVS.z - reconstructedPos.z) could be too small or too large. Ensure appropriate handling of those edge cases to avoid unwanted flickering or artifacts.
    7. Occlusion Calculation:

      • You compute occlusion and normalize it by the kernel size at the end, which makes sense for producing a final scalar occlusion value. Consider also adding capabilities for clamping the value between [0,1] if there's any potential for values to go outside this range.
    8. Output Color:

      • The resulting FragColor = vec4(occlusion, occlusion, occlusion, 1.0); is a good way of visualizing SSAO. You might want to adjust how it’s displayed (e.g., using multiplier values) to enhance your SSAO effects based on scene lighting or materials, if desired.

    Suggestions for Improvements

    • Verbose Variable Names: Consider using more descriptive names for your variables. While the current names are fairly self-explanatory, clearer names can help others (and yourself) understand the code better in the future.

    • Modularity: If you find commonalities in your shaders over multiple effects, creating separate modules for these common functionalities can reduce redundancy.

    • Error Handling: It’s a good idea to ensure for each shader resource (textures, buffers) that you verify its loading/sampling is successful. While this is more relevant to your C++ code, having helpful assertive messages can streamline debugging.

    • Debugging: While developing the shader, consider temporarily outputting intermediate values (like posVS, samplePos, or normal into FragColor) to visualize these constructs while debugging.

    Conclusion

    Overall, your shader does appear to follow the typical structure and logic used in SSAO applications. The primary focus should be on the accuracy of the data that feeds into it (especially depth information and normals), and the handling of edge cases where approximations happen (like depth comparison). Lastly, ensure your testing covers various scenarios to catch any anomalies in different lighting or material contexts. Good luck with your development!