Update bgfx and migrate to explicit swap-chain APIs

Apps/UnitTests/CMakeLists.txt

@@ -29,9 +29,11 @@ set_source_files_properties(${TEST_SCRIPTS} PROPERTIES HEADER_FILE_ONLY TRUE)
 set(SOURCES
     "Source/App.h"
     "Source/App.cpp"
+    "Source/Tests.BgfxCallback.cpp"
     "Source/Tests.Canvas.TextMetrics.cpp"
     "Source/Tests.Canvas.Readback.cpp"
     "Source/Tests.Device.FrameEncoder.cpp"
+    "Source/Tests.Device.SwapChain.cpp"
     "Source/Tests.ExternalTexture.cpp"
     "Source/Tests.ExternalTexture.Lifecycle.cpp"
     "Source/Tests.ExternalTexture.DeviceLoss.cpp"
@@ -55,7 +57,8 @@ endif()
 
 if(GRAPHICS_API STREQUAL "D3D11")
     set(SOURCES ${SOURCES}
-        "Source/Tests.Device.${GRAPHICS_API}.cpp")
+        "Source/Tests.Device.${GRAPHICS_API}.cpp"
+        "Source/Tests.Device.D3D11.ExternalBackBuffer.cpp")
 endif()
 
 if(APPLE)
@@ -99,6 +102,11 @@ target_link_libraries(UnitTests
 
 target_compile_definitions(UnitTests PRIVATE ${ADDITIONAL_COMPILE_DEFINITIONS})
 
+if(BABYLON_NATIVE_PLUGIN_SHADERCOMPILER)
+    target_link_libraries(UnitTests PRIVATE ShaderCompilerInternal)
+    target_compile_definitions(UnitTests PRIVATE HAS_SHADER_COMPILER)
+endif()
+
 # NativeDraco and NativeMeshopt default to OFF, so link and exercise them only when the
 # consuming build opted in. CI turns both on for the jobs that run UnitTests.
 if(BABYLON_NATIVE_PLUGIN_NATIVEDRACO)
@@ -112,7 +120,7 @@ if(BABYLON_NATIVE_PLUGIN_NATIVEMESHOPT)
 endif()
 
 if(GRAPHICS_API STREQUAL "D3D12")
-    target_compile_definitions(UnitTests PRIVATE SKIP_RENDER_TESTS)
+    target_compile_definitions(UnitTests PRIVATE SKIP_RENDER_TESTS BABYLON_NATIVE_GRAPHICS_API_D3D12)
 endif()
 
 if(GRAPHICS_API STREQUAL "Vulkan")

Apps/UnitTests/Source/Tests.BgfxCallback.cpp

@@ -0,0 +1,65 @@
+#include <gtest/gtest.h>
+
+#include <Babylon/Graphics/BgfxCallback.h>
+
+#include <array>
+
+using Babylon::Graphics::BgfxCallback;
+
+TEST(BgfxCallback, CoalescesScreenshotsAndCapture)
+{
+    const std::array<uint8_t, 12> pixels{3, 2, 1, 255, 6, 5, 4, 255, 0, 0, 0, 0};
+    const BgfxCallback::CaptureData data{2, 1, 12, bgfx::TextureFormat::BGRA8, false, pixels.data(), 12};
+    const std::vector<uint8_t> expected{1, 2, 3, 255, 4, 5, 6, 255};
+
+    size_t captures{};
+    BgfxCallback callback{[&](const auto& captured) {
+        ++captures;
+        EXPECT_EQ(captured.Data, pixels.data());
+        EXPECT_EQ(captured.Pitch, 12u);
+        EXPECT_EQ(captured.Format, bgfx::TextureFormat::BGRA8);
+    }};
+    size_t screenshots{};
+    for (size_t i = 0; i < 2; ++i)
+    {
+        callback.AddScreenShotCallback([&](const auto& captured) {
+            ++screenshots;
+            EXPECT_EQ(captured, expected);
+        });
+    }
+    callback.CaptureNextScreenShot();
+    callback.CompleteScreenShot(data);
+    EXPECT_EQ(captures, 1u);
+    EXPECT_EQ(screenshots, 2u);
+
+    callback.AddScreenShotCallback([&](const auto&) { ++screenshots; });
+    callback.CompleteScreenShot(data);
+    EXPECT_EQ(captures, 1u);
+    EXPECT_EQ(screenshots, 3u);
+}
+
+TEST(BgfxCallback, CaptureDoesNotRequireScreenshotCallback)
+{
+    const std::array<uint8_t, 4> pixels{1, 2, 3, 4};
+    const BgfxCallback::CaptureData data{1, 1, 4, bgfx::TextureFormat::RGBA8, true, pixels.data(), 4};
+    size_t captures{};
+    BgfxCallback callback{[&](const auto& captured) {
+        ++captures;
+        EXPECT_TRUE(captured.YFlip);
+        EXPECT_EQ(captured.DataSize, pixels.size());
+    }};
+    callback.CaptureNextScreenShot();
+    callback.CompleteScreenShot(data);
+    EXPECT_EQ(captures, 1u);
+}
+
+TEST(BgfxCallback, NormalizesFlippedRgbaScreenshots)
+{
+    const std::array<uint8_t, 16> pixels{1, 2, 3, 4, 0, 0, 0, 0, 5, 6, 7, 8, 0, 0, 0, 0};
+    const BgfxCallback::CaptureData data{1, 2, 8, bgfx::TextureFormat::RGBA8, true, pixels.data(), 16};
+    BgfxCallback callback{[](const auto&) {}};
+    callback.AddScreenShotCallback([](const auto& captured) {
+        EXPECT_EQ(captured, (std::vector<uint8_t>{5, 6, 7, 8, 1, 2, 3, 4}));
+    });
+    callback.CompleteScreenShot(data);
+}