Debug Rendering

.github/workflows/windows-build.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Install Vulkan SDK
         uses: humbletim/install-vulkan-sdk@c2aa128094d42ba02959a660f03e0a4e012192f9
         with:
-          version: latest
+          version: 1.3.296.0
           cache: true
 
       - name: Configure CMake

CMakeLists.txt

@@ -1,21 +1,22 @@
 cmake_minimum_required(VERSION 3.28)
 project(WillEngine)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 
 add_definitions(-DVK_NO_PROTOTYPES)
+
 add_definitions(-DGLM_FORCE_DEPTH_ZERO_TO_ONE)
 add_definitions(-DGLM_ENABLE_EXPERIMENTAL)
-add_definitions(-DJPH_DEBUG_RENDERER)
+
 #add_definitions(-DJPH_PROFILE_ENABLED=0)
-#add_definitions(-DJPH_DEBUG_RENDERER=0)
 add_definitions(-DJPH_ENABLE_ASSERTS=1)
 add_definitions(-DJPH_ENABLE_ASSERT_MESSAGES=1)
 
 # #if WILL_ENGINE_DEBUG
 # ##endif
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
     add_definitions(-DWILL_ENGINE_DEBUG=1)
+    add_definitions(-DJPH_DEBUG_RENDERER)
 elseif (CMAKE_BUILD_TYPE STREQUAL "Release")
     add_definitions(-DWILL_ENGINE_RELEASE=1)
 endif ()
@@ -48,7 +49,7 @@ add_subdirectory(extern/fastgltf/deps) # simdjson
 # Jolt Physics
 set(PHYSICS_REPO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/extern/JoltPhysics")
 include(extern/JoltPhysics/Jolt/Jolt.cmake)
-set(CMAKE_CXX_STANDARD 20) # Jolt sets it to 17
+set(CMAKE_CXX_STANDARD 23) # Jolt sets it to 17
 
 include_directories(${CMAKE_SOURCE_DIR})
 
@@ -131,8 +132,8 @@ set(PHYSICS_SOURCES
         src/physics/physics_utils.h
         src/physics/physics_utils.cpp
         src/physics/physics_constants.h
-        src/physics/debug/debug_renderer.cpp
-        src/physics/debug/debug_renderer.h
+        src/physics/debug/jolt_debug_renderer.cpp
+        src/physics/debug/jolt_debug_renderer.h
         src/physics/physics_body.h
 )
 
@@ -263,7 +264,13 @@ set(TEMP_SOURCES
         src/renderer/pipelines/geometry/transparent_pipeline/transparent_pipeline_types.h
         src/renderer/pipelines/basic/basic_compute/basic_compute_pipeline_types.h
         src/renderer/pipelines/visibility_pass/visibility_pass_pipeline_types.h
-
+        src/renderer/pipelines/debug/debug_renderer.cpp
+        src/renderer/pipelines/debug/debug_renderer.h
+        src/renderer/pipelines/debug/debug_renderer_types.h
+        src/renderer/pipelines/debug/debug_composite_pipeline.cpp
+        src/renderer/pipelines/debug/debug_composite_pipeline.h
+        src/renderer/pipelines/debug/debug_highlighter.cpp
+        src/renderer/pipelines/debug/debug_highlighter.h
 )
 
 add_executable(WillEngine main.cpp

assets/settings.willengine

@@ -9,18 +9,18 @@
     },
     "cameraSettings": {
         "position": [
-            -19.169994354248047,
-            105.9618911743164,
-            36.455501556396484
+            -7.438582420349121,
+            34.399600982666016,
+            47.61833953857422
         ],
         "rotation": [
-            -0.14886538684368134,
-            -0.2690022885799408,
-            -0.04212456941604614,
-            0.9506327509880066
+            0.025229064747691154,
+            -0.12272556871175766,
+            0.0031201005913317204,
+            0.9921150803565979
         ],
         "fov": 1.3089969158172607,
-        "aspectRatio": 1.4861111640930176,
+        "aspectRatio": 1.7777777910232544,
         "nearPlane": 1000.0,
         "farPlane": 0.10000000149011612
     },

shaders/ambient_occlusion/ground_truth/gtao_main_pass.comp

@@ -132,6 +132,7 @@ void main() {
 
     // Get view space normal by sampling normal buffer and converting from world to view (code not relevant)
     vec3 viewNormal = texture(normalBuffer, uv).rgb;
+    viewNormal = unpackNormal(viewNormal);
 
     if (pushConstants.debug == 2){
         imageStore(debugImage, screenPos, vec4(viewNormal, 1.0f));

shaders/debug/debug_composite.comp

@@ -0,0 +1,29 @@
+#version 460
+
+#include "scene.glsl"
+
+layout (local_size_x = 16, local_size_y = 16) in;
+
+// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl
+
+layout(set = 1, binding = 0) uniform sampler2D debugImage;
+layout(set = 1, binding = 1, rgba16) uniform image2D finalImage;
+
+void main() {
+    ivec2 pixelCoord = ivec2(gl_GlobalInvocationID.xy);
+    if (any(greaterThan(pixelCoord, ivec2(sceneData.renderTargetSize)))) {
+        return;
+    }
+    vec2 uv = (vec2(pixelCoord) + 0.5) / sceneData.renderTargetSize;
+    vec4 mainColor = imageLoad(finalImage, pixelCoord);
+
+    vec2 debugUv = uv;
+    // Flip (Main image is flipped in PP)
+    debugUv.y = 1 - debugUv.y;
+    // Unjitter
+    debugUv += sceneData.jitter.xy / 2.0f;
+    vec4 debugColor = texture(debugImage, debugUv);
+
+    vec4 finalColor = mix(mainColor, debugColor, debugColor.a);
+    imageStore(finalImage, pixelCoord, finalColor);
+}

shaders/debug/debug_highlighter.frag

@@ -0,0 +1,9 @@
+#version 460
+
+layout (location = 0) in vec3 inColor;
+
+layout (location = 0) out vec4 imageTarget;
+
+void main() {
+    imageTarget = vec4(inColor, 1.0);
+}

shaders/debug/debug_highlighter.vert

@@ -0,0 +1,21 @@
+#version 460
+
+#include "scene.glsl"
+
+layout(location = 0) in vec3 inPosition;
+
+layout(location = 0) out vec3 outColor;
+
+// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl
+
+layout (push_constant) uniform PushConstants {
+    mat4 modelMatrix;
+    vec4 color;
+} push;
+
+void main() {
+    gl_Position = sceneData.viewProj * push.modelMatrix * vec4(inPosition, 1.0);
+    // fixed depth offset so that the whole object can be seen in most cases
+    gl_Position.z += 0.001;
+    outColor = push.color.xyz;
+}

shaders/debug/debug_highlighter_processing.comp

@@ -0,0 +1,60 @@
+#version 460
+
+#include "scene.glsl"
+
+layout (local_size_x = 16, local_size_y = 16) in;
+
+// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl
+
+layout(set = 1, binding = 0, r8ui) uniform uimage2D highlighterStencil;
+layout(set = 1, binding = 1, rgba16) uniform image2D debugTarget;
+
+const int OUTLINE_THICKNESS = 2;
+
+void main() {
+    ivec2 pixelCoord = ivec2(gl_GlobalInvocationID.xy);
+    if (any(greaterThan(pixelCoord, ivec2(sceneData.renderTargetSize)))) {
+        return;
+    }
+
+    uint stencilValue = imageLoad(highlighterStencil, pixelCoord).r;
+
+    if (stencilValue == 0) {
+        return;
+    }
+
+    bool isEdge = false;
+
+    for (int thickness = 1; thickness <= OUTLINE_THICKNESS; thickness++) {
+        for (int dir = 0; dir < 4; dir++) {
+            ivec2 offset;
+            if (dir == 0) offset = ivec2(thickness, 0);  // Right
+            if (dir == 1) offset = ivec2(-thickness, 0); // Left
+            if (dir == 2) offset = ivec2(0, thickness);  // Down
+            if (dir == 3) offset = ivec2(0, -thickness); // Up
+
+            ivec2 neighborCoord = pixelCoord + offset;
+
+            if (all(greaterThanEqual(neighborCoord, ivec2(0))) &&
+            all(lessThan(neighborCoord, ivec2(sceneData.renderTargetSize)))) {
+                uint neighborValue = imageLoad(highlighterStencil, neighborCoord).r;
+                if (neighborValue == 0) {
+                    isEdge = true;
+                    break;
+                }
+            } else {
+                isEdge = true;
+                break;
+            }
+        }
+
+        if (isEdge) {
+            break;
+        }
+    }
+
+    if (isEdge) {
+        vec4 outlineColor = vec4(1.0, 0.647, 0.0, 1.0);
+        imageStore(debugTarget, pixelCoord, outlineColor);
+    }
+}

shaders/debug/debug_renderer.frag

@@ -0,0 +1,10 @@
+#version 460
+
+layout (location = 0) in vec3 inColor;
+
+layout (location = 0) out vec4 imageTarget;
+
+void main() {
+    // 0 indicates this won't do light calculations in deferred resolve
+    imageTarget = vec4(inColor, 1.0);
+}

shaders/debug/debug_renderer.vert

@@ -0,0 +1,16 @@
+#version 460
+
+#include "scene.glsl"
+
+layout(location = 0) in vec3 inPosition;
+layout(location = 1) in vec3 inColor;
+
+layout(location = 0) out vec3 outColor;
+
+// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl
+
+void main() {
+    gl_Position = sceneData.viewProj * vec4(inPosition, 1.0);
+    gl_Position.xy += gl_Position.w * sceneData.jitter.xy;
+    outColor = inColor;
+}

shaders/debug/debug_renderer_instanced.frag

@@ -0,0 +1,10 @@
+#version 460
+
+layout (location = 0) in vec3 inColor;
+
+layout (location = 0) out vec4 imageTarget;
+
+void main() {
+    // 0 indicates this won't do light calculations in deferred resolve
+    imageTarget = vec4(inColor, 1.0);
+}

shaders/debug/debug_renderer_instanced.vert

@@ -0,0 +1,26 @@
+#version 460
+
+layout(location = 0) in vec3 inPosition;
+
+layout(location = 0) out vec3 outColor;
+
+#include "scene.glsl"
+
+struct Instance{
+    mat4 transform;
+    vec3 color;
+    float padding;
+};
+
+// layout (std140, set = 0, binding = 0) uniform SceneData - scene.glsl
+
+layout(std140, set = 1, binding = 0) readonly buffer InstanceBuffer {
+    Instance instances[];
+} instances;
+
+void main() {
+    Instance instance = instances.instances[gl_InstanceIndex];
+    gl_Position = sceneData.viewProj * instance.transform * vec4(inPosition, 1.0);
+    gl_Position.xy += gl_Position.w * sceneData.jitter.xy;
+    outColor = instance.color;
+}

shaders/deferredMrt.frag

@@ -73,8 +73,7 @@ void main() {
         roughness *= metalRoughSample.g;
     }
 
-
-    normalTarget = vec4(normalize(inViewNormal), 0.0f);
+    normalTarget = vec4(packNormal(normalize(inViewNormal)), 0.0f);
     albedoTarget = vec4(albedo.xyz, 1.0f);
     pbrTarget = vec4(metallic, roughness, 0.0f, inHasTransparent);
 

shaders/deferredResolve.comp

@@ -1,6 +1,7 @@
 #version 460
 #extension GL_EXT_nonuniform_qualifier: enable
 
+#include "common.glsl"
 #include "scene.glsl"
 #include "pbr.glsl"
 #include "environment.glsl"
@@ -86,6 +87,8 @@ void main() {
     }
     float depth = texture(depthBuffer, uv).r;
     vec3 viewNormal = texture(normalRenderTarget, uv).rgb;
+    viewNormal = unpackNormal(viewNormal);
+
     vec4 pbrData = texture(pbrRenderTarget, uv);
     vec3 viewPosition = reconstructPosition(uv, depth);
 
@@ -174,7 +177,7 @@ void main() {
         imageStore(outputImage, screenPos, albedo);
         break;
         case 4:
-        imageStore(outputImage, screenPos, vec4(worldN * 0.5f + 0.5f, 1.0f));
+        imageStore(outputImage, screenPos, vec4(packNormal(viewNormal), 1.0f));
         break;
         case 5:
         imageStore(outputImage, screenPos, pbrData);

shaders/environment/environment.frag

@@ -1,5 +1,6 @@
 #version 450
 
+#include "common.glsl"
 #include "scene.glsl"
 
 layout (location = 0) in vec3 uv;
@@ -21,11 +22,10 @@ void main()
     direction.y = -direction.y;
     vec3 envColor = textureLod(environmentMap, direction, 0).rgb;
 
-    // 0 = environment map flag
+    // 0 = "do not calculate lighting" flag
     albedoTarget = vec4(envColor, 0.0);
 
-    vec3 normal = mat3(sceneData.view) * -direction;
-    normalTarget = vec4(normal, 0.0f);
+    normalTarget = vec4(packNormal(mat3(sceneData.view) * -direction), 0.0f);
     pbrTarget = vec4(0.0f);
 
     vec2 currNdc = inCurrMvpPosition.xy / inCurrMvpPosition.w;

shaders/include/common.glsl

@@ -47,4 +47,20 @@ bool nearlyEqual(float a, float b, float epsilon) {
     return abs(a - b) <= epsilon;
 }
 
+vec3 unpackNormal(vec3 packedNormal) {
+    #ifdef REMAP_NORMALS
+    return packedNormal * 2.0 - 1.0;
+    #else
+    return packedNormal;
+    #endif
+}
+
+vec3 packNormal(vec3 normal) {
+    #ifdef REMAP_NORMALS
+    return normal * 0.5 + 0.5;
+    #else
+    return normal;
+    #endif
+}
+
 #endif // COMMON_GLSL

shaders/terrain/terrain.frag

@@ -3,10 +3,10 @@
 #extension GL_EXT_buffer_reference: require
 #extension GL_EXT_nonuniform_qualifier: enable
 
+#include "common.glsl"
 #include "scene.glsl"
 #include "structure.glsl"
 
-
 // world space
 layout (location = 0) in vec3 inPosition;
 layout (location = 1) in vec3 inNormal;
@@ -41,7 +41,7 @@ float smoothBlend(float value, float threshold, float range) {
 }
 
 void main() {
-    normalTarget = vec4(mat3(sceneData.view) * normalize(inNormal), 0.0f);
+    normalTarget = vec4(packNormal(mat3(sceneData.view) * normalize(inNormal)), 0.0f);;
 
     float slope = 1.0 - abs(dot(normalize(inNormal), vec3(0.0, 1.0, 0.0)));
     float height = inPosition.y;