Update bgfx

Author: pezcode

3rdparty/CMakeLists.txt

@@ -1,18 +1,6 @@
 # bigg (bgfx + imgui + glfw + glm)
 
-# BGFX_CONFIG_RENDERER_OPENGL_MIN_VERSION and
-# BGFX_CONFIG_RENDERER_OPENGLES_MIN_VERSION
-# set the minimum OpenGL version without
-# forcing the renderer to always be OpenGL
-# as BGFX_CONFIG_RENDERER_OPENGL does
-
-# bgfx.cmake only has an option BGFX_OPENGL_VERSION
-# for setting BGFX_CONFIG_RENDERER_OPENGL
-# need a newer version of bgfx/bigg to take effect
-
 add_definitions(-DBGFX_CONFIG_RENDERER_OPENGL_MIN_VERSION=43)
-#add_definitions(-DBGFX_CONFIG_RENDERER_OPENGLES_MIN_VERSION=43)
-#add_definitions(-DBGFX_CONFIG_RENDERER_OPENGL=43)
 set(BIGG_EXAMPLES OFF CACHE INTERNAL "")
 set(BGFX_BUILD_EXAMPLES OFF CACHE INTERNAL "")
 add_subdirectory(bigg)

src/CMakeLists.txt

@@ -64,6 +64,7 @@ set(SHADERS
     Renderer/Shaders/clusters.sh
     Renderer/Shaders/colormap.sh
     Renderer/Shaders/util.sh
+    Renderer/Shaders/common.sh
 )
 
 if(MSVC)
@@ -115,27 +116,39 @@ foreach(SHADER ${SHADERS})
     get_filename_component(SHADER_NAME "${SHADER}" NAME)
     get_filename_component(SHADER_FILE "${SHADER}" ABSOLUTE)
     # add_shader defaults to GLSL 120, 430 for compute
-    # 130 is needed for switch statements but requires OpenGL 3.0 or higher
-    # need a newer bgfx version that uses BGFX_CONFIG_RENDERER_OPENGL_MIN_VERSION to set
-    # OpenGL version without forcing the OpenGL renderer
-    # (https://github.com/bkaradzic/bgfx/commit/3f6d8a516d5e61db795c0c1881e9b333fedc5d43)
+    # GLSL 1.30 is needed for switch statements but shaderc produces
+    # shader binaries without any #version directive unless 4.30 is used
+    # this makes shader compilation fail with no error message
+    # just use 4.30 for all shaders
     # default DX11 model is 5_0
-    set(GLSL_VERSION 130)
+    set(GLSL_VERSION 430)
     set(GLSL_COMPUTE_VERSION 430)
     set(DX_MODEL 5_0)
 
     # DX9/11 shaders can only be compiled on Windows
-    set(SHADER_PLATFORMS glsl)
+    set(SHADER_PLATFORMS glsl spirv)
     if(WIN32)
         set(SHADER_PLATFORMS ${SHADER_PLATFORMS} dx11)
     endif()
 
     if(SHADER_NAME MATCHES "^vs_")
-        add_shader("${SHADER_FILE}" VERTEX   OUTPUT "${SHADER_DIR}" GLSL_VERSION ${GLSL_VERSION} DX11_MODEL ${DX_MODEL} PLATFORMS ${SHADER_PLATFORMS})
+        add_shader("${SHADER_FILE}" VERTEX
+            OUTPUT "${SHADER_DIR}"
+            GLSL_VERSION ${GLSL_VERSION}
+            DX11_MODEL ${DX_MODEL}
+            PLATFORMS ${SHADER_PLATFORMS})
     elseif(SHADER_NAME MATCHES "^fs_")
-        add_shader("${SHADER_FILE}" FRAGMENT OUTPUT "${SHADER_DIR}" GLSL_VERSION ${GLSL_VERSION} DX11_MODEL ${DX_MODEL} PLATFORMS ${SHADER_PLATFORMS})
+        add_shader("${SHADER_FILE}" FRAGMENT
+            OUTPUT "${SHADER_DIR}"
+            GLSL_VERSION ${GLSL_VERSION}
+            DX11_MODEL ${DX_MODEL}
+            PLATFORMS ${SHADER_PLATFORMS})
     elseif(SHADER_NAME MATCHES "^cs_")
-        add_shader("${SHADER_FILE}" COMPUTE  OUTPUT "${SHADER_DIR}" GLSL_VERSION ${GLSL_COMPUTE_VERSION} DX11_MODEL ${DX_MODEL} PLATFORMS ${SHADER_PLATFORMS})
+        add_shader("${SHADER_FILE}" COMPUTE
+            OUTPUT "${SHADER_DIR}"
+            GLSL_VERSION ${GLSL_COMPUTE_VERSION}
+            DX11_MODEL ${DX_MODEL}
+            PLATFORMS ${SHADER_PLATFORMS})
     endif()
     add_custom_command(TARGET invalidate_shaders PRE_BUILD
         COMMAND "${CMAKE_COMMAND}" -E touch "${SHADER_FILE}")

src/Config.cpp

@@ -35,21 +35,20 @@ void Config::readArgv(int argc, char* argv[])
     bx::CommandLine cmdLine(argc, argv);
 
     // D3D 9.0c (shader model 3.0) doesn't allow indexing into the light buffer
-    // so shaders for D3D9 aren't even compiled anymore
-
     // D3D11, D3D12, OpenGL work
-    // Vulkan? need to update bgfx/bigg
-
-    //cmdLine.hasArg("gl");
+    // Vulkan has issues:
+    // - no sRGB backbuffer support
+    // - clustered shading doesn't work, some descriptors are not getting bound correctly
+    //   it works in RenderDoc for a few seconds (with similar errors but different bindings), then crashes
 
     renderer = bgfx::RendererType::OpenGL;
+    //renderer = bgfx::RendererType::Direct3D11;
     //renderer = bgfx::RendererType::Direct3D12;
+    renderer = bgfx::RendererType::Vulkan;
 
     profile = true;
 
     showStatsOverlay = false;
     showLog = false;
     showBuffers = false;
-
-    msaa = true;
 }

src/Renderer/ClusterShader.cpp

@@ -6,7 +6,7 @@
 #include <glm/gtc/type_ptr.hpp>
 #include <cmath>
 
-bgfx::VertexDecl ClusterShader::ClusterVertex::decl;
+bgfx::VertexLayout ClusterShader::ClusterVertex::layout;
 
 ClusterShader::ClusterShader() :
     clusterSizesVecUniform(BGFX_INVALID_HANDLE),
@@ -29,7 +29,7 @@ void ClusterShader::initialize()
     zNearFarVecUniform = bgfx::createUniform("u_zNearFarVec", bgfx::UniformType::Vec4);
 
     clustersBuffer =
-        bgfx::createDynamicVertexBuffer(CLUSTER_COUNT, ClusterVertex::decl, BGFX_BUFFER_COMPUTE_READ_WRITE);
+        bgfx::createDynamicVertexBuffer(CLUSTER_COUNT, ClusterVertex::layout, BGFX_BUFFER_COMPUTE_READ_WRITE);
     lightIndicesBuffer = bgfx::createDynamicIndexBuffer(CLUSTER_COUNT * MAX_LIGHTS_PER_CLUSTER,
                                                         BGFX_BUFFER_COMPUTE_READ_WRITE | BGFX_BUFFER_INDEX32);
     lightGridBuffer =
@@ -66,7 +66,7 @@ void ClusterShader::setUniforms(const Scene* scene, uint16_t screenWidth, uint16
 
 void ClusterShader::bindBuffers(bool lightingPass) const
 {
-    // binding ReadWrite in the fragment shader doesn't work
+    // binding ReadWrite in the fragment shader doesn't work with D3D11/12
     bgfx::Access::Enum access = lightingPass ? bgfx::Access::Read : bgfx::Access::ReadWrite;
     if(!lightingPass)
     {

src/Renderer/ClusterShader.h

@@ -36,12 +36,12 @@ class ClusterShader
 
         static void init()
         {
-            decl.begin()
+            layout.begin()
                 .add(bgfx::Attrib::TexCoord0, 4, bgfx::AttribType::Float)
                 .add(bgfx::Attrib::TexCoord1, 4, bgfx::AttribType::Float)
                 .end();
         }
-        static bgfx::VertexDecl decl;
+        static bgfx::VertexLayout layout;
     };
 
     bgfx::UniformHandle clusterSizesVecUniform;

src/Renderer/ClusteredRenderer.cpp

@@ -22,9 +22,7 @@ bool ClusteredRenderer::supported()
            // compute shader
            (caps->supported & BGFX_CAPS_COMPUTE) != 0 &&
            // 32-bit index buffers, used for light grid structure
-           // D3D12 doesn't report this but it works fine...
-           // TODO try again with updated bgfx
-           ((caps->supported & BGFX_CAPS_INDEX32) != 0 || caps->rendererType == bgfx::RendererType::Direct3D12) &&
+           ((caps->supported & BGFX_CAPS_INDEX32) != 0) &&
            // fragment depth available in fragment shader
            (caps->supported & BGFX_CAPS_FRAGMENT_DEPTH) != 0;
 }
@@ -58,7 +56,22 @@ void ClusteredRenderer::onRender(float dt)
         vLightCulling,
         vLighting
     };
+        
+    bgfx::setViewName(vClusterBuilding, "Cluster building pass (compute)");
+    bgfx::setViewClear(vClusterBuilding, BGFX_CLEAR_NONE);
+    // set u_viewRect for screen2Eye to work correctly
+    bgfx::setViewRect(vClusterBuilding, 0, 0, width, height);
+    // this could be set by a different renderer, reset it (D3D12 cares and crashes)
+    bgfx::setViewFrameBuffer(vClusterBuilding, BGFX_INVALID_HANDLE);
+    //bgfx::touch(vClusterBuilding);
+
+    bgfx::setViewName(vLightCulling, "Clustered light culling pass (compute)");
+    bgfx::setViewClear(vLightCulling, BGFX_CLEAR_NONE);
+    bgfx::setViewRect(vLightCulling, 0, 0, width, height);
+    bgfx::setViewFrameBuffer(vLightCulling, BGFX_INVALID_HANDLE);
+    //bgfx::touch(vLightCulling);
 
+    bgfx::setViewName(vLighting, "Clustered lighting pass");
     bgfx::setViewClear(vLighting, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, clearColor, 1.0f, 0);
     bgfx::setViewRect(vLighting, 0, 0, width, height);
     bgfx::setViewFrameBuffer(vLighting, frameBuffer);
@@ -67,50 +80,36 @@ void ClusteredRenderer::onRender(float dt)
     if(!scene->loaded)
         return;
 
-    // D3D12 crashes if this is not set, even for compute only views
-    // TODO try again with updated bgfx
-    bgfx::setViewFrameBuffer(vClusterBuilding, BGFX_INVALID_HANDLE);
-    bgfx::setViewFrameBuffer(vLightCulling, BGFX_INVALID_HANDLE);
-
     clusters.setUniforms(scene, width, height);
 
-    // set u_viewRect for screen2Eye to work correctly
-    bgfx::setViewRect(vClusterBuilding, 0, 0, width, height);
-    bgfx::setViewRect(vLightCulling, 0, 0, width, height);
-
     // cluster building needs u_invProj to transform screen coordinates to eye space
     setViewProjection(vClusterBuilding);
     // light culling needs u_view to transform lights to eye space
     setViewProjection(vLightCulling);
+    setViewProjection(vLighting);
 
-    {
-        bgfx::setViewName(vClusterBuilding, "Cluster building pass (compute)");
+    // cluster building
 
-        clusters.bindBuffers(false); // write access, all buffers
+    clusters.bindBuffers(false); // write access, all buffers
 
-        bgfx::dispatch(vClusterBuilding,
-                       clusterBuildingComputeProgram,
-                       ClusterShader::CLUSTERS_X,
-                       ClusterShader::CLUSTERS_Y,
-                       ClusterShader::CLUSTERS_Z);
-    }
+    bgfx::dispatch(vClusterBuilding,
+                    clusterBuildingComputeProgram,
+                    ClusterShader::CLUSTERS_X,
+                    ClusterShader::CLUSTERS_Y,
+                    ClusterShader::CLUSTERS_Z);
 
-    {
-        bgfx::setViewName(vLightCulling, "Clustered light culling pass (compute)");
+    // light culling
 
-        lights.bindLights(scene);
-        clusters.bindBuffers(false); // write access, all buffers
+    lights.bindLights(scene);
+    clusters.bindBuffers(false); // write access, all buffers
 
-        bgfx::dispatch(vLightCulling,
-                       lightCullingComputeProgram,
-                       1,
-                       1,
-                       ClusterShader::CLUSTERS_Z / ClusterShader::CLUSTERS_Z_THREADS);
-    }
+    bgfx::dispatch(vLightCulling,
+                    lightCullingComputeProgram,
+                    1,
+                    1,
+                    ClusterShader::CLUSTERS_Z / ClusterShader::CLUSTERS_Z_THREADS);
 
-    bgfx::setViewName(vLighting, "Clustered lighting pass");
-
-    setViewProjection(vLighting);
+    // lighting    
 
     uint64_t state = BGFX_STATE_DEFAULT & ~BGFX_STATE_CULL_MASK;
 

src/Renderer/DeferredRenderer.cpp

@@ -86,7 +86,7 @@ void DeferredRenderer::onInitialize()
         4, 5, 1, 1, 0, 4  // bottom
     };
 
-    pointLightVertexBuffer = bgfx::createVertexBuffer(bgfx::copy(&vertices, sizeof(vertices)), PosVertex::decl);
+    pointLightVertexBuffer = bgfx::createVertexBuffer(bgfx::copy(&vertices, sizeof(vertices)), PosVertex::layout);
     pointLightIndexBuffer = bgfx::createIndexBuffer(bgfx::copy(&indices, sizeof(indices)));
 
     char vsName[128], fsName[128];
@@ -152,21 +152,25 @@ void DeferredRenderer::onRender(float dt)
 
     const uint32_t BLACK = 0x000000FF;
 
+    bgfx::setViewName(vGeometry, "Deferred geometry pass");
     bgfx::setViewClear(vGeometry, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, BLACK, 1.0f);
     bgfx::setViewRect(vGeometry, 0, 0, width, height);
     bgfx::setViewFrameBuffer(vGeometry, gBuffer);
     bgfx::touch(vGeometry);
 
+    bgfx::setViewName(vFullscreenLight, "Deferred light pass (ambient + emissive)");
     bgfx::setViewClear(vFullscreenLight, BGFX_CLEAR_COLOR, clearColor);
     bgfx::setViewRect(vFullscreenLight, 0, 0, width, height);
     bgfx::setViewFrameBuffer(vFullscreenLight, accumFrameBuffer);
     bgfx::touch(vFullscreenLight);
 
+    bgfx::setViewName(vLight, "Deferred light pass (point lights)");
     bgfx::setViewClear(vLight, BGFX_CLEAR_NONE);
     bgfx::setViewRect(vLight, 0, 0, width, height);
     bgfx::setViewFrameBuffer(vLight, accumFrameBuffer);
     bgfx::touch(vLight);
 
+    bgfx::setViewName(vTransparent, "Transparent forward pass");
     bgfx::setViewClear(vTransparent, BGFX_CLEAR_NONE);
     bgfx::setViewRect(vTransparent, 0, 0, width, height);
     bgfx::setViewFrameBuffer(vTransparent, accumFrameBuffer);
@@ -184,8 +188,6 @@ void DeferredRenderer::onRender(float dt)
     setViewProjection(vLight);
     setViewProjection(vTransparent);
 
-    bgfx::setViewName(vGeometry, "Deferred geometry pass");
-
     // render geometry, write to G-Buffer
 
     const uint64_t state = BGFX_STATE_DEFAULT & ~BGFX_STATE_CULL_MASK;
@@ -207,8 +209,6 @@ void DeferredRenderer::onRender(float dt)
         }
     }
 
-    bgfx::setViewName(vFullscreenLight, "Deferred light pass (ambient + emissive)");
-
     // render lights to framebuffer
     // cull with light geometry
     //   - axis-aligned bounding box (TODO? sphere for point lights)
@@ -242,8 +242,6 @@ void DeferredRenderer::onRender(float dt)
     bgfx::setState(BGFX_STATE_WRITE_RGB | BGFX_STATE_DEPTH_TEST_GREATER | BGFX_STATE_CULL_CW);
     bgfx::submit(vFullscreenLight, fullscreenProgram);
 
-    bgfx::setViewName(vLight, "Deferred light pass (point lights)");
-
     // point lights
 
     for(size_t i = 0; i < scene->pointLights.lights.size(); i++)
@@ -270,7 +268,7 @@ void DeferredRenderer::onRender(float dt)
         bgfx::submit(vLight, pointLightProgram);
     }
 
-    bgfx::setViewName(vTransparent, "Transparent forward pass");
+    // transparent
 
     for(const Mesh& mesh : scene->meshes)
     {

src/Renderer/ForwardRenderer.cpp

@@ -30,7 +30,9 @@ void ForwardRenderer::onRender(float dt)
     bgfx::setViewRect(vDefault, 0, 0, width, height);
     bgfx::setViewFrameBuffer(vDefault, frameBuffer);
 
-    bgfx::touch(vDefault); // empty primitive in case nothing follows
+    // empty primitive in case nothing follows
+    // this makes sure the clear happens
+    bgfx::touch(vDefault);
 
     if(!scene->loaded)
         return;