Fix test

Test adding a label to descriptor sets for WebGPU
Handle WebGPUDescriptorSetLayout creation
2025-04-15 17:44:40 -04:00 · 2025-04-15 17:29:49 -04:00 · 2025-04-15 13:51:14 -04:00 · 2025-04-15 13:35:50 -04:00 · 2025-04-14 16:50:53 -05:00 · 2025-04-14 18:27:52 +00:00
23 changed files with 768 additions and 502 deletions
--- a/filament/backend/include/backend/BufferObjectStreamDescriptor.h
+++ b/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
--- a/filament/backend/include/backend/DriverEnums.h
+++ b/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
--- a/filament/backend/include/backend/platforms/WebGPUPlatform.h
+++ b/filament/backend/include/backend/platforms/WebGPUPlatform.h
@@ -38,6 +38,12 @@ public:

    [[nodiscard]] wgpu::Instance& getInstance() noexcept { return mInstance; }

+    // TODO consider that this functionality is not WebGPU-specific, and thus could be
+    //      placed in a generic place and even reused across backends. Alternatively,
+    //      a 3rd party library could be considered. However, this was a simple and
+    //      quick change and works for now.
+    // gets the size (height and width) of the surface/window
+    [[nodiscard]] wgpu::Extent2D getSurfaceExtent(void* nativeWindow) const;
    // either returns a valid surface or panics
    [[nodiscard]] wgpu::Surface createSurface(void* nativeWindow, uint64_t flags);
    // either returns a valid adapter or panics
--- a/filament/backend/src/opengl/ShaderCompilerService.cpp
+++ b/filament/backend/src/opengl/ShaderCompilerService.cpp
@@ -54,31 +54,27 @@ using namespace utils;

 // ------------------------------------------------------------------------------------------------

-static void logCompilationError(utils::io::ostream& out,
-        ShaderStage shaderType, const char* name,
+static inline std::string to_string(bool b) noexcept { return b ? "true" : "false"; }
+static inline std::string to_string(int i) noexcept { return std::to_string(i); }
+static inline std::string to_string(float f) noexcept { return "float(" + std::to_string(f) + ")"; }
+
+static void logCompilationError(io::ostream& out, ShaderStage shaderType, const char* name,
        GLuint shaderId, CString const& sourceCode) noexcept;
+static void logProgramLinkError(io::ostream& out, char const* name, GLuint program) noexcept;

-static void logProgramLinkError(utils::io::ostream& out,
-        const char* name, GLuint program) noexcept;
-
-static inline std::string to_string(bool b) noexcept {
-    return b ? "true" : "false";
-}
-
-static inline std::string to_string(int i) noexcept {
-    return std::to_string(i);
-}
-
-static inline std::string to_string(float f) noexcept {
-    return "float(" + std::to_string(f) + ")";
-}
+static void process_GOOGLE_cpp_style_line_directive(OpenGLContext& context, char* source,
+        size_t len) noexcept;
+static void process_OVR_multiview2(OpenGLContext& context, int32_t eyeCount, char* source,
+        size_t len) noexcept;
+static std::string_view process_ARB_shading_language_packing(OpenGLContext& context) noexcept;
+static std::array<std::string_view, 3> splitShaderSource(std::string_view source) noexcept;

 // ------------------------------------------------------------------------------------------------

 struct ShaderCompilerService::OpenGLProgramToken : ProgramToken {
    struct ProgramData {
        GLuint program{};
-        std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders{};
+        shaders_t shaders{};
    };

    ~OpenGLProgramToken() override;
@@ -90,10 +86,10 @@ struct ShaderCompilerService::OpenGLProgramToken : ProgramToken {
    ShaderCompilerService& compiler;
    utils::CString const& name;
    utils::FixedCapacityVector<std::pair<utils::CString, uint8_t>> attributes;
-    std::array<utils::CString, Program::SHADER_TYPE_COUNT> shaderSourceCode;
+    shaders_source_t shaderSourceCode;
    void* user = nullptr;
    struct {
-        std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders{};
+        shaders_t shaders{};
        GLuint program = 0;
    } gl; // 12 bytes

@@ -140,11 +136,12 @@ struct ShaderCompilerService::OpenGLProgramToken : ProgramToken {

 ShaderCompilerService::OpenGLProgramToken::~OpenGLProgramToken() = default;

-void ShaderCompilerService::setUserData(const program_token_t& token, void* user) noexcept {
+/* static */ void ShaderCompilerService::setUserData(const program_token_t& token,
+        void* user) noexcept {
    token->user = user;
 }

-void* ShaderCompilerService::getUserData(const program_token_t& token) noexcept {
+/* static */ void* ShaderCompilerService::getUserData(const program_token_t& token) noexcept {
    return token->user;
 }

@@ -268,101 +265,111 @@ ShaderCompilerService::program_token_t ShaderCompilerService::createProgram(
    token->handle = mCallbackManager.get();

    CompilerPriorityQueue const priorityQueue = program.getPriorityQueue();
-    if (mMode == Mode::THREAD_POOL) {
-        // queue a compile job
-        mCompilerThreadPool.queue(priorityQueue, token,
-                [this, &gl, program = std::move(program), token]() mutable {
-                    // compile the shaders
-                    std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders{};
-                    compileShaders(gl,
-                            std::move(program.getShadersSource()),
-                            program.getSpecializationConstants(),
-                            program.isMultiview(),
-                            shaders,
-                            token->shaderSourceCode);
+    switch (mMode) {
+        case Mode::THREAD_POOL: {
+            // queue a compile job
+            mCompilerThreadPool.queue(priorityQueue, token,
+                    [this, &gl, program = std::move(program), token]() mutable {
+                        // compile the shaders
+                        shaders_t shaders{};
+                        compileShaders(gl,
+                                std::move(program.getShadersSource()),
+                                program.getSpecializationConstants(),
+                                program.isMultiview(),
+                                shaders,
+                                token->shaderSourceCode);

-                    // link the program
-                    GLuint const glProgram = linkProgram(gl, shaders, token->attributes);
+                        // link the program
+                        GLuint const glProgram = linkProgram(gl, shaders, token->attributes);

-                    OpenGLProgramToken::ProgramData programData;
-                    programData.shaders = shaders;
+                        OpenGLProgramToken::ProgramData programData;
+                        programData.shaders = shaders;

-                    // We need to query the link status here to guarantee that the
-                    // program is compiled and linked now (we don't want this to be
-                    // deferred to later). We don't care about the result at this point.
-                    GLint status = GL_FALSE;
-                    glGetProgramiv(glProgram, GL_LINK_STATUS, &status);
-                    programData.program = glProgram;
+                        // We need to query the link status here to guarantee that the
+                        // program is compiled and linked now (we don't want this to be
+                        // deferred to later). We don't care about the result at this point.
+                        GLint status = GL_FALSE;
+                        glGetProgramiv(glProgram, GL_LINK_STATUS, &status);
+                        programData.program = glProgram;

-                    // we don't need to check for success here, it'll be done on the
-                    // main thread side.
-                    token->set(programData);
+                        // we don't need to check for success here, it'll be done on the
+                        // main thread side.
+                        token->set(programData);

-                    mCallbackManager.put(token->handle);
+                        mCallbackManager.put(token->handle);

-                    // caching must be the last thing we do
-                    if (token->key && status == GL_TRUE) {
-                        // Attempt to cache. This calls glGetProgramBinary.
-                        mBlobCache.insert(mDriver.mPlatform, token->key, glProgram);
-                    }
-                });
+                        // caching must be the last thing we do
+                        if (token->key && status == GL_TRUE) {
+                            // Attempt to cache. This calls glGetProgramBinary.
+                            mBlobCache.insert(mDriver.mPlatform, token->key, glProgram);
+                        }
+                    });
+            break;
+        }

-    } else {
-        // this cannot fail because we check compilation status after linking the program
-        // shaders[] is filled with id of shader stages present.
-        compileShaders(gl,
-                std::move(program.getShadersSource()),
-                program.getSpecializationConstants(),
-                program.isMultiview(),
-                token->gl.shaders,
-                token->shaderSourceCode);
+        case Mode::SYNCHRONOUS:
+        case Mode::ASYNCHRONOUS: {
+            // this cannot fail because we check compilation status after linking the program
+            // shaders[] is filled with id of shader stages present.
+            compileShaders(gl,
+                    std::move(program.getShadersSource()),
+                    program.getSpecializationConstants(),
+                    program.isMultiview(),
+                    token->gl.shaders,
+                    token->shaderSourceCode);

-        runAtNextTick(priorityQueue, token, [this, token](Job const&) {
-            assert_invariant(mMode != Mode::THREAD_POOL);
-            if (mMode == Mode::ASYNCHRONOUS) {
-                // don't attempt to link this program if all shaders are not done compiling
-                GLint status;
-                if (token->gl.program) {
-                    glGetProgramiv(token->gl.program, GL_COMPLETION_STATUS, &status);
-                    if (status == GL_FALSE) {
-                        return false;
-                    }
-                } else {
-                    for (auto shader: token->gl.shaders) {
-                        if (shader) {
-                            glGetShaderiv(shader, GL_COMPLETION_STATUS, &status);
-                            if (status == GL_FALSE) {
-                                return false;
+            runAtNextTick(priorityQueue, token, [this, token](Job const&) {
+                assert_invariant(mMode != Mode::THREAD_POOL);
+                if (mMode == Mode::ASYNCHRONOUS) {
+                    // don't attempt to link this program if all shaders are not done compiling
+                    GLint status;
+                    if (token->gl.program) {
+                        glGetProgramiv(token->gl.program, GL_COMPLETION_STATUS, &status);
+                        if (status == GL_FALSE) {
+                            return false;
+                        }
+                    } else {
+                        for (auto shader: token->gl.shaders) {
+                            if (shader) {
+                                glGetShaderiv(shader, GL_COMPLETION_STATUS, &status);
+                                if (status == GL_FALSE) {
+                                    return false;
+                                }
                            }
                        }
                    }
                }
-            }

-            if (!token->gl.program) {
-                // link the program, this also cannot fail because status is checked later.
-                token->gl.program = linkProgram(mDriver.getContext(),
-                        token->gl.shaders, token->attributes);
-                if (mMode == Mode::ASYNCHRONOUS) {
-                    // wait until the link finishes...
-                    return false;
+                if (!token->gl.program) {
+                    // link the program, this also cannot fail because status is checked later.
+                    token->gl.program = linkProgram(mDriver.getContext(),
+                            token->gl.shaders, token->attributes);
+                    if (mMode == Mode::ASYNCHRONOUS) {
+                        // wait until the link finishes...
+                        return false;
+                    }
                }
-            }

-            assert_invariant(token->gl.program);
+                assert_invariant(token->gl.program);

-            mCallbackManager.put(token->handle);
+                mCallbackManager.put(token->handle);

-            if (token->key) {
-                // TODO: technically we don't have to cache right now. Is it advantageous to
-                //       do this later, maybe depending on CPU usage?
-                // attempt to cache if we don't have a thread pool (otherwise it's done
-                // by the pool).
-                mBlobCache.insert(mDriver.mPlatform, token->key, token->gl.program);
-            }
+                if (token->key) {
+                    // TODO: technically we don't have to cache right now. Is it advantageous to
+                    //       do this later, maybe depending on CPU usage?
+                    // attempt to cache if we don't have a thread pool (otherwise it's done
+                    // by the pool).
+                    mBlobCache.insert(mDriver.mPlatform, token->key, token->gl.program);
+                }

-            return true;
-        });
+                return true;
+            });
+            break;
+        }
+
+        case Mode::UNDEFINED: {
+            assert_invariant(false);
+        }
    }

    return token;
@@ -377,12 +384,12 @@ GLuint ShaderCompilerService::getProgram(ShaderCompilerService::program_token_t&
    return program;
 }

-void ShaderCompilerService::terminate(program_token_t& token) {
+/* static */ void ShaderCompilerService::terminate(program_token_t& token) {
    assert_invariant(token);

    token->canceled = true;

-    bool const canceled = token->compiler.cancelTickOp(token);
+    bool const isTickOpCanceled = token->compiler.cancelTickOp(token);

    if (token->compiler.mMode == Mode::THREAD_POOL) {
        auto job = token->compiler.mCompilerThreadPool.dequeue(token);
@@ -395,7 +402,7 @@ void ShaderCompilerService::terminate(program_token_t& token) {
            // order for future callbacks to be successfully called.
            token->compiler.mCallbackManager.put(token->handle);
        }
-    } else if (canceled) {
+    } else if (isTickOpCanceled) {
        // Since the tick op was canceled, we need to .put the token here.
        token->compiler.mCallbackManager.put(token->handle);
    }
@@ -432,7 +439,8 @@ void ShaderCompilerService::notifyWhenAllProgramsAreReady(

 // ------------------------------------------------------------------------------------------------

-void ShaderCompilerService::getProgramFromCompilerPool(program_token_t& token) noexcept {
+/* static */ void ShaderCompilerService::getProgramFromCompilerPool(
+        program_token_t& token) noexcept {
    OpenGLProgramToken::ProgramData const& programData{ token->get() };
    if (!token->canceled) {
        token->gl.shaders = programData.shaders;
@@ -443,40 +451,53 @@ void ShaderCompilerService::getProgramFromCompilerPool(program_token_t& token) n
 GLuint ShaderCompilerService::initialize(program_token_t& token) noexcept {
    SYSTRACE_CALL();
    if (!token->gl.program) {
-        if (mMode == Mode::THREAD_POOL) {
-            // we need this program right now, remove it from the queue
-            auto job = mCompilerThreadPool.dequeue(token);
-            if (job) {
-                // if we were able to remove it, we execute the job now, otherwise it means
-                // it's being executed right now.
-                job();
+        switch (mMode) {
+            case Mode::THREAD_POOL: {
+                // we need this program right now, remove it from the queue
+                auto job = mCompilerThreadPool.dequeue(token);
+                if (job) {
+                    // if we were able to remove it, we execute the job now, otherwise it means
+                    // it's being executed right now.
+                    job();
+                }
+
+                if (!token->canceled) {
+                    token->compiler.cancelTickOp(token);
+                }
+
+                // Block until we get the program from the pool. Generally this wouldn't block
+                // because we just compiled the program above, when executing job.
+                ShaderCompilerService::getProgramFromCompilerPool(token);
+                break;
            }

-            if (!token->canceled) {
+            case Mode::ASYNCHRONOUS: {
+                // we force the program link -- which might stall, either here or below in
+                // checkProgramStatus(), but we don't have a choice, we need to use the program now.
                token->compiler.cancelTickOp(token);
+
+                token->gl.program =
+                        linkProgram(mDriver.getContext(), token->gl.shaders, token->attributes);
+
+                assert_invariant(token->gl.program);
+
+                mCallbackManager.put(token->handle);
+
+                if (token->key) {
+                    mBlobCache.insert(mDriver.mPlatform, token->key, token->gl.program);
+                }
+                break;
            }

-            // Block until we get the program from the pool. Generally this wouldn't block
-            // because we just compiled the program above, when executing job.
-            ShaderCompilerService::getProgramFromCompilerPool(token);
-        } else if (mMode == Mode::ASYNCHRONOUS) {
-            // we force the program link -- which might stall, either here or below in
-            // checkProgramStatus(), but we don't have a choice, we need to use the program now.
-            token->compiler.cancelTickOp(token);
-
-            token->gl.program = linkProgram(mDriver.getContext(),
-                    token->gl.shaders, token->attributes);
-
-            assert_invariant(token->gl.program);
-
-            mCallbackManager.put(token->handle);
-
-            if (token->key) {
-                mBlobCache.insert(mDriver.mPlatform, token->key, token->gl.program);
+            case Mode::SYNCHRONOUS: {
+                // if we don't have a program yet, block until we get it.
+                tick();
+                break;
+            }
+
+            case Mode::UNDEFINED: {
+                assert_invariant(false);
            }
-        } else {
-            // if we don't have a program yet, block until we get it.
-            tick();
        }
    }

@@ -519,12 +540,12 @@ GLuint ShaderCompilerService::initialize(program_token_t& token) noexcept {
 * checked until after the program is linked.
 * This always returns the GL shader IDs or zero a shader stage is not present.
 */
-void ShaderCompilerService::compileShaders(OpenGLContext& context,
+/* static */ void ShaderCompilerService::compileShaders(OpenGLContext& context,
        Program::ShaderSource shadersSource,
        utils::FixedCapacityVector<Program::SpecializationConstant> const& specializationConstants,
        bool multiview,
-        std::array<GLuint, Program::SHADER_TYPE_COUNT>& outShaders,
-        UTILS_UNUSED_IN_RELEASE std::array<CString, Program::SHADER_TYPE_COUNT>& outShaderSourceCode) noexcept {
+        shaders_t& outShaders,
+        UTILS_UNUSED_IN_RELEASE shaders_source_t& outShaderSourceCode) noexcept {

    SYSTRACE_CALL();

@@ -635,209 +656,13 @@ void ShaderCompilerService::compileShaders(OpenGLContext& context,
    }
 }

-// If usages of the Google-style line directive are present, remove them, as some
-// drivers don't allow the quotation marks. This source modification happens in-place.
-void ShaderCompilerService::process_GOOGLE_cpp_style_line_directive(OpenGLContext& context,
-        char* source, size_t len) noexcept {
-    if (!context.ext.GOOGLE_cpp_style_line_directive) {
-        if (UTILS_UNLIKELY(requestsGoogleLineDirectivesExtension({ source, len }))) {
-            removeGoogleLineDirectives(source, len); // length is unaffected
-        }
-    }
-}
-
-// Look up the `source` to replace the number of eyes for multiview with the given number. This is
-// necessary for OpenGL because OpenGL relies on the number specified in shader files to determine
-// the number of views, which is assumed as a single digit, for multiview.
-// This source modification happens in-place.
-void ShaderCompilerService::process_OVR_multiview2(OpenGLContext& context,
-        int32_t eyeCount, char* source, size_t len) noexcept {
-    // We don't use regular expression in favor of performance.
-    if (context.ext.OVR_multiview2) {
-        const std::string_view shader{ source, len };
-        const std::string_view layout = "layout";
-        const std::string_view num_views = "num_views";
-        size_t found = 0;
-        while (true) {
-            found = shader.find(layout, found);
-            if (found == std::string_view::npos) {
-                break;
-            }
-            found = shader.find_first_not_of(' ', found + layout.size());
-            if (found == std::string_view::npos || shader[found] != '(') {
-                continue;
-            }
-            found = shader.find_first_not_of(' ', found + 1);
-            if (found == std::string_view::npos) {
-                continue;
-            }
-            if (shader.compare(found, num_views.size(), num_views) != 0) {
-                continue;
-            }
-            found = shader.find_first_not_of(' ', found + num_views.size());
-            if (found == std::string_view::npos || shader[found] != '=') {
-                continue;
-            }
-            found = shader.find_first_not_of(' ', found + 1);
-            if (found == std::string_view::npos) {
-                continue;
-            }
-            // We assume the value should be one-digit number.
-            assert_invariant(eyeCount < 10);
-            assert_invariant(!::isdigit(source[found + 1]));
-            source[found] = '0' + eyeCount;
-            break;
-        }
-    }
-}
-
-// Tragically, OpenGL 4.1 doesn't support unpackHalf2x16 (appeared in 4.2) and
-// macOS doesn't support GL_ARB_shading_language_packing
-// Also GLES3.0 didn't have the full set of packing/unpacking functions
-std::string_view ShaderCompilerService::process_ARB_shading_language_packing(OpenGLContext& context) noexcept {
-    using namespace std::literals;
-#ifdef BACKEND_OPENGL_VERSION_GL
-    if (!context.isAtLeastGL<4, 2>() && !context.ext.ARB_shading_language_packing) {
-        return R"(
-
-// these don't handle denormals, NaNs or inf
-float u16tofp32(highp uint v) {
-    v <<= 16u;
-    highp uint s = v & 0x80000000u;
-    highp uint n = v & 0x7FFFFFFFu;
-    highp uint nz = (n == 0u) ? 0u : 0xFFFFFFFFu;
-    return uintBitsToFloat(s | ((((n >> 3u) + (0x70u << 23u))) & nz));
-}
-vec2 unpackHalf2x16(highp uint v) {
-    return vec2(u16tofp32(v&0xFFFFu), u16tofp32(v>>16u));
-}
-uint fp32tou16(float val) {
-    uint f32 = floatBitsToUint(val);
-    uint f16 = 0u;
-    uint sign = (f32 >> 16u) & 0x8000u;
-    int exponent = int((f32 >> 23u) & 0xFFu) - 127;
-    uint mantissa = f32 & 0x007FFFFFu;
-    if (exponent > 15) {
-        f16 = sign | (0x1Fu << 10u);
-    } else if (exponent > -15) {
-        exponent += 15;
-        mantissa >>= 13;
-        f16 = sign | uint(exponent << 10) | mantissa;
-    } else {
-        f16 = sign;
-    }
-    return f16;
-}
-highp uint packHalf2x16(vec2 v) {
-    highp uint x = fp32tou16(v.x);
-    highp uint y = fp32tou16(v.y);
-    return (y << 16u) | x;
-}
-highp uint packUnorm4x8(mediump vec4 v) {
-    v = round(clamp(v, 0.0, 1.0) * 255.0);
-    highp uint a = uint(v.x);
-    highp uint b = uint(v.y) <<  8;
-    highp uint c = uint(v.z) << 16;
-    highp uint d = uint(v.w) << 24;
-    return (a|b|c|d);
-}
-highp uint packSnorm4x8(mediump vec4 v) {
-    v = round(clamp(v, -1.0, 1.0) * 127.0);
-    highp uint a = uint((int(v.x) & 0xff));
-    highp uint b = uint((int(v.y) & 0xff)) <<  8;
-    highp uint c = uint((int(v.z) & 0xff)) << 16;
-    highp uint d = uint((int(v.w) & 0xff)) << 24;
-    return (a|b|c|d);
-}
-mediump vec4 unpackUnorm4x8(highp uint v) {
-    return vec4(float((v & 0x000000ffu)      ),
-                float((v & 0x0000ff00u) >>  8),
-                float((v & 0x00ff0000u) >> 16),
-                float((v & 0xff000000u) >> 24)) / 255.0;
-}
-mediump vec4 unpackSnorm4x8(highp uint v) {
-    int a = int(((v       ) & 0xffu) << 24u) >> 24 ;
-    int b = int(((v >>  8u) & 0xffu) << 24u) >> 24 ;
-    int c = int(((v >> 16u) & 0xffu) << 24u) >> 24 ;
-    int d = int(((v >> 24u) & 0xffu) << 24u) >> 24 ;
-    return clamp(vec4(float(a), float(b), float(c), float(d)) / 127.0, -1.0, 1.0);
-}
-)"sv;
-    }
-#endif // BACKEND_OPENGL_VERSION_GL
-
-#ifdef BACKEND_OPENGL_VERSION_GLES
-    if (!context.isES2() && !context.isAtLeastGLES<3, 1>()) {
-        return R"(
-
-highp uint packUnorm4x8(mediump vec4 v) {
-    v = round(clamp(v, 0.0, 1.0) * 255.0);
-    highp uint a = uint(v.x);
-    highp uint b = uint(v.y) <<  8;
-    highp uint c = uint(v.z) << 16;
-    highp uint d = uint(v.w) << 24;
-    return (a|b|c|d);
-}
-highp uint packSnorm4x8(mediump vec4 v) {
-    v = round(clamp(v, -1.0, 1.0) * 127.0);
-    highp uint a = uint((int(v.x) & 0xff));
-    highp uint b = uint((int(v.y) & 0xff)) <<  8;
-    highp uint c = uint((int(v.z) & 0xff)) << 16;
-    highp uint d = uint((int(v.w) & 0xff)) << 24;
-    return (a|b|c|d);
-}
-mediump vec4 unpackUnorm4x8(highp uint v) {
-    return vec4(float((v & 0x000000ffu)      ),
-                float((v & 0x0000ff00u) >>  8),
-                float((v & 0x00ff0000u) >> 16),
-                float((v & 0xff000000u) >> 24)) / 255.0;
-}
-mediump vec4 unpackSnorm4x8(highp uint v) {
-    int a = int(((v       ) & 0xffu) << 24u) >> 24 ;
-    int b = int(((v >>  8u) & 0xffu) << 24u) >> 24 ;
-    int c = int(((v >> 16u) & 0xffu) << 24u) >> 24 ;
-    int d = int(((v >> 24u) & 0xffu) << 24u) >> 24 ;
-    return clamp(vec4(float(a), float(b), float(c), float(d)) / 127.0, -1.0, 1.0);
-}
-)"sv;
-    }
-#endif // BACKEND_OPENGL_VERSION_GLES
-    return ""sv;
-}
-
-// split shader source code in three:
-// - the version line
-// - extensions
-// - everything else
-std::array<std::string_view, 3> ShaderCompilerService::splitShaderSource(std::string_view source) noexcept {
-    auto version_start = source.find("#version");
-    assert_invariant(version_start != std::string_view::npos);
-
-    auto version_eol = source.find('\n', version_start) + 1;
-    assert_invariant(version_eol != std::string_view::npos);
-
-    auto prolog_start = version_eol;
-    auto prolog_eol = source.rfind("\n#extension"); // last #extension line
-    if (prolog_eol == std::string_view::npos) {
-        prolog_eol = prolog_start;
-    } else {
-        prolog_eol = source.find('\n', prolog_eol + 1) + 1;
-    }
-    auto body_start = prolog_eol;
-
-    std::string_view const version = source.substr(version_start, version_eol - version_start);
-    std::string_view const prolog = source.substr(prolog_start, prolog_eol - prolog_start);
-    std::string_view const body = source.substr(body_start, source.length() - body_start);
-    return { version, prolog, body };
-}
-
 /*
 * Create a program from the given shader IDs and links it. This cannot fail because errors
 * are checked later. This always returns a valid GL program ID (which doesn't mean the
 * program itself is valid).
 */
-GLuint ShaderCompilerService::linkProgram(OpenGLContext& context,
-        std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders,
+/* static */ GLuint ShaderCompilerService::linkProgram(OpenGLContext& context,
+        shaders_t const& shaders,
        utils::FixedCapacityVector<std::pair<utils::CString, uint8_t>> const& attributes) noexcept {

    SYSTRACE_CALL();
@@ -913,7 +738,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 * Checks a program link status and logs errors and frees resources on failure.
 * Returns true on success.
 */
-bool ShaderCompilerService::checkProgramStatus(program_token_t const& token) noexcept {
+/* static */ bool ShaderCompilerService::checkProgramStatus(program_token_t const& token) noexcept {

    SYSTRACE_CALL();

@@ -948,20 +773,24 @@ bool ShaderCompilerService::checkProgramStatus(program_token_t const& token) noe
    return false;
 }

+// ------------------------------------------------------------------------------------------------
+
 UTILS_NOINLINE
-void logCompilationError(io::ostream& out, ShaderStage shaderType,
-        const char* name, GLuint shaderId,
-        UTILS_UNUSED_IN_RELEASE CString const& sourceCode) noexcept {
+/* static */ void logCompilationError(io::ostream& out, ShaderStage shaderType, const char* name,
+        GLuint shaderId, UTILS_UNUSED_IN_RELEASE CString const& sourceCode) noexcept {

    auto to_string = [](ShaderStage type) -> const char* {
        switch (type) {
-            case ShaderStage::VERTEX:   return "vertex";
-            case ShaderStage::FRAGMENT: return "fragment";
-            case ShaderStage::COMPUTE:  return "compute";
+            case ShaderStage::VERTEX:
+                return "vertex";
+            case ShaderStage::FRAGMENT:
+                return "fragment";
+            case ShaderStage::COMPUTE:
+                return "compute";
        }
    };

-    { // scope for the temporary string storage
+    {// scope for the temporary string storage
        GLint length = 0;
        glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &length);

@@ -969,8 +798,7 @@ void logCompilationError(io::ostream& out, ShaderStage shaderType,
        glGetShaderInfoLog(shaderId, length, nullptr, infoLog.data());

        out << "Compilation error in " << to_string(shaderType) << " shader \"" << name << "\":\n"
-            << "\"" << infoLog.c_str() << "\""
-            << io::endl;
+            << "\"" << infoLog.c_str() << "\"" << io::endl;
    }

 #ifndef NDEBUG
@@ -996,7 +824,7 @@ void logCompilationError(io::ostream& out, ShaderStage shaderType,
 }

 UTILS_NOINLINE
-void logProgramLinkError(io::ostream& out, char const* name, GLuint program) noexcept {
+/* static */ void logProgramLinkError(io::ostream& out, char const* name, GLuint program) noexcept {
    GLint length = 0;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);

@@ -1004,9 +832,204 @@ void logProgramLinkError(io::ostream& out, char const* name, GLuint program) noe
    glGetProgramInfoLog(program, length, nullptr, infoLog.data());

    out << "Link error in \"" << name << "\":\n"
-        << "\"" << infoLog.c_str() << "\""
-        << io::endl;
+        << "\"" << infoLog.c_str() << "\"" << io::endl;
 }

+// If usages of the Google-style line directive are present, remove them, as some
+// drivers don't allow the quotation marks. This source modification happens in-place.
+/* static */ void process_GOOGLE_cpp_style_line_directive(OpenGLContext& context, char* source,
+        size_t len) noexcept {
+    if (!context.ext.GOOGLE_cpp_style_line_directive) {
+        if (UTILS_UNLIKELY(requestsGoogleLineDirectivesExtension({ source, len }))) {
+            removeGoogleLineDirectives(source, len);// length is unaffected
+        }
+    }
+}
+
+// Look up the `source` to replace the number of eyes for multiview with the given number. This is
+// necessary for OpenGL because OpenGL relies on the number specified in shader files to determine
+// the number of views, which is assumed as a single digit, for multiview.
+// This source modification happens in-place.
+/* static */ void process_OVR_multiview2(OpenGLContext& context, int32_t eyeCount, char* source,
+        size_t len) noexcept {
+    // We don't use regular expression in favor of performance.
+    if (context.ext.OVR_multiview2) {
+        const std::string_view shader{ source, len };
+        const std::string_view layout = "layout";
+        const std::string_view num_views = "num_views";
+        size_t found = 0;
+        while (true) {
+            found = shader.find(layout, found);
+            if (found == std::string_view::npos) {
+                break;
+            }
+            found = shader.find_first_not_of(' ', found + layout.size());
+            if (found == std::string_view::npos || shader[found] != '(') {
+                continue;
+            }
+            found = shader.find_first_not_of(' ', found + 1);
+            if (found == std::string_view::npos) {
+                continue;
+            }
+            if (shader.compare(found, num_views.size(), num_views) != 0) {
+                continue;
+            }
+            found = shader.find_first_not_of(' ', found + num_views.size());
+            if (found == std::string_view::npos || shader[found] != '=') {
+                continue;
+            }
+            found = shader.find_first_not_of(' ', found + 1);
+            if (found == std::string_view::npos) {
+                continue;
+            }
+            // We assume the value should be one-digit number.
+            assert_invariant(eyeCount < 10);
+            assert_invariant(!::isdigit(source[found + 1]));
+            source[found] = '0' + eyeCount;
+            break;
+        }
+    }
+}
+
+// Tragically, OpenGL 4.1 doesn't support unpackHalf2x16 (appeared in 4.2) and
+// macOS doesn't support GL_ARB_shading_language_packing
+// Also GLES3.0 didn't have the full set of packing/unpacking functions
+/* static */ std::string_view process_ARB_shading_language_packing(
+        OpenGLContext& context) noexcept {
+    using namespace std::literals;
+#ifdef BACKEND_OPENGL_VERSION_GL
+    if (!context.isAtLeastGL<4, 2>() && !context.ext.ARB_shading_language_packing) {
+        return R"(
+
+// these don't handle denormals, NaNs or inf
+float u16tofp32(highp uint v) {
+    v <<= 16u;
+    highp uint s = v & 0x80000000u;
+    highp uint n = v & 0x7FFFFFFFu;
+    highp uint nz = (n == 0u) ? 0u : 0xFFFFFFFFu;
+    return uintBitsToFloat(s | ((((n >> 3u) + (0x70u << 23u))) & nz));
+}
+vec2 unpackHalf2x16(highp uint v) {
+    return vec2(u16tofp32(v&0xFFFFu), u16tofp32(v>>16u));
+}
+uint fp32tou16(float val) {
+    uint f32 = floatBitsToUint(val);
+    uint f16 = 0u;
+    uint sign = (f32 >> 16u) & 0x8000u;
+    int exponent = int((f32 >> 23u) & 0xFFu) - 127;
+    uint mantissa = f32 & 0x007FFFFFu;
+    if (exponent > 15) {
+        f16 = sign | (0x1Fu << 10u);
+    } else if (exponent > -15) {
+        exponent += 15;
+        mantissa >>= 13;
+        f16 = sign | uint(exponent << 10) | mantissa;
+    } else {
+        f16 = sign;
+    }
+    return f16;
+}
+highp uint packHalf2x16(vec2 v) {
+    highp uint x = fp32tou16(v.x);
+    highp uint y = fp32tou16(v.y);
+    return (y << 16u) | x;
+}
+highp uint packUnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, 0.0, 1.0) * 255.0);
+    highp uint a = uint(v.x);
+    highp uint b = uint(v.y) <<  8;
+    highp uint c = uint(v.z) << 16;
+    highp uint d = uint(v.w) << 24;
+    return (a|b|c|d);
+}
+highp uint packSnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, -1.0, 1.0) * 127.0);
+    highp uint a = uint((int(v.x) & 0xff));
+    highp uint b = uint((int(v.y) & 0xff)) <<  8;
+    highp uint c = uint((int(v.z) & 0xff)) << 16;
+    highp uint d = uint((int(v.w) & 0xff)) << 24;
+    return (a|b|c|d);
+}
+mediump vec4 unpackUnorm4x8(highp uint v) {
+    return vec4(float((v & 0x000000ffu)      ),
+                float((v & 0x0000ff00u) >>  8),
+                float((v & 0x00ff0000u) >> 16),
+                float((v & 0xff000000u) >> 24)) / 255.0;
+}
+mediump vec4 unpackSnorm4x8(highp uint v) {
+    int a = int(((v       ) & 0xffu) << 24u) >> 24 ;
+    int b = int(((v >>  8u) & 0xffu) << 24u) >> 24 ;
+    int c = int(((v >> 16u) & 0xffu) << 24u) >> 24 ;
+    int d = int(((v >> 24u) & 0xffu) << 24u) >> 24 ;
+    return clamp(vec4(float(a), float(b), float(c), float(d)) / 127.0, -1.0, 1.0);
+}
+)"sv;
+    }
+#endif// BACKEND_OPENGL_VERSION_GL
+
+#ifdef BACKEND_OPENGL_VERSION_GLES
+    if (!context.isES2() && !context.isAtLeastGLES<3, 1>()) {
+        return R"(
+
+highp uint packUnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, 0.0, 1.0) * 255.0);
+    highp uint a = uint(v.x);
+    highp uint b = uint(v.y) <<  8;
+    highp uint c = uint(v.z) << 16;
+    highp uint d = uint(v.w) << 24;
+    return (a|b|c|d);
+}
+highp uint packSnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, -1.0, 1.0) * 127.0);
+    highp uint a = uint((int(v.x) & 0xff));
+    highp uint b = uint((int(v.y) & 0xff)) <<  8;
+    highp uint c = uint((int(v.z) & 0xff)) << 16;
+    highp uint d = uint((int(v.w) & 0xff)) << 24;
+    return (a|b|c|d);
+}
+mediump vec4 unpackUnorm4x8(highp uint v) {
+    return vec4(float((v & 0x000000ffu)      ),
+                float((v & 0x0000ff00u) >>  8),
+                float((v & 0x00ff0000u) >> 16),
+                float((v & 0xff000000u) >> 24)) / 255.0;
+}
+mediump vec4 unpackSnorm4x8(highp uint v) {
+    int a = int(((v       ) & 0xffu) << 24u) >> 24 ;
+    int b = int(((v >>  8u) & 0xffu) << 24u) >> 24 ;
+    int c = int(((v >> 16u) & 0xffu) << 24u) >> 24 ;
+    int d = int(((v >> 24u) & 0xffu) << 24u) >> 24 ;
+    return clamp(vec4(float(a), float(b), float(c), float(d)) / 127.0, -1.0, 1.0);
+}
+)"sv;
+    }
+#endif// BACKEND_OPENGL_VERSION_GLES
+    return ""sv;
+}
+
+// split shader source code in three:
+// - the version line
+// - extensions
+// - everything else
+/* static */ std::array<std::string_view, 3> splitShaderSource(std::string_view source) noexcept {
+    auto version_start = source.find("#version");
+    assert_invariant(version_start != std::string_view::npos);
+
+    auto version_eol = source.find('\n', version_start) + 1;
+    assert_invariant(version_eol != std::string_view::npos);
+
+    auto prolog_start = version_eol;
+    auto prolog_eol = source.rfind("\n#extension");// last #extension line
+    if (prolog_eol == std::string_view::npos) {
+        prolog_eol = prolog_start;
+    } else {
+        prolog_eol = source.find('\n', prolog_eol + 1) + 1;
+    }
+    auto body_start = prolog_eol;
+
+    std::string_view const version = source.substr(version_start, version_eol - version_start);
+    std::string_view const prolog = source.substr(prolog_start, prolog_eol - prolog_start);
+    std::string_view const body = source.substr(body_start, source.length() - body_start);
+    return { version, prolog, body };
+}

 } // namespace filament::backend
--- a/filament/backend/src/opengl/ShaderCompilerService.h
+++ b/filament/backend/src/opengl/ShaderCompilerService.h
@@ -57,6 +57,8 @@ class ShaderCompilerService {

 public:
    using program_token_t = std::shared_ptr<OpenGLProgramToken>;
+    using shaders_t = std::array<GLuint, Program::SHADER_TYPE_COUNT>;
+    using shaders_source_t = std::array<utils::CString, Program::SHADER_TYPE_COUNT>;

    explicit ShaderCompilerService(OpenGLDriver& driver);

@@ -134,22 +136,9 @@ private:
            OpenGLContext& context,
            Program::ShaderSource shadersSource,
            utils::FixedCapacityVector<Program::SpecializationConstant> const& specializationConstants,
-            bool multiview,
-            std::array<GLuint, Program::SHADER_TYPE_COUNT>& outShaders,
-            std::array<utils::CString, Program::SHADER_TYPE_COUNT>& outShaderSourceCode) noexcept;
+            bool multiview, shaders_t& outShaders, shaders_source_t& outShaderSourceCode) noexcept;

-    static void process_GOOGLE_cpp_style_line_directive(OpenGLContext& context,
-            char* source, size_t len) noexcept;
-
-    static void process_OVR_multiview2(OpenGLContext& context, int32_t eyeCount,
-            char* source, size_t len) noexcept;
-
-    static std::string_view process_ARB_shading_language_packing(OpenGLContext& context) noexcept;
-
-    static std::array<std::string_view, 3> splitShaderSource(std::string_view source) noexcept;
-
-    static GLuint linkProgram(OpenGLContext& context,
-            std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders,
+    static GLuint linkProgram(OpenGLContext& context, shaders_t const& shaders,
            utils::FixedCapacityVector<std::pair<utils::CString, uint8_t>> const& attributes) noexcept;

    static bool checkProgramStatus(program_token_t const& token) noexcept;
--- a/filament/backend/src/ostream.cpp
+++ b/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
--- a/filament/backend/src/vulkan/VulkanDriver.cpp
+++ b/filament/backend/src/vulkan/VulkanDriver.cpp
@@ -327,7 +327,7 @@ void VulkanDriver::terminate() {

    mStagePool.terminate();
    mPipelineCache.terminate();
-    mFramebufferCache.reset();
+    mFramebufferCache.terminate();
    mSamplerCache.terminate();
    mDescriptorSetLayoutCache.terminate();
    mDescriptorSetCache.terminate();
@@ -1523,7 +1523,7 @@ void VulkanDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain>
    swapChain->acquire(resized);

    if (resized) {
-        mFramebufferCache.reset();
+        mFramebufferCache.resetFramebuffers();
    }

    if (UTILS_LIKELY(mDefaultRenderTarget)) {
--- a/filament/backend/src/vulkan/VulkanFboCache.cpp
+++ b/filament/backend/src/vulkan/VulkanFboCache.cpp
@@ -340,15 +340,21 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey const& config) noexcept
    return renderPass;
 }

-void VulkanFboCache::reset() noexcept {
-    for (auto pair : mFramebufferCache) {
+void VulkanFboCache::resetFramebuffers() noexcept {
+    for (const auto& pair: mFramebufferCache) {
        mRenderPassRefCount[pair.first.renderPass]--;
        vkDestroyFramebuffer(mDevice, pair.second.handle, VKALLOC);
    }
    mFramebufferCache.clear();
-    for (auto pair : mRenderPassCache) {
+}
+
+void VulkanFboCache::terminate() noexcept {
+    resetFramebuffers();
+
+    for (const auto& pair: mRenderPassCache) {
        vkDestroyRenderPass(mDevice, pair.second.handle, VKALLOC);
    }
+    mRenderPassRefCount.clear();
    mRenderPassCache.clear();
 }

--- a/filament/backend/src/vulkan/VulkanFboCache.h
+++ b/filament/backend/src/vulkan/VulkanFboCache.h
@@ -106,8 +106,11 @@ public:
    // Evicts old unused Vulkan objects. Call this once per frame.
    void gc() noexcept;

+    // Frees all Framebuffer objects. Call this every time a the swapchain is resized
+    void resetFramebuffers() noexcept;
+
    // Frees all Vulkan objects. Call this during shutdown before the device is destroyed.
-    void reset() noexcept;
+    void terminate() noexcept;

 private:
    VkDevice mDevice;
--- a/filament/backend/src/vulkan/platform/VulkanPlatformApple.mm
+++ b/filament/backend/src/vulkan/platform/VulkanPlatformApple.mm
@@ -24,28 +24,12 @@
 #include <bluevk/BlueVK.h>

 // Platform specific includes and defines
-#if defined(__APPLE__)
-    #include <Cocoa/Cocoa.h>
-    #import <Metal/Metal.h>
-    #import <QuartzCore/CAMetalLayer.h>
+#include <Cocoa/Cocoa.h>
+#import <Metal/Metal.h>
+#import <QuartzCore/CAMetalLayer.h>

-    #ifndef VK_MVK_macos_surface
-         #error VK_MVK_macos_surface is not defined
-    #endif
-#elif defined(FILAMENT_IOS)
-    // Metal is not available when building for the iOS simulator on Desktop.
-    #define METAL_AVAILABLE __has_include(<QuartzCore/CAMetalLayer.h>)
-    #if METAL_AVAILABLE
-        #import <Metal/Metal.h>
-        #import <QuartzCore/CAMetalLayer.h>
-    #endif
-
-    #ifndef VK_MVK_ios_surface
-        #error VK_MVK_ios_surface is not defined
-    #endif
-    #define METALVIEW_TAG 255
-#else
-    #error Not a supported Apple + Vulkan platform
+#ifndef VK_MVK_macos_surface
+    #error VK_MVK_macos_surface is not defined
 #endif

 using namespace bluevk;
@@ -54,11 +38,7 @@ namespace filament::backend {

 VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() {
    ExtensionSet const ret = {
-    #if defined(__APPLE__)
        VK_MVK_MACOS_SURFACE_EXTENSION_NAME,  // TODO: replace with VK_EXT_metal_surface
-    #elif defined(FILAMENT_IOS) && defined(METAL_AVAILABLE)
-        VK_MVK_IOS_SURFACE_EXTENSION_NAME,
-    #endif
    };
    return ret;
 }
@@ -90,36 +70,20 @@ VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
 VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
        VkInstance instance, uint64_t flags) noexcept {
    VkSurfaceKHR surface;
-    #if defined(__APPLE__)
-        NSView* nsview = (__bridge NSView*) nativeWindow;
-        FILAMENT_CHECK_POSTCONDITION(nsview) << "Unable to obtain Metal-backed NSView.";
+    NSView* nsview = (__bridge NSView*) nativeWindow;
+    FILAMENT_CHECK_POSTCONDITION(nsview) << "Unable to obtain Metal-backed NSView.";

-        // Create the VkSurface.
-        FILAMENT_CHECK_POSTCONDITION(vkCreateMacOSSurfaceMVK)
-                << "Unable to load vkCreateMacOSSurfaceMVK.";
-        VkMacOSSurfaceCreateInfoMVK createInfo = {};
-        createInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
-        createInfo.pView = (__bridge void*) nsview;
-        VkResult result = vkCreateMacOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
-                (VkSurfaceKHR*) &surface);
-        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                << "vkCreateMacOSSurfaceMVK. error=" << static_cast<int32_t>(result);
-#elif defined(FILAMENT_IOS) && defined(METAL_AVAILABLE)
-    CAMetalLayer* metalLayer = (CAMetalLayer*) nativeWindow;
    // Create the VkSurface.
-    FILAMENT_CHECK_POSTCONDITION(vkCreateIOSSurfaceMVK)
-            << "Unable to load vkCreateIOSSurfaceMVK function.";
-    VkIOSSurfaceCreateInfoMVK createInfo = {};
-    createInfo.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
-    createInfo.pNext = NULL;
-    createInfo.flags = 0;
-    createInfo.pView = metalLayer;
-    VkResult result = vkCreateIOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
+    FILAMENT_CHECK_POSTCONDITION(vkCreateMacOSSurfaceMVK)
+            << "Unable to load vkCreateMacOSSurfaceMVK.";
+    VkMacOSSurfaceCreateInfoMVK createInfo = {};
+    createInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+    createInfo.pView = (__bridge void*) nsview;
+    VkResult result = vkCreateMacOSSurfaceMVK((VkInstance) instance, &createInfo, VKALLOC,
            (VkSurfaceKHR*) &surface);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkCreateIOSSurfaceMVK failed. error=" << static_cast<int32_t>(result);
-#endif
-        return std::make_tuple(surface, VkExtent2D{});
+            << "vkCreateMacOSSurfaceMVK. error=" << static_cast<int32_t>(result);
+    return std::make_tuple(surface, VkExtent2D{});
 }

 } // namespace filament::backend
--- a/filament/backend/src/webgpu/WebGPUDriver.cpp
+++ b/filament/backend/src/webgpu/WebGPUDriver.cpp
@@ -16,6 +16,7 @@

 #include "webgpu/WebGPUDriver.h"

+#include "WebGPUSwapChain.h"
 #include "webgpu/WebGPUConstants.h"
 #include <backend/platforms/WebGPUPlatform.h>

@@ -227,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
 }

@@ -286,15 +295,27 @@ void WebGPUDriver::finish(int) {
 }

 void WebGPUDriver::destroyRenderPrimitive(Handle<HwRenderPrimitive> rph) {
+   if (rph) {
+        destructHandle<WGPURenderPrimitive>(rph);
+    }
 }

 void WebGPUDriver::destroyVertexBufferInfo(Handle<HwVertexBufferInfo> vbih) {
+   if (vbih) {
+        destructHandle<WGPUVertexBufferInfo>(vbih);
+    }
 }

 void WebGPUDriver::destroyVertexBuffer(Handle<HwVertexBuffer> vbh) {
+    if (vbh) {
+        destructHandle<WGPUVertexBuffer>(vbh);
+    }
 }

 void WebGPUDriver::destroyIndexBuffer(Handle<HwIndexBuffer> ibh) {
+    if (ibh) {
+        destructHandle<WGPUIndexBuffer>(ibh);
+    }
 }

 void WebGPUDriver::destroyBufferObject(Handle<HwBufferObject> boh) {
@@ -310,13 +331,10 @@ void WebGPUDriver::destroyRenderTarget(Handle<HwRenderTarget> rth) {
 }

 void WebGPUDriver::destroySwapChain(Handle<HwSwapChain> sch) {
+    if (sch) {
+        destructHandle<WebGPUSwapChain>(sch);
+    }
    mSwapChain = nullptr;
-    // TODO:  use webgpu handle allocator from
-    //        https://github.com/google/filament/pull/8566
-//    if (sch) {
-//        HwSwapChain* hwSwapChain = handleCast<HwSwapChain*>(sch);
-//        destruct(sch, hwSwapChain);
-//    }
 }

 void WebGPUDriver::destroyStream(Handle<HwStream> sh) {
@@ -326,16 +344,16 @@ void WebGPUDriver::destroyTimerQuery(Handle<HwTimerQuery> tqh) {
 }

 void WebGPUDriver::destroyDescriptorSetLayout(Handle<HwDescriptorSetLayout> tqh) {
+    if (tqh) {
+        destructHandle<WebGPUDescriptorSetLayout>(tqh);
+    }
 }

 void WebGPUDriver::destroyDescriptorSet(Handle<HwDescriptorSet> tqh) {
 }

 Handle<HwSwapChain> WebGPUDriver::createSwapChainS() noexcept {
-    // TODO:  use webgpu handle allocator from.
-    //        https://github.com/google/filament/pull/8566
-    // return allocAndConstructHandle<HwSwapChain>();
-    return Handle<HwSwapChain>((Handle<HwSwapChain>::HandleId) mNextFakeHandle++);
+    return allocHandle<WebGPUSwapChain>();
 }

 Handle<HwSwapChain> WebGPUDriver::createSwapChainHeadlessS() noexcept {
@@ -387,7 +405,7 @@ Handle<HwDescriptorSet> WebGPUDriver::createDescriptorSetS() noexcept {
 }

 Handle<HwRenderPrimitive> WebGPUDriver::createRenderPrimitiveS() noexcept {
-    return Handle<HwRenderPrimitive>((Handle<HwRenderPrimitive>::HandleId) mNextFakeHandle++);
+    return allocHandle<WGPURenderPrimitive>();
 }

 Handle<HwVertexBufferInfo> WebGPUDriver::createVertexBufferInfoS() noexcept {
@@ -403,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 {
@@ -420,21 +437,15 @@ Handle<HwTexture> WebGPUDriver::createTextureExternalImagePlaneS() noexcept {
 }

 void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
-    // TODO:  use webgpu handle allocator from.
-    //        https://github.com/google/filament/pull/8566
-    // HwSwapChain* hwSwapChain = handleCast<HwSwapChain*>(sch);
+    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();
-    mSwapChain = std::make_unique<WebGPUSwapChain>(std::move(surface), mAdapter, mDevice, flags);
+    wgpu::Extent2D surfaceSize = mPlatform.getSurfaceExtent(mNativeWindow);
+    mSwapChain = constructHandle<WebGPUSwapChain>(sch, std::move(surface), surfaceSize, mAdapter,
+            mDevice, flags);
+    assert_invariant(mSwapChain);
    FWGPU_LOGW << "WebGPU support is still essentially a no-op at this point in development (only "
                  "background components have been instantiated/selected, such as surface/screen, "
                  "graphics device/GPU, etc.), thus nothing is being drawn to the screen."
@@ -447,9 +458,6 @@ void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
                  "rebuilding Filament with that flag, e.g. ./build.sh -x "
               << FWGPU_PRINT_SYSTEM << " ..." << utils::io::endl;
 #endif
-    // TODO:  use webgpu handle allocator from.
-    //        https://github.com/google/filament/pull/8566
-    // hwSwapChain->swapChain = mSwapChain.get();
 }

 void WebGPUDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch, uint32_t width,
@@ -514,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) {}
@@ -705,10 +715,6 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
    };
    mCommandEncoder = mDevice.CreateCommandEncoder(&commandEncoderDescriptor);
    assert_invariant(mCommandEncoder);
-
-    mTextureView = mSwapChain->getNextSurfaceTextureView(params.viewport.width, params.viewport.height);
-    assert_invariant(mTextureView);
-
    // TODO: Remove this code once WebGPU pipeline is implemented
    static float red = 1.0f;
    if (red - 0.01 > 0) {
@@ -716,7 +722,7 @@ void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
    } else {
        red = 1.0f;
    }
-
+    assert_invariant(mTextureView);
    wgpu::RenderPassColorAttachment renderPassColorAttachment = {
        .view = mTextureView,
        // TODO: remove this code once WebGPU Pipeline is implemented with render targets, pipeline and buffers.
@@ -752,6 +758,14 @@ void WebGPUDriver::nextSubpass(int) {
 }

 void WebGPUDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain> readSch) {
+    ASSERT_PRECONDITION_NON_FATAL(drawSch == readSch,
+            "WebGPU driver does not support distinct draw/read swap chains.");
+    auto* swapChain = handleCast<WebGPUSwapChain>(drawSch);
+    mSwapChain = swapChain;
+    assert_invariant(mSwapChain);
+    wgpu::Extent2D surfaceSize = mPlatform.getSurfaceExtent(mNativeWindow);
+    mTextureView = mSwapChain->getCurrentSurfaceTextureView(surfaceSize);
+    assert_invariant(mTextureView);
 }

 void WebGPUDriver::commit(Handle<HwSwapChain> sch) {
@@ -759,6 +773,7 @@ void WebGPUDriver::commit(Handle<HwSwapChain> sch) {
    mQueue.Submit(1, &mCommandBuffer);
    mCommandBuffer = nullptr;
    mTextureView = nullptr;
+    assert_invariant(mSwapChain);
    mSwapChain->present();
 }

--- a/filament/backend/src/webgpu/WebGPUDriver.h
+++ b/filament/backend/src/webgpu/WebGPUDriver.h
@@ -18,7 +18,6 @@
 #define TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H

 #include "WebGPUHandles.h"
-#include "webgpu/WebGPUSwapChain.h"
 #include <backend/platforms/WebGPUPlatform.h>

 #include "DriverBase.h"
@@ -40,6 +39,8 @@

 namespace filament::backend {

+class WebGPUSwapChain;
+
 /**
 * WebGPU backend (driver) implementation
 */
@@ -61,8 +62,8 @@ private:
    wgpu::Adapter mAdapter = nullptr;
    wgpu::Device mDevice = nullptr;
    wgpu::Queue mQueue = nullptr;
-    // TODO consider moving to handle allocator when ready
-    std::unique_ptr<WebGPUSwapChain> mSwapChain = nullptr;
+    void* mNativeWindow = nullptr;
+    WebGPUSwapChain* mSwapChain = nullptr;
    uint64_t mNextFakeHandle = 1;
    wgpu::CommandEncoder mCommandEncoder = nullptr;
    wgpu::TextureView mTextureView = nullptr;
@@ -102,11 +103,17 @@ private:
    D* constructHandle(Handle<B>& handle, ARGS&& ... args) noexcept {
        return mHandleAllocator.construct<D>(handle, std::forward<ARGS>(args)...);
    }
+
    template<typename D, typename B>
    D* handleCast(Handle<B> handle) noexcept {
        return mHandleAllocator.handle_cast<D*>(handle);
    }

+    template<typename D, typename B>
+    void destructHandle(Handle<B>& handle) noexcept {
+        auto* p = mHandleAllocator.handle_cast<D*>(handle);
+        return mHandleAllocator.deallocate(handle, p);
+    }
 };

 }// namespace filament::backend
--- a/filament/backend/src/webgpu/WebGPUHandles.cpp
+++ b/filament/backend/src/webgpu/WebGPUHandles.cpp
@@ -16,13 +16,42 @@

 #include "WebGPUHandles.h"

+#include <utility>
+
+namespace {
+
+wgpu::Buffer createIndexBuffer(wgpu::Device const& device, uint8_t elementSize, uint32_t indexCount) {
+    wgpu::BufferDescriptor descriptor{ .label = "index_buffer",
+        .usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Index,
+        .size = elementSize * indexCount,
+        .mappedAtCreation = false };
+    return device.CreateBuffer(&descriptor);
+}
+} // namespace
+
 namespace filament::backend {

-WGPUVertexBuffer::WGPUVertexBuffer(uint32_t vextexCount, uint32_t bufferCount,
-        Handle<WGPUVertexBufferInfo> vbih)
-    : HwVertexBuffer(vextexCount),
-      vbih(vbih),
-      buffers(MAX_VERTEX_BUFFER_COUNT) {}
+
+WGPUIndexBuffer::WGPUIndexBuffer(wgpu::Device const& device, uint8_t elementSize,
+        uint32_t indexCount)
+    : buffer(createIndexBuffer(device, elementSize, indexCount)) {}
+
+
+WGPUVertexBuffer::WGPUVertexBuffer(wgpu::Device const &device, uint32_t vextexCount, uint32_t bufferCount,
+                                   Handle<WGPUVertexBufferInfo> vbih)
+        : HwVertexBuffer(vextexCount),
+          vbih(vbih),
+          buffers(bufferCount) {
+    wgpu::BufferDescriptor descriptor {
+            .usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Vertex,
+            .size = vextexCount * bufferCount,
+            .mappedAtCreation = false };
+
+    for (uint32_t i = 0; i < bufferCount; ++i) {
+        descriptor.label = ("vertex_buffer_" + std::to_string(i)).c_str();
+        buffers[i] = device.CreateBuffer(&descriptor);
+    }
+}

 // TODO: Empty function is a place holder for verxtex buffer updates and should be
 // updated for that purpose.
@@ -31,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
--- a/filament/backend/src/webgpu/WebGPUHandles.h
+++ b/filament/backend/src/webgpu/WebGPUHandles.h
@@ -42,20 +42,19 @@ struct WGPUVertexBufferInfo : public HwVertexBufferInfo {
    AttributeArray attributes;
 };

-// TODO: Currently WGPUVertexBuffer is not used by WebGPU for useful task.
-// Update the struct when used by WebGPU driver.
 struct WGPUVertexBuffer : public HwVertexBuffer {
-    WGPUVertexBuffer(uint32_t vextexCount, uint32_t bufferCount, Handle<WGPUVertexBufferInfo> vbih);
-    void setBuffer(WGPUBufferObject* bufferObject, uint32_t index);
+    WGPUVertexBuffer(wgpu::Device const &device, uint32_t vextexCount, uint32_t bufferCount,
+                     Handle<WGPUVertexBufferInfo> vbih);
+
+    void setBuffer(WGPUBufferObject *bufferObject, uint32_t index);

    Handle<WGPUVertexBufferInfo> vbih;
    utils::FixedCapacityVector<wgpu::Buffer> buffers;
 };

-// TODO: Currently WGPUIndexBuffer is not used by WebGPU for useful task.
-// Update the struct when used by WebGPU driver.
 struct WGPUIndexBuffer : public HwIndexBuffer {
-    WGPUIndexBuffer(BufferUsage usage, uint8_t elementSize, uint32_t indexCount);
+    WGPUIndexBuffer(wgpu::Device const &device, uint8_t elementSize,
+                    uint32_t indexCount);

    wgpu::Buffer buffer;
 };
@@ -68,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.
@@ -81,6 +92,16 @@ struct WGPUTexture : public HwTexture {
    wgpu::Texture texture = nullptr;
 };

+struct WGPURenderPrimitive : public HwRenderPrimitive {
+    WGPURenderPrimitive();
+
+    void setBuffers(WGPUVertexBufferInfo const* const vbi,
+            WGPUVertexBuffer* vertexBuffer, WGPUIndexBuffer* indexBuffer);
+
+    WGPUVertexBuffer* vertexBuffer = nullptr;
+    WGPUIndexBuffer* indexBuffer = nullptr;
+};
+
 // TODO: Currently WGPURenderTarget is not used by WebGPU for useful task.
 // Update the struct when used by WebGPU driver.
 struct WGPURenderTarget : public HwRenderTarget {
--- a/filament/backend/src/webgpu/WebGPUSwapChain.cpp
+++ b/filament/backend/src/webgpu/WebGPUSwapChain.cpp
@@ -191,9 +191,12 @@ wgpu::CompositeAlphaMode selectAlphaMode(size_t availableAlphaModesCount,
 }

 void initConfig(wgpu::SurfaceConfiguration& config, wgpu::Device const& device,
-        wgpu::SurfaceCapabilities const& capabilities, bool useSRGBColorSpace) {
+        wgpu::SurfaceCapabilities const& capabilities, wgpu::Extent2D const& surfaceSize,
+        bool useSRGBColorSpace) {
    config.device = device;
    config.usage = wgpu::TextureUsage::RenderAttachment;
+    config.width = surfaceSize.width;
+    config.height = surfaceSize.height;
    config.format =
            selectColorFormat(capabilities.formatCount, capabilities.formats, useSRGBColorSpace);
    config.presentMode =
@@ -205,8 +208,8 @@ void initConfig(wgpu::SurfaceConfiguration& config, wgpu::Device const& device,

 namespace filament::backend {

-WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Adapter& adapter,
-        wgpu::Device& device, uint64_t flags)
+WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const& surfaceSize,
+        wgpu::Adapter& adapter, wgpu::Device& device, uint64_t flags)
    : mSurface(surface) {
    wgpu::SurfaceCapabilities capabilities = {};
    if (!mSurface.GetCapabilities(adapter, &capabilities)) {
@@ -217,43 +220,42 @@ WebGPUSwapChain::WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Adapter& adapter
 #endif
    }
    const bool useSRGBColorSpace = (flags & SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0;
-    initConfig(mConfig, device, capabilities, useSRGBColorSpace);
+    initConfig(mConfig, device, capabilities, surfaceSize, useSRGBColorSpace);
+    mSurface.Configure(&mConfig);
 }

 WebGPUSwapChain::~WebGPUSwapChain() {
-    if (mConfigured) {
-        mSurface.Unconfigure();
-        mConfigured = false;
-    }
+    mSurface.Unconfigure();
 }

-void WebGPUSwapChain::getCurrentTexture(uint32_t width, uint32_t height, wgpu::SurfaceTexture* texture) {
-    if (width < 1 || height < 1) {
-        PANIC_LOG("WebGPUSwapChain::GetCurrentTexture: Invalid width and/or height requested.");
-        return;
-    }
-    if (mConfig.width != width || mConfig.height != height || !mConfigured) {
-        mConfig.width = width;
-        mConfig.height = height;
+void WebGPUSwapChain::setExtent(wgpu::Extent2D const& currentSurfaceSize) {
+    FILAMENT_CHECK_POSTCONDITION(currentSurfaceSize.width > 0 || currentSurfaceSize.height > 0)
+            << "WebGPUSwapChain::setExtent: Invalid width " << currentSurfaceSize.width
+            << " and/or height " << currentSurfaceSize.height << " requested.";
+    if (mConfig.width != currentSurfaceSize.width || mConfig.height != currentSurfaceSize.height) {
+        mConfig.width = currentSurfaceSize.width;
+        mConfig.height = currentSurfaceSize.height;
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
        printSurfaceConfiguration(mConfig);
 #endif
+        FWGPU_LOGD << "Resizing to width " << mConfig.width << " height " << mConfig.height
+                   << utils::io::endl;
+        // TODO we may need to ensure no surface texture is flight when we do this. some
+        //      synchronization may be necessary
        mSurface.Configure(&mConfig);
-        mConfigured = true;
    }
-
-    mSurface.GetCurrentTexture(texture);
 }

-wgpu::TextureView WebGPUSwapChain::getNextSurfaceTextureView(uint32_t width, uint32_t height) {
+wgpu::TextureView WebGPUSwapChain::getCurrentSurfaceTextureView(
+        wgpu::Extent2D const& currentSurfaceSize) {
+    setExtent(currentSurfaceSize);
    wgpu::SurfaceTexture surfaceTexture;
-    getCurrentTexture(width, height, &surfaceTexture);
+    mSurface.GetCurrentTexture(&surfaceTexture);
    if (surfaceTexture.status != wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal) {
        return nullptr;
    }
-
    // Create a view for this surface texture
-    //TODO: review these initiliazations as webgpu pipeline gets mature
+    // TODO: review these initiliazations as webgpu pipeline gets mature
    wgpu::TextureViewDescriptor textureViewDescriptor = {
        .label = "texture_view",
        .format = surfaceTexture.texture.GetFormat(),
--- a/filament/backend/src/webgpu/WebGPUSwapChain.h
+++ b/filament/backend/src/webgpu/WebGPUSwapChain.h
@@ -19,26 +19,28 @@

 #include <webgpu/webgpu_cpp.h>

+#include "DriverBase.h"
 #include <backend/Platform.h>

 #include <cstdint>

 namespace filament::backend {

-class WebGPUSwapChain : public Platform::SwapChain {
+class WebGPUSwapChain final : public Platform::SwapChain, HwSwapChain {
 public:
-    WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Adapter& adapter, wgpu::Device& device,
-            uint64_t flags);
+    WebGPUSwapChain(wgpu::Surface&& surface, wgpu::Extent2D const& surfaceSize,
+            wgpu::Adapter& adapter, wgpu::Device& device, uint64_t flags);
    ~WebGPUSwapChain();

-    wgpu::TextureView getNextSurfaceTextureView(uint32_t width, uint32_t height);
+    wgpu::TextureView getCurrentSurfaceTextureView(wgpu::Extent2D const&);
+
    void present();

 private:
-    void getCurrentTexture(uint32_t width, uint32_t height, wgpu::SurfaceTexture*);
+    void setExtent(wgpu::Extent2D const&);
+
    wgpu::Surface mSurface = {};
    wgpu::SurfaceConfiguration mConfig = {};
-    bool mConfigured = false;
 };

 } // namespace filament::backend
--- a/filament/backend/src/webgpu/platform/WebGPUPlatformAndroid.cpp
+++ b/filament/backend/src/webgpu/platform/WebGPUPlatformAndroid.cpp
@@ -18,6 +18,7 @@

 #include <utils/Panic.h>

+#include <android/native_window.h>
 #include <webgpu/webgpu_cpp.h>

 #include <cstdint>
@@ -28,6 +29,14 @@

 namespace filament::backend {

+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    ANativeWindow* window = static_cast<ANativeWindow*>(nativeWindow);
+    return wgpu::Extent2D{
+        .width = static_cast<uint32_t>(ANativeWindow_getWidth(window)),
+        .height = static_cast<uint32_t>(ANativeWindow_getHeight(window))
+    };
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
    wgpu::SurfaceSourceAndroidNativeWindow surfaceSourceAndroidWindow{};
    surfaceSourceAndroidWindow.window = nativeWindow;
--- a/filament/backend/src/webgpu/platform/WebGPUPlatformApple.mm
+++ b/filament/backend/src/webgpu/platform/WebGPUPlatformApple.mm
@@ -33,6 +33,15 @@

 namespace filament::backend {

+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    // Both IOS and MacOS expects CAMetalLayer.
+    CAMetalLayer* metalLayer = (__bridge CAMetalLayer*) nativeWindow;
+    return wgpu::Extent2D{
+        .width = static_cast<uint32_t>(metalLayer.drawableSize.width),
+        .height = static_cast<uint32_t>(metalLayer.drawableSize.height)
+    };
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
    wgpu::Surface surface = nullptr;
    // Both IOS and MacOS expects CAMetalLayer.
--- a/filament/backend/src/webgpu/platform/WebGPUPlatformLinux.cpp
+++ b/filament/backend/src/webgpu/platform/WebGPUPlatformLinux.cpp
@@ -79,6 +79,74 @@

 namespace filament::backend {

+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    auto surfaceExtent = wgpu::Extent2D{};
+#if defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
+    wl* ptrval = reinterpret_cast<wl*>(nativeWindow);
+    surfaceExtent.width = ptrval->width;
+    surfaceExtent.height = ptrval->height;
+    FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+            << "Unable to get window size for Linux Wayland-backed surface.";
+#elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
+    if (g_x11.library == nullptr) {
+        g_x11.library = dlopen(LIBRARY_X11, RTLD_LOCAL | RTLD_NOW);
+        FILAMENT_CHECK_PRECONDITION(g_x11.library) << "Unable to open X11 library.";
+        #if defined(FILAMENT_SUPPORTS_XCB)
+            g_x11.xcbConnect = (XCB_CONNECT) dlsym(g_x11.library, "xcb_connect");
+            int screen = 0;
+            g_x11.connection = g_x11.xcbConnect(nullptr, &screen);
+        #endif
+        #if defined(FILAMENT_SUPPORTS_XLIB)
+            g_x11.openDisplay = (X11_OPEN_DISPLAY) dlsym(g_x11.library, "XOpenDisplay");
+            g_x11.display = g_x11.openDisplay(NULL);
+            FILAMENT_CHECK_PRECONDITION(g_x11.display) << "Unable to open X11 display.";
+        #endif
+    }
+    #if defined(FILAMENT_SUPPORTS_XCB) || defined(FILAMENT_SUPPORTS_XLIB)
+        bool useXcb = false;
+    #endif
+    #if defined(FILAMENT_SUPPORTS_XCB)
+        #if defined(FILAMENT_SUPPORTS_XLIB)
+            useXcb = (SWAP_CHAIN_CONFIG_ENABLE_XCB) != 0;
+        #else
+            useXcb = true;
+        #endif
+        if (useXcb) {
+            const xcb_setup_t* setup = xcb_get_setup(g_x11.connection);
+            xcb_screen_iterator_t screen_iter = xcb_setup_roots_iterator(setup);
+            xcb_screen_t* screen = screen_iter.data;
+            surfaceExtent.width = static_cast<uint32_t>(screen->width_in_pixels);
+            surfaceExtent.height = static_cast<uint32_t>(screen->height_in_pixels);
+            FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+                    << "Unable to get window surface size for Linux (or FreeBSD) "
+                       "XCB-backed surface.";
+        }
+    #endif
+    #if defined(FILAMENT_SUPPORTS_XLIB)
+        if (!useXcb) {
+            int screenNumber = DefaultScreen(g_x11.display);
+            Screen* screen = ScreenOfDisplay(g_x11.display, screenNumber);
+            surfaceExtent.width = static_cast<uint32_t>(WidthOfScreen(screen));
+            surfaceExtent.height = static_cast<uint32_t>(HeightOfScreen(screen));
+            FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+                    << "Unable to get window surface size for Linux (or FreeBSD) "
+                       "XLib-backed surface.";
+        }
+    #endif
+    FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+            << "Cannot get window surface size for X11 surface for Linux (or FreeBSD) OS "
+               "(not built with support for XCB or XLIB?)";
+#elif defined(__linux__)
+    FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+            << "Cannot get window surface size for Linux (or FreeBSD) OS "
+               "(not built with support for Wayland or X11?)";
+#else
+    FILAMENT_CHECK_POSTCONDITION(surfaceExtent.width != 0 && surfaceExtent.height != 0)
+            << "Not a supported (Linux) OS + WebGPU platform";
+#endif
+    return surfaceExtent;
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t flags) {
    wgpu::Surface surface = nullptr;
 #if defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
--- a/filament/backend/src/webgpu/platform/WebGPUPlatformWindows.cpp
+++ b/filament/backend/src/webgpu/platform/WebGPUPlatformWindows.cpp
@@ -30,6 +30,16 @@

 namespace filament::backend {

+wgpu::Extent2D WebGPUPlatform::getSurfaceExtent(void* nativeWindow) const {
+    HWND window = static_cast<HWND>(nativeWindow);
+    RECT windowRect;
+    GetWindowRect(window, &windowRect);
+    return wgpu::Extent2D{
+        .width = static_cast<uint32_t>(windowRect.right - windowRect.left),
+        .height = static_cast<uint32_t>(windowRect.bottom - windowRect.top)
+    };
+}
+
 wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
    // TODO verify this is necessary for Dawn implementation as well:
    // On (at least) NVIDIA drivers, the Vulkan implementation (specifically the call to
--- a/filament/backend/test/Shader.cpp
+++ b/filament/backend/test/Shader.cpp
@@ -56,7 +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 }));
+            api.createDescriptorSetLayout(DescriptorSetLayout{ "kLayouts", kLayouts }));
 }

 filament::backend::DescriptorSetHandle Shader::createDescriptorSet(DriverApi& api) const {
--- a/filament/src/details/MaterialInstance.cpp
+++ b/filament/src/details/MaterialInstance.cpp
@@ -269,12 +269,14 @@ void FMaterialInstance::setParameterImpl(std::string_view const name,
    if (texture && texture->textureHandleCanMutate()) {
        mTextureParameters[binding] = { texture, sampler.getSamplerParams() };
    } else {
+        // Ensure to erase the binding from mTextureParameters since it will not
+        // be updated.
+        mTextureParameters.erase(binding);
+
        Handle<HwTexture> handle{};
        if (texture) {
            handle = texture->getHwHandleForSampling();
            assert_invariant(handle == texture->getHwHandle());
-        } else {
-            mTextureParameters.erase(binding);
        }
        mDescriptorSet.setSampler(binding, handle, sampler.getSamplerParams());
    }
--- a/libs/filabridge/src/DescriptorSets.cpp
+++ b/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         },
Author	SHA1	Message	Date
bridgewaterrobbie	3f04387651	Fix test	2025-04-15 17:44:40 -04:00
bridgewaterrobbie	7b13964363	Test adding a label to descriptor sets for WebGPU	2025-04-15 17:29:49 -04:00
bridgewaterrobbie	44b6c63fed	Handle WebGPUDescriptorSetLayout creation	2025-04-15 13:51:14 -04:00
Syed Idris Shah	6908f1b8af	Move adapter and device creation to the begining	2025-04-15 13:35:50 -04:00
Andy Hovingh	ad1b36d2b3	fix: DEBUG_COMMAND_STREAM could not be compiled as true due to lack of BufferObjectStreamDescriptor insertion operator	2025-04-14 16:50:53 -05:00
Sungun Park	315c2c273f	Cleanup shader compiler (#8613 ) There's no functional difference.	2025-04-14 18:27:52 +00:00
Juan Caldas	005d835dbe	wgpu: Add Vertex and Index Buffer (#8616 ) * implement vertex and index buffers	2025-04-14 10:36:14 -04:00
Jeremy Nelson	cade94ab2c	webgpu: surface window size for swapchain/surface	2025-04-11 17:30:08 -05:00
Max Rebuschatis	5cd2f5626c	Fix bug in FMaterialInstance::setParameterImpl() where mTextureParameters was not updated when a texture was reassigned if !texture->textureHandleCanMutate(). This could cause a crash in FMaterialInstance::commit() since the old texture binding was still in mTextureParameters but may have been destroyed.	2025-04-11 12:51:46 -07:00
Jeremy Nelson	94bbcbf1c3	wgpu: combine swapchain classes	2025-04-10 09:20:12 -05:00
Andy Hovingh	52c998d2b6	webgpu: use handle allocator with swapchain	2025-04-10 07:37:53 -05:00
rafadevai	527d831c15	VK: Reuse renderpasses after swapchain resize (#8601 ) When a swapchain is resized the FBO cache gets resets which includes the framebuffer and renderpass objects. This causes pipelines to be recreated instead of being reused from the previous frames, causing stalls. In the case of renderpasses there's no need to clear these objects, since the state of the renderpass is the same, only their refcount should be adjusted, fixing the issue mentioned above.	2025-04-10 07:08:20 +00:00
Syed Idris Shah	2790f2e64c	Cleanup the dead code from VulkanPlatformApple.mm __APPLE__ is defined for both macos and ios platform. #elif code will never be excuted.	2025-04-09 14:16:11 -04:00