Fix test

filament/backend/include/backend/BufferObjectStreamDescriptor.h

@@ -55,4 +55,9 @@ public:
 
 } // namespace filament::backend
 
+#if !defined(NDEBUG)
+utils::io::ostream& operator<<(utils::io::ostream& out,
+        const filament::backend::BufferObjectStreamDescriptor& b);
+#endif
+
 #endif // TNT_FILAMENT_BACKEND_BUFFEROBJECTSTREAMDESCRIPTOR_H

filament/backend/include/backend/DriverEnums.h

@@ -1139,6 +1139,7 @@ struct ExternalSamplerDatum {
 static_assert(sizeof(ExternalSamplerDatum) == 12);
 
 struct DescriptorSetLayout {
+    std::string label;
     utils::FixedCapacityVector<DescriptorSetLayoutBinding> bindings;
 
 //  TODO: uncomment when needed

filament/backend/src/ostream.cpp

@@ -15,6 +15,7 @@
  */
 
 #include <backend/BufferDescriptor.h>
+#include <backend/BufferObjectStreamDescriptor.h>
 #include <backend/DescriptorSetOffsetArray.h>
 #include <backend/DriverEnums.h>
 #include <backend/PipelineState.h>
@@ -437,6 +438,10 @@ io::ostream& operator<<(io::ostream& out, BufferDescriptor const& b) {
     << ", user=" << b.getUser() << " }";
 }
 
+io::ostream& operator<<(io::ostream& out, const BufferObjectStreamDescriptor& b) {
+    return out << "BufferObjectStreamDescriptor{ streams(" << b.mStreams.size() << ")=... }";
+}
+
 io::ostream& operator<<(io::ostream& out, PixelBufferDescriptor const& b) {
     BufferDescriptor const& base = static_cast<BufferDescriptor const&>(b);
     return out << "PixelBufferDescriptor{ " << base

filament/backend/src/webgpu/WebGPUDriver.cpp

@@ -228,6 +228,14 @@ WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfi
               driverConfig.disableHeapHandleTags) {
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
     printInstanceDetails(mPlatform.getInstance());
+#endif
+    mAdapter = mPlatform.requestAdapter(nullptr);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printAdapterDetails(mAdapter);
+#endif
+    mDevice = mPlatform.requestDevice(mAdapter);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printDeviceDetails(mDevice);
 #endif
 }
 
@@ -336,6 +344,9 @@ void WebGPUDriver::destroyTimerQuery(Handle<HwTimerQuery> tqh) {
 }
 
 void WebGPUDriver::destroyDescriptorSetLayout(Handle<HwDescriptorSetLayout> tqh) {
+    if (tqh) {
+        destructHandle<WebGPUDescriptorSetLayout>(tqh);
+    }
 }
 
 void WebGPUDriver::destroyDescriptorSet(Handle<HwDescriptorSet> tqh) {
@@ -410,8 +421,7 @@ Handle<HwRenderTarget> WebGPUDriver::createDefaultRenderTargetS() noexcept {
 }
 
 Handle<HwDescriptorSetLayout> WebGPUDriver::createDescriptorSetLayoutS() noexcept {
-    return Handle<HwDescriptorSetLayout>(
-            (Handle<HwDescriptorSetLayout>::HandleId) mNextFakeHandle++);
+    return allocHandle<WebGPUDescriptorSetLayout>();
 }
 
 Handle<HwTexture> WebGPUDriver::createTextureExternalImageS() noexcept {
@@ -430,14 +440,7 @@ void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
     mNativeWindow = nativeWindow;
     assert_invariant(!mSwapChain);
     wgpu::Surface surface = mPlatform.createSurface(nativeWindow, flags);
-    mAdapter = mPlatform.requestAdapter(surface);
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-    printAdapterDetails(mAdapter);
-#endif
-    mDevice = mPlatform.requestDevice(mAdapter);
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-    printDeviceDetails(mDevice);
-#endif
+
     mQueue = mDevice.GetQueue();
     wgpu::Extent2D surfaceSize = mPlatform.getSurfaceExtent(mNativeWindow);
     mSwapChain = constructHandle<WebGPUSwapChain>(sch, std::move(surface), surfaceSize, mAdapter,
@@ -519,7 +522,9 @@ void WebGPUDriver::createFenceR(Handle<HwFence> fh, int) {}
 void WebGPUDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {}
 
 void WebGPUDriver::createDescriptorSetLayoutR(Handle<HwDescriptorSetLayout> dslh,
-        backend::DescriptorSetLayout&& info) {}
+        backend::DescriptorSetLayout&& info) {
+    constructHandle<WebGPUDescriptorSetLayout>(dslh, std::move(info), &mDevice);
+}
 
 void WebGPUDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
         Handle<HwDescriptorSetLayout> dslh) {}

filament/backend/src/webgpu/WebGPUHandles.cpp

@@ -60,4 +60,94 @@ void WGPUVertexBuffer::setBuffer(WGPUBufferObject* bufferObject, uint32_t index)
 WGPUBufferObject::WGPUBufferObject(BufferObjectBinding bindingType, uint32_t byteCount)
     : HwBufferObject(byteCount),
       bufferObjectBinding(bindingType) {}
+
+wgpu::ShaderStage WebGPUDescriptorSetLayout::filamentStageToWGPUStage(ShaderStageFlags fFlags) {
+    wgpu::ShaderStage ret = wgpu::ShaderStage::None;
+    if (any(ShaderStageFlags::VERTEX & fFlags)) {
+        ret |= wgpu::ShaderStage::Vertex;
+    }
+    if (any(ShaderStageFlags::FRAGMENT & fFlags)) {
+        ret |= wgpu::ShaderStage::Fragment;
+    }
+    if (any(ShaderStageFlags::COMPUTE & fFlags)) {
+        ret |= wgpu::ShaderStage::Compute;
+    }
+    return ret;
+}
+
+WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout,
+        wgpu::Device const* device) {
+    assert_invariant(device->Get());
+
+    // TODO: layoutDescriptor has a "Label". Ideally we can get info on what this layout is for
+    // debugging. For now, hack an incrementing value.
+    static int layoutNum = 0;
+
+
+    uint samplerCount =
+            std::count_if(layout.bindings.begin(), layout.bindings.end(), [](auto& fEntry) {
+                return fEntry.type == DescriptorType::SAMPLER ||
+                       fEntry.type == DescriptorType::SAMPLER_EXTERNAL;
+            });
+
+
+    std::vector<wgpu::BindGroupLayoutEntry> wEntries;
+    wEntries.reserve(layout.bindings.size() + samplerCount);
+
+    for (auto fEntry: layout.bindings) {
+        auto& wEntry = wEntries.emplace_back();
+        wEntry.visibility = filamentStageToWGPUStage(fEntry.stageFlags);
+        wEntry.binding = fEntry.binding * 2;
+
+        switch (fEntry.type) {
+            // TODO Metal treats these the same. Is this fine?
+            case DescriptorType::SAMPLER_EXTERNAL:
+            case DescriptorType::SAMPLER: {
+                // Sampler binding is 2n+1 due to split.
+                auto& samplerEntry = wEntries.emplace_back();
+                samplerEntry.binding = fEntry.binding * 2 + 1;
+                samplerEntry.visibility = wEntry.visibility;
+                // We are simply hoping that undefined and defaults suffices here.
+                samplerEntry.sampler.type = wgpu::SamplerBindingType::Undefined;
+                wEntry.texture.sampleType = wgpu::TextureSampleType::Undefined;
+                break;
+            }
+            case DescriptorType::UNIFORM_BUFFER: {
+                wEntry.buffer.hasDynamicOffset =
+                        any(fEntry.flags & DescriptorFlags::DYNAMIC_OFFSET);
+                wEntry.buffer.type = wgpu::BufferBindingType::Uniform;
+                // TODO: Ideally we fill minBindingSize
+                break;
+            }
+
+            case DescriptorType::INPUT_ATTACHMENT: {
+                // TODO: support INPUT_ATTACHMENT. Metal does not currently.
+                PANIC_POSTCONDITION("Input Attachment is not supported");
+                break;
+            }
+
+            case DescriptorType::SHADER_STORAGE_BUFFER: {
+                // TODO: Vulkan does not support this, can we?
+                PANIC_POSTCONDITION("Shader storage is not supported");
+                break;
+            }
+        }
+
+        // Currently flags are only used to specify dynamic offset.
+
+        // UNUSED
+        // fEntry.count
+    }
+
+    wgpu::BindGroupLayoutDescriptor layoutDescriptor{
+        // TODO: layoutDescriptor has a "Label". Ideally we can get info on what this layout is for
+        // debugging. For now, hack an incrementing value.
+        .label{ "layout_"+ layout.label + std::to_string(++layoutNum) },
+        .entryCount = wEntries.size(),
+        .entries = wEntries.data()
+    };
+    // TODO Do we need to defer this until we have more info on textures and samplers??
+    mLayout = device->CreateBindGroupLayout(&layoutDescriptor);
+}
+WebGPUDescriptorSetLayout::~WebGPUDescriptorSetLayout() {}
 }// namespace filament::backend

filament/backend/src/webgpu/WebGPUHandles.h

@@ -67,6 +67,18 @@ struct WGPUBufferObject : HwBufferObject {
     wgpu::Buffer buffer;
     const BufferObjectBinding bufferObjectBinding;
 };
+class WebGPUDescriptorSetLayout : public HwDescriptorSetLayout {
+public:
+    WebGPUDescriptorSetLayout(DescriptorSetLayout const& layout, wgpu::Device const* device);
+    ~WebGPUDescriptorSetLayout();
+
+private:
+    // TODO: If this is useful elsewhere, remove it from this class
+    // Convert Filament Shader Stage Flags bitmask to webgpu equivilant
+    static wgpu::ShaderStage filamentStageToWGPUStage(ShaderStageFlags fFlags);
+
+    wgpu::BindGroupLayout mLayout;
+};
 
 // TODO: Currently WGPUTexture is not used by WebGPU for useful task.
 // Update the struct when used by WebGPU driver.

filament/backend/test/Shader.cpp

@@ -23,14 +23,6 @@ namespace test {
 
 using namespace filament::backend;
 
-filament::backend::descriptor_binding_t TextureBindingConfig::getBinding() const {
-    return binding.value_or(0);
-}
-
-filament::backend::SamplerParams TextureBindingConfig::getParams() const {
-    return samplerParams.value_or(SamplerParams{});
-}
-
 Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) : mCleanup(cleanup) {
     utils::FixedCapacityVector<DescriptorSetLayoutBinding> kLayouts(config.uniforms.size());
     for (unsigned char i = 0; i < config.uniforms.size(); ++i) {
@@ -64,20 +56,7 @@ Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) : mCleanup
     mProgram = cleanup.add(api.createProgram(std::move(prog)));
 
     mDescriptorSetLayout = cleanup.add(
-            api.createDescriptorSetLayout(DescriptorSetLayout{ kLayouts }));
-
-    mDefaultDescriptorSet = createDescriptorSet(api);
-}
-
-void Shader::updateTextureUniform(filament::backend::DriverApi& api,
-        TextureBindingConfig config) const {
-    DescriptorSetHandle descriptorSet = config.descriptorSet.value_or(mDefaultDescriptorSet);
-    api.updateDescriptorSetTexture(descriptorSet, config.getBinding(), config.textureHandle,
-            config.getParams());
-
-    if (config.alsoBindToSet.has_value()) {
-        api.bindDescriptorSet(descriptorSet, *config.alsoBindToSet, {});
-    }
+            api.createDescriptorSetLayout(DescriptorSetLayout{ "kLayouts", kLayouts }));
 }
 
 filament::backend::DescriptorSetHandle Shader::createDescriptorSet(DriverApi& api) const {

filament/backend/test/Shader.h

@@ -61,18 +61,6 @@ struct UniformBindingConfig {
     ResolvedUniformBindingConfig resolve();
 };
 
-struct TextureBindingConfig {
-    filament::backend::TextureHandle textureHandle;
-    std::optional<filament::backend::DescriptorSetHandle> descriptorSet;
-    std::optional<filament::backend::descriptor_binding_t> binding;
-    std::optional<filament::backend::SamplerParams> samplerParams;
-    // If present then the call to update the texture will also bind the descriptor set.
-    std::optional<filament::backend::descriptor_set_t> alsoBindToSet;
-
-    filament::backend::descriptor_binding_t getBinding() const;
-    filament::backend::SamplerParams getParams() const;
-};
-
 class Shader {
 public:
     // All graphics resources have their lifetime controlled by the Cleanup and not this object.
@@ -98,20 +86,17 @@ public:
     void bindUniform(filament::backend::DriverApi& api,
             filament::backend::Handle<filament::backend::HwBufferObject> hwBuffer,
             UniformBindingConfig config) const;
-    void updateTextureUniform(filament::backend::DriverApi& api, TextureBindingConfig config) const;
-
-    filament::backend::DescriptorSetHandle createDescriptorSet(
-            filament::backend::DriverApi& api) const;
 
     filament::backend::ProgramHandle getProgram() const;
     filament::backend::DescriptorSetLayoutHandle getDescriptorSetLayout() const;
 
+    filament::backend::DescriptorSetHandle createDescriptorSet(
+            filament::backend::DriverApi& api) const;
+
 protected:
     Cleanup& mCleanup;
     filament::backend::ProgramHandle mProgram;
     filament::backend::DescriptorSetLayoutHandle mDescriptorSetLayout;
-    // Used whenever the caller doesn't provide a descriptor set.
-    filament::backend::DescriptorSetHandle mDefaultDescriptorSet;
 };
 
 template<typename UniformType>
@@ -148,8 +133,12 @@ void Shader::bindUniform(filament::backend::DriverApi& api,
         UniformBindingConfig config) const {
     auto resolvedConfig = config.resolve<UniformType>();
 
-    filament::backend::DescriptorSetHandle descriptorSet =
-            resolvedConfig.descriptorSet.value_or(mDefaultDescriptorSet);
+    filament::backend::DescriptorSetHandle descriptorSet;
+    if (resolvedConfig.descriptorSet.has_value()) {
+        descriptorSet = *resolvedConfig.descriptorSet;
+    } else {
+        descriptorSet = createDescriptorSet(api);
+    }
 
     api.updateDescriptorSetBuffer(descriptorSet, resolvedConfig.binding, hwBuffer, 0,
             resolvedConfig.bufferSize);

filament/backend/test/test_FeedbackLoops.cpp

@@ -198,14 +198,12 @@ TEST_F(BackendTest, FeedbackLoops) {
                 params.viewport.width = kTexWidth >> targetLevel;
                 params.viewport.height = kTexHeight >> targetLevel;
 
-                // Each pass needs its own descriptor set.
                 auto descriptorSet = shader.createDescriptorSet(api);
                 auto textureView = passCleanup.add(api.createTextureView(texture, sourceLevel, 1));
-                shader.updateTextureUniform(api,
-                        TextureBindingConfig{ .textureHandle = textureView,
-                            .descriptorSet = descriptorSet,
-                            .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::LINEAR,
-                                .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST } });
+                api.updateDescriptorSetTexture(descriptorSet, 0, textureView, {
+                        .filterMag = SamplerMagFilter::LINEAR,
+                        .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
+                });
 
                 UniformBindingConfig uniformBinding{
                     .binding = 1,

filament/backend/test/test_LoadImage.cpp

@@ -329,14 +329,12 @@ TEST_F(LoadImageTest, UpdateImage2D) {
                     checkerboardPixelBuffer(t.pixelFormat, t.pixelType, 512, t.bufferPadding));
         }
 
-        // Each loop needs its own descriptor set.
         DescriptorSetHandle  descriptorSet = shader.createDescriptorSet(api);
-        shader.updateTextureUniform(api,
-                TextureBindingConfig{ .textureHandle = texture,
-                    .descriptorSet = descriptorSet,
-                    .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::NEAREST,
-                        .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST },
-                    .alsoBindToSet = 1 });
+        api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
+                .filterMag = SamplerMagFilter::NEAREST,
+                .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
+
+        api.bindDescriptorSet(descriptorSet, 1, {});
 
         renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
                 defaultRenderTarget, swapChain, shader.getProgram());
@@ -407,11 +405,13 @@ TEST_F(LoadImageTest, UpdateImageSRGB) {
     api.beginFrame(0, 0, 0);
 
     // Update samplers.
-    shader.updateTextureUniform(api,
-            TextureBindingConfig{ .textureHandle = texture,
-                    .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::LINEAR,
-                            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST },
-                    .alsoBindToSet = 1 });
+    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
+    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
+            .filterMag = SamplerMagFilter::LINEAR,
+            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
+    });
+
+    api.bindDescriptorSet(descriptorSet, 1, {});
 
     renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
             defaultRenderTarget, swapChain, shader.getProgram());
@@ -467,11 +467,13 @@ TEST_F(LoadImageTest, UpdateImageMipLevel) {
     api.beginFrame(0, 0, 0);
 
     // Update samplers.
-    shader.updateTextureUniform(api,
-            TextureBindingConfig{ .textureHandle = texture,
-                    .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::LINEAR,
-                            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST },
-                    .alsoBindToSet = 1 });
+    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
+    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
+            .filterMag = SamplerMagFilter::LINEAR,
+            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
+    });
+
+    api.bindDescriptorSet(descriptorSet, 1, {});
 
     renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
             defaultRenderTarget, swapChain, shader.getProgram());
@@ -539,11 +541,13 @@ TEST_F(LoadImageTest, UpdateImage3D) {
     api.beginFrame(0, 0, 0);
 
     // Update samplers.
-    shader.updateTextureUniform(api,
-            TextureBindingConfig{ .textureHandle = texture,
-                .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::LINEAR,
-                    .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST },
-                .alsoBindToSet = 1 });
+    DescriptorSetHandle  descriptorSet = shader.createDescriptorSet(api);
+    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {
+            .filterMag = SamplerMagFilter::LINEAR,
+            .filterMin = SamplerMinFilter::LINEAR_MIPMAP_NEAREST
+    });
+
+    api.bindDescriptorSet(descriptorSet, 1, {});
 
     renderTriangle({{ DescriptorSetLayoutHandle{}, shader.getDescriptorSetLayout() }},
             defaultRenderTarget, swapChain, shader.getProgram());

filament/backend/test/test_MipLevels.cpp

@@ -171,12 +171,11 @@ TEST_F(BackendTest, TextureViewLod) {
         state.rasterState.culling = CullingMode::NONE;
 
         DescriptorSetHandle descriptorSet13 = texturedShader.createDescriptorSet(api);
-        texturedShader.updateTextureUniform(api,
-                TextureBindingConfig{ .textureHandle = texture13,
-                        .descriptorSet = descriptorSet13,
-                        .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::NEAREST,
-                                .filterMin = SamplerMinFilter::NEAREST },
-                        .alsoBindToSet = 0 });
+        api.updateDescriptorSetTexture(descriptorSet13, 0, texture13, {
+                .filterMag = SamplerMagFilter::NEAREST,
+                .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
+
+        api.bindDescriptorSet(descriptorSet13, 0, {});
 
         // Render a triangle to the screen, sampling from mip level 1.
         // Because the min level is 1, the result color should be the white triangle drawn in the
@@ -190,12 +189,11 @@ TEST_F(BackendTest, TextureViewLod) {
         auto texture22 = cleanup.add(api.createTextureView(texture, 2, 2));
 
         DescriptorSetHandle descriptorSet22 = texturedShader.createDescriptorSet(api);
-        texturedShader.updateTextureUniform(api,
-                TextureBindingConfig{ .textureHandle = texture22,
-                        .descriptorSet = descriptorSet22,
-                        .samplerParams = SamplerParams{ .filterMag = SamplerMagFilter::NEAREST,
-                                .filterMin = SamplerMinFilter::NEAREST },
-                        .alsoBindToSet = 0 });
+        api.updateDescriptorSetTexture(descriptorSet22, 0, texture22, {
+                .filterMag = SamplerMagFilter::NEAREST,
+                .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
+
+        api.bindDescriptorSet(descriptorSet22, 0, {});
 
         // Render a second, smaller, triangle, again sampling from mip level 1.
         // This triangle should be yellow striped.

filament/backend/test/test_RenderExternalImage.cpp

@@ -84,12 +84,14 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {
     state.rasterState.depthFunc = RasterState::DepthFunc::A;
     state.rasterState.culling = CullingMode::NONE;
 
+    DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
+
     api.startCapture(0);
     api.makeCurrent(swapChain, swapChain);
     api.beginFrame(0, 0, 0);
 
-    shader.updateTextureUniform(api,
-            TextureBindingConfig{ .textureHandle = texture, .alsoBindToSet = 1 });
+    api.updateDescriptorSetTexture(descriptorSet, 0, texture, {});
+    api.bindDescriptorSet(descriptorSet, 1, {});
 
     // Render a triangle.
     api.beginRenderPass(defaultRenderTarget, params);

libs/filabridge/src/DescriptorSets.cpp

@@ -33,11 +33,11 @@ namespace filament::descriptor_sets {
 
 using namespace backend;
 
-static DescriptorSetLayout const postProcessDescriptorSetLayout{{
+static DescriptorSetLayout const postProcessDescriptorSetLayout{"postProcess", {
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
 }};
 
-static DescriptorSetLayout const depthVariantDescriptorSetLayout{{
+static DescriptorSetLayout const depthVariantDescriptorSetLayout{"depthVariant",{
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
 }};
 
@@ -46,14 +46,14 @@ static DescriptorSetLayout const depthVariantDescriptorSetLayout{{
 // dedicated SSR vertex shader), which uses perViewDescriptorSetLayout.
 // This means that PerViewBindingPoints::SHADOWS must be in the layout even though it's not used
 // by the SSR variant.
-static DescriptorSetLayout const ssrVariantDescriptorSetLayout{{
+static DescriptorSetLayout const ssrVariantDescriptorSetLayout{"ssrVariant", {
    { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
    { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::SHADOWS        },
    { DescriptorType::SAMPLER,                                   ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::STRUCTURE      },
    { DescriptorType::SAMPLER,                                   ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::SSR            },
 }};
 
-static DescriptorSetLayout perViewDescriptorSetLayout = {{
+static DescriptorSetLayout perViewDescriptorSetLayout = {"perView", {
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FRAME_UNIFORMS },
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::SHADOWS        },
     { DescriptorType::UNIFORM_BUFFER,                            ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::LIGHTS         },
@@ -68,7 +68,7 @@ static DescriptorSetLayout perViewDescriptorSetLayout = {{
     { DescriptorType::SAMPLER,                                   ShaderStageFlags::FRAGMENT,  +PerViewBindingPoints::FOG            },
 }};
 
-static DescriptorSetLayout perRenderableDescriptorSetLayout = {{
+static DescriptorSetLayout perRenderableDescriptorSetLayout = {"preRenderable",{
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerRenderableBindingPoints::OBJECT_UNIFORMS, DescriptorFlags::DYNAMIC_OFFSET },
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerRenderableBindingPoints::BONES_UNIFORMS,  DescriptorFlags::DYNAMIC_OFFSET },
     { DescriptorType::UNIFORM_BUFFER, ShaderStageFlags::VERTEX | ShaderStageFlags::FRAGMENT,  +PerRenderableBindingPoints::MORPHING_UNIFORMS         },