tmp - testing edge cases

Webgpu: Move Filter mode check (#8804 )
BUGS=[397432947]
2025-06-02 20:02:21 -07:00 · 2025-06-02 14:10:33 +00:00 · 2025-06-01 23:27:55 -07:00 · 2025-05-30 17:53:04 -04:00 · 2025-05-30 13:52:44 -07:00 · 2025-05-30 13:52:01 -07:00
384 changed files with 23950 additions and 18720 deletions
@@ -57,7 +57,7 @@ SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
 SpaceBeforeRangeBasedForLoopColon: false
 SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 0
+SpacesBeforeTrailingComments: 1
 SpacesInAngles: false
 SpacesInCStyleCastParentheses: false
 SpacesInContainerLiterals: false
@@ -26,4 +26,4 @@ jobs:
          path: out/filament-release-darwin.tgz
      - name: Check public headers
        run: |
-          build/common/check-headers.sh out/release/filament/include
+          test/check-headers/test.sh out/release/filament/include
@@ -131,7 +131,7 @@ jobs:
      - name: Prerequisites
        id: prereqs
        run: |
-          bash test/utils/get_mesa.sh
+          bash build/common/get-mesa.sh
          pip install tifffile numpy
      - name: Run Test
        run: bash test/renderdiff/test.sh
@@ -153,8 +153,8 @@ jobs:
      - name: Run test
        run: ./out/cmake-debug/libs/filamat/test_filamat --gtest_filter=MaterialCompiler.Wgsl*

-  code-correctness:
-    name: code-correctness
+  test-code-correctness:
+    name: test-code-correctness
    runs-on: 'macos-14-xlarge'
    steps:
      - uses: actions/checkout@v4.1.6
@@ -163,6 +163,9 @@ jobs:
          mv out/filamat-android-release.aar out/filamat-${TAG}-android.aar
          mv out/gltfio-android-release.aar out/gltfio-${TAG}-android.aar
          mv out/filament-utils-android-release.aar out/filament-utils-${TAG}-android.aar
+          cd out/android-release/filament
+          tar -czf ../../filament-${TAG}-android-native.tgz .
+          cd ../../..
      - name: Sign sample-gltf-viewer
        run: |
          echo "${APK_KEYSTORE_BASE64}" > filament.jks.base64
@@ -184,7 +187,7 @@ jobs:
          script: |
            const upload = require('./build/common/upload-release-assets');
            const { TAG } = process.env;
-            const globber = await glob.create(['out/*.aar', 'out/*.apk'].join('\n'));
+            const globber = await glob.create(['out/*.aar', 'out/*.apk', 'out/*.tgz'].join('\n'));
            await upload({ github, context }, await globber.glob(), TAG);

  build-ios:
@@ -97,6 +97,10 @@ Make sure you've installed the following dependencies:
 - `libxcomposite-dev` (`libXcomposite-devel` on Fedora)
 - `libxxf86vm-dev` (`libXxf86vm-devel` on Fedora)

+```shell
+sudo apt install clang-14 libglu1-mesa-dev libc++-14-dev libc++abi-14-dev ninja-build libxi-dev libxcomposite-dev libxxf86vm-dev -y
+```
+
 After dependencies have been installed, we highly recommend using the [easy build](#easy-build)
 script.

@@ -49,6 +49,10 @@ option(FILAMENT_SUPPORTS_OSMESA "Enable OSMesa (headless GL context) for Filamen

 option(FILAMENT_ENABLE_FGVIEWER "Enable the frame graph viewer" OFF)

+# This is to disable GTAO for the short-term while we investigate a way to better manage size increases.
+# On the regular filament build (where size is of less concern), we enable GTAO by default.
+option(FILAMENT_DISABLE_GTAO "Disable GTAO" OFF)
+
 set(FILAMENT_NDK_VERSION "" CACHE STRING
    "Android NDK version or version prefix to be used when building for Android."
 )
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.59.5'
+    implementation 'com.google.android.filament:filament-android:1.60.1'
 }
 ```

@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:

 ```shell
-pod 'Filament', '~> 1.59.5'
+pod 'Filament', '~> 1.60.1'
 ```

 ## Documentation
@@ -7,10 +7,21 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).

+## v1.61.0
+
+- materials: sampler now export their type in the material binary [⚠️ **New Material Version**]
+- samples/texturedquad.cpp now has CLI to select backend api
+- samples/hellopbr.cpp CLI now allows for selecting webgpu
+
+## v1.60.1
+
+
 ## v1.60.0

 - materials: remove dependence on per-view descset layout from filamat. [⚠️ **New Material Version**]
- `ColorGrading::Builder::toneMapper` now takes a `shared_ptr<ToneMapper>`
+- matc non-functional change: Update GLSL postprocessor to
+  isolate calls to SPVRemap from calls to SPIRV-Cross.
+

 ## v1.59.5

@@ -18,7 +18,6 @@

 #include <filament/ColorGrading.h>
 #include <filament/ToneMapper.h>
-#include <memory>

 #include <math/vec3.h>
 #include <math/vec4.h>
@@ -68,9 +67,8 @@ extern "C" JNIEXPORT void JNICALL
 Java_com_google_android_filament_ColorGrading_nBuilderToneMapper(JNIEnv*, jclass,
        jlong nativeBuilder, jlong toneMapper_) {
    ColorGrading::Builder* builder = (ColorGrading::Builder*) nativeBuilder;
-    ToneMapper* toneMapper = reinterpret_cast<ToneMapper*>(toneMapper_);
-    std::shared_ptr<ToneMapper> toneMapperCopy(toneMapper->clone());
-    builder->toneMapper(toneMapperCopy);
+    const ToneMapper* toneMapper = (const ToneMapper*) toneMapper_;
+    builder->toneMapper(toneMapper);
 }

 #pragma clang diagnostic push
@@ -214,9 +214,9 @@ public class ColorGrading {
         *
         * The default tone mapping operator is {@link ToneMapper.ACESLegacy}.
         *
-         * The copy of the specified tone mapper is set to this builder. It is safe to delete
-         * the original tone mapper object while the copied one is held by the built ColorGrading
-         * object.
+         * The specified tone mapper must have a lifecycle that exceeds the lifetime of
+         * this builder. Since the build(Engine&) method is synchronous, it is safe to
+         * delete the tone mapper object after that finishes executing.
         *
         * @param toneMapper The tone mapping operator to apply to the HDR color buffer
         *
@@ -1801,6 +1801,22 @@ public class View {
     * @see setAmbientOcclusionOptions()
     */
    public static class AmbientOcclusionOptions {
+        public enum AmbientOcclusionType {
+            /**
+             * use Scalable Ambient Occlusion
+             */
+            SAO,
+            /**
+             * use Ground Truth-Based Ambient Occlusion
+             */
+            GTAO,
+        }
+
+        /**
+         * Type of ambient occlusion algorithm.
+         */
+        @NonNull
+        public AmbientOcclusionOptions.AmbientOcclusionType aoType = AmbientOcclusionOptions.AmbientOcclusionType.SAO;
        /**
         * Ambient Occlusion radius in meters, between 0 and ~10.
         */
@@ -1810,7 +1826,8 @@ public class View {
         */
        public float power = 1.0f;
        /**
-         * Self-occlusion bias in meters. Use to avoid self-occlusion. Between 0 and a few mm.
+         * Self-occlusion bias in meters. Use to avoid self-occlusion.
+         * Between 0 and a few mm. No effect when aoType set to GTAO
         */
        public float bias = 0.0005f;
        /**
@@ -1826,12 +1843,12 @@ public class View {
         */
        public float bilateralThreshold = 0.05f;
        /**
-         * affects # of samples used for AO.
+         * affects # of samples used for AO and params for filtering
         */
        @NonNull
        public QualityLevel quality = QualityLevel.LOW;
        /**
-         * affects AO smoothness
+         * affects AO smoothness. Recommend setting to HIGH when aoType set to GTAO.
         */
        @NonNull
        public QualityLevel lowPassFilter = QualityLevel.MEDIUM;
@@ -1849,7 +1866,7 @@ public class View {
         */
        public boolean bentNormals = false;
        /**
-         * min angle in radian to consider
+         * min angle in radian to consider. No effect when aoType set to GTAO.
         */
        public float minHorizonAngleRad = 0.0f;
        /**
@@ -1904,6 +1921,19 @@ public class View {
         */
        public boolean ssctEnabled = false;

+        /**
+         * Ground Truth-base Ambient Occlusion (GTAO) options
+         */
+        public int gtaoSampleSliceCount = 4;
+        /**
+         * Ground Truth-base Ambient Occlusion (GTAO) options
+         */
+        public int gtaoSampleStepsPerSlice = 3;
+        /**
+         * Ground Truth-base Ambient Occlusion (GTAO) options
+         */
+        public float gtaoThicknessHeuristic = 0.004f;
+
    }

    /**
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.59.5
+VERSION_NAME=1.60.1

 POM_DESCRIPTION=Real-time physically based rendering engine for Android.

@@ -151,7 +151,7 @@ function print_fgviewer_help {
 }

 # Unless explicitly specified, NDK version will be selected as highest available version within same major release chain
-FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION:-$(cat `dirname $0`/build/common/versions | grep GITHUB_NDK_VERSION | cut -f 1 -d ".")}
+FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION:-$(cat `dirname $0`/build/common/versions | grep GITHUB_NDK_VERSION | sed s/GITHUB_NDK_VERSION=//g | cut -f 1 -d ".")}

 # Requirements
 CMAKE_MAJOR=3
@@ -463,16 +463,6 @@ function ensure_android_build {
        echo "Error: Android NDK side-by-side version ${FILAMENT_NDK_VERSION} or compatible must be installed, exiting"
        exit 1
    fi
-
-    local cmake_version=$(cmake --version)
-    if [[ "${cmake_version}" =~ ([0-9]+)\.([0-9]+)\.[0-9]+ ]]; then
-        if [[ "${BASH_REMATCH[1]}" -lt "${CMAKE_MAJOR}" ]] || \
-           [[ "${BASH_REMATCH[2]}" -lt "${CMAKE_MINOR}" ]]; then
-            echo "Error: cmake version ${CMAKE_MAJOR}.${CMAKE_MINOR}+ is required," \
-                 "${BASH_REMATCH[1]}.${BASH_REMATCH[2]} installed, exiting"
-            exit 1
-        fi
-    fi
 }

 function build_android {
@@ -1023,8 +1023,12 @@ samplerCubemap         | Cubemap texture
 [Table [materialParamsTypes]: Material parameter types]

 Samplers
-:     Sampler types can also specify a `format` which can be either `int` or `float` (defaults to
-      `float`).
+:     Sampler types can specify additional options:
+
+      - `format`: either `int` or `float` (defaults to `float`).
+      - `stages`: array of strings containing the list of shader stages this
+        sampler can be accessed from. Each entry must be either `vertex` or
+        `fragment` (defaults to both).

 Arrays
 :     A parameter can define an array of values by appending `[size]` after the type name, where
@@ -19,6 +19,7 @@
    - [Vulkan](./notes/vulkan_debugging.md)
    - [SPIR-V](./notes/spirv_debugging.md)
    - [Running with ASAN and UBSAN](./notes/asan_ubsan.md)
+    - [Using Instruments on macOS](./notes/instruments.md)
  - [Libraries](./notes/libs.md)
    - [bluegl](./dup/bluegl.md)
    - [bluevk](./dup/bluevk.md)
@@ -0,0 +1,36 @@
+# Using Instruments on macOS
+
+When running a binary under Instruments on macOS, you may run into the following issue when
+launching or attaching to an executable:
+
+```
+Failed to gain authorization
+Recovery Suggestion: Target binary needs to be debuggable and signed with 'get-task-allow'
+```
+
+This is a security precaution; the solution is to code sign the binary with the
+`com.apple.security.get-task-allow` entitlement.
+
+1. Create an `entitlements.plist` file with the following contents:
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.get-task-allow</key>
+    <true/>
+</dict>
+</plist>
+```
+
+2. Run the following command:
+
+```
+codesign -s - --entitlements entitlements.plist <binary>
+```
+
+Replace `<binary>` with the name of the binary, for example: `out/cmake-debug/samples/gltf_viewer`.
+
+Afterwards, you should be able to successfully launch and attach to the executable using
+Instruments.
@@ -265,6 +265,13 @@ set(MATERIAL_SRCS
        src/materials/vsmMipmap.mat
 )

+if (NOT FILAMENT_DISABLE_GTAO)
+    list(APPEND MATERIAL_SRCS
+        src/materials/ssao/gtao.mat
+        src/materials/ssao/gtaoBentNormals.mat
+    )
+endif()
+
 set(MATERIAL_FL0_SRCS
        src/materials/defaultMaterial.mat
        src/materials/skybox.mat
@@ -314,12 +321,14 @@ if (FILAMENT_FORCE_PROFILING_MODE)
    add_definitions(-DFILAMENT_FORCE_PROFILING_MODE)
 endif()

+if (FILAMENT_DISABLE_GTAO)
+    add_definitions(-DFILAMENT_DISABLE_GTAO)
+endif()
+
 # ==================================================================================================
 # Definitions
 # ==================================================================================================

-# "2" corresponds to SYSTRACE_TAG_FILEMENT (See: utils/Systrace.h)
-add_definitions(-DSYSTRACE_TAG=2)
 add_definitions(-DFILAMENT_DFG_LUT_SIZE=${DFG_LUT_SIZE})
 add_definitions(
    -DFILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB=${FILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB}
@@ -463,6 +472,30 @@ add_custom_command(
        APPEND
 )

+if (NOT FILAMENT_DISABLE_GTAO)
+    add_custom_command(
+            OUTPUT "${MATERIAL_DIR}/gtao.filamat"
+            DEPENDS src/materials/ssao/ssaoUtils.fs
+            DEPENDS src/materials/ssao/ssct.fs
+            DEPENDS src/materials/utils/depthUtils.fs
+            DEPENDS src/materials/utils/geometry.fs
+            DEPENDS src/materials/ssao/gtaoImpl.fs
+            DEPENDS src/materials/ssao/ssctImpl.fs
+            APPEND
+    )
+
+    add_custom_command(
+            OUTPUT "${MATERIAL_DIR}/gtaoBentNormals.filamat"
+            DEPENDS src/materials/ssao/ssaoUtils.fs
+            DEPENDS src/materials/ssao/ssct.fs
+            DEPENDS src/materials/utils/depthUtils.fs
+            DEPENDS src/materials/utils/geometry.fs
+            DEPENDS src/materials/ssao/gtaoImpl.fs
+            DEPENDS src/materials/ssao/ssctImpl.fs
+            APPEND
+    )
+endif()
+
 add_custom_command(
        OUTPUT "${MATERIAL_DIR}/bilateralBlur.filamat"
        DEPENDS src/materials/ssao/ssaoUtils.fs
@@ -261,6 +261,7 @@ if (FILAMENT_SUPPORTS_WEBGPU)
            src/webgpu/WebGPUHandles.h
            src/webgpu/WebGPUPipelineCreation.cpp
            src/webgpu/WebGPUPipelineCreation.h
+            src/webgpu/WebGPUStrings.h
            src/webgpu/WebGPUSwapChain.cpp
            src/webgpu/WebGPUSwapChain.h
            src/webgpu/WGPUProgram.cpp
@@ -290,12 +291,6 @@ if (ANDROID)
    list(APPEND SRCS src/BackendUtilsAndroid.cpp)
 endif()

-# ==================================================================================================
-# Definitions
-# ==================================================================================================
-# "2" corresponds to SYSTRACE_TAG_FILEMENT (See: utils/Systrace.h)
-add_definitions(-DSYSTRACE_TAG=2 )
-
 # ==================================================================================================
 # Includes & target definition
 # ==================================================================================================
@@ -20,10 +20,15 @@
 #define TNT_FILAMENT_BACKEND_BUFFERDESCRIPTOR_H

 #include <utils/compiler.h>
-#include <utils/ostream.h>
+
+#include <utility>

 #include <stddef.h>

+namespace utils::io {
+class ostream;
+} // namespace utils::io
+
 namespace filament::backend {

 class CallbackHandler;
@@ -89,8 +94,8 @@ public:
     * @param callback  A callback used to release the CPU buffer from this BufferDescriptor
     * @param user      An opaque user pointer passed to the callback function when it's called
     */
-    BufferDescriptor(void const* buffer, size_t size,
-            Callback callback = nullptr, void* user = nullptr) noexcept
+    BufferDescriptor(void const* buffer, size_t const size,
+            Callback const callback = nullptr, void* user = nullptr) noexcept
                : buffer(const_cast<void*>(buffer)), size(size), mCallback(callback), mUser(user) {
    }

@@ -98,11 +103,12 @@ public:
     * Creates a BufferDescriptor that references a CPU memory-buffer
     * @param buffer    Memory address of the CPU buffer to reference
     * @param size      Size of the CPU buffer in bytes
+     * @param handler   A custom handler for the callback
     * @param callback  A callback used to release the CPU buffer from this BufferDescriptor
     * @param user      An opaque user pointer passed to the callback function when it's called
     */
-    BufferDescriptor(void const* buffer, size_t size,
-            CallbackHandler* handler, Callback callback, void* user = nullptr) noexcept
+    BufferDescriptor(void const* buffer, size_t const size,
+            CallbackHandler* handler, Callback const callback, void* user = nullptr) noexcept
                : buffer(const_cast<void*>(buffer)), size(size),
                mCallback(callback), mUser(user), mHandler(handler) {
    }
@@ -116,8 +122,9 @@ public:
     *
     * @param buffer    Memory address of the CPU buffer to reference
     * @param size      Size of the CPU buffer in bytes
+     * @param data      A pointer to the data
     * @param handler   Handler to use to dispatch the callback, or nullptr for the default handler
-     * @return          a new BufferDescriptor
+     * @return          A new BufferDescriptor
     */
    template<typename T, void(T::*method)(void const*, size_t)>
    static BufferDescriptor make(void const* buffer, size_t size, T* data,
@@ -164,7 +171,7 @@ public:
     * @param callback  The new callback function
     * @param user      An opaque user pointer passed to the callbeck function when it's called
     */
-    void setCallback(Callback callback, void* user = nullptr) noexcept {
+    void setCallback(Callback const callback, void* user = nullptr) noexcept {
        this->mCallback = callback;
        this->mUser = user;
        this->mHandler = nullptr;
@@ -176,7 +183,7 @@ public:
     * @param callback  The new callback function
     * @param user      An opaque user pointer passed to the callbeck function when it's called
     */
-    void setCallback(CallbackHandler* handler, Callback callback, void* user = nullptr) noexcept {
+    void setCallback(CallbackHandler* handler, Callback const callback, void* user = nullptr) noexcept {
        mCallback = callback;
        mUser = user;
        mHandler = handler;
@@ -19,8 +19,6 @@

 #include <backend/DriverApiForward.h>

-#include <utils/ostream.h>
-
 #include <initializer_list>
 #include <memory>

@@ -28,6 +26,10 @@
 #include <stdint.h>


+namespace utils::io {
+class ostream;
+} // namespace utils::io
+
 namespace filament::backend {

 void* allocateFromCommandStream(DriverApi& driver, size_t size, size_t alignment) noexcept;
@@ -25,22 +25,26 @@
 #include <backend/PresentCallable.h>

 #include <utils/BitmaskEnum.h>
+#include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Invocable.h>
-#include <utils/compiler.h>
-#include <utils/debug.h>
-#include <utils/ostream.h>
 #include <utils/StaticString.h>
+#include <utils/debug.h>

 #include <math/vec4.h>

 #include <array>
 #include <type_traits>
 #include <variant>
+#include <string_view>

 #include <stddef.h>
 #include <stdint.h>

+namespace utils::io {
+class ostream;
+} // namespace utils::io
+
 /**
 * Types and enums used by filament's driver.
 *
@@ -159,7 +163,7 @@ enum class TimerQueryResult : int8_t {
    AVAILABLE = 1,  // result is available
 };

-static constexpr const char* backendToString(Backend backend) {
+constexpr std::string_view to_string(Backend const backend) noexcept {
    switch (backend) {
        case Backend::NOOP:
            return "Noop";
@@ -171,9 +175,10 @@ static constexpr const char* backendToString(Backend backend) {
            return "Metal";
        case Backend::WEBGPU:
            return "WebGPU";
-        default:
-            return "Unknown";
+        case Backend::DEFAULT:
+            return "Default";
    }
+    return "Unknown";
 }

 /**
@@ -190,7 +195,7 @@ enum class ShaderLanguage {
    WGSL = 5,
 };

-static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) {
+constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) noexcept {
    switch (shaderLanguage) {
        case ShaderLanguage::ESSL1:
            return "ESSL 1.0";
@@ -205,6 +210,7 @@ static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguag
        case ShaderLanguage::WGSL:
            return "WGSL";
    }
+    return "UNKNOWN";
 }

 enum class ShaderStage : uint8_t {
@@ -222,7 +228,7 @@ enum class ShaderStageFlags : uint8_t {
    ALL_SHADER_STAGE_FLAGS = VERTEX | FRAGMENT | COMPUTE
 };

-static inline constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept {
+constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept {
    switch (type) {
        case ShaderStage::VERTEX:
            return bool(uint8_t(flags) & uint8_t(ShaderStageFlags::VERTEX));
@@ -233,14 +239,239 @@ static inline constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage t
    }
 }

-enum class DescriptorType : uint8_t {
-    UNIFORM_BUFFER,
-    SHADER_STORAGE_BUFFER,
-    SAMPLER,
-    INPUT_ATTACHMENT,
-    SAMPLER_EXTERNAL
+enum class TextureType : uint8_t {
+    FLOAT,
+    INT,
+    UINT,
+    DEPTH,
+    STENCIL,
+    DEPTH_STENCIL
 };

+constexpr std::string_view to_string(TextureType type) noexcept {
+    switch (type) {
+        case TextureType::FLOAT:            return "FLOAT";
+        case TextureType::INT:              return "INT";
+        case TextureType::UINT:             return "UINT";
+        case TextureType::DEPTH:            return "DEPTH";
+        case TextureType::STENCIL:          return "STENCIL";
+        case TextureType::DEPTH_STENCIL:    return "DEPTH_STENCIL";
+    }
+    return "UNKNOWN";
+}
+
+ enum class DescriptorType : uint8_t {
+     SAMPLER_2D_FLOAT,
+     SAMPLER_2D_INT,
+     SAMPLER_2D_UINT,
+     SAMPLER_2D_DEPTH,
+
+     SAMPLER_2D_ARRAY_FLOAT,
+     SAMPLER_2D_ARRAY_INT,
+     SAMPLER_2D_ARRAY_UINT,
+     SAMPLER_2D_ARRAY_DEPTH,
+
+     SAMPLER_CUBE_FLOAT,
+     SAMPLER_CUBE_INT,
+     SAMPLER_CUBE_UINT,
+     SAMPLER_CUBE_DEPTH,
+
+     SAMPLER_CUBE_ARRAY_FLOAT,
+     SAMPLER_CUBE_ARRAY_INT,
+     SAMPLER_CUBE_ARRAY_UINT,
+     SAMPLER_CUBE_ARRAY_DEPTH,
+
+     SAMPLER_3D_FLOAT,
+     SAMPLER_3D_INT,
+     SAMPLER_3D_UINT,
+
+     SAMPLER_2D_MS_FLOAT,
+     SAMPLER_2D_MS_INT,
+     SAMPLER_2D_MS_UINT,
+
+     SAMPLER_2D_MS_ARRAY_FLOAT,
+     SAMPLER_2D_MS_ARRAY_INT,
+     SAMPLER_2D_MS_ARRAY_UINT,
+
+     SAMPLER_EXTERNAL,
+     UNIFORM_BUFFER,
+     SHADER_STORAGE_BUFFER,
+     INPUT_ATTACHMENT,
+ };
+
+constexpr bool isDepthDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_2D_DEPTH:
+        case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
+        case DescriptorType::SAMPLER_CUBE_DEPTH:
+        case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr bool isFloatDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_2D_FLOAT:
+        case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
+        case DescriptorType::SAMPLER_CUBE_FLOAT:
+        case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
+        case DescriptorType::SAMPLER_3D_FLOAT:
+        case DescriptorType::SAMPLER_2D_MS_FLOAT:
+        case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr bool isIntDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_2D_INT:
+        case DescriptorType::SAMPLER_2D_ARRAY_INT:
+        case DescriptorType::SAMPLER_CUBE_INT:
+        case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
+        case DescriptorType::SAMPLER_3D_INT:
+        case DescriptorType::SAMPLER_2D_MS_INT:
+        case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr bool isUnsignedIntDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_2D_UINT:
+        case DescriptorType::SAMPLER_2D_ARRAY_UINT:
+        case DescriptorType::SAMPLER_CUBE_UINT:
+        case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
+        case DescriptorType::SAMPLER_3D_UINT:
+        case DescriptorType::SAMPLER_2D_MS_UINT:
+        case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr bool is3dTypeDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_3D_FLOAT:
+        case DescriptorType::SAMPLER_3D_INT:
+        case DescriptorType::SAMPLER_3D_UINT:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr bool is2dTypeDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_2D_FLOAT:
+        case DescriptorType::SAMPLER_2D_INT:
+        case DescriptorType::SAMPLER_2D_UINT:
+        case DescriptorType::SAMPLER_2D_DEPTH:
+        case DescriptorType::SAMPLER_2D_MS_FLOAT:
+        case DescriptorType::SAMPLER_2D_MS_INT:
+        case DescriptorType::SAMPLER_2D_MS_UINT:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr bool is2dArrayTypeDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
+        case DescriptorType::SAMPLER_2D_ARRAY_INT:
+        case DescriptorType::SAMPLER_2D_ARRAY_UINT:
+        case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
+        case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
+        case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
+        case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr bool isCubeTypeDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_CUBE_FLOAT:
+        case DescriptorType::SAMPLER_CUBE_INT:
+        case DescriptorType::SAMPLER_CUBE_UINT:
+        case DescriptorType::SAMPLER_CUBE_DEPTH:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr bool isCubeArrayTypeDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
+        case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
+        case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
+        case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr bool isMultiSampledTypeDescriptor(DescriptorType const type) noexcept {
+    switch (type) {
+        case DescriptorType::SAMPLER_2D_MS_FLOAT:
+        case DescriptorType::SAMPLER_2D_MS_INT:
+        case DescriptorType::SAMPLER_2D_MS_UINT:
+        case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
+        case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
+        case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+            return true;
+        default: ;
+    }
+    return false;
+}
+
+constexpr std::string_view to_string(DescriptorType type) noexcept {
+    #define DESCRIPTOR_TYPE_CASE(TYPE)  case DescriptorType::TYPE: return #TYPE;
+    switch (type) {
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_FLOAT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_INT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_UINT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_DEPTH)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_FLOAT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_INT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_UINT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_DEPTH)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_FLOAT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_INT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_UINT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_DEPTH)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_FLOAT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_INT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_UINT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_DEPTH)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_3D_FLOAT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_3D_INT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_3D_UINT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_FLOAT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_INT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_UINT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_ARRAY_FLOAT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_ARRAY_INT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_ARRAY_UINT)
+        DESCRIPTOR_TYPE_CASE(SAMPLER_EXTERNAL)
+        DESCRIPTOR_TYPE_CASE(UNIFORM_BUFFER)
+        DESCRIPTOR_TYPE_CASE(SHADER_STORAGE_BUFFER)
+        DESCRIPTOR_TYPE_CASE(INPUT_ATTACHMENT)
+    }
+    return "UNKNOWN";
+    #undef DESCRIPTOR_TYPE_CASE
+}
+
 enum class DescriptorFlags : uint8_t {
    NONE = 0x00,
    DYNAMIC_OFFSET = 0x01
@@ -251,6 +482,13 @@ using descriptor_set_t = uint8_t;
 using descriptor_binding_t = uint8_t;

 struct DescriptorSetLayoutBinding {
+    static bool isSampler(DescriptorType type) noexcept {
+        return int(type) <= int(DescriptorType::SAMPLER_EXTERNAL);
+    }
+    static bool isBuffer(DescriptorType type) noexcept {
+        return type == DescriptorType::UNIFORM_BUFFER ||
+               type == DescriptorType::SHADER_STORAGE_BUFFER;
+    }
    DescriptorType type;
    ShaderStageFlags stageFlags;
    descriptor_binding_t binding;
@@ -261,7 +499,7 @@ struct DescriptorSetLayoutBinding {
    //  no uninitialized padding bytes.
    //    uint8_t externalSamplerDataIndex = EXTERNAL_SAMPLER_DATA_INDEX_UNUSED;

-    friend inline bool operator==(DescriptorSetLayoutBinding const& lhs,
+    friend bool operator==(DescriptorSetLayoutBinding const& lhs,
            DescriptorSetLayoutBinding const& rhs) noexcept {
        return lhs.type == rhs.type &&
               lhs.flags == rhs.flags &&
@@ -294,7 +532,7 @@ enum class TargetBufferFlags : uint32_t {
    ALL = COLOR_ALL | DEPTH | STENCIL       //!< Color, depth and stencil buffer selected.
 };

-inline constexpr TargetBufferFlags getTargetBufferFlagsAt(size_t index) noexcept {
+constexpr TargetBufferFlags getTargetBufferFlagsAt(size_t index) noexcept {
    if (index == 0u) return TargetBufferFlags::COLOR0;
    if (index == 1u) return TargetBufferFlags::COLOR1;
    if (index == 2u) return TargetBufferFlags::COLOR2;
@@ -451,6 +689,24 @@ enum class SamplerType : uint8_t {
    SAMPLER_CUBEMAP_ARRAY,  //!< Cube map array texture (feature level 2)
 };

+constexpr std::string_view to_string(SamplerType const type) noexcept {
+    switch (type) {
+        case SamplerType::SAMPLER_2D:
+            return "SAMPLER_2D";
+        case SamplerType::SAMPLER_2D_ARRAY:
+            return "SAMPLER_2D_ARRAY";
+        case SamplerType::SAMPLER_CUBEMAP:
+            return "SAMPLER_CUBEMAP";
+        case SamplerType::SAMPLER_EXTERNAL:
+            return "SAMPLER_EXTERNAL";
+        case SamplerType::SAMPLER_3D:
+            return "SAMPLER_3D";
+        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
+            return "SAMPLER_CUBEMAP_ARRAY";
+    }
+    return "Unknown";
+}
+
 //! Subpass type
 enum class SubpassType : uint8_t {
    SUBPASS_INPUT
@@ -464,6 +720,20 @@ enum class SamplerFormat : uint8_t {
    SHADOW = 3      //!< shadow sampler (PCF)
 };

+constexpr std::string_view to_string(SamplerFormat const format) noexcept {
+    switch (format) {
+        case SamplerFormat::INT:
+            return "INT";
+        case SamplerFormat::UINT:
+            return "UINT";
+        case SamplerFormat::FLOAT:
+            return "FLOAT";
+        case SamplerFormat::SHADOW:
+            return "SHADOW";
+    }
+    return "Unknown";
+}
+
 /**
 * Supported element types
 */
@@ -503,6 +773,15 @@ enum class BufferObjectBinding : uint8_t {
    SHADER_STORAGE
 };

+constexpr std::string_view to_string(BufferObjectBinding type) noexcept {
+    switch (type) {
+        case BufferObjectBinding::VERTEX:           return "VERTEX";
+        case BufferObjectBinding::UNIFORM:          return "UNIFORM";
+        case BufferObjectBinding::SHADER_STORAGE:   return "SHADER_STORAGE";
+    }
+    return "UNKNOWN";
+}
+
 //! Face culling Mode
 enum class CullingMode : uint8_t {
    NONE,               //!< No culling, front and back faces are visible
@@ -764,6 +1043,8 @@ enum class TextureFormat : uint16_t {
    SRGB_ALPHA_BPTC_UNORM,  // BC7 sRGB
 };

+TextureType getTextureType(TextureFormat format) noexcept;
+
 //! Bitmask describing the intended Texture Usage
 enum class TextureUsage : uint16_t {
    NONE                = 0x0000,
@@ -791,7 +1072,7 @@ enum class TextureSwizzle : uint8_t {
 };

 //! returns whether this format a depth format
-static constexpr bool isDepthFormat(TextureFormat format) noexcept {
+constexpr bool isDepthFormat(TextureFormat format) noexcept {
    switch (format) {
        case TextureFormat::DEPTH32F:
        case TextureFormat::DEPTH24:
@@ -804,7 +1085,7 @@ static constexpr bool isDepthFormat(TextureFormat format) noexcept {
    }
 }

-static constexpr bool isStencilFormat(TextureFormat format) noexcept {
+constexpr bool isStencilFormat(TextureFormat format) noexcept {
    switch (format) {
        case TextureFormat::STENCIL8:
        case TextureFormat::DEPTH24_STENCIL8:
@@ -815,7 +1096,7 @@ static constexpr bool isStencilFormat(TextureFormat format) noexcept {
    }
 }

-inline constexpr bool isColorFormat(TextureFormat format) noexcept {
+constexpr bool isColorFormat(TextureFormat format) noexcept {
    switch (format) {
        // Standard color formats
        case TextureFormat::R8:
@@ -842,7 +1123,7 @@ inline constexpr bool isColorFormat(TextureFormat format) noexcept {
    return false;
 }

-static constexpr bool isUnsignedIntFormat(TextureFormat format) {
+constexpr bool isUnsignedIntFormat(TextureFormat format) {
    switch (format) {
        case TextureFormat::R8UI:
        case TextureFormat::R16UI:
@@ -863,7 +1144,7 @@ static constexpr bool isUnsignedIntFormat(TextureFormat format) {
    }
 }

-static constexpr bool isSignedIntFormat(TextureFormat format) {
+constexpr bool isSignedIntFormat(TextureFormat format) {
    switch (format) {
        case TextureFormat::R8I:
        case TextureFormat::R16I:
@@ -885,35 +1166,35 @@ static constexpr bool isSignedIntFormat(TextureFormat format) {
 }

 //! returns whether this format is a compressed format
-static constexpr bool isCompressedFormat(TextureFormat format) noexcept {
+constexpr bool isCompressedFormat(TextureFormat format) noexcept {
    return format >= TextureFormat::EAC_R11;
 }

 //! returns whether this format is an ETC2 compressed format
-static constexpr bool isETC2Compression(TextureFormat format) noexcept {
+constexpr bool isETC2Compression(TextureFormat format) noexcept {
    return format >= TextureFormat::EAC_R11 && format <= TextureFormat::ETC2_EAC_SRGBA8;
 }

 //! returns whether this format is an S3TC compressed format
-static constexpr bool isS3TCCompression(TextureFormat format) noexcept {
+constexpr bool isS3TCCompression(TextureFormat format) noexcept {
    return format >= TextureFormat::DXT1_RGB && format <= TextureFormat::DXT5_SRGBA;
 }

-static constexpr bool isS3TCSRGBCompression(TextureFormat format) noexcept {
+constexpr bool isS3TCSRGBCompression(TextureFormat format) noexcept {
    return format >= TextureFormat::DXT1_SRGB && format <= TextureFormat::DXT5_SRGBA;
 }

 //! returns whether this format is an RGTC compressed format
-static constexpr bool isRGTCCompression(TextureFormat format) noexcept {
+constexpr bool isRGTCCompression(TextureFormat format) noexcept {
    return format >= TextureFormat::RED_RGTC1 && format <= TextureFormat::SIGNED_RED_GREEN_RGTC2;
 }

 //! returns whether this format is an BPTC compressed format
-static constexpr bool isBPTCCompression(TextureFormat format) noexcept {
+constexpr bool isBPTCCompression(TextureFormat format) noexcept {
    return format >= TextureFormat::RGB_BPTC_SIGNED_FLOAT && format <= TextureFormat::SRGB_ALPHA_BPTC_UNORM;
 }

-static constexpr bool isASTCCompression(TextureFormat format) noexcept {
+constexpr bool isASTCCompression(TextureFormat format) noexcept {
    return format >= TextureFormat::RGBA_ASTC_4x4 && format <= TextureFormat::SRGB8_ALPHA8_ASTC_12x12;
 }

@@ -1034,19 +1315,23 @@ struct SamplerParams {             // NOLINT
            assert_invariant(lhs.padding2 == 0);
            auto* pLhs = reinterpret_cast<uint32_t const*>(reinterpret_cast<char const*>(&lhs));
            auto* pRhs = reinterpret_cast<uint32_t const*>(reinterpret_cast<char const*>(&rhs));
-            return *pLhs == *pRhs;
+            return *pLhs < *pRhs;
        }
    };

+    bool isFiltered() const noexcept {
+        return filterMag != SamplerMagFilter::NEAREST || filterMin != SamplerMinFilter::NEAREST;
+    }
+
 private:
-    friend inline bool operator == (SamplerParams lhs, SamplerParams rhs) noexcept {
-        return SamplerParams::EqualTo{}(lhs, rhs);
+    friend bool operator == (SamplerParams lhs, SamplerParams rhs) noexcept {
+        return EqualTo{}(lhs, rhs);
    }
-    friend inline bool operator != (SamplerParams lhs, SamplerParams rhs) noexcept {
-        return  !SamplerParams::EqualTo{}(lhs, rhs);
+    friend bool operator != (SamplerParams lhs, SamplerParams rhs) noexcept {
+        return  !EqualTo{}(lhs, rhs);
    }
-    friend inline bool operator < (SamplerParams lhs, SamplerParams rhs) noexcept {
-        return SamplerParams::LessThan{}(lhs, rhs);
+    friend bool operator < (SamplerParams lhs, SamplerParams rhs) noexcept {
+        return LessThan{}(lhs, rhs);
    }
 };

@@ -1096,15 +1381,15 @@ struct SamplerYcbcrConversion {// NOLINT
    };

 private:
-    friend inline bool operator == (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+    friend bool operator == (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
            noexcept {
        return SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
    }
-    friend inline bool operator != (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+    friend bool operator != (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
            noexcept {
        return  !SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
    }
-    friend inline bool operator < (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+    friend bool operator < (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
            noexcept {
        return SamplerYcbcrConversion::LessThan{}(lhs, rhs);
    }
@@ -17,9 +17,6 @@
 #ifndef TNT_FILAMENT_BACKEND_HANDLE_H
 #define TNT_FILAMENT_BACKEND_HANDLE_H

-#if !defined(NDEBUG)
-#include <utils/ostream.h>
-#endif
 #include <utils/debug.h>

 #include <type_traits> // FIXME: STL headers are not allowed in public headers
@@ -27,6 +24,10 @@

 #include <stdint.h>

+namespace utils::io {
+class ostream;
+} // namespace utils::io
+
 namespace filament::backend {

 struct HwBufferObject;
@@ -20,12 +20,14 @@
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>

-#include <utils/ostream.h>
-
 #include <array>

 #include <stdint.h>

+namespace utils::io {
+class ostream;
+} // namespace utils::io
+
 namespace filament::backend {

 //! \privatesection
@@ -24,11 +24,14 @@

 #include <utils/compiler.h>
 #include <utils/debug.h>
-#include <utils/ostream.h>

 #include <stddef.h>
 #include <stdint.h>

+namespace utils::io {
+class ostream;
+} // namespace utils::io
+
 namespace filament::backend {

 /**
@@ -201,23 +204,15 @@ public:
                }, new T(std::forward<T>(functor))
        };
    }
-
-    // --------------------------------------------------------------------------------------------
-
    /**
-     * Computes the size in bytes needed to fit an image of given dimensions and format
+     * Computes the size in bytes for a pixel of given dimensions and format
     *
     * @param format    Format of the image pixels
     * @param type      Type of the image pixels
-     * @param stride    Stride of a row in pixels
-     * @param height    Height of the image in rows
-     * @param alignment Alignment in bytes of pixel rows
-     * @return The buffer size needed to fit this image in bytes
+     * @return The size of the specified pixel in bytes
     */
-    static constexpr size_t computeDataSize(PixelDataFormat format, PixelDataType type,
-            size_t stride, size_t height, size_t alignment) noexcept {
-        assert_invariant(alignment);

+    static constexpr size_t computePixelSize(PixelDataFormat format, PixelDataType type) noexcept {
        if (type == PixelDataType::COMPRESSED) {
            return 0;
        }
@@ -239,7 +234,7 @@ public:
            case PixelDataFormat::RGB_INTEGER:
                n = 3;
                break;
-            case PixelDataFormat::UNUSED: // shouldn't happen (used to be rgbm)
+            case PixelDataFormat::UNUSED:// shouldn't happen (used to be rgbm)
            case PixelDataFormat::RGBA:
            case PixelDataFormat::RGBA_INTEGER:
                n = 4;
@@ -248,7 +243,7 @@ public:

        size_t bpp = n;
        switch (type) {
-            case PixelDataType::COMPRESSED: // Impossible -- to squash the IDE warnings
+            case PixelDataType::COMPRESSED:// Impossible -- to squash the IDE warnings
            case PixelDataType::UBYTE:
            case PixelDataType::BYTE:
                // nothing to do
@@ -279,16 +274,35 @@ public:
                bpp = 2;
                break;
        }
+        return bpp;
+    }

+    // --------------------------------------------------------------------------------------------
+
+    /**
+     * Computes the size in bytes needed to fit an image of given dimensions and format
+     *
+     * @param format    Format of the image pixels
+     * @param type      Type of the image pixels
+     * @param stride    Stride of a row in pixels
+     * @param height    Height of the image in rows
+     * @param alignment Alignment in bytes of pixel rows
+     * @return The buffer size needed to fit this image in bytes
+     */
+    static constexpr size_t computeDataSize(PixelDataFormat format, PixelDataType type,
+            size_t stride, size_t height, size_t alignment) noexcept {
+        assert_invariant(alignment);
+
+        size_t bpp = computePixelSize(format, type);
        size_t const bpr = bpp * stride;
        size_t const bprAligned = (bpr + (alignment - 1)) & (~alignment + 1);
        return bprAligned * height;
    }

    //! left coordinate in pixels
-    uint32_t left   = 0;
+    uint32_t left = 0;
    //! top coordinate in pixels
-    uint32_t top    = 0;
+    uint32_t top = 0;
    union {
        struct {
            //! stride in pixels
@@ -20,12 +20,10 @@
 #include <utils/CString.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Invocable.h>
-#include <utils/ostream.h>

 #include <backend/DriverEnums.h>

 #include <array>
-#include <unordered_map>
 #include <tuple>
 #include <utility>
 #include <variant>
@@ -33,6 +31,10 @@
 #include <stddef.h>
 #include <stdint.h>

+namespace utils::io {
+class ostream;
+} // namespace utils::io
+
 namespace filament::backend {

 class Program {
@@ -19,22 +19,26 @@

 #include <backend/Handle.h>

-#include <utils/ostream.h>
+#include <utility>

 #include <stddef.h>
 #include <stdint.h>

+namespace utils::io {
+class ostream;
+} // namespace utils::io
+
 namespace filament::backend {

 //! \privatesection

 struct TargetBufferInfo {
    // note: the parameters of this constructor are not in the order of this structure's fields
-    TargetBufferInfo(Handle<HwTexture> handle, uint8_t level, uint16_t layer) noexcept
-            : handle(handle), level(level), layer(layer) {
+    TargetBufferInfo(Handle<HwTexture> handle, uint8_t const level, uint16_t const layer) noexcept
+            : handle(std::move(handle)), level(level), layer(layer) {
    }

-    TargetBufferInfo(Handle<HwTexture> handle, uint8_t level) noexcept
+    TargetBufferInfo(Handle<HwTexture> handle, uint8_t const level) noexcept
            : handle(handle), level(level) {
    }

@@ -70,11 +74,11 @@ private:
    TargetBufferInfo mInfos[MAX_SUPPORTED_RENDER_TARGET_COUNT];

 public:
-    TargetBufferInfo const& operator[](size_t i) const noexcept {
+    TargetBufferInfo const& operator[](size_t const i) const noexcept {
        return mInfos[i];
    }

-    TargetBufferInfo& operator[](size_t i) noexcept {
+    TargetBufferInfo& operator[](size_t const i) noexcept {
        return mInfos[i];
    }

@@ -199,7 +199,7 @@ public:
     */
    virtual bool makeCurrent(ContextType type,
            SwapChain* UTILS_NONNULL drawSwapChain,
-            SwapChain* UTILS_NONNULL readSwapChain) noexcept = 0;
+            SwapChain* UTILS_NONNULL readSwapChain) = 0;

    /**
     * Called by the driver to make the OpenGL context active on the calling thread and bind
@@ -219,7 +219,7 @@ public:
            SwapChain* UTILS_NONNULL drawSwapChain,
            SwapChain* UTILS_NONNULL readSwapChain,
            utils::Invocable<void()> preContextChange,
-            utils::Invocable<void(size_t index)> postContextChange) noexcept;
+            utils::Invocable<void(size_t index)> postContextChange);

    /**
     * Called by the backend just before calling commit()
@@ -58,7 +58,7 @@ protected:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
    void commit(SwapChain* swapChain) noexcept override;
    ExternalTexture* createExternalImageTexture() noexcept override;
    void destroyExternalImageTexture(ExternalTexture* texture) noexcept override;
@@ -55,7 +55,7 @@ public:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
    void commit(SwapChain* swapChain) noexcept override;

    ExternalTexture* createExternalImageTexture() noexcept override;
@@ -109,11 +109,11 @@ protected:

    bool makeCurrent(ContextType type,
            SwapChain* drawSwapChain,
-            SwapChain* readSwapChain) noexcept override;
+            SwapChain* readSwapChain) override;

    void makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain,
            utils::Invocable<void()> preContextChange,
-            utils::Invocable<void(size_t index)> postContextChange) noexcept override;
+            utils::Invocable<void(size_t index)> postContextChange) override;

    void commit(SwapChain* swapChain) noexcept override;

@@ -148,12 +148,12 @@ protected:
    EGLContext getContextForType(ContextType type) const noexcept;

    // makes the draw and read surface current without changing the current context
-    EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) noexcept {
+    EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) {
        return egl.makeCurrent(drawSurface, readSurface);
    }

    // makes context current and set draw and read surfaces to EGL_NO_SURFACE
-    EGLBoolean makeCurrent(EGLContext context) noexcept {
+    EGLBoolean makeCurrent(EGLContext context) {
        return egl.makeCurrent(context, mEGLDummySurface, mEGLDummySurface);
    }

@@ -211,9 +211,9 @@ private:
    public:
        explicit EGL(EGLDisplay& dpy) : mEGLDisplay(dpy) {}
        EGLBoolean makeCurrent(EGLContext context,
-                EGLSurface drawSurface, EGLSurface readSurface) noexcept;
+                EGLSurface drawSurface, EGLSurface readSurface);

-        EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) noexcept {
+        EGLBoolean makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) {
            return makeCurrent(mCurrentContext, drawSurface, readSurface);
        }
    } egl{ mEGLDisplay };
@@ -127,7 +127,7 @@ protected:
 protected:
    bool makeCurrent(ContextType type,
            SwapChain* drawSwapChain,
-            SwapChain* readSwapChain) noexcept override;
+            SwapChain* readSwapChain) override;

 private:
    struct InitializeJvmForPerformanceManagerIfNeeded {
@@ -51,7 +51,7 @@ protected:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
    void commit(SwapChain* swapChain) noexcept override;

 private:
@@ -39,18 +39,40 @@ public:
    Driver* createDriver(void* sharedContext, const Platform::DriverConfig& driverConfig) noexcept override;
    int getOSVersion() const noexcept override { return 0; }

+    /**
+     * Optionally initializes the Metal platform by acquiring resources necessary for rendering.
+     *
+     * This method attempts to acquire a Metal device and command queue, returning true if both are
+     * successfully obtained, or false otherwise. Typically, these objects are acquired when
+     * the Metal backend is initialized. This method allows clients to check for their availability
+     * earlier.
+     *
+     * Calling initialize() is optional and safe to do so multiple times. After initialize() returns
+     * true, subsequent calls will continue to return true but have no effect.
+     *
+     * initialize() must be called from the main thread.
+     *
+     * @returns true if the device and command queue have been successfully obtained; false
+     * otherwise.
+     */
+    bool initialize() noexcept;
+
    /**
     * Obtain the preferred Metal device object for the backend to use.
     *
     * On desktop platforms, there may be multiple GPUs suitable for rendering, and this method is
     * free to decide which one to use. On mobile systems with a single GPU, implementations should
     * simply return the result of MTLCreateSystemDefaultDevice();
+     *
+     * createDevice is called by the Metal backend from the backend thread.
     */
    virtual void createDevice(MetalDevice& outDevice) noexcept;

    /**
     * Create a command submission queue on the Metal device object.
     *
+     * createCommandQueue is called by the Metal backend from the backend thread.
+     *
     * @param device The device which was returned from createDevice()
     */
    virtual void createCommandQueue(
@@ -60,6 +82,8 @@ public:
     * Obtain a MTLCommandBuffer enqueued on this Platform's MTLCommandQueue. The command buffer is
     * guaranteed to execute before all subsequent command buffers created either by Filament, or
     * further calls to this method.
+     *
+     * createAndEnqueueCommandBuffer must be called from the main thread.
     */
    void createAndEnqueueCommandBuffer(MetalCommandBuffer& outCommandBuffer) noexcept;

@@ -68,6 +92,8 @@ public:
     *
     * Each frame rendered requires a CAMetalDrawable texture, which is presented on-screen at the
     * completion of each frame. These are limited and provided round-robin style by the system.
+     *
+     * setDrawableFailureBehavior must be called from the main thread.
     */
    enum class DrawableFailureBehavior : uint8_t {
        /**
@@ -56,7 +56,7 @@ protected:
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
    bool makeCurrent(ContextType type, SwapChain* drawSwapChain,
-            SwapChain* readSwapChain) noexcept override;
+            SwapChain* readSwapChain) override;
    void commit(SwapChain* swapChain) noexcept override;

 private:
@@ -53,7 +53,7 @@ protected:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
    void commit(SwapChain* swapChain) noexcept override;

 protected:
@@ -46,7 +46,7 @@ protected:
    SwapChain* createSwapChain(void* nativewindow, uint64_t flags) noexcept override;
    SwapChain* createSwapChain(uint32_t width, uint32_t height, uint64_t flags) noexcept override;
    void destroySwapChain(SwapChain* swapChain) noexcept override;
-    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept override;
+    bool makeCurrent(ContextType type, SwapChain* drawSwapChain, SwapChain* readSwapChain) override;
    void commit(SwapChain* swapChain) noexcept override;
 };

@@ -27,8 +27,11 @@
 #include <utils/Hash.h>
 #include <utils/PrivateImplementation.h>

+#include <cstddef>
+#include <functional>
 #include <tuple>
 #include <unordered_set>
+#include <string>

 #include <stddef.h>
 #include <stdint.h>
@@ -22,6 +22,7 @@
 #include <webgpu/webgpu_cpp.h>

 #include <cstdint>
+#include <vector>

 namespace filament::backend {

@@ -56,6 +57,10 @@ protected:
            const Platform::DriverConfig& driverConfig) noexcept override;

 private:
+    // returns adapter request option variations applicable for the particular
+    // platform
+    [[nodiscard]] static std::vector<wgpu::RequestAdapterOptions> getAdapterOptions();
+
    // we may consider having the driver own this in the future
    wgpu::Instance mInstance;
 };
@@ -72,7 +72,7 @@ public:
    Range getBuffer() noexcept;

 private:
-    void* alloc(size_t size) noexcept;
+    void* alloc(size_t size);
    void dealloc() noexcept;

    // pointer to the beginning of the circular buffer (constant)
@@ -76,7 +76,7 @@ public:

    // all commands buffers (Slices) written to this point are returned by waitForCommand(). This
    // call blocks until the CircularBuffer has at least mRequiredSize bytes available.
-    void flush() noexcept;
+    void flush();

    // returns from waitForCommands() immediately.
    void requestExit();
@@ -222,6 +222,56 @@ public:
        return static_cast<Dp>(p);
    }

+    template<typename Dp, typename B>
+    inline std::enable_if_t<
+            std::is_pointer_v<Dp> && std::is_base_of_v<B, std::remove_pointer_t<Dp>>, int16_t>
+    handle_set_value(Handle<B>& handle, uint8_t v) {
+        assert_invariant(handle);
+        auto [p, tag] = handleToPointer(handle.getId());
+
+        if (isPoolHandle(handle.getId())) {
+            // check for pool handle use-after-free
+            if (UTILS_UNLIKELY(!mUseAfterFreeCheckDisabled)) {
+                auto const pNode = static_cast<typename Allocator::Node*>(p);
+                pNode[-1].test_value = v;
+                return 1;
+            }
+            return 0;
+        } else {
+            // check for heap handle use-after-free
+            if (UTILS_UNLIKELY(!mUseAfterFreeCheckDisabled)) {
+                return -1;
+            }
+            return -2;
+        }
+    }
+
+    template<typename Dp, typename B>
+    inline std::enable_if_t<
+            std::is_pointer_v<Dp> && std::is_base_of_v<B, std::remove_pointer_t<Dp>>, int16_t>
+    handle_get_value(Handle<B>& handle) {
+        assert_invariant(handle);
+        auto [p, tag] = handleToPointer(handle.getId());
+
+        if (isPoolHandle(handle.getId())) {
+            // check for pool handle use-after-free
+            if (UTILS_UNLIKELY(!mUseAfterFreeCheckDisabled)) {
+                auto const pNode = static_cast<typename Allocator::Node*>(p);
+                uint8_t age = pNode[-1].age;
+                uint8_t test_value = pNode[-1].test_value;
+                int16_t ret = (int16_t) ((age << 8) | test_value);
+                return ret;
+            }
+            return 0;
+        } else {
+            // check for heap handle use-after-free
+            if (UTILS_UNLIKELY(!mUseAfterFreeCheckDisabled)) {
+                return -1;
+            }
+            return -2;
+        }
+    }
+
    utils::CString getHandleTag(HandleBase::HandleId key) const noexcept;

    template<typename B>
@@ -276,7 +326,10 @@ private:
    class Allocator {
        friend class HandleAllocator;
        static constexpr size_t MIN_ALIGNMENT = alignof(std::max_align_t);
-        struct Node { uint8_t age; };
+        struct Node {
+            uint8_t age;
+            uint8_t test_value = 0xff;
+        };
        // Note: using the `extra` parameter of PoolAllocator<>, even with a 1-byte structure,
        // generally increases all pool allocations by 8-bytes because of alignment restrictions.
        template<size_t SIZE>
@@ -27,13 +27,13 @@ namespace filament {
 class VirtualMachineEnv {
 public:
    // must be called before VirtualMachineEnv::get() from a thread that is attached to the JavaVM
-    static jint JNI_OnLoad(JavaVM* vm) noexcept;
+    static jint JNI_OnLoad(JavaVM* vm);

    // must be called on backend thread
    static VirtualMachineEnv& get() noexcept;

    // can be called from any thread that already has a JniEnv
-    static JNIEnv* getThreadEnvironment() noexcept;
+    static JNIEnv* getThreadEnvironment();

    // must be called from the backend thread
    JNIEnv* getEnvironment() noexcept {
@@ -49,7 +49,7 @@ public:
 private:
    explicit VirtualMachineEnv(JavaVM* vm) noexcept;
    ~VirtualMachineEnv() noexcept;
-    JNIEnv* getEnvironmentSlow() noexcept;
+    JNIEnv* getEnvironmentSlow();

    static utils::Mutex sLock;
    static JavaVM* sVirtualMachine;
@@ -18,6 +18,8 @@

 #include "DataReshaper.h"

+#include <backend/DriverEnums.h>
+
 #include <utils/CString.h>

 #include <string_view>
@@ -223,6 +225,143 @@ size_t getFormatSize(TextureFormat format) noexcept {
    }
 }

+TextureType getTextureType(TextureFormat const format) noexcept {
+    switch (format) {
+        case TextureFormat::UNUSED:
+            // should not happen
+            return TextureType::FLOAT;
+
+        case TextureFormat::R8:
+        case TextureFormat::R16F:
+        case TextureFormat::RG8:
+        case TextureFormat::RGB565:
+        case TextureFormat::RGB5_A1:
+        case TextureFormat::RGBA4:
+        case TextureFormat::R32F:
+        case TextureFormat::RGB8:
+        case TextureFormat::SRGB8:
+        case TextureFormat::RG16F:
+        case TextureFormat::R11F_G11F_B10F:
+        case TextureFormat::RGB9_E5:
+        case TextureFormat::RGBA8:
+        case TextureFormat::SRGB8_A8:
+        case TextureFormat::RGB10_A2:
+        case TextureFormat::RGB16F:
+        case TextureFormat::RG32F:
+        case TextureFormat::RGBA16F:
+        case TextureFormat::RGB32F:
+        case TextureFormat::RGBA32F:
+            return TextureType::FLOAT;
+
+        case TextureFormat::R8_SNORM:
+        case TextureFormat::RG8_SNORM:
+        case TextureFormat::RGB8_SNORM:
+        case TextureFormat::RGBA8_SNORM:
+            // SNORM are treated as float
+            return TextureType::FLOAT;
+
+        case TextureFormat::R8UI:
+        case TextureFormat::R16UI:
+        case TextureFormat::RG8UI:
+        case TextureFormat::RGB8UI:
+        case TextureFormat::R32UI:
+        case TextureFormat::RG16UI:
+        case TextureFormat::RGBA8UI:
+        case TextureFormat::RGB16UI:
+        case TextureFormat::RG32UI:
+        case TextureFormat::RGBA16UI:
+        case TextureFormat::RGB32UI:
+        case TextureFormat::RGBA32UI:
+            return TextureType::UINT;
+
+        case TextureFormat::R8I:
+        case TextureFormat::R16I:
+        case TextureFormat::RG8I:
+        case TextureFormat::RGB8I:
+        case TextureFormat::R32I:
+        case TextureFormat::RG16I:
+        case TextureFormat::RGBA8I:
+        case TextureFormat::RGB16I:
+        case TextureFormat::RG32I:
+        case TextureFormat::RGBA16I:
+        case TextureFormat::RGB32I:
+        case TextureFormat::RGBA32I:
+            return TextureType::INT;
+
+        case TextureFormat::DEPTH16:
+        case TextureFormat::DEPTH24:
+        case TextureFormat::DEPTH32F:
+            return TextureType::DEPTH;
+
+        case TextureFormat::STENCIL8:
+            return TextureType::STENCIL;
+
+        case TextureFormat::DEPTH24_STENCIL8:
+        case TextureFormat::DEPTH32F_STENCIL8:
+            return TextureType::DEPTH_STENCIL;
+
+        // Compressed formats ---------------------------------------------------------------------
+
+        case TextureFormat::EAC_RG11:
+        case TextureFormat::EAC_RG11_SIGNED:
+        case TextureFormat::ETC2_EAC_RGBA8:
+        case TextureFormat::ETC2_EAC_SRGBA8:
+        case TextureFormat::EAC_R11:
+        case TextureFormat::EAC_R11_SIGNED:
+        case TextureFormat::ETC2_RGB8:
+        case TextureFormat::ETC2_SRGB8:
+        case TextureFormat::ETC2_RGB8_A1:
+        case TextureFormat::ETC2_SRGB8_A1:
+        case TextureFormat::DXT1_RGB:
+        case TextureFormat::DXT1_RGBA:
+        case TextureFormat::DXT1_SRGB:
+        case TextureFormat::DXT1_SRGBA:
+        case TextureFormat::DXT3_RGBA:
+        case TextureFormat::DXT3_SRGBA:
+        case TextureFormat::DXT5_RGBA:
+        case TextureFormat::DXT5_SRGBA:
+        case TextureFormat::RED_RGTC1:
+        case TextureFormat::SIGNED_RED_RGTC1:
+        case TextureFormat::RED_GREEN_RGTC2:
+        case TextureFormat::SIGNED_RED_GREEN_RGTC2:
+        case TextureFormat::RGB_BPTC_SIGNED_FLOAT:
+        case TextureFormat::RGB_BPTC_UNSIGNED_FLOAT:
+        case TextureFormat::RGBA_BPTC_UNORM:
+        case TextureFormat::SRGB_ALPHA_BPTC_UNORM:
+        case TextureFormat::RGBA_ASTC_4x4:
+        case TextureFormat::RGBA_ASTC_5x4:
+        case TextureFormat::RGBA_ASTC_5x5:
+        case TextureFormat::RGBA_ASTC_6x5:
+        case TextureFormat::RGBA_ASTC_6x6:
+        case TextureFormat::RGBA_ASTC_8x5:
+        case TextureFormat::RGBA_ASTC_8x6:
+        case TextureFormat::RGBA_ASTC_8x8:
+        case TextureFormat::RGBA_ASTC_10x5:
+        case TextureFormat::RGBA_ASTC_10x6:
+        case TextureFormat::RGBA_ASTC_10x8:
+        case TextureFormat::RGBA_ASTC_10x10:
+        case TextureFormat::RGBA_ASTC_12x10:
+        case TextureFormat::RGBA_ASTC_12x12:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_4x4:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_5x4:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_5x5:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_6x5:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_6x6:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_8x5:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_8x6:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_8x8:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_10x5:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_10x6:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_10x8:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_10x10:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_12x10:
+        case TextureFormat::SRGB8_ALPHA8_ASTC_12x12:
+            return TextureType::FLOAT;
+    }
+
+    return TextureType::FLOAT;
+}
+
 size_t getFormatComponentCount(TextureFormat format) noexcept {
    switch (format) {
        case TextureFormat::R8:
@@ -65,7 +65,7 @@ CircularBuffer::~CircularBuffer() noexcept {
 // to each others and a special case in circularize()

 UTILS_NOINLINE
-void* CircularBuffer::alloc(size_t size) noexcept {
+void* CircularBuffer::alloc(size_t size) {
 #if HAS_MMAP
    void* data = nullptr;
    void* vaddr = MAP_FAILED;
@@ -18,12 +18,13 @@
 #include "private/backend/CircularBuffer.h"
 #include "private/backend/CommandStream.h"

+#include <private/utils/Tracing.h>
+
 #include <utils/compiler.h>
 #include <utils/Log.h>
 #include <utils/Mutex.h>
 #include <utils/ostream.h>
 #include <utils/Panic.h>
-#include <utils/Systrace.h>
 #include <utils/debug.h>

 #include <algorithm>
@@ -52,18 +53,18 @@ CommandBufferQueue::~CommandBufferQueue() {
 }

 void CommandBufferQueue::requestExit() {
-    std::lock_guard<utils::Mutex> const lock(mLock);
+    std::lock_guard const lock(mLock);
    mExitRequested = EXIT_REQUESTED;
    mCondition.notify_one();
 }

 bool CommandBufferQueue::isPaused() const noexcept {
-    std::lock_guard<utils::Mutex> const lock(mLock);
+    std::lock_guard const lock(mLock);
    return mPaused;
 }

 void CommandBufferQueue::setPaused(bool paused) {
-    std::lock_guard<utils::Mutex> const lock(mLock);
+    std::lock_guard const lock(mLock);
    if (paused) {
        mPaused = true;
    } else {
@@ -73,13 +74,13 @@ void CommandBufferQueue::setPaused(bool paused) {
 }

 bool CommandBufferQueue::isExitRequested() const {
-    std::lock_guard<utils::Mutex> const lock(mLock);
-    return (bool)mExitRequested;
+    std::lock_guard const lock(mLock);
+    return bool(mExitRequested);
 }


-void CommandBufferQueue::flush() noexcept {
-    SYSTRACE_CALL();
+void CommandBufferQueue::flush() {
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);

    CircularBuffer& circularBuffer = mCircularBuffer;
    if (circularBuffer.empty()) {
@@ -102,7 +103,7 @@ void CommandBufferQueue::flush() noexcept {
            static_cast<char const*>(begin), static_cast<char const*>(end));


-    std::unique_lock<utils::Mutex> lock(mLock);
+    std::unique_lock lock(mLock);

    // circular buffer is too small, we corrupted the stream
    FILAMENT_CHECK_POSTCONDITION(used <= mFreeSpace) <<
@@ -129,7 +130,7 @@ void CommandBufferQueue::flush() noexcept {
        mHighWatermark = std::max(mHighWatermark, totalUsed);
 #endif

-        SYSTRACE_NAME("waiting: CircularBuffer::flush()");
+        FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "waiting: CircularBuffer::flush()");

        FILAMENT_CHECK_POSTCONDITION(!mPaused) <<
                "CommandStream is full, but since the rendering thread is paused, "
@@ -146,7 +147,7 @@ std::vector<CommandBufferQueue::Range> CommandBufferQueue::waitForCommands() con
    if (!UTILS_HAS_THREADING) {
        return std::move(mCommandBuffersToExecute);
    }
-    std::unique_lock<utils::Mutex> lock(mLock);
+    std::unique_lock lock(mLock);
    while ((mCommandBuffersToExecute.empty() || mPaused) && !mExitRequested) {
        mCondition.wait(lock);
    }
@@ -156,7 +157,7 @@ std::vector<CommandBufferQueue::Range> CommandBufferQueue::waitForCommands() con
 void CommandBufferQueue::releaseBuffer(CommandBufferQueue::Range const& buffer) {
    size_t const used = std::distance(
            static_cast<char const*>(buffer.begin), static_cast<char const*>(buffer.end));
-    std::lock_guard<utils::Mutex> const lock(mLock);
+    std::lock_guard const lock(mLock);
    mFreeSpace += used;
    mCondition.notify_one();
 }
@@ -16,6 +16,8 @@

 #include "private/backend/CommandStream.h"

+#include <private/utils/Tracing.h>
+
 #if DEBUG_COMMAND_STREAM
 #include <utils/CallStack.h>
 #endif
@@ -24,7 +26,6 @@
 #include <utils/Log.h>
 #include <utils/ostream.h>
 #include <utils/Profiler.h>
-#include <utils/Systrace.h>

 #include <cstddef>
 #include <functional>
@@ -79,12 +80,13 @@ CommandStream::CommandStream(Driver& driver, CircularBuffer& buffer) noexcept
 }

 void CommandStream::execute(void* buffer) {
-    // NOTE: we can't use SYSTRACE_CALL() or similar here because, execute() below, also
+    // NOTE: we can't use FILAMENT_TRACING_CALL() or similar here because, execute() below, also
    // uses systrace BEGIN/END and the END is not guaranteed to be happening in this scope.

    Profiler profiler;

-    if (SYSTRACE_TAG) {
+
+    if constexpr (FILAMENT_TRACING_ENABLED) {
        if (UTILS_UNLIKELY(mUsePerformanceCounter)) {
            // we want to remove all this when tracing is completely disabled
            profiler.resetEvents(Profiler::EV_CPU_CYCLES  | Profiler::EV_BPU_MISSES);
@@ -100,17 +102,17 @@ void CommandStream::execute(void* buffer) {
        }
    });

-    if (SYSTRACE_TAG) {
+    if constexpr (FILAMENT_TRACING_ENABLED) {
        if (UTILS_UNLIKELY(mUsePerformanceCounter)) {
            // we want to remove all this when tracing is completely disabled
            profiler.stop();
            UTILS_UNUSED Profiler::Counters const counters = profiler.readCounters();
-            SYSTRACE_CONTEXT();
-            SYSTRACE_VALUE32("GLThread (I)", counters.getInstructions());
-            SYSTRACE_VALUE32("GLThread (C)", counters.getCpuCycles());
-            SYSTRACE_VALUE32("GLThread (CPI x10)", counters.getCPI() * 10);
-            SYSTRACE_VALUE32("GLThread (BPU miss)", counters.getBranchMisses());
-            SYSTRACE_VALUE32("GLThread (I / BPU miss)",
+            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (I)", counters.getInstructions());
+            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (C)", counters.getCpuCycles());
+            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (CPI x10)", counters.getCPI() * 10);
+            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (BPU miss)", counters.getBranchMisses());
+            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (I / BPU miss)",
                    counters.getInstructions() / counters.getBranchMisses());
        }
    }
@@ -20,8 +20,9 @@
 #include "private/backend/Driver.h"
 #include "private/backend/CommandStream.h"

+#include <private/utils/Tracing.h>
+
 #include <utils/compiler.h>
-#include <utils/Systrace.h>

 #include <utility>

@@ -38,7 +39,7 @@
 #if DEBUG_LEVEL == DEBUG_LEVEL_NONE
 #   define SYSTRACE()
 #elif DEBUG_LEVEL == DEBUG_LEVEL_SYSTRACE
-#   define SYSTRACE() SYSTRACE_CALL();
+#   define SYSTRACE() FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
 #else
 #   error "invalid debug level"
 #endif
@@ -16,7 +16,7 @@

 #include "CompilerThreadPool.h"

-#include <utils/Systrace.h>
+#include <private/utils/Tracing.h>

 #include <memory>

@@ -41,7 +41,7 @@ void CompilerThreadPool::init(uint32_t threadCount,

    for (size_t i = 0; i < threadCount; i++) {
        mCompilerThreads.emplace_back([this, setup, cleanup]() {
-            SYSTRACE_CONTEXT();
+            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);

            (*setup)();

@@ -54,7 +54,7 @@ void CompilerThreadPool::init(uint32_t threadCount,
                                    [](auto&& q) { return q.empty(); }));
                });

-                SYSTRACE_VALUE32("CompilerThreadPool Jobs",
+                FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "CompilerThreadPool Jobs",
                        mQueues[0].size() + mQueues[1].size());

                if (UTILS_LIKELY(!mExitRequested)) {
@@ -23,11 +23,12 @@
 #include <backend/BufferDescriptor.h>
 #include <backend/DriverEnums.h>

+#include <private/utils/Tracing.h>
+
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/Log.h>
 #include <utils/ostream.h>
-#include <utils/Systrace.h>

 #include <math/half.h>
 #include <math/vec2.h>
@@ -151,30 +152,31 @@ void DriverBase::debugCommandBegin(CommandStream* cmds, bool synchronous, const
            utils::slog.d << methodName << utils::io::endl;
        }
        if constexpr (bool(FILAMENT_DEBUG_COMMANDS & FILAMENT_DEBUG_COMMANDS_SYSTRACE)) {
-            SYSTRACE_CONTEXT();
-            SYSTRACE_NAME_BEGIN(methodName);
+            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+            FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, methodName);

            if (!synchronous) {
                cmds->queueCommand([=]() {
-                    SYSTRACE_CONTEXT();
-                    SYSTRACE_NAME_BEGIN(methodName);
+                    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+                    FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, methodName);
                });
            }
        }
    }
 }

-void DriverBase::debugCommandEnd(CommandStream* cmds, bool synchronous, const char* methodName) noexcept {
+void DriverBase::debugCommandEnd(CommandStream* cmds, bool synchronous,
+        const char* methodName) noexcept {
    if constexpr (bool(FILAMENT_DEBUG_COMMANDS > FILAMENT_DEBUG_COMMANDS_NONE)) {
        if constexpr (bool(FILAMENT_DEBUG_COMMANDS & FILAMENT_DEBUG_COMMANDS_SYSTRACE)) {
            if (!synchronous) {
                cmds->queueCommand([]() {
-                    SYSTRACE_CONTEXT();
-                    SYSTRACE_NAME_END();
+                    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+                    FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
                });
            }
-            SYSTRACE_CONTEXT();
-            SYSTRACE_NAME_END();
+            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+            FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
        }
    }
 }
@@ -17,6 +17,7 @@
 #include <backend/Platform.h>

 #include <utils/compiler.h>
+#include <utils/ostream.h>

 #include <atomic>
 #include <utility>
@@ -16,7 +16,8 @@

 #include <private/backend/PlatformFactory.h>

-#include <utils/Systrace.h>
+#include <private/utils/Tracing.h>
+
 #include <utils/debug.h>

 // We need to keep this up top for the linux (X11) name collisions.
@@ -85,7 +86,7 @@ namespace filament::backend {
 // responsible for destroying it. Initialization of the backend API is deferred until
 // createDriver(). The passed-in backend hint is replaced with the resolved backend.
 Platform* PlatformFactory::create(Backend* backend) noexcept {
-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
    assert_invariant(backend);

 #if defined(__ANDROID__)
@@ -17,7 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_SYSTRACEPROFILE_H
 #define TNT_FILAMENT_BACKEND_SYSTRACEPROFILE_H

-#include <utils/Systrace.h>
+#include <private/utils/Tracing.h>

 #define PROFILE_SCOPE(marker)       SYSTRACE_NAME(marker)

@@ -50,7 +50,7 @@ JavaVM* VirtualMachineEnv::getVirtualMachine() {
 */
 UTILS_PUBLIC
 UTILS_NOINLINE
-jint VirtualMachineEnv::JNI_OnLoad(JavaVM* vm) noexcept {
+jint VirtualMachineEnv::JNI_OnLoad(JavaVM* vm) {
    std::lock_guard const lock(sLock);
    if (sVirtualMachine) {
        // It doesn't make sense for JNI_OnLoad() to be called more than once
@@ -77,7 +77,7 @@ VirtualMachineEnv& VirtualMachineEnv::get() noexcept {
 }

 UTILS_NOINLINE
-JNIEnv* VirtualMachineEnv::getThreadEnvironment() noexcept {
+JNIEnv* VirtualMachineEnv::getThreadEnvironment() {
    JavaVM* const vm = getVirtualMachine();
    JNIEnv* env = nullptr;
    jint const result = vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
@@ -101,7 +101,7 @@ VirtualMachineEnv::~VirtualMachineEnv() noexcept {
 }

 UTILS_NOINLINE
-JNIEnv* VirtualMachineEnv::getEnvironmentSlow() noexcept {
+JNIEnv* VirtualMachineEnv::getEnvironmentSlow() {
    FILAMENT_CHECK_PRECONDITION(mVirtualMachine)
            << "JNI_OnLoad() has not been called";

@@ -19,6 +19,8 @@

 #include "MetalContext.h"

+#include <utils/Panic.h>
+
 namespace filament {
 namespace backend {

@@ -672,22 +672,8 @@ void MetalDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {
    // nothing to do, timer query was constructed in createTimerQueryS
 }

-const char* toString(DescriptorType type) {
-    switch (type) {
-        case DescriptorType::UNIFORM_BUFFER:
-            return "UNIFORM_BUFFER";
-        case DescriptorType::SHADER_STORAGE_BUFFER:
-            return "SHADER_STORAGE_BUFFER";
-        case DescriptorType::SAMPLER:
-            return "SAMPLER";
-        case DescriptorType::INPUT_ATTACHMENT:
-            return "INPUT_ATTACHMENT";
-        case DescriptorType::SAMPLER_EXTERNAL:
-            return "SAMPLER_EXTERNAL";
-    }
-}
-
-const char* toString(ShaderStageFlags flags) {
+UTILS_UNUSED
+static const char* toString(ShaderStageFlags flags) {
    std::vector<const char*> stages;
    if (any(flags & ShaderStageFlags::VERTEX)) {
        stages.push_back("VERTEX");
@@ -721,15 +707,25 @@ const char* toString(DescriptorFlags flags) {

 void MetalDriver::createDescriptorSetLayoutR(
        Handle<HwDescriptorSetLayout> dslh, DescriptorSetLayout&& info) {
+#if FILAMENT_METAL_DEBUG_LOG == 1
+    const char* labelStr = "";
+    std::visit([&labelStr](auto&& arg) {
+        using T = std::decay_t<decltype(arg)>;
+        if constexpr (std::is_same_v<T, utils::CString> || std::is_same_v<T, utils::StaticString>) {
+            labelStr = arg.c_str();
+        }
+    }, info.label);
    std::sort(info.bindings.begin(), info.bindings.end(),
            [](const auto& a, const auto& b) { return a.binding < b.binding; });
-    DEBUG_LOG("createDescriptorSetLayoutR(dslh = %d, info = {\n", dslh.getId());
+    DEBUG_LOG("createDescriptorSetLayoutR(dslh = %d, info = { label = %s,\n", dslh.getId(),
+            labelStr);
    for (size_t i = 0; i < info.bindings.size(); i++) {
        DEBUG_LOG("    {binding = %d, type = %s, count = %d, stage = %s, flags = %s},\n",
                info.bindings[i].binding, toString(info.bindings[i].type), info.bindings[i].count,
                toString(info.bindings[i].stageFlags), toString(info.bindings[i].flags));
    }
    DEBUG_LOG("})\n");
+#endif
    construct_handle<MetalDescriptorSetLayout>(dslh, std::move(info));
 }

@@ -1356,7 +1356,31 @@ id<MTLArgumentEncoder> MetalDescriptorSetLayout::getArgumentEncoderSlow(id<MTLDe
                [arguments addObject:bufferArgument];
                break;
            }
-            case DescriptorType::SAMPLER:
+            case DescriptorType::SAMPLER_2D_FLOAT:
+            case DescriptorType::SAMPLER_2D_INT:
+            case DescriptorType::SAMPLER_2D_UINT:
+            case DescriptorType::SAMPLER_2D_DEPTH:
+            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
+            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_INT:
+            case DescriptorType::SAMPLER_CUBE_UINT:
+            case DescriptorType::SAMPLER_CUBE_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_3D_FLOAT:
+            case DescriptorType::SAMPLER_3D_INT:
+            case DescriptorType::SAMPLER_3D_UINT:
+            case DescriptorType::SAMPLER_2D_MS_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_INT:
+            case DescriptorType::SAMPLER_2D_MS_UINT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
            case DescriptorType::SAMPLER_EXTERNAL: {
                MTLArgumentDescriptor* textureArgument = [MTLArgumentDescriptor argumentDescriptor];
                textureArgument.index = binding.binding * 2;
@@ -1382,6 +1406,9 @@ id<MTLArgumentEncoder> MetalDescriptorSetLayout::getArgumentEncoderSlow(id<MTLDe
                break;
        }
    }
+    if (arguments.count == 0) {
+        return nil;
+    }
    return [device newArgumentEncoderWithArguments:arguments];
 }

@@ -1442,6 +1469,9 @@ id<MTLBuffer> MetalDescriptorSet::finalizeAndGetBuffer(MetalDriver* driver, Shad

    id<MTLArgumentEncoder> encoder =
            layout->getArgumentEncoder(context.device, stage, textureTypes);
+    if (!encoder) {
+        return nil;
+    }

    {
        ScopedAllocationTimer timer("descriptor_set");
@@ -1472,7 +1502,31 @@ id<MTLBuffer> MetalDescriptorSet::finalizeAndGetBuffer(MetalDriver* driver, Shad
                           atIndex:binding.binding * 2];
                break;
            }
-            case DescriptorType::SAMPLER:
+            case DescriptorType::SAMPLER_2D_FLOAT:
+            case DescriptorType::SAMPLER_2D_INT:
+            case DescriptorType::SAMPLER_2D_UINT:
+            case DescriptorType::SAMPLER_2D_DEPTH:
+            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
+            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_INT:
+            case DescriptorType::SAMPLER_CUBE_UINT:
+            case DescriptorType::SAMPLER_CUBE_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_3D_FLOAT:
+            case DescriptorType::SAMPLER_3D_INT:
+            case DescriptorType::SAMPLER_3D_UINT:
+            case DescriptorType::SAMPLER_2D_MS_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_INT:
+            case DescriptorType::SAMPLER_2D_MS_UINT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
            case DescriptorType::SAMPLER_EXTERNAL: {
                auto found = textures.find(binding.binding);
                if (found == textures.end()) {
@@ -20,18 +20,19 @@
 #include <Metal/Metal.h>

 #include "private/backend/Driver.h"
-#include "backend/Program.h"

 #include <backend/DriverEnums.h>
+#include <backend/Program.h>

+#include <utils/bitset.h>
 #include <utils/FixedCapacityVector.h>
-
-#include <memory>
-#include <tsl/robin_map.h>
-
 #include <utils/Hash.h>
 #include <utils/Invocable.h>

+#include <tsl/robin_map.h>
+
+#include <memory>
+
 namespace filament {
 namespace backend {

@@ -24,14 +24,22 @@
 #import <Foundation/Foundation.h>

 #include <atomic>
+#include <mutex>

 namespace filament::backend {

 struct PlatformMetalImpl {
+    std::mutex mLock;   // locks mDevice and mCommandQueue
+    id<MTLDevice> mDevice = nil;
    id<MTLCommandQueue> mCommandQueue = nil;
+
    // read form driver thread, read/written to from client thread
    std::atomic<PlatformMetal::DrawableFailureBehavior> mDrawableFailureBehavior =
            PlatformMetal::DrawableFailureBehavior::PANIC;
+
+    // These methods must be called with mLock held
+    void createDeviceImpl(MetalDevice& outDevice);
+    void createCommandQueueImpl(MetalDevice& device, MetalCommandQueue& outCommandQueue);
 };

 Platform* createDefaultMetalPlatform() {
@@ -48,7 +56,59 @@ Driver* PlatformMetal::createDriver(void* /*sharedContext*/, const Platform::Dri
    return MetalDriverFactory::create(this, driverConfig);
 }

+
+bool PlatformMetal::initialize() noexcept {
+    std::lock_guard<std::mutex> lock(pImpl->mLock);
+
+    MetalDevice device{};
+    pImpl->createDeviceImpl(device);
+    if (device.device == nil) {
+        return false;
+    }
+
+    MetalCommandQueue commandQueue{};
+    pImpl->createCommandQueueImpl(device, commandQueue);
+    if (commandQueue.commandQueue == nil) {
+        return false;
+    }
+
+    return true;
+}
+
 void PlatformMetal::createDevice(MetalDevice& outDevice) noexcept {
+    std::lock_guard<std::mutex> lock(pImpl->mLock);
+    pImpl->createDeviceImpl(outDevice);
+}
+
+void PlatformMetal::createCommandQueue(
+        MetalDevice& device, MetalCommandQueue& outCommandQueue) noexcept {
+    std::lock_guard<std::mutex> lock(pImpl->mLock);
+    pImpl->createCommandQueueImpl(device, outCommandQueue);
+}
+
+void PlatformMetal::createAndEnqueueCommandBuffer(MetalCommandBuffer& outCommandBuffer) noexcept {
+    std::lock_guard<std::mutex> lock(pImpl->mLock);
+    id<MTLCommandBuffer> commandBuffer = [pImpl->mCommandQueue commandBuffer];
+    [commandBuffer enqueue];
+    outCommandBuffer.commandBuffer = commandBuffer;
+}
+
+void PlatformMetal::setDrawableFailureBehavior(DrawableFailureBehavior behavior) noexcept {
+    pImpl->mDrawableFailureBehavior = behavior;
+}
+
+PlatformMetal::DrawableFailureBehavior PlatformMetal::getDrawableFailureBehavior() const noexcept {
+    return pImpl->mDrawableFailureBehavior;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+void PlatformMetalImpl::createDeviceImpl(MetalDevice& outDevice) {
+    if (mDevice) {
+        outDevice.device = mDevice;
+        return;
+    }
+
    id<MTLDevice> result;

 #if !defined(FILAMENT_IOS)
@@ -74,27 +134,17 @@ void PlatformMetal::createDevice(MetalDevice& outDevice) noexcept {
                  << utils::io::endl;

    outDevice.device = result;
+    mDevice = result;
 }

-void PlatformMetal::createCommandQueue(
-        MetalDevice& device, MetalCommandQueue& outCommandQueue) noexcept {
-    pImpl->mCommandQueue = [device.device newCommandQueue];
-    pImpl->mCommandQueue.label = @"Filament";
-    outCommandQueue.commandQueue = pImpl->mCommandQueue;
-}
-
-void PlatformMetal::createAndEnqueueCommandBuffer(MetalCommandBuffer& outCommandBuffer) noexcept {
-    id<MTLCommandBuffer> commandBuffer = [pImpl->mCommandQueue commandBuffer];
-    [commandBuffer enqueue];
-    outCommandBuffer.commandBuffer = commandBuffer;
-}
-
-void PlatformMetal::setDrawableFailureBehavior(DrawableFailureBehavior behavior) noexcept {
-    pImpl->mDrawableFailureBehavior = behavior;
-}
-
-PlatformMetal::DrawableFailureBehavior PlatformMetal::getDrawableFailureBehavior() const noexcept {
-    return pImpl->mDrawableFailureBehavior;
+void PlatformMetalImpl::createCommandQueueImpl(MetalDevice& device, MetalCommandQueue& outCommandQueue) {
+    if (mCommandQueue) {
+        outCommandQueue.commandQueue = mCommandQueue;
+        return;
+    }
+    mCommandQueue = [device.device newCommandQueue];
+    mCommandQueue.label = @"Filament";
+    outCommandQueue.commandQueue = mCommandQueue;
 }

 } // namespace filament
@@ -69,9 +69,8 @@ public:
        assert_invariant(set < MAX_DESCRIPTOR_SET_COUNT);
        assert_invariant(binding < MAX_DESCRIPTOR_COUNT);
        assert_invariant(entry.binding < 128); // we reserve 1 bit for the type right now
-        mStorage[set][binding] = { (uint8_t)entry.binding,
-                                   entry.type == DescriptorType::SAMPLER ||
-                                   entry.type == DescriptorType::SAMPLER_EXTERNAL };
+        mStorage[set][binding] = { uint8_t(entry.binding),
+                                   DescriptorSetLayoutBinding::isSampler(entry.type) };
        mActiveDescriptors[set].set(binding);
    }

@@ -95,7 +95,32 @@ GLDescriptorSet::GLDescriptorSet(OpenGLContext& gl, DescriptorSetLayoutHandle ds
                }
                break;
            }
-            case DescriptorType::SAMPLER:
+
+            case DescriptorType::SAMPLER_2D_FLOAT:
+            case DescriptorType::SAMPLER_2D_INT:
+            case DescriptorType::SAMPLER_2D_UINT:
+            case DescriptorType::SAMPLER_2D_DEPTH:
+            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
+            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_INT:
+            case DescriptorType::SAMPLER_CUBE_UINT:
+            case DescriptorType::SAMPLER_CUBE_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_3D_FLOAT:
+            case DescriptorType::SAMPLER_3D_INT:
+            case DescriptorType::SAMPLER_3D_UINT:
+            case DescriptorType::SAMPLER_2D_MS_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_INT:
+            case DescriptorType::SAMPLER_2D_MS_UINT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
            case DescriptorType::SAMPLER_EXTERNAL:
                if (UTILS_UNLIKELY(gl.isES2())) {
                    desc.emplace<SamplerGLES2>();
@@ -137,8 +162,11 @@ void GLDescriptorSet::update(OpenGLContext&,
    }, descriptors[binding].desc);
 }

-void GLDescriptorSet::update(OpenGLContext& gl,
-        descriptor_binding_t binding, GLTexture* t, SamplerParams params) noexcept {
+void GLDescriptorSet::update(OpenGLContext& gl, HandleAllocatorGL& handleAllocator,
+        descriptor_binding_t binding, TextureHandle th, SamplerParams params) noexcept {
+
+    GLTexture* t = th ? handleAllocator.handle_cast<GLTexture*>(th) : nullptr;
+
    assert_invariant(binding < descriptors.size());
    std::visit([=, &gl](auto&& arg) mutable {
        using T = std::decay_t<decltype(arg)>;
@@ -171,20 +199,12 @@ void GLDescriptorSet::update(OpenGLContext& gl,
                }
            }

-            arg.target = t ? t->gl.target : 0;
-            arg.id = t ? t->gl.id : 0;
-            arg.external = t ? t->gl.external :  false;
+            arg.handle = th;
            if constexpr (std::is_same_v<T, Sampler> ||
                          std::is_same_v<T, SamplerWithAnisotropyWorkaround>) {
                if constexpr (std::is_same_v<T, SamplerWithAnisotropyWorkaround>) {
                    arg.anisotropy = float(1u << params.anisotropyLog2);
                }
-                if (t) {
-                    arg.ref = t->ref;
-                    arg.baseLevel = t->gl.baseLevel;
-                    arg.maxLevel = t->gl.maxLevel;
-                    arg.swizzle = t->gl.swizzle;
-                }
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
                arg.sampler = gl.getSampler(params);
 #else
@@ -200,39 +220,39 @@ void GLDescriptorSet::update(OpenGLContext& gl,
    }, descriptors[binding].desc);
 }

-template<typename T>
 void GLDescriptorSet::updateTextureView(OpenGLContext& gl,
-        HandleAllocatorGL& handleAllocator, GLuint unit, T const& desc) noexcept {
+        HandleAllocatorGL& handleAllocator, GLuint unit, GLTexture const* t) noexcept {
    // The common case is that we don't have a ref handle (we only have one if
    // the texture ever had a View on it).
-    assert_invariant(desc.ref);
-    GLTextureRef* const ref = handleAllocator.handle_cast<GLTextureRef*>(desc.ref);
-    if (UTILS_UNLIKELY((desc.baseLevel != ref->baseLevel || desc.maxLevel != ref->maxLevel))) {
+    assert_invariant(t);
+    assert_invariant(t->ref);
+    GLTextureRef* const ref = handleAllocator.handle_cast<GLTextureRef*>(t->ref);
+    if (UTILS_UNLIKELY((t->gl.baseLevel != ref->baseLevel || t->gl.maxLevel != ref->maxLevel))) {
        // If we have views, then it's still uncommon that we'll switch often
        // handle the case where we reset to the original texture
-        GLint baseLevel = GLint(desc.baseLevel); // NOLINT(*-signed-char-misuse)
-        GLint maxLevel = GLint(desc.maxLevel); // NOLINT(*-signed-char-misuse)
+        GLint baseLevel = GLint(t->gl.baseLevel); // NOLINT(*-signed-char-misuse)
+        GLint maxLevel = GLint(t->gl.maxLevel); // NOLINT(*-signed-char-misuse)
        if (baseLevel > maxLevel) {
            baseLevel = 0;
            maxLevel = 1000; // per OpenGL spec
        }
        // that is very unfortunate that we have to call activeTexture here
        gl.activeTexture(unit);
-        glTexParameteri(desc.target, GL_TEXTURE_BASE_LEVEL, baseLevel);
-        glTexParameteri(desc.target, GL_TEXTURE_MAX_LEVEL,  maxLevel);
-        ref->baseLevel = desc.baseLevel;
-        ref->maxLevel = desc.maxLevel;
+        glTexParameteri(t->gl.target, GL_TEXTURE_BASE_LEVEL, baseLevel);
+        glTexParameteri(t->gl.target, GL_TEXTURE_MAX_LEVEL,  maxLevel);
+        ref->baseLevel = t->gl.baseLevel;
+        ref->maxLevel = t->gl.maxLevel;
    }
-    if (UTILS_UNLIKELY(desc.swizzle != ref->swizzle)) {
+    if (UTILS_UNLIKELY(t->gl.swizzle != ref->swizzle)) {
        using namespace GLUtils;
        gl.activeTexture(unit);
 #if !defined(__EMSCRIPTEN__)  && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
-        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_R, (GLint)getSwizzleChannel(desc.swizzle[0]));
-        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_G, (GLint)getSwizzleChannel(desc.swizzle[1]));
-        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_B, (GLint)getSwizzleChannel(desc.swizzle[2]));
-        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_A, (GLint)getSwizzleChannel(desc.swizzle[3]));
+        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_R, (GLint)getSwizzleChannel(t->gl.swizzle[0]));
+        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_G, (GLint)getSwizzleChannel(t->gl.swizzle[1]));
+        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_B, (GLint)getSwizzleChannel(t->gl.swizzle[2]));
+        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_A, (GLint)getSwizzleChannel(t->gl.swizzle[3]));
 #endif
-        ref->swizzle = desc.swizzle;
+        ref->swizzle = t->gl.swizzle;
    }
 }

@@ -285,27 +305,31 @@ void GLDescriptorSet::bind(
                }
            } else if constexpr (std::is_same_v<T, Sampler>) {
                GLuint const unit = p.getTextureUnit(set, binding);
-                if (arg.target) {
-                    gl.bindTexture(unit, arg.target, arg.id, arg.external);
+
+
+                if (arg.handle) {
+                    GLTexture const* const t = handleAllocator.handle_cast<GLTexture*>(arg.handle);
+                    gl.bindTexture(unit, t->gl.target, t->gl.id, t->gl.external);
                    gl.bindSampler(unit, arg.sampler);
-                    if (UTILS_UNLIKELY(arg.ref)) {
-                        updateTextureView(gl, handleAllocator, unit, arg);
+                    if (UTILS_UNLIKELY(t->ref)) {
+                        updateTextureView(gl, handleAllocator, unit, t);
                    }
                } else {
                    gl.unbindTextureUnit(unit);
                }
            } else if constexpr (std::is_same_v<T, SamplerWithAnisotropyWorkaround>) {
                GLuint const unit = p.getTextureUnit(set, binding);
-                if (arg.target) {
-                    gl.bindTexture(unit, arg.target, arg.id, arg.external);
+                if (arg.handle) {
+                    GLTexture const* const t = handleAllocator.handle_cast<GLTexture*>(arg.handle);
+                    gl.bindTexture(unit, t->gl.target, t->gl.id, t->gl.external);
                    gl.bindSampler(unit, arg.sampler);
-                    if (UTILS_UNLIKELY(arg.ref)) {
-                        updateTextureView(gl, handleAllocator, unit, arg);
+                    if (UTILS_UNLIKELY(t->ref)) {
+                        updateTextureView(gl, handleAllocator, unit, t);
                    }
 #if defined(GL_EXT_texture_filter_anisotropic)
                    // Driver claims to support anisotropic filtering, but it fails when set on
                    // the sampler, we have to set it on the texture instead.
-                    glTexParameterf(arg.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
+                    glTexParameterf(t->gl.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                            std::min(gl.gets.max_anisotropy, float(arg.anisotropy)));
 #endif
                } else {
@@ -314,19 +338,20 @@ void GLDescriptorSet::bind(
            } else if constexpr (std::is_same_v<T, SamplerGLES2>) {
                // in ES2 the sampler parameters need to be set on the texture itself
                GLuint const unit = p.getTextureUnit(set, binding);
-                if (arg.target) {
-                    gl.bindTexture(unit, arg.target, arg.id, arg.external);
+                if (arg.handle) {
+                    GLTexture const* const t = handleAllocator.handle_cast<GLTexture*>(arg.handle);
+                    gl.bindTexture(unit, t->gl.target, t->gl.id, t->gl.external);
                    SamplerParams const params = arg.params;
-                    glTexParameteri(arg.target, GL_TEXTURE_MIN_FILTER,
+                    glTexParameteri(t->gl.target, GL_TEXTURE_MIN_FILTER,
                            (GLint)GLUtils::getTextureFilter(params.filterMin));
-                    glTexParameteri(arg.target, GL_TEXTURE_MAG_FILTER,
+                    glTexParameteri(t->gl.target, GL_TEXTURE_MAG_FILTER,
                            (GLint)GLUtils::getTextureFilter(params.filterMag));
-                    glTexParameteri(arg.target, GL_TEXTURE_WRAP_S,
+                    glTexParameteri(t->gl.target, GL_TEXTURE_WRAP_S,
                            (GLint)GLUtils::getWrapMode(params.wrapS));
-                    glTexParameteri(arg.target, GL_TEXTURE_WRAP_T,
+                    glTexParameteri(t->gl.target, GL_TEXTURE_WRAP_T,
                            (GLint)GLUtils::getWrapMode(params.wrapT));
 #if defined(GL_EXT_texture_filter_anisotropic)
-                    glTexParameterf(arg.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
+                    glTexParameterf(t->gl.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                            std::min(gl.gets.max_anisotropy, arg.anisotropy));
 #endif
                } else {
@@ -59,8 +59,8 @@ struct GLDescriptorSet : public HwDescriptorSet {
            descriptor_binding_t binding, GLBufferObject* bo, size_t offset, size_t size) noexcept;

    // update a sampler descriptor in the set
-    void update(OpenGLContext& gl,
-            descriptor_binding_t binding, GLTexture* t, SamplerParams params) noexcept;
+    void update(OpenGLContext& gl, HandleAllocatorGL& handleAllocator,
+            descriptor_binding_t binding, TextureHandle th, SamplerParams params) noexcept;

    // conceptually bind the set to the command buffer
    void bind(
@@ -111,46 +111,19 @@ private:

    // A sampler descriptor
    struct Sampler {
-        uint16_t target;                        // 2 (GLenum)
-        bool external = false;                  // 1
-        bool reserved = false;                  // 1
-        GLuint id = 0;                          // 4
+        TextureHandle handle;                   // 4
        GLuint sampler = 0;                     // 4
-        Handle<GLTextureRef> ref;               // 4
-        int8_t baseLevel = 0x7f;                // 1
-        int8_t maxLevel = -1;                   // 1
-        std::array<TextureSwizzle, 4> swizzle{  // 4
-                TextureSwizzle::CHANNEL_0,
-                TextureSwizzle::CHANNEL_1,
-                TextureSwizzle::CHANNEL_2,
-                TextureSwizzle::CHANNEL_3
-        };
    };

    struct SamplerWithAnisotropyWorkaround {
-        uint16_t target;                        // 2 (GLenum)
-        bool external = false;                  // 1
-        bool reserved = false;                  // 1
-        GLuint id = 0;                          // 4
+        TextureHandle handle;                   // 4
        GLuint sampler = 0;                     // 4
-        Handle<GLTextureRef> ref;               // 4
        math::half anisotropy = 1.0f;           // 2
-        int8_t baseLevel = 0x7f;                // 1
-        int8_t maxLevel = -1;                   // 1
-        std::array<TextureSwizzle, 4> swizzle{  // 4
-                TextureSwizzle::CHANNEL_0,
-                TextureSwizzle::CHANNEL_1,
-                TextureSwizzle::CHANNEL_2,
-                TextureSwizzle::CHANNEL_3
-        };
    };

    // A sampler descriptor for ES2
    struct SamplerGLES2 {
-        uint16_t target;                        // 2 (GLenum)
-        bool external = false;                  // 1
-        bool reserved = false;                  // 1
-        GLuint id = 0;                          // 4
+        TextureHandle handle;                   // 4
        SamplerParams params{};                 // 4
        float anisotropy = 1.0f;                // 4
    };
@@ -165,9 +138,8 @@ private:
    };
    static_assert(sizeof(Descriptor) <= 32);

-    template<typename T>
    static void updateTextureView(OpenGLContext& gl,
-            HandleAllocatorGL& handleAllocator, GLuint unit, T const& desc) noexcept;
+            HandleAllocatorGL& handleAllocator, GLuint unit, GLTexture const* t) noexcept;

    utils::FixedCapacityVector<Descriptor> descriptors;     // 16
    utils::bitset64 dynamicBuffers;                         // 8
@@ -21,7 +21,7 @@
 #include <backend/Platform.h>
 #include <backend/Program.h>

-#include <utils/Systrace.h>
+#include <private/utils/Tracing.h>

 namespace filament::backend {

@@ -36,7 +36,7 @@ OpenGLBlobCache::OpenGLBlobCache(OpenGLContext& gl) noexcept

 GLuint OpenGLBlobCache::retrieve(BlobCacheKey* outKey, Platform& platform,
        Program const& program) const noexcept {
-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
    if (!mCachingSupported || !platform.hasRetrieveBlobFunc()) {
        // the key is never updated in that case
        return 0;
@@ -68,7 +68,7 @@ GLuint OpenGLBlobCache::retrieve(BlobCacheKey* outKey, Platform& platform,
        programId = glCreateProgram();

        { // scope for systrace
-            SYSTRACE_NAME("glProgramBinary");
+            FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glProgramBinary");
            glProgramBinary(programId, blob->format, blob->data, programBinarySize);
        }

@@ -90,7 +90,7 @@ GLuint OpenGLBlobCache::retrieve(BlobCacheKey* outKey, Platform& platform,

 void OpenGLBlobCache::insert(Platform& platform,
        BlobCacheKey const& key, GLuint program) noexcept {
-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
    if (!mCachingSupported || !platform.hasInsertBlobFunc()) {
        // the key is never updated in that case
        return;
@@ -100,7 +100,7 @@ void OpenGLBlobCache::insert(Platform& platform,
    GLenum format;
    GLint programBinarySize = 0;
    { // scope for systrace
-        SYSTRACE_NAME("glGetProgramiv");
+        FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glGetProgramiv");
        glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &programBinarySize);
    }
    if (programBinarySize) {
@@ -108,7 +108,7 @@ void OpenGLBlobCache::insert(Platform& platform,
        std::unique_ptr<Blob, decltype(&::free)> blob{ (Blob*)malloc(size), &::free };
        if (UTILS_LIKELY(blob)) {
            { // scope for systrace
-                SYSTRACE_NAME("glGetProgramBinary");
+                FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glGetProgramBinary");
                glGetProgramBinary(program, programBinarySize,
                        &programBinarySize, &format, blob->data);
            }
@@ -542,6 +542,13 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
        } else if (strstr(renderer, "Intel")) {
            // Intel GPU
            bugs->vao_doesnt_store_element_array_buffer_binding = true;
+
+            if (strstr(renderer, "Mesa")) {
+                // Mesa Intel driver on Linux/Android
+                // Renderer of the form [Mesa Intel(R) HD Graphics 505 (APL 3)]
+                // b/405252622
+                bugs->disable_invalidate_framebuffer = true;
+            }
        } else if (strstr(renderer, "PowerVR")) {
            // PowerVR GPU
            // On PowerVR (Rogue GE8320) glFlush doesn't seem to do anything, in particular,
@@ -44,6 +44,8 @@
 #include "private/backend/Dispatcher.h"
 #include "private/backend/DriverApi.h"

+#include <private/utils/Tracing.h>
+
 #include <type_traits>
 #include <utils/BitmaskEnum.h>
 #include <utils/FixedCapacityVector.h>
@@ -51,7 +53,6 @@
 #include <utils/Invocable.h>
 #include <utils/Log.h>
 #include <utils/Panic.h>
-#include <utils/Systrace.h>
 #include <utils/Slice.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
@@ -98,13 +99,13 @@

 #define DEBUG_GROUP_MARKER_NONE       0x00    // no debug marker
 #define DEBUG_GROUP_MARKER_OPENGL     0x01    // markers in the gl command queue (req. driver support)
-#define DEBUG_GROUP_MARKER_BACKEND    0x02    // markers on the backend side (systrace)
+#define DEBUG_GROUP_MARKER_BACKEND    0x02    // markers on the backend side (perfetto)
 #define DEBUG_GROUP_MARKER_ALL        0xFF    // all markers

 #define DEBUG_MARKER_NONE             0x00    // no debug marker
 #define DEBUG_MARKER_OPENGL           0x01    // markers in the gl command queue (req. driver support)
-#define DEBUG_MARKER_BACKEND          0x02    // markers on the backend side (systrace)
-#define DEBUG_MARKER_PROFILE          0x04    // profiling on the backend side (systrace)
+#define DEBUG_MARKER_BACKEND          0x02    // markers on the backend side (perfetto)
+#define DEBUG_MARKER_PROFILE          0x04    // profiling on the backend side (perfetto)
 #define DEBUG_MARKER_ALL              (0xFF & ~DEBUG_MARKER_PROFILE) // all markers

 // set to the desired debug marker level (for user markers [default: All])
@@ -248,8 +249,8 @@ OpenGLDriver::DebugMarker::DebugMarker(OpenGLDriver& driver, const char* string)
 #endif

 #if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
-    SYSTRACE_CONTEXT();
-    SYSTRACE_NAME_BEGIN(string);
+    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, string);
 #endif
 #endif
 }
@@ -265,8 +266,8 @@ OpenGLDriver::DebugMarker::~DebugMarker() noexcept {
 #endif

 #if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
-    SYSTRACE_CONTEXT();
-    SYSTRACE_NAME_END();
+    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
 #endif
 #endif
 }
@@ -642,6 +643,25 @@ void OpenGLDriver::createVertexBufferInfoR(
        AttributeArray attributes) {
    DEBUG_MARKER()
    construct<GLVertexBufferInfo>(vbih, bufferCount, attributeCount, attributes);
+
+    // test ----
+    int16_t returned_value = handle_set_value<GLVertexBufferInfo*>(vbih, 90);
+    uint8_t age = (uint8_t) (returned_value >> 8);
+    uint8_t test_value = (returned_value & 0xff);
+    switch (test_value) {
+        case -2:
+        case -1:
+        case 0:
+            utils::slog.w << "@@@ createVertexBufferInfoR: unexpected result, age:" << (int) age
+                          << ", test_value:" << (int) test_value << utils::io::endl;
+            break;
+        default:
+            FILAMENT_CHECK_POSTCONDITION(test_value == 1)
+                    << "@@@ createVertexBufferInfoR: shouldn't happen, age:" << (int) age
+                    << ", test_value:" << (int) test_value << utils::io::endl;
+            break;
+    }
+    //----------
 }

 void OpenGLDriver::createVertexBufferR(
@@ -760,6 +780,25 @@ void OpenGLDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {

    construct<OpenGLProgram>(ph, *this, std::move(program));
    CHECK_GL_ERROR(utils::slog.e)
+
+    // test ----
+    int16_t returned_value = handle_set_value<OpenGLProgram*>(ph, 100);
+    uint8_t age = (uint8_t) (returned_value >> 8);
+    uint8_t test_value = (returned_value & 0xff);
+    switch (test_value) {
+        case -2:
+        case -1:
+        case 0:
+            utils::slog.w << "@@@ createProgramR: unexpected result, age:" << (int)age << ", test_value:" << (int)test_value
+                          << utils::io::endl;
+            break;
+        default:
+            FILAMENT_CHECK_POSTCONDITION(test_value == 1)
+                    << "@@@ createProgramR: shouldn't happen, age:" << (int)age
+                    << ", test_value:" << (int)test_value << utils::io::endl;
+            break;
+    }
+    //----------
 }

 UTILS_NOINLINE
@@ -931,7 +970,12 @@ void OpenGLDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
 #if defined(BACKEND_OPENGL_LEVEL_GLES31)
                if (gl.features.multisample_texture) {
                    // multi-sample texture on GL 3.2 / GLES 3.1 and above
-                    t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
+                    if (depth <= 1) {
+                        // We forcibly change the target to 2D-multisample only for flat texture.
+                        // A depth value greater than 1 may indicate multiview usage, which requires
+                        // GL_TEXTURE_2D_ARRAY. Also 2D MSAA won't work with non-flat texture anyway.
+                        t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
+                    }
                } else {
                    // Turn off multi-sampling for that texture. It's just not supported.
                }
@@ -1207,7 +1251,12 @@ void OpenGLDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
 #if defined(BACKEND_OPENGL_LEVEL_GLES31)
        if (gl.features.multisample_texture) {
            // multi-sample texture on GL 3.2 / GLES 3.1 and above
-            t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
+            if (depth <= 1) {
+                // We forcibly change the target to 2D-multisample only for flat texture.
+                // A depth value greater than 1 may indicate multiview usage, which requires
+                // GL_TEXTURE_2D_ARRAY. Also 2D MSAA won't work with non-flat texture anyway.
+                t->gl.target = GL_TEXTURE_2D_MULTISAMPLE;
+            }
        } else {
            // Turn off multi-sampling for that texture. It's just not supported.
        }
@@ -1452,8 +1501,15 @@ void OpenGLDriver::framebufferTexture(TargetBufferInfo const& binfo,
 #if !defined(__EMSCRIPTEN__) && !defined(FILAMENT_IOS)
                if (layerCount > 1) {
                    // if layerCount > 1, it means we use the multiview extension.
-                    glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, attachment,
-                        t->gl.id, 0, binfo.layer, layerCount);
+                    if (rt->gl.samples > 1) {
+                        // For MSAA
+                        glFramebufferTextureMultisampleMultiviewOVR(GL_FRAMEBUFFER, attachment,
+                                t->gl.id, 0, rt->gl.samples, binfo.layer, layerCount);
+                    }
+                    else {
+                        glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, attachment, t->gl.id, 0,
+                                binfo.layer, layerCount);
+                    }
                } else
 #endif // !defined(__EMSCRIPTEN__) && !defined(FILAMENT_IOS)
                {
@@ -1900,6 +1956,25 @@ void OpenGLDriver::destroyRenderPrimitive(Handle<HwRenderPrimitive> rph) {
 void OpenGLDriver::destroyProgram(Handle<HwProgram> ph) {
    DEBUG_MARKER()
    if (ph) {
+        // test ----
+        int16_t returned_value = handle_set_value<OpenGLProgram*>(ph, 101);
+        uint8_t age = (uint8_t) (returned_value >> 8);
+        uint8_t test_value = (returned_value & 0xff);
+        switch (test_value) {
+            case -2:
+            case -1:
+            case 0:
+                utils::slog.w << "@@@ destroyProgram: unexpected result, age:" << (int) age
+                              << ", test_value:" << (int) test_value << utils::io::endl;
+                break;
+            default:
+                FILAMENT_CHECK_POSTCONDITION(test_value == 1)
+                        << "@@@ destroyProgram: shouldn't happen, age:" << (int) age
+                        << ", test_value:" << (int) test_value << utils::io::endl;
+                break;
+        }
+        //----------
+
        OpenGLProgram* p = handle_cast<OpenGLProgram*>(ph);
        destruct(ph, p);
    }
@@ -2513,10 +2588,28 @@ void OpenGLDriver::makeCurrent(Handle<HwSwapChain> schDraw, Handle<HwSwapChain>

    mPlatform.makeCurrent(scDraw->swapChain, scRead->swapChain,
            [this]() {
+                for (auto t: mTexturesWithStreamsAttached) {
+                    if (t->hwStream->streamType == StreamType::NATIVE) {
+                        mPlatform.detach(t->hwStream->stream);
+                    }
+                }
                // OpenGL context is about to change, unbind everything
                mContext.unbindEverything();
            },
            [this](size_t index) {
+                for (auto t: mTexturesWithStreamsAttached) {
+                    if (t->hwStream->streamType == StreamType::NATIVE) {
+                        glGenTextures(1, &t->gl.id);
+                        mPlatform.attach(t->hwStream->stream, t->gl.id);
+                        mContext.updateTexImage(GL_TEXTURE_EXTERNAL_OES, t->gl.id);
+                    }
+                }
+
+                // force invalidation of all bound descriptor sets
+                decltype(mInvalidDescriptorSetBindings) changed;
+                changed.setValue((1 << MAX_DESCRIPTOR_SET_COUNT) - 1);
+                mInvalidDescriptorSetBindings |= changed;
+
                // OpenGL context has changed, resynchronize the state with the cache
                mContext.synchronizeStateAndCache(index);
                slog.d << "*** OpenGL context change : " << (index ? "protected" : "default") << io::endl;
@@ -3348,8 +3441,8 @@ void OpenGLDriver::pushGroupMarker(char const* string) {
 #endif

 #if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_BACKEND
-    SYSTRACE_CONTEXT();
-    SYSTRACE_NAME_BEGIN(string);
+    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, string);
 #endif
 #endif
 }
@@ -3365,8 +3458,8 @@ void OpenGLDriver::popGroupMarker(int) {
 #endif

 #if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_BACKEND
-    SYSTRACE_CONTEXT();
-    SYSTRACE_NAME_END();
+    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
 #endif
 #endif
 }
@@ -3685,7 +3778,7 @@ void OpenGLDriver::endFrame(UTILS_UNUSED uint32_t frameId) {
    gl.depthFunc(GL_LESS);
    gl.disable(GL_SCISSOR_TEST);
 #endif
-    //SYSTRACE_NAME("glFinish");
+    //FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glFinish");
    //glFinish();
    mPlatform.endFrame(frameId);
    insertEventMarker("endFrame");
@@ -3707,8 +3800,7 @@ void OpenGLDriver::updateDescriptorSetTexture(
        TextureHandle th,
        SamplerParams params) {
    GLDescriptorSet* ds = handle_cast<GLDescriptorSet*>(dsh);
-    GLTexture* t = th ? handle_cast<GLTexture*>(th) : nullptr;
-    ds->update(mContext, binding, t, params);
+    ds->update(mContext, mHandleAllocator, binding, th, params);
 }

 void OpenGLDriver::flush(int) {
@@ -4031,6 +4123,24 @@ void OpenGLDriver::bindPipeline(PipelineState const& state) {
    setRasterState(state.rasterState);
    setStencilState(state.stencilState);
    gl.polygonOffset(state.polygonOffset.slope, state.polygonOffset.constant);
+    // test ----
+    Handle<HwProgram> pro = state.program;
+    int16_t returned_value = handle_get_value<OpenGLProgram*>(pro);
+    uint8_t age = (uint8_t)(returned_value >> 8);
+    uint8_t test_value = (returned_value & 0xff);
+    switch (test_value) {
+    case -2:
+    case -1:
+    case 0:
+        utils::slog.w << "@@@ bindPipeline: unexpected result, age:" << (int)age << ", test_value:" << (int)test_value << utils::io::endl;
+        break;
+    default:
+        if (test_value != 100) {
+            utils::slog.w << "@@@ bindPipeline: program is not valid OpenGLProgram, age:" << (int)age << ", test_value:" << (int)test_value << utils::io::endl;
+        }
+        break;
+    }
+    //----------
    OpenGLProgram* const p = handle_cast<OpenGLProgram*>(state.program);
    mValidProgram = useProgram(p);
    (*mCurrentPushConstants) = p->getPushConstants();
@@ -282,6 +282,20 @@ private:
        return mHandleAllocator.handle_cast<Dp, B>(handle);
    }

+    template<typename Dp, typename B>
+    std::enable_if_t<std::is_pointer_v<Dp> && std::is_base_of_v<B, std::remove_pointer_t<Dp>>,
+            int16_t>
+    handle_set_value(Handle<B>& handle, uint8_t v) {
+        return mHandleAllocator.handle_set_value<Dp, B>(handle, v);
+    }
+
+    template<typename Dp, typename B>
+    std::enable_if_t<std::is_pointer_v<Dp> && std::is_base_of_v<B, std::remove_pointer_t<Dp>>,
+            int16_t>
+    handle_get_value(Handle<B>& handle) {
+        return mHandleAllocator.handle_get_value<Dp, B>(handle);
+    }
+
    friend class OpenGLProgram;
    friend class ShaderCompilerService;

@@ -64,7 +64,7 @@ utils::CString OpenGLPlatform::getRendererString(Driver const* driver) {
 }

 void OpenGLPlatform::makeCurrent(SwapChain* drawSwapChain, SwapChain* readSwapChain,
-        utils::Invocable<void()>, utils::Invocable<void(size_t)>) noexcept {
+        utils::Invocable<void()>, utils::Invocable<void(size_t)>) {
    makeCurrent(getCurrentContextType(), drawSwapChain, readSwapChain);
 }

@@ -25,12 +25,13 @@
 #include <backend/Program.h>
 #include <backend/Handle.h>

+#include <private/utils/Tracing.h>
+
 #include <utils/BitmaskEnum.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
-#include <utils/Systrace.h>

 #include <algorithm>
 #include <array>
@@ -96,8 +97,7 @@ OpenGLProgram::~OpenGLProgram() noexcept {
 }

 void OpenGLProgram::initialize(OpenGLDriver& gld) {
-
-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);

    assert_invariant(gl.program == 0);
    assert_invariant(mToken);
@@ -122,8 +122,7 @@ void OpenGLProgram::initialize(OpenGLDriver& gld) {
 */
 void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint program,
        LazyInitializationData& lazyInitializationData) noexcept {
-
-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);

    // from the pipeline layout we compute a mapping from {set, binding} to {binding}
    // for both buffers and textures
@@ -175,7 +174,31 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
                    }
                    break;
                }
-                case DescriptorType::SAMPLER:
+                case DescriptorType::SAMPLER_2D_FLOAT:
+                case DescriptorType::SAMPLER_2D_INT:
+                case DescriptorType::SAMPLER_2D_UINT:
+                case DescriptorType::SAMPLER_2D_DEPTH:
+                case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
+                case DescriptorType::SAMPLER_2D_ARRAY_INT:
+                case DescriptorType::SAMPLER_2D_ARRAY_UINT:
+                case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
+                case DescriptorType::SAMPLER_CUBE_FLOAT:
+                case DescriptorType::SAMPLER_CUBE_INT:
+                case DescriptorType::SAMPLER_CUBE_UINT:
+                case DescriptorType::SAMPLER_CUBE_DEPTH:
+                case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
+                case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
+                case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
+                case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
+                case DescriptorType::SAMPLER_3D_FLOAT:
+                case DescriptorType::SAMPLER_3D_INT:
+                case DescriptorType::SAMPLER_3D_UINT:
+                case DescriptorType::SAMPLER_2D_MS_FLOAT:
+                case DescriptorType::SAMPLER_2D_MS_INT:
+                case DescriptorType::SAMPLER_2D_MS_UINT:
+                case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
+                case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
+                case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
                case DescriptorType::SAMPLER_EXTERNAL: {
                    if (!entry.name.empty()) {
                        GLint const loc = glGetUniformLocation(program, entry.name.c_str());
@@ -23,12 +23,13 @@
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/DriverEnums.h>

+#include <private/utils/Tracing.h>
+
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/JobSystem.h>
 #include <utils/Log.h>
 #include <utils/Mutex.h>
-#include <utils/Systrace.h>

 #include <atomic>
 #include <memory>
@@ -240,8 +241,8 @@ void TimerQueryFenceFactory::beginTimeElapsedQuery(GLTimerQuery* tq) {
        if (state) {
            platform.waitFence(fence, FENCE_WAIT_FOR_EVER);
            state->then = clock::now().time_since_epoch().count();
-            SYSTRACE_CONTEXT();
-            SYSTRACE_ASYNC_BEGIN("OpenGLTimerQueryFence", intptr_t(state.get()));
+            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+            FILAMENT_TRACING_ASYNC_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, "OpenGLTimerQueryFence", intptr_t(state.get()));
        }
        platform.destroyFence(fence);
    });
@@ -257,8 +258,8 @@ void TimerQueryFenceFactory::endTimeElapsedQuery(OpenGLDriver&, GLTimerQuery* tq
            platform.waitFence(fence, FENCE_WAIT_FOR_EVER);
            int64_t const now = clock::now().time_since_epoch().count();
            state->elapsed.store(now - state->then, std::memory_order_relaxed);
-            SYSTRACE_CONTEXT();
-            SYSTRACE_ASYNC_END("OpenGLTimerQueryFence", intptr_t(state.get()));
+            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+            FILAMENT_TRACING_ASYNC_END(FILAMENT_TRACING_CATEGORY_FILAMENT, "OpenGLTimerQueryFence", intptr_t(state.get()));
        }
        platform.destroyFence(fence);
    });
@@ -28,6 +28,8 @@
 #include <backend/DriverEnums.h>
 #include <backend/Program.h>

+#include <private/utils/Tracing.h>
+
 #include <utils/compiler.h>
 #include <utils/CString.h>
 #include <utils/debug.h>
@@ -36,7 +38,6 @@
 #include <utils/Log.h>
 #include <utils/ostream.h>
 #include <utils/Panic.h>
-#include <utils/Systrace.h>

 #include <algorithm>
 #include <array>
@@ -367,7 +368,7 @@ void ShaderCompilerService::notifyWhenAllProgramsAreReady(

 GLuint ShaderCompilerService::initialize(program_token_t& token) {

-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);

    assert_invariant(token);// This function should be called when the token is still alive.

@@ -454,8 +455,8 @@ void ShaderCompilerService::runAtNextTick(CompilerPriorityQueue priority,
            });
    ops.emplace(pos, priority, token, std::move(job));

-    SYSTRACE_CONTEXT();
-    SYSTRACE_VALUE32("ShaderCompilerService Jobs", mRunAtNextTickOps.size());
+    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "ShaderCompilerService Jobs", mRunAtNextTickOps.size());
 }

 bool ShaderCompilerService::cancelTickOp(program_token_t const& token) noexcept {
@@ -468,8 +469,8 @@ bool ShaderCompilerService::cancelTickOp(program_token_t const& token) noexcept
        ops.erase(pos);
        return true;
    }
-    SYSTRACE_CONTEXT();
-    SYSTRACE_VALUE32("ShaderCompilerService Jobs", ops.size());
+    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "ShaderCompilerService Jobs", ops.size());
    return false;
 }

@@ -485,15 +486,15 @@ void ShaderCompilerService::executeTickOps() noexcept {
            ++it;
        }
    }
-    SYSTRACE_CONTEXT();
-    SYSTRACE_VALUE32("ShaderCompilerService Jobs", ops.size());
+    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "ShaderCompilerService Jobs", ops.size());
 }

 /* static */ void ShaderCompilerService::compileShaders(OpenGLContext& context,
        Program::ShaderSource shadersSource,
        FixedCapacityVector<Program::SpecializationConstant> const& specializationConstants,
        bool multiview, program_token_t const& token) noexcept {
-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);

    auto const appendSpecConstantString = +[](std::string& s, Program::SpecializationConstant const& sc) {
        s += "#define SPIRV_CROSS_CONSTANT_ID_" + std::to_string(sc.id) + ' ';
@@ -616,7 +617,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 }

 /* static */ void ShaderCompilerService::checkCompileStatus(program_token_t const& token) noexcept {
-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);

    UTILS_NOUNROLL
    for (size_t i = 0; i < Program::SHADER_TYPE_COUNT; i++) {
@@ -639,7 +640,7 @@ void ShaderCompilerService::executeTickOps() noexcept {

 /* static */ void ShaderCompilerService::linkProgram(OpenGLContext const& context,
        program_token_t const& token) noexcept {
-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);

    // Shader compilation should be completed by now. Check the status and log errors on failure.
    checkCompileStatus(token);
@@ -675,7 +676,7 @@ void ShaderCompilerService::executeTickOps() noexcept {

 /* static */ bool ShaderCompilerService::checkLinkStatusAndCleanupShaders(
        program_token_t const& token) noexcept {
-    SYSTRACE_CALL();
+    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
    assert_invariant(token->gl.program);

    bool linked = true;
@@ -70,6 +70,9 @@ PFNGLMAXSHADERCOMPILERTHREADSKHRPROC glMaxShaderCompilerThreadsKHR;
 #ifdef GL_OVR_multiview
 PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC glFramebufferTextureMultiviewOVR;
 #endif
+#ifdef GL_OVR_multiview_multisampled_render_to_texture
+PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC glFramebufferTextureMultisampleMultiviewOVR;
+#endif

 #if defined(__ANDROID__) && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
 // On Android, If we want to support a build system less than ANDROID_API 21, we need to
@@ -123,6 +126,9 @@ void importGLESExtensionsEntryPoints() {
 #ifdef GL_OVR_multiview
        getProcAddress(glFramebufferTextureMultiviewOVR, "glFramebufferTextureMultiviewOVR");
 #endif
+#ifdef GL_OVR_multiview_multisampled_render_to_texture
+        getProcAddress(glFramebufferTextureMultisampleMultiviewOVR, "glFramebufferTextureMultisampleMultiviewOVR");
+#endif
 #if defined(__ANDROID__) && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
        getProcAddress(glDispatchCompute, "glDispatchCompute");
 #endif
@@ -154,6 +154,9 @@ extern PFNGLMAXSHADERCOMPILERTHREADSKHRPROC glMaxShaderCompilerThreadsKHR;
 #ifdef GL_OVR_multiview
 extern PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC glFramebufferTextureMultiviewOVR;
 #endif
+#ifdef GL_OVR_multiview_multisampled_render_to_texture
+extern PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC glFramebufferTextureMultisampleMultiviewOVR;
+#endif
 #if defined(__ANDROID__) && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
 extern PFNGLDISPATCHCOMPUTEPROC glDispatchCompute;
 #endif
@@ -54,7 +54,7 @@ struct PlatformCocoaGLImpl {
    CVOpenGLTextureCacheRef mTextureCache = nullptr;
    std::unique_ptr<CocoaExternalImage::SharedGl> mExternalImageSharedGl;
    void updateOpenGLContext(NSView *nsView, bool resetView, bool clearView);
-    struct ExternalImageCocoaGL : public Platform::ExternalImage {
+    struct ExternalImageCocoaGL final : public Platform::ExternalImage {
        CVPixelBufferRef cvBuffer;
    protected:
        ~ExternalImageCocoaGL() noexcept final;
@@ -255,7 +255,7 @@ void PlatformCocoaGL::destroySwapChain(Platform::SwapChain* swapChain) noexcept
 }

 bool PlatformCocoaGL::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) noexcept {
+        SwapChain* readSwapChain) {
    ASSERT_PRECONDITION_NON_FATAL(drawSwapChain == readSwapChain,
            "ContextManagerCocoa does not support using distinct draw/read swap chains.");
    CocoaGLSwapChain* swapChain = (CocoaGLSwapChain*)drawSwapChain;
@@ -155,7 +155,7 @@ uint32_t PlatformCocoaTouchGL::getDefaultFramebufferObject() noexcept {
 }

 bool PlatformCocoaTouchGL::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) noexcept {
+        SwapChain* readSwapChain) {
    ASSERT_PRECONDITION_NON_FATAL(drawSwapChain == readSwapChain,
            "PlatformCocoaTouchGL does not support using distinct draw/read swap chains.");
    CAEAGLLayer* const glLayer = (__bridge CAEAGLLayer*) drawSwapChain;
@@ -577,18 +577,18 @@ OpenGLPlatform::ContextType PlatformEGL::getCurrentContextType() const noexcept
 }

 bool PlatformEGL::makeCurrent(ContextType type,
-        SwapChain* drawSwapChain, SwapChain* readSwapChain) noexcept {
+        SwapChain* drawSwapChain, SwapChain* readSwapChain) {
    SwapChainEGL const* const dsc = static_cast<SwapChainEGL const*>(drawSwapChain);
    SwapChainEGL const* const rsc = static_cast<SwapChainEGL const*>(readSwapChain);
    EGLContext context = getContextForType(type);
    EGLBoolean const success = egl.makeCurrent(context, dsc->sur, rsc->sur);
-    return success == EGL_TRUE ? true : false;
+    return success == EGL_TRUE;
 }

 void PlatformEGL::makeCurrent(SwapChain* drawSwapChain,
        SwapChain* readSwapChain,
        Invocable<void()> preContextChange,
-        Invocable<void(size_t index)> postContextChange) noexcept {
+        Invocable<void(size_t index)> postContextChange) {

    assert_invariant(drawSwapChain);
    assert_invariant(readSwapChain);
@@ -796,7 +796,7 @@ void PlatformEGL::Config::erase(EGLint name) noexcept {
 // ------------------------------------------------------------------------------------------------

 EGLBoolean PlatformEGL::EGL::makeCurrent(EGLContext context, EGLSurface drawSurface,
-        EGLSurface readSurface) noexcept {
+        EGLSurface readSurface) {
    if (UTILS_UNLIKELY((
            mCurrentContext != context ||
            drawSurface != mCurrentDrawSurface || readSurface != mCurrentReadSurface))) {
@@ -135,7 +135,7 @@ static constexpr const std::string_view kNativeWindowInvalidMsg =

 bool PlatformEGLAndroid::makeCurrent(ContextType type,
        SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) noexcept {
+        SwapChain* readSwapChain) {

    // fast & safe path
    if (UTILS_LIKELY(!mAssertNativeWindowIsValid)) {
@@ -255,6 +255,7 @@ Platform::ExternalImageHandle PlatformEGLAndroid::createExternalImage(AHardwareB
        p->height = hardwareBufferDescription.height;
        p->width = hardwareBufferDescription.width;
        auto textureFormat = mapToFilamentFormat(hardwareBufferDescription.format, sRGB);
+        p->format = textureFormat;
        p->usage = mapToFilamentUsage(hardwareBufferDescription.usage, textureFormat);
        return ExternalImageHandle{ p };
    }
@@ -266,7 +266,7 @@ void PlatformGLX::destroySwapChain(Platform::SwapChain* swapChain) noexcept {
 }

 bool PlatformGLX::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) noexcept {
+        SwapChain* readSwapChain) {
    g_glx.setCurrentContext(mGLXDisplay,
            (GLXDrawable)drawSwapChain, (GLXDrawable)readSwapChain, mGLXContext);
    return true;
@@ -169,7 +169,7 @@ void PlatformOSMesa::destroySwapChain(Platform::SwapChain* swapChain) noexcept {
 }

 bool PlatformOSMesa::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) noexcept {
+        SwapChain* readSwapChain) {
    OSMesaAPI* api = (OSMesaAPI*) mOsMesaApi;
    OSMesaSwapchain* impl = (OSMesaSwapchain*) drawSwapChain;

@@ -262,7 +262,7 @@ void PlatformWGL::destroySwapChain(Platform::SwapChain* swapChain) noexcept {
 }

 bool PlatformWGL::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) noexcept {
+        SwapChain* readSwapChain) {
    ASSERT_PRECONDITION_NON_FATAL(drawSwapChain == readSwapChain,
                                  "PlatformWGL does not support distinct draw/read swap chains.");

@@ -47,7 +47,7 @@ void PlatformWebGL::destroySwapChain(Platform::SwapChain* swapChain) noexcept {
 }

 bool PlatformWebGL::makeCurrent(ContextType type, SwapChain* drawSwapChain,
-        SwapChain* readSwapChain) noexcept {
+        SwapChain* readSwapChain) {
    return true;
 }

@@ -28,7 +28,7 @@ VulkanBuffer::VulkanBuffer(VmaAllocator allocator, VulkanStagePool& stagePool,
    : mAllocator(allocator),
      mStagePool(stagePool),
      mUsage(usage),
-	  mUpdatedOffset(0),
+      mUpdatedOffset(0),
      mUpdatedBytes(0) {
    // for now make sure that only 1 bit is set in usage
    // (because loadFromCpu() assumes that somewhat)
@@ -56,11 +56,12 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
    vmaMapMemory(mAllocator, stage->memory, &mapped);
    memcpy(mapped, cpuData, numBytes);
    vmaUnmapMemory(mAllocator, stage->memory);
-    vmaFlushAllocation(mAllocator, stage->memory, byteOffset, numBytes);
+    vmaFlushAllocation(mAllocator, stage->memory, 0, numBytes);

    // If there was a previous update, then we need to make sure the following write is properly
    // synced with the previous read.
-    if (mUpdatedBytes > 0) {
+    if (mUpdatedBytes > 0 &&
+            (byteOffset >= mUpdatedOffset && byteOffset <= (mUpdatedOffset + mUpdatedBytes))) {
        VkAccessFlags srcAccess = 0;
        VkPipelineStageFlags srcStage = 0;
        if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
@@ -74,28 +75,28 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
            srcStage = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
        }

-        VkBufferMemoryBarrier barrier{
+        VkBufferMemoryBarrier barrier = {
            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
            .srcAccessMask = srcAccess,
            .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
            .buffer = mGpuBuffer,
-			.offset = mUpdatedOffset,
-            .size = mUpdatedBytes,
+            .offset = byteOffset,
+            .size = numBytes,
        };
        vkCmdPipelineBarrier(cmdbuf, srcStage, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1,
                &barrier, 0, nullptr);
    }

-    VkBufferCopy region {
-            .srcOffset = 0,
-            .dstOffset = byteOffset,
-            .size = numBytes,
+    VkBufferCopy region = {
+        .srcOffset = 0,
+        .dstOffset = byteOffset,
+        .size = numBytes,
    };
    vkCmdCopyBuffer(cmdbuf, stage->buffer, mGpuBuffer, 1, &region);

-	mUpdatedOffset = byteOffset;
+    mUpdatedOffset = byteOffset;
    mUpdatedBytes = numBytes;

    // Firstly, ensure that the copy finishes before the next draw call.
@@ -112,21 +113,21 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
        dstAccessMask |= VK_ACCESS_INDEX_READ_BIT;
        dstStageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
    } else if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
-        dstAccessMask |= VK_ACCESS_UNIFORM_READ_BIT;
-        dstStageMask |=
-                (VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+        dstAccessMask |= VK_ACCESS_SHADER_READ_BIT;
+        dstStageMask |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
    } else if (mUsage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) {
        // TODO: implement me
    }

-    VkBufferMemoryBarrier barrier{
+    VkBufferMemoryBarrier barrier = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
        .dstAccessMask = dstAccessMask,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .buffer = mGpuBuffer,
-        .size = VK_WHOLE_SIZE,
+        .offset = byteOffset,
+        .size = numBytes,
    };

    vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageMask, 0, 0, nullptr, 1,
@@ -151,13 +151,13 @@ static_assert(FVK_ENABLED(FVK_DEBUG_VALIDATION));

 #elif FVK_ENABLED(FVK_DEBUG_SYSTRACE)

-    #include <utils/Systrace.h>
-    
-    #define FVK_SYSTRACE_CONTEXT()      SYSTRACE_CONTEXT()
-    #define FVK_SYSTRACE_START(marker)  SYSTRACE_NAME_BEGIN(marker)
-    #define FVK_SYSTRACE_END()          SYSTRACE_NAME_END()
-    #define FVK_SYSTRACE_SCOPE()        SYSTRACE_NAME(__func__)
-    #define FVK_PROFILE_MARKER(marker)  FVK_SYSTRACE_SCOPE()
+    #include <private/utils/Tracing.h>
+
+    #define FVK_SYSTRACE_CONTEXT()      FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT)
+    #define FVK_SYSTRACE_START(marker)  FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, marker)
+    #define FVK_SYSTRACE_END()          FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT)
+    #define FVK_SYSTRACE_SCOPE()        FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT)
+    #define FVK_PROFILE_MARKER(marker)  FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT)

 #else
    #define FVK_SYSTRACE_CONTEXT()
@@ -358,12 +358,11 @@ void VulkanDescriptorSetCache::updateSamplerImpl(VkDescriptorSet vkset, uint8_t
        range.levelCount = 1;
        range.layerCount = 1;
    }
-    VkDescriptorImageInfo info{
+    VkDescriptorImageInfo info = {
        .sampler = sampler,
        .imageView = texture->getView(range),
-        .imageLayout = fvkutils::getVkLayout(texture->getDefaultLayout()),
+        .imageLayout = fvkutils::getVkLayout(texture->getSamplerLayout()),
    };
-
    VkWriteDescriptorSet descriptorWrite = {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
        .pNext = nullptr,
@@ -622,7 +622,7 @@ void VulkanDriver::createTextureExternalImage2R(Handle<HwTexture> th, backend::S
    auto& commands = mCommands.get();
    // Unlike uploaded textures or swapchains, we need to explicit transition this
    // texture into the read layout.
-    texture->transitionLayout(&commands, texture->getPrimaryViewRange(), VulkanLayout::READ_ONLY);
+    texture->transitionLayout(&commands, texture->getPrimaryViewRange(), VulkanLayout::FRAG_READ);

    if (imgData.external.valid()) {
        mExternalImageManager.addExternallySampledTexture(texture, externalImage);
@@ -93,7 +93,32 @@ BitmaskGroup fromBackendLayout(DescriptorSetLayout const& layout) {
            case DescriptorType::SAMPLER_EXTERNAL:
                fromStageFlags(binding.stageFlags, binding.binding, mask.externalSampler);
                UTILS_FALLTHROUGH;
-            case DescriptorType::SAMPLER: {
+
+            case DescriptorType::SAMPLER_2D_FLOAT:
+            case DescriptorType::SAMPLER_2D_INT:
+            case DescriptorType::SAMPLER_2D_UINT:
+            case DescriptorType::SAMPLER_2D_DEPTH:
+            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
+            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_INT:
+            case DescriptorType::SAMPLER_CUBE_UINT:
+            case DescriptorType::SAMPLER_CUBE_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_3D_FLOAT:
+            case DescriptorType::SAMPLER_3D_INT:
+            case DescriptorType::SAMPLER_3D_UINT:
+            case DescriptorType::SAMPLER_2D_MS_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_INT:
+            case DescriptorType::SAMPLER_2D_MS_UINT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT: {
                fromStageFlags(binding.stageFlags, binding.binding, mask.sampler);
                break;
            }
@@ -495,7 +520,8 @@ void VulkanRenderTarget::emitBarriersEndRenderPass(VulkanCommandBuffer& commands
            }
        } else {
            texture->setLayout(range, VulkanFboCache::FINAL_COLOR_ATTACHMENT_LAYOUT);
-            if (!texture->transitionLayout(&commands, range, VulkanLayout::READ_WRITE)) {
+            if (texture->isSampleable() &&
+                    !texture->transitionLayout(&commands, range, VulkanLayout::FRAG_READ)) {
                texture->attachmentToSamplerBarrier(&commands, range);
            }
        }
@@ -234,6 +234,7 @@ void VulkanReadPixels::run(fvkmemory::resource_ptr<VulkanRenderTarget> srcTarget

    VulkanAttachment const srcAttachment = srcTarget->getColor0();
    VkImageSubresourceRange const srcRange = srcAttachment.getSubresourceRange();
+    VulkanLayout const srcLayout = srcAttachment.getLayout();
    srcTexture->transitionLayout(cmdbuffer, srcRange, VulkanLayout::TRANSFER_SRC);

    VkImageCopy const imageCopyRegion = {
@@ -270,7 +271,7 @@ void VulkanReadPixels::run(fvkmemory::resource_ptr<VulkanRenderTarget> srcTarget
            fvkutils::getVkLayout(VulkanLayout::TRANSFER_DST), 1, &imageCopyRegion);

    // Restore the source image layout.
-    srcTexture->transitionLayout(cmdbuffer, srcRange, srcTexture->getDefaultLayout());
+    srcTexture->transitionLayout(cmdbuffer, srcRange, srcLayout);

    vkEndCommandBuffer(cmdbuffer);

@@ -125,7 +125,7 @@ VulkanStageImage const* VulkanStagePool::acquireImage(PixelDataFormat format, Pi
    fvkutils::transitionLayout(cmdbuffer, {
            .image = image->image,
            .oldLayout = VulkanLayout::UNDEFINED,
-            .newLayout = VulkanLayout::READ_WRITE, // (= VK_IMAGE_LAYOUT_GENERAL)
+            .newLayout = VulkanLayout::STAGING, // (= VK_IMAGE_LAYOUT_GENERAL)
            .subresources = { aspectFlags, 0, 1, 0, 1 },
        });
    return image;
@@ -125,7 +125,7 @@ inline VulkanLayout getDefaultLayoutImpl(TextureUsage usage) {
        return VulkanLayout::COLOR_ATTACHMENT;
    }
    // Finally, the layout for an immutable texture is optimal read-only.
-    return VulkanLayout::READ_ONLY;
+    return VulkanLayout::FRAG_READ;
 }

 inline VulkanLayout getDefaultLayoutImpl(VkImageUsageFlags vkusage) {
@@ -187,7 +187,7 @@ VkImageUsageFlags getUsage(VulkanContext const& context, uint8_t samples,
            VkFormatProperties props;
            vkGetPhysicalDeviceFormatProperties(physicalDevice, vkFormat, &props);
            if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
-                FVK_LOGW << "Texture usage is SAMPLEABLE but format " << mState->mVkFormat << " is not "
+                FVK_LOGW << "Texture usage is SAMPLEABLE but format " << vkFormat << " is not "
                        "sampleable with optimal tiling." << utils::io::endl;
            }
        }
@@ -691,6 +691,7 @@ bool VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, VkImageSubresourceR
                 << " is skipped because of no change in layout" << utils::io::endl;
 #endif
    }
+
    return hasTransitions;
 }

@@ -700,16 +701,15 @@ void VulkanTexture::samplerToAttachmentBarrier(VulkanCommandBuffer* commands,
    VkImageLayout const layout =
            fvkutils::getVkLayout(getLayout(range.baseArrayLayer, range.baseMipLevel));
    VkImageMemoryBarrier barrier = {
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .srcAccessMask = VK_ACCESS_SHADER_READ_BIT,
-            .dstAccessMask =
-                    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-            .oldLayout = layout,
-            .newLayout = layout,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = mState->mTextureImage,
-            .subresourceRange = range,
+        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+        .srcAccessMask = VK_ACCESS_SHADER_READ_BIT,
+        .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+        .oldLayout = layout,
+        .newLayout = layout,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .image = mState->mTextureImage,
+        .subresourceRange = range,
    };
    vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
            VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
@@ -723,15 +723,15 @@ void VulkanTexture::attachmentToSamplerBarrier(VulkanCommandBuffer* commands,
    VkImageLayout const layout
            = fvkutils::getVkLayout(getLayout(range.baseArrayLayer, range.baseMipLevel));
    VkImageMemoryBarrier barrier = {
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
-            .oldLayout = layout,
-            .newLayout = layout,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = mState->mTextureImage,
-            .subresourceRange = range,
+        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+        .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+        .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
+        .oldLayout = layout,
+        .newLayout = layout,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .image = mState->mTextureImage,
+        .subresourceRange = range,
    };
    vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
@@ -145,8 +145,14 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {

    VkImageSubresourceRange const& getPrimaryViewRange() const { return mPrimaryViewRange; }

-    VulkanLayout getPrimaryImageLayout() const {
-        return getLayout(mPrimaryViewRange.baseArrayLayer, mPrimaryViewRange.baseMipLevel);
+    VulkanLayout getSamplerLayout() const {
+        if (!isSampleable()) {
+            return VulkanLayout::UNDEFINED;
+        }
+        if (mState->mUsage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
+            return VulkanLayout::DEPTH_SAMPLER;
+        }
+        return VulkanLayout::FRAG_READ;
    }

    // Returns the layout for the intended use of this texture (and not the expected layout at the
@@ -180,6 +186,10 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
        return mState->mUsage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
    }

+    bool isSampleable() const {
+        return mState->mUsage & VK_IMAGE_USAGE_SAMPLED_BIT;
+    }
+
    bool getIsProtected() const {
        return mState->mIsProtected;
    }
@@ -21,6 +21,7 @@

 #include <utils/bitset.h>
 #include <utils/FixedCapacityVector.h>
+#include <utils/Panic.h>

 #include <bluevk/BlueVK.h>

@@ -42,20 +42,22 @@ getVkTransition(const VulkanLayoutTransition& transition) {
            srcStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
            break;
        case VulkanLayout::COLOR_ATTACHMENT:
-            srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
-                            VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+            srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
                            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                       VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+            srcStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
            break;
-        case VulkanLayout::READ_WRITE:
+        case VulkanLayout::STAGING:
            srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
            srcStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
            break;
-        case VulkanLayout::READ_ONLY:
+        case VulkanLayout::FRAG_READ:
            srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
            srcStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
            break;
+        case VulkanLayout::VERT_READ:
+            srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
+            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+            break;
        case VulkanLayout::TRANSFER_SRC:
            srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
            srcStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
@@ -69,7 +71,7 @@ getVkTransition(const VulkanLayoutTransition& transition) {
            srcStage = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
            break;
        case VulkanLayout::DEPTH_SAMPLER:
-            srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+            srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
            srcStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
            break;
        case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:
@@ -84,19 +86,21 @@ getVkTransition(const VulkanLayoutTransition& transition) {

    switch (transition.newLayout) {
        case VulkanLayout::COLOR_ATTACHMENT:
-            dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT
-                            | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
+            dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
                            | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-            dstStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
-                       | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+            dstStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
            break;
-        case VulkanLayout::READ_WRITE:
+        case VulkanLayout::STAGING:
            dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
            dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
            break;
-        case VulkanLayout::READ_ONLY:
+        case VulkanLayout::FRAG_READ:
            dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-            dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+            dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+            break;
+        case VulkanLayout::VERT_READ:
+            dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+            dstStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
            break;
        case VulkanLayout::TRANSFER_SRC:
            dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
@@ -112,10 +116,8 @@ getVkTransition(const VulkanLayoutTransition& transition) {
            dstStage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
            break;
        case VulkanLayout::DEPTH_SAMPLER:
-            dstAccessMask =
-                    VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-            dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                       VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
+            dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+            dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
            break;
        case VulkanLayout::PRESENT:
        case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:
@@ -138,7 +140,6 @@ bool transitionLayout(VkCommandBuffer cmdbuffer,
    }
    auto [srcAccessMask, dstAccessMask, srcStage, dstStage, oldLayout, newLayout]
            = getVkTransition(transition);
-
    if (oldLayout == newLayout) {
        return false;
    }
@@ -155,7 +156,7 @@ bool transitionLayout(VkCommandBuffer cmdbuffer,
            .image = transition.image,
            .subresourceRange = transition.subresources,
    };
-    vkCmdPipelineBarrier(cmdbuffer, srcStage, dstStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);
+   vkCmdPipelineBarrier(cmdbuffer, srcStage, dstStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);
    return true;
 }

@@ -264,8 +265,9 @@ utils::io::ostream& operator<<(utils::io::ostream& out,
        const filament::backend::VulkanLayout& layout) {
    switch (layout) {
        CASE(UNDEFINED)
-        CASE(READ_ONLY)
-        CASE(READ_WRITE)
+        CASE(FRAG_READ)
+        CASE(VERT_READ)
+        CASE(STAGING)
        CASE(TRANSFER_SRC)
        CASE(TRANSFER_DST)
        CASE(DEPTH_ATTACHMENT)
@@ -32,9 +32,11 @@ enum class VulkanLayout : uint8_t {
    // any transition.
    UNDEFINED,
    // Fragment/vertex shader accessible layout for reading and writing.
-    READ_WRITE,
-    // Fragment/vertex shader accessible layout for reading only.
-    READ_ONLY,
+    STAGING,
+    // Fragment shader accessible layout for reading only.
+    FRAG_READ,
+    // Vertex shader accessible layout for reading only.
+    VERT_READ,
    // For the source of a copy operation.
    TRANSFER_SRC,
    // For the destination of a copy operation.
@@ -65,9 +67,10 @@ constexpr inline VkImageLayout getVkLayout(VulkanLayout layout) {
    switch (layout) {
        case VulkanLayout::UNDEFINED:
            return VK_IMAGE_LAYOUT_UNDEFINED;
-        case VulkanLayout::READ_WRITE:
+        case VulkanLayout::STAGING:
            return VK_IMAGE_LAYOUT_GENERAL;
-        case VulkanLayout::READ_ONLY:
+        case VulkanLayout::FRAG_READ:
+        case VulkanLayout::VERT_READ:
            return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
        case VulkanLayout::TRANSFER_SRC:
            return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
@@ -80,9 +83,8 @@ constexpr inline VkImageLayout getVkLayout(VulkanLayout layout) {
        case VulkanLayout::PRESENT:
            return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
        // Filament sometimes samples from one miplevel while writing to another level in the
-        // same texture (e.g. bloom does this). Moreover we'd like to avoid lots of expensive
-        // layout transitions. So, keep it simple and use GENERAL for all color-attachable
-        // textures.
+        // same texture (e.g. bloom does this). So, keep it simple and use GENERAL for all
+        // color-attachable textures.
        case VulkanLayout::COLOR_ATTACHMENT:
            return VK_IMAGE_LAYOUT_GENERAL;
        case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:
@@ -17,6 +17,7 @@
 #include "WebGPUHandles.h"

 #include "WebGPUConstants.h"
+#include "WebGPUStrings.h"

 #include "DriverBase.h"
 #include <backend/DriverEnums.h>
@@ -28,39 +29,116 @@
 #include <webgpu/webgpu_cpp.h>

 #include <algorithm>
+#include <cstdint>
 #include <sstream>
+#include <string>
 #include <string_view>
-#include <vector>
+#include <unordered_map>
+#include <variant>

 namespace filament::backend {

 namespace {

-[[nodiscard]] constexpr std::string_view toString(ShaderStage stage) {
-    switch (stage) {
-        case ShaderStage::VERTEX:
-            return "vertex";
-        case ShaderStage::FRAGMENT:
-            return "fragment";
-        case ShaderStage::COMPUTE:
-            return "compute";
+[[nodiscard]] std::string replaceSpecConstants(std::string_view shaderLabel,
+        std::string_view shaderSource,
+        std::unordered_map<uint32_t, std::variant<int32_t, float, bool>> const&
+                specConstants) {
+    assert_invariant(!specConstants.empty());
+    constexpr std::string_view specConstantPrefix = "FILAMENT_SPEC_CONST_";
+    constexpr size_t specConstantPrefixSize = specConstantPrefix.size();
+    const char* const sourceData = shaderSource.data();
+    std::stringstream processedShaderSourceStr{};
+    size_t pos = 0;
+    while (pos < shaderSource.size()) {
+        const size_t posOfNextSpecConstant = shaderSource.find(specConstantPrefix, pos);
+        if (posOfNextSpecConstant == std::string::npos) {
+            // no more spec constants, so just stream the rest of the source code string
+            processedShaderSourceStr
+                    << std::string_view(sourceData + pos, shaderSource.size() - pos);
+            break;
+        }
+        const size_t posOfId = posOfNextSpecConstant + specConstantPrefixSize;
+        const size_t posAfterId = shaderSource.find('_', posOfId);
+        FILAMENT_CHECK_POSTCONDITION(posAfterId != std::string::npos)
+                << "malformed " << shaderLabel << ". Found spec constant prefix '"
+                << specConstantPrefix << "' without an id or '_' after it.";
+        const std::string_view idStr =
+                std::string_view(sourceData + posOfId, posAfterId - posOfId);
+        const size_t posEndOfStatement = shaderSource.find(';', posAfterId);
+        FILAMENT_CHECK_POSTCONDITION(posEndOfStatement != std::string::npos)
+                << "malformed " << shaderLabel << ". Found spec constant assignment with id "
+                << idStr << " without a terminating ';' character?";
+        const std::string_view statementSegment =
+                std::string_view(sourceData + posAfterId, posEndOfStatement - posAfterId);
+        size_t posOfEqual = statementSegment.find('=');
+        if (posOfEqual == std::string::npos) {
+            // not an assignment statement, so stream to the end of the statement and continue...
+            processedShaderSourceStr
+                    << std::string_view(sourceData + pos, posEndOfStatement + 1 - pos);
+            pos = posEndOfStatement + 1;
+            continue;
+        }
+        posOfEqual += posAfterId; // position in original source, not just the segment
+        int id = 0;
+        try {
+            id = std::stoi(idStr.data());
+        } catch (const std::invalid_argument& e) {
+            PANIC_POSTCONDITION("Invalid spec constant id '%s' in %s (not a valid integer?): %s",
+                    idStr.data(), shaderLabel.data(), e.what());
+        } catch (const std::out_of_range& e) {
+            PANIC_POSTCONDITION(
+                    "Invalid spec constant id '%s' in %s (not an integer? out of range?): %s",
+                    idStr.data(), shaderLabel.data(), e.what());
+        }
+        const auto newValueItr = specConstants.find(static_cast<uint32_t>(id));
+        if (newValueItr == specConstants.end()) {
+            // not going to override the constant (stream to the end of the statement)...
+            processedShaderSourceStr
+                    << std::string_view(sourceData + pos, posEndOfStatement + 1 - pos);
+            pos = posEndOfStatement + 1;
+            continue;
+        }
+        // need to override the constant...
+        const std::variant<int32_t, float, bool> newValue = newValueItr->second;
+        // stream up to the equal sign...
+        processedShaderSourceStr << std::string_view(sourceData + pos, posOfEqual + 1 - pos);
+        // stream the new value...
+        if (auto* v = std::get_if<int32_t>(&newValue)) {
+            processedShaderSourceStr << " " << *v << "i";
+        } else if (auto* f = std::get_if<float>(&newValue)) {
+            processedShaderSourceStr << " " << *f << "f";
+        } else if (auto* b = std::get_if<bool>(&newValue)) {
+            processedShaderSourceStr << " " << ((*b) ? "true" : "false");
+        }
+        processedShaderSourceStr << ";";
+        // and skip to after the end of the statement in the original source...
+        pos = posEndOfStatement + 1;
    }
+    return processedShaderSourceStr.str();
 }

-[[nodiscard]] wgpu::ShaderModule createShaderModule(wgpu::Device& device, const char* programName,
-        std::array<utils::FixedCapacityVector<uint8_t>, Program::SHADER_TYPE_COUNT> const&
-                shaderSource,
-        ShaderStage stage) {
+[[nodiscard]] wgpu::ShaderModule createShaderModule(wgpu::Device& device, Program& program,
+        ShaderStage stage,
+        std::unordered_map<uint32_t, std::variant<int32_t, float, bool>> const& specConstants) {
+    const char* const programName = program.getName().c_str_safe();
+    std::array<utils::FixedCapacityVector<uint8_t>, Program::SHADER_TYPE_COUNT> const&
+            shaderSource = program.getShadersSource();
    utils::FixedCapacityVector<uint8_t> const& sourceBytes =
            shaderSource[static_cast<size_t>(stage)];
    if (sourceBytes.empty()) {
        return nullptr;// nothing to compile, the shader was not provided
    }
-    wgpu::ShaderModuleWGSLDescriptor wgslDescriptor{};
-    wgslDescriptor.code = wgpu::StringView(reinterpret_cast<const char*>(sourceBytes.data()));
    std::stringstream labelStream;
-    labelStream << programName << " " << toString(stage) << " shader";
+    labelStream << programName << " " << filamentShaderStageToString(stage) << " shader";
    auto label = labelStream.str();
+    const std::string processedShaderSource =
+            specConstants.empty()
+                    ? reinterpret_cast<const char*>(sourceBytes.data())
+                    : replaceSpecConstants(label, reinterpret_cast<const char*>(sourceBytes.data()),
+                              specConstants);
+    wgpu::ShaderModuleWGSLDescriptor wgslDescriptor{};
+    wgslDescriptor.code = wgpu::StringView(processedShaderSource);
    wgpu::ShaderModuleDescriptor descriptor{
        .nextInChain = &wgslDescriptor,
        .label = label.data()
@@ -119,85 +197,33 @@ namespace {
                                    << ":\n"
                                    << errorStream.str();
                        }
+#if FWGPU_ENABLED(FWGPU_DEBUG_VALIDATION)
                        FWGPU_LOGD << descriptor.label << " compiled successfully"
                                   << utils::io::endl;
+#endif
                    }),
-            UINT16_MAX);
+            SHADER_COMPILATION_TIMEOUT_NANOSECONDS);
    return module;
 }

-// This is a 1 to 1 mapping of the ReservedSpecializationConstants enum in EngineEnums.h
-// The _hack is a workaround until https://issues.chromium.org/issues/42250586 is resolved
-// This workaround is the same one being used on the generateSpecializationConstant() function
-wgpu::StringView getSpecConstantStringId(uint32_t id) {
-    switch (id) {
-        case 0:
-            return "0";// BACKEND_FEATURE_LEVEL_hack
-        case 1:
-            return "1";// CONFIG_MAX_INSTANCES_hack
-        case 2:
-            return "2";// ONFIG_STATIC_TEXTURE_TARGET_WORKAROUND_hack
-        case 3:
-            return "3";// CONFIG_SRGB_SWAPCHAIN_EMULATION_hack
-        case 4:
-            return "4";// CONFIG_FROXEL_BUFFER_HEIGHT_hack
-        case 5:
-            return "5";// CONFIG_POWER_VR_SHADER_WORKAROUNDS_hack
-        case 6:
-            return "6";// CONFIG_DEBUG_DIRECTIONAL_SHADOWMAP_hack
-        case 7:
-            return "7";// CONFIG_DEBUG_FROXEL_VISUALIZATION_hack
-        case 8:
-            return "8";// CONFIG_STEREO_EYE_COUNT_hack
-        case 9:
-            return "9";// CONFIG_SH_BANDS_COUNT_hack
-        case 10:
-            return "10";// CONFIG_SHADOW_SAMPLING_METHOD_hack
-        default:
-            PANIC_POSTCONDITION("Unknown/unhandled spec constant key/id: %d", id);
+void toMap(utils::FixedCapacityVector<Program::SpecializationConstant> const& specConstants,
+        std::unordered_map<uint32_t, std::variant<int32_t, float, bool>>& constantById) {
+    constantById.reserve(specConstants.size());
+    for (auto const& specConstant: specConstants) {
+        constantById.emplace(specConstant.id, specConstant.value);
    }
 }

-std::vector<wgpu::ConstantEntry> convertConstants(
-        utils::FixedCapacityVector<filament::backend::Program::SpecializationConstant> const&
-                constantsInfo) {
-    std::vector<wgpu::ConstantEntry> constants;
-    constants.reserve(constantsInfo.size());
-    for (filament::backend::Program::SpecializationConstant const& constant: constantsInfo) {
-        // CONFIG_MAX_INSTANCES (1) and CONFIG_FROXEL_BUFFER_HEIGHT (4) will not be present
-        // as constant overrides in the generated WGSL, because WGSL doesn't support specialization
-        // constants as an array length
-        // More information at https://github.com/gpuweb/gpuweb/issues/572#issuecomment-649760005
-        // CONFIG_SRGB_SWAPCHAIN_EMULATION (3) is being skipped all together since it's only
-        // included for the case of mFeatureLevel == FeatureLevel::FEATURE_LEVEL_0, which should
-        // not be possible for WebGPU
-        if (constant.id == 1 || constant.id == 3 || constant.id == 4) {
-            continue;
-        }
-        double value = 0.0;
-        if (auto* v = std::get_if<int32_t>(&constant.value)) {
-            value = static_cast<double>(*v);
-        } else if (auto* f = std::get_if<float>(&constant.value)) {
-            value = static_cast<double>(*f);
-        } else if (auto* b = std::get_if<bool>(&constant.value)) {
-            value = *b ? 0.0 : 1.0;
-        }
-        constants.push_back(
-                wgpu::ConstantEntry{ .key = getSpecConstantStringId(constant.id), .value = value });
-    }
-    return constants;
-}
-
 }// namespace

 WGPUProgram::WGPUProgram(wgpu::Device& device, Program& program)
-    : HwProgram(program.getName()),
-      vertexShaderModule(createShaderModule(device, name.c_str_safe(), program.getShadersSource(),
-              ShaderStage::VERTEX)),
-      fragmentShaderModule(createShaderModule(device, name.c_str_safe(), program.getShadersSource(),
-              ShaderStage::FRAGMENT)),
-      computeShaderModule(createShaderModule(device, name.c_str_safe(), program.getShadersSource(),
-              ShaderStage::COMPUTE)),
-      constants(convertConstants(program.getSpecializationConstants())) {}
+    : HwProgram(program.getName()) {
+    std::unordered_map<uint32_t, std::variant<int32_t, float, bool>> specConstants;
+    toMap(program.getSpecializationConstants(), specConstants);
+    vertexShaderModule = createShaderModule(device, program, ShaderStage::VERTEX, specConstants);
+    fragmentShaderModule =
+            createShaderModule(device, program, ShaderStage::FRAGMENT, specConstants);
+    computeShaderModule = createShaderModule(device, program, ShaderStage::COMPUTE, specConstants);
+}

 }// namespace filament::backend
@@ -63,4 +63,13 @@
    #define FWGPU_LOGI (utils::slog.i)
 #endif

+constexpr uint64_t REQUEST_ADAPTER_TIMEOUT_NANOSECONDS =
+        /* milliseconds */ 1000u * /* converted to ns */ 1000000u;
+
+constexpr uint64_t REQUEST_DEVICE_TIMEOUT_NANOSECONDS =
+        /* milliseconds */ 1000u * /* converted to ns */ 1000000u;
+
+constexpr uint64_t SHADER_COMPILATION_TIMEOUT_NANOSECONDS =
+        /* milliseconds */ 1000u * /* converted to ns */ 1000000u;
+
 #endif// TNT_FILAMENT_BACKEND_WEBGPUCONSTANTS_H
@@ -26,193 +26,24 @@
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>
 #include <backend/TargetBufferInfo.h>
-
+#include <private/backend/BackendUtils.h>
 #include <math/mat3.h>
 #include <utils/CString.h>
 #include <utils/Panic.h>
 #include <utils/ostream.h>

-#include <dawn/webgpu_cpp_print.h>
 #include <webgpu/webgpu_cpp.h>

 #include <algorithm>
 #include <array>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <sstream>
-#include <string_view>
 #include <utility>
-#include <variant>

 namespace filament::backend {

-namespace {
-
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-void printInstanceDetails(wgpu::Instance const& instance) {
-    wgpu::SupportedWGSLLanguageFeatures supportedWGSLLanguageFeatures{};
-    if (!instance.GetWGSLLanguageFeatures(&supportedWGSLLanguageFeatures)) {
-        FWGPU_LOGW << "Failed to get WebGPU instance supported WGSL language features"
-                   << utils::io::endl;
-    } else {
-        FWGPU_LOGI << "WebGPU instance supported WGSL language features ("
-                   << supportedWGSLLanguageFeatures.featureCount << "):" << utils::io::endl;
-        if (supportedWGSLLanguageFeatures.featureCount > 0 &&
-                supportedWGSLLanguageFeatures.features != nullptr) {
-            std::for_each(supportedWGSLLanguageFeatures.features,
-                    supportedWGSLLanguageFeatures.features +
-                            supportedWGSLLanguageFeatures.featureCount,
-                    [](wgpu::WGSLLanguageFeatureName const featureName) {
-                        std::stringstream nameStream{};
-                        nameStream << featureName;
-                        FWGPU_LOGI << "  " << nameStream.str() << utils::io::endl;
-                    });
-        }
-    }
-}
-#endif
-
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-void printLimit(std::string_view name, const std::variant<uint32_t, uint64_t> value) {
-    FWGPU_LOGI << "  " << name.data() << ": ";
-    bool undefined = true;
-    if (std::holds_alternative<uint32_t>(value)) {
-        if (std::get<uint32_t>(value) != WGPU_LIMIT_U32_UNDEFINED) {
-            undefined = false;
-            FWGPU_LOGI << std::get<uint32_t>(value);
-        }
-    } else if (std::holds_alternative<uint64_t>(value)) {
-        if (std::get<uint64_t>(value) != WGPU_LIMIT_U64_UNDEFINED) {
-            undefined = false;
-            FWGPU_LOGI << std::get<uint64_t>(value);
-        }
-    }
-    if (undefined) {
-        FWGPU_LOGI << "UNDEFINED";
-    }
-    FWGPU_LOGI << utils::io::endl;
-}
-#endif
-
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-void printLimits(wgpu::Limits const& limits) {
-    printLimit("maxTextureDimension1D", limits.maxTextureDimension1D);
-    printLimit("maxTextureDimension2D", limits.maxTextureDimension2D);
-    printLimit("maxTextureDimension3D", limits.maxTextureDimension3D);
-    printLimit("maxTextureArrayLayers", limits.maxTextureArrayLayers);
-    printLimit("maxBindGroups", limits.maxBindGroups);
-    printLimit("maxBindGroupsPlusVertexBuffers", limits.maxBindGroupsPlusVertexBuffers);
-    printLimit("maxBindingsPerBindGroup", limits.maxBindingsPerBindGroup);
-    printLimit("maxDynamicUniformBuffersPerPipelineLayout",
-            limits.maxDynamicUniformBuffersPerPipelineLayout);
-    printLimit("maxDynamicStorageBuffersPerPipelineLayout",
-            limits.maxDynamicStorageBuffersPerPipelineLayout);
-    printLimit("maxSampledTexturesPerShaderStage", limits.maxSampledTexturesPerShaderStage);
-    printLimit("maxSamplersPerShaderStage", limits.maxSamplersPerShaderStage);
-    printLimit("maxStorageBuffersPerShaderStage", limits.maxStorageBuffersPerShaderStage);
-    printLimit("maxStorageTexturesPerShaderStage", limits.maxStorageTexturesPerShaderStage);
-    printLimit("maxUniformBuffersPerShaderStage", limits.maxUniformBuffersPerShaderStage);
-    printLimit("maxUniformBufferBindingSize", limits.maxUniformBufferBindingSize);
-    printLimit("maxStorageBufferBindingSize", limits.maxStorageBufferBindingSize);
-    printLimit("minUniformBufferOffsetAlignment", limits.minUniformBufferOffsetAlignment);
-    printLimit("minStorageBufferOffsetAlignment", limits.minStorageBufferOffsetAlignment);
-    printLimit("maxVertexBuffers", limits.maxVertexBuffers);
-    printLimit("maxBufferSize", limits.maxBufferSize);
-    printLimit("maxVertexAttributes", limits.maxVertexAttributes);
-    printLimit("maxVertexBufferArrayStride", limits.maxVertexBufferArrayStride);
-    printLimit("maxInterStageShaderVariables", limits.maxInterStageShaderVariables);
-    printLimit("maxColorAttachments", limits.maxColorAttachments);
-    printLimit("maxColorAttachmentBytesPerSample", limits.maxColorAttachmentBytesPerSample);
-    printLimit("maxComputeWorkgroupStorageSize", limits.maxComputeWorkgroupStorageSize);
-    printLimit("maxComputeInvocationsPerWorkgroup", limits.maxComputeInvocationsPerWorkgroup);
-    printLimit("maxComputeWorkgroupSizeX", limits.maxComputeWorkgroupSizeX);
-    printLimit("maxComputeWorkgroupSizeY", limits.maxComputeWorkgroupSizeY);
-    printLimit("maxComputeWorkgroupSizeZ", limits.maxComputeWorkgroupSizeZ);
-    printLimit("maxComputeWorkgroupsPerDimension", limits.maxComputeWorkgroupsPerDimension);
-    printLimit("maxStorageBuffersInVertexStage", limits.maxStorageBuffersInVertexStage);
-    printLimit("maxStorageTexturesInVertexStage", limits.maxStorageTexturesInVertexStage);
-    printLimit("maxStorageBuffersInFragmentStage", limits.maxStorageBuffersInFragmentStage);
-    printLimit("maxStorageTexturesInFragmentStage", limits.maxStorageTexturesInFragmentStage);
-}
-#endif
-
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-void printAdapterDetails(wgpu::Adapter const& adapter) {
-    wgpu::DawnAdapterPropertiesPowerPreference powerPreferenceProperties{};
-    wgpu::AdapterInfo adapterInfo{};
-    adapterInfo.nextInChain = &powerPreferenceProperties;
-    if (!adapter.GetInfo(&adapterInfo)) {
-        FWGPU_LOGW << "Failed to get WebGPU adapter info" << utils::io::endl;
-    } else {
-        std::stringstream backendTypeStream{};
-        backendTypeStream << adapterInfo.backendType;
-        std::stringstream adapterTypeStream{};
-        adapterTypeStream << adapterInfo.adapterType;
-        std::stringstream powerPreferenceStream{};
-        powerPreferenceStream << powerPreferenceProperties.powerPreference;
-        FWGPU_LOGI << "WebGPU adapter info:" << utils::io::endl;
-        FWGPU_LOGI << "  vendor: " << adapterInfo.vendor.data << utils::io::endl;
-        FWGPU_LOGI << "  architecture: " << adapterInfo.architecture.data << utils::io::endl;
-        FWGPU_LOGI << "  device: " << adapterInfo.device.data << utils::io::endl;
-        FWGPU_LOGI << "  description: " << adapterInfo.description.data << utils::io::endl;
-        FWGPU_LOGI << "  backend type: " << backendTypeStream.str().data() << utils::io::endl;
-        FWGPU_LOGI << "  adapter type: " << adapterTypeStream.str().data() << utils::io::endl;
-        FWGPU_LOGI << "  device ID: " << adapterInfo.deviceID << utils::io::endl;
-        FWGPU_LOGI << "  vendor ID: " << adapterInfo.vendorID << utils::io::endl;
-        FWGPU_LOGI << "  subgroup min size: " << adapterInfo.subgroupMinSize << utils::io::endl;
-        FWGPU_LOGI << "  subgroup max size: " << adapterInfo.subgroupMaxSize << utils::io::endl;
-        FWGPU_LOGI << "  power preference: " << powerPreferenceStream.str() << utils::io::endl;
-    }
-    wgpu::SupportedFeatures supportedFeatures{};
-    adapter.GetFeatures(&supportedFeatures);
-    FWGPU_LOGI << "WebGPU adapter supported features (" << supportedFeatures.featureCount
-               << "):" << utils::io::endl;
-    if (supportedFeatures.featureCount > 0 && supportedFeatures.features != nullptr) {
-        std::for_each(supportedFeatures.features,
-                supportedFeatures.features + supportedFeatures.featureCount,
-                [](wgpu::FeatureName const name) {
-                    std::stringstream nameStream{};
-                    nameStream << name;
-                    FWGPU_LOGI << "  " << nameStream.str().data() << utils::io::endl;
-                });
-    }
-    wgpu::Limits supportedLimits{};
-    if (!adapter.GetLimits(&supportedLimits)) {
-        FWGPU_LOGW << "Failed to get WebGPU adapter supported limits" << utils::io::endl;
-    } else {
-        FWGPU_LOGI << "WebGPU adapter supported limits:" << utils::io::endl;
-        printLimits(supportedLimits);
-    }
-}
-#endif
-
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-void printDeviceDetails(wgpu::Device const& device) {
-    wgpu::SupportedFeatures supportedFeatures{};
-    device.GetFeatures(&supportedFeatures);
-    FWGPU_LOGI << "WebGPU device supported features (" << supportedFeatures.featureCount
-               << "):" << utils::io::endl;
-    if (supportedFeatures.featureCount > 0 && supportedFeatures.features != nullptr) {
-        std::for_each(supportedFeatures.features,
-                supportedFeatures.features + supportedFeatures.featureCount,
-                [](wgpu::FeatureName const name) {
-                    std::stringstream nameStream{};
-                    nameStream << name;
-                    FWGPU_LOGI << "  " << nameStream.str().data() << utils::io::endl;
-                });
-    }
-    wgpu::Limits supportedLimits{};
-    if (!device.GetLimits(&supportedLimits)) {
-        FWGPU_LOGW << "Failed to get WebGPU supported device limits" << utils::io::endl;
-    } else {
-        FWGPU_LOGI << "WebGPU device supported limits:" << utils::io::endl;
-        printLimits(supportedLimits);
-    }
-}
-#endif
-
-}// namespace
-
 Driver* WebGPUDriver::create(WebGPUPlatform& platform, const Platform::DriverConfig& driverConfig) noexcept {
    constexpr size_t defaultSize = FILAMENT_WEBGPU_HANDLE_ARENA_SIZE_IN_MB * 1024U * 1024U;
    Platform::DriverConfig validConfig {driverConfig};
@@ -220,23 +51,16 @@ Driver* WebGPUDriver::create(WebGPUPlatform& platform, const Platform::DriverCon
    return new WebGPUDriver(platform, validConfig);
 }

-WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfig& driverConfig) noexcept
+WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform,
+        const Platform::DriverConfig& driverConfig) noexcept
    : mPlatform(platform),
-      mHandleAllocator("Handles",
-              driverConfig.handleArenaSize,
-              driverConfig.disableHandleUseAfterFreeCheck,
-              driverConfig.disableHeapHandleTags) {
-#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
-    printInstanceDetails(mPlatform.getInstance());
-#endif
+      mHandleAllocator("Handles", driverConfig.handleArenaSize,
+              driverConfig.disableHandleUseAfterFreeCheck, driverConfig.disableHeapHandleTags) {
    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
+    wgpu::Limits supportedLimits{};
+    mDevice.GetLimits(&supportedLimits);
+    mMinUniformBufferOffsetAlignment = supportedLimits.minUniformBufferOffsetAlignment;
    mQueue = mDevice.GetQueue();
 }

@@ -350,6 +174,20 @@ void WebGPUDriver::destroyProgram(Handle<HwProgram> ph) {
 }

 void WebGPUDriver::destroyRenderTarget(Handle<HwRenderTarget> rth) {
+    if (rth) {
+        WGPURenderTarget* rt = handleCast<WGPURenderTarget>(rth);
+        if (rt == mDefaultRenderTarget) {
+            mDefaultRenderTarget = nullptr;
+        }
+        if (rt == mCurrentRenderTarget) {
+            mCurrentRenderTarget = nullptr;
+        }
+        // WGPURenderTarget destructor is trivial.
+        // The HwTexture handles stored within WGPURenderTarget (via MRT, TargetBufferInfo)
+        // are not owned by WGPURenderTarget, so they are not destroyed here.
+        // They are destroyed via WebGPUDriver::destroyTexture.
+        destructHandle<WGPURenderTarget>(rth);
+    }
 }

 void WebGPUDriver::destroySwapChain(Handle<HwSwapChain> sch) {
@@ -372,6 +210,19 @@ void WebGPUDriver::destroyDescriptorSetLayout(Handle<HwDescriptorSetLayout> tqh)
 }

 void WebGPUDriver::destroyDescriptorSet(Handle<HwDescriptorSet> tqh) {
+    auto* bindGroup = handleCast<WebGPUDescriptorSet>(tqh);
+    assert_invariant(bindGroup);
+    if (bindGroup->getBindGroup() != nullptr) {
+        for (size_t i = 0; i < MAX_DESCRIPTOR_SET_COUNT; i++) {
+            if (mCurrentDescriptorSets[i].bindGroup != nullptr &&
+                    bindGroup->getBindGroup().Get() == mCurrentDescriptorSets[i].bindGroup.Get()) {
+                // Clear this from our current entries
+                mCurrentDescriptorSets[i].bindGroup = nullptr;
+                mCurrentDescriptorSets[i].offsets.clear();
+                mCurrentDescriptorSets[i].offsetCount = 0;
+            }
+        }
+    }
    if (tqh) {
        destructHandle<WebGPUDescriptorSet>(tqh);
    }
@@ -468,11 +319,10 @@ void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
    mSwapChain = constructHandle<WebGPUSwapChain>(sch, std::move(surface), surfaceSize, mAdapter,
            mDevice, flags);
    assert_invariant(mSwapChain);
-    WebGPUDescriptorSet::initializeDummyResourcesIfNotAlready(mDevice,
-            mSwapChain->getColorFormat());
-    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."
+
+    FWGPU_LOGW << "WebGPU support is highly experimental, in development, and tested for only a "
+                  "small set of simple samples (e.g. hellotriangle and texturedquad), thus issues "
+                  "are likely to be encountered at this stage."
               << utils::io::endl;
 #if !FWGPU_ENABLED(FWGPU_PRINT_SYSTEM) && !defined(NDEBUG)
    FWGPU_LOGI << "If the FILAMENT_BACKEND_DEBUG_FLAG variable were set with the " << utils::io::hex
@@ -577,7 +427,21 @@ void WebGPUDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {

 void WebGPUDriver::createRenderTargetR(Handle<HwRenderTarget> rth, TargetBufferFlags targets,
        uint32_t width, uint32_t height, uint8_t samples, uint8_t layerCount, MRT color,
-        TargetBufferInfo depth, TargetBufferInfo stencil) {}
+        TargetBufferInfo depth, TargetBufferInfo stencil) {
+    // The `targets` flags indicate which of the `color`, `depth`, `stencil` TargetBufferInfo
+    // are actually active for this render target.
+    // We'll pass all TargetBufferInfo to WGPURenderTarget; it will use them if their handles are valid.
+
+    // Ensure that textures intended for use as attachments were created with
+    // wgpu::TextureUsage::RenderAttachment. This check should ideally be in createTextureR
+    // or validated here if possible.
+
+    // The `layerCount` parameter might be for creating array textures that this RT targets.
+    // Individual attachments (color[i].layer, depth.layer, stencil.layer) specify which layer
+    // of an array texture to bind. For now, we assume textures are pre-configured.
+
+    constructHandle<WGPURenderTarget>(rth, width, height, samples, color, depth, stencil);
+}

 void WebGPUDriver::createFenceR(Handle<HwFence> fh, int) {}

@@ -721,17 +585,20 @@ size_t WebGPUDriver::getMaxArrayTextureLayers() {

 void WebGPUDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor&& p,
        uint32_t byteOffset) {
-    updateGPUBuffer(handleCast<WGPUIndexBuffer>(ibh), std::move(p), byteOffset);
+    handleCast<WGPUIndexBuffer>(ibh)->updateGPUBuffer(p, byteOffset, mQueue);
+    scheduleDestroy(std::move(p));
 }

 void WebGPUDriver::updateBufferObject(Handle<HwBufferObject> ibh, BufferDescriptor&& p,
        uint32_t byteOffset) {
-    updateGPUBuffer(handleCast<WGPUBufferObject>(ibh), std::move(p), byteOffset);
+    handleCast<WGPUBufferObject>(ibh)->updateGPUBuffer(p, byteOffset, mQueue);
+    scheduleDestroy(std::move(p));
 }

 void WebGPUDriver::updateBufferObjectUnsynchronized(Handle<HwBufferObject> ibh,
        BufferDescriptor&& p, uint32_t byteOffset) {
-    updateGPUBuffer(handleCast<WGPUBufferObject>(ibh), std::move(p), byteOffset);
+    handleCast<WGPUBufferObject>(ibh)->updateGPUBuffer(p, byteOffset, mQueue);
+    scheduleDestroy(std::move(p));
 }

 void WebGPUDriver::resetBufferObject(Handle<HwBufferObject> boh) {
@@ -743,15 +610,76 @@ void WebGPUDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh, uint32_t in
    auto* vertexBuffer = handleCast<WGPUVertexBuffer>(vbh);
    auto* bufferObject = handleCast<WGPUBufferObject>(boh);
    assert_invariant(index < vertexBuffer->buffers.size());
-    assert_invariant(bufferObject->buffer.GetUsage() & wgpu::BufferUsage::Vertex);
-    vertexBuffer->buffers[index] = bufferObject->buffer;
+    assert_invariant(bufferObject->getBuffer().GetUsage() & wgpu::BufferUsage::Vertex);
+    vertexBuffer->buffers[index] = bufferObject->getBuffer();
 }

-void WebGPUDriver::update3DImage(Handle<HwTexture> th,
-        uint32_t level, uint32_t xoffset, uint32_t yoffset, uint32_t zoffset,
-        uint32_t width, uint32_t height, uint32_t depth,
-        PixelBufferDescriptor&& data) {
-    scheduleDestroy(std::move(data));
+void WebGPUDriver::update3DImage(Handle<HwTexture> th, uint32_t level, uint32_t xoffset,
+        uint32_t yoffset, uint32_t zoffset, uint32_t width, uint32_t height, uint32_t depth,
+        PixelBufferDescriptor&& p) {
+    PixelBufferDescriptor* data = &p;
+    PixelBufferDescriptor reshapedData;
+    if (reshape(p, reshapedData)) {
+        data = &reshapedData;
+    }
+    auto texture = handleCast<WGPUTexture>(th);
+
+    // TODO: Writing to a depth texture is illegal and errors. I'm not sure why Filament is trying
+    // to do so, but early returning is working?
+    if(texture->getAspect() == wgpu::TextureAspect::DepthOnly){
+        scheduleDestroy(std::move(p));
+        return;
+    }
+    size_t blockWidth = texture->getBlockWidth();
+    size_t blockHeight = texture->getBlockHeight();
+    // WebGPU specification requires that for compressed textures, the x and y offsets
+    // must be a multiple of the compressed texture format's block width and height.
+    // See: https://www.w3.org/TR/webgpu/#abstract-opdef-validating-gputexelcopytextureinfo
+    if (blockWidth > 1 || blockHeight > 1) {
+        FILAMENT_CHECK_PRECONDITION(xoffset % blockWidth == 0)
+                << "xoffset must be aligned to blockwidth, but offset is " << blockWidth
+                << "and offset is " << xoffset;
+        FILAMENT_CHECK_PRECONDITION(yoffset % blockHeight == 0)
+                << "yoffset must be aligned to blockHeight, but offset is " << blockHeight
+                << "and offset is " << yoffset;
+    }
+
+    auto copyInfo = wgpu::TexelCopyTextureInfo{ .texture = texture->getTexture(),
+        .mipLevel = level,
+        .origin = { .x = xoffset, .y = yoffset, .z = zoffset },
+        .aspect = texture->getAspect() };
+    uint32_t bytesPerRow = static_cast<uint32_t>(
+            PixelBufferDescriptor::computePixelSize(data->format, data->type) * width);
+    auto extent = wgpu::Extent3D{ .width = width, .height = height, .depthOrArrayLayers = depth };
+
+    const uint8_t* dataBuff = static_cast<const uint8_t*>(data->buffer);
+    size_t dataSize = data->size;
+    std::unique_ptr<uint8_t[]> paddedBuffer;
+
+    if (bytesPerRow % 256 != 0) {
+        uint32_t padding = 256 - (bytesPerRow % 256);
+        uint32_t paddedBytesPerRow = bytesPerRow + padding;
+
+        size_t paddedBufferSize = static_cast<size_t>(paddedBytesPerRow) * height * depth;
+        paddedBuffer = std::make_unique<uint8_t[]>(paddedBufferSize);
+        uint8_t* dest = paddedBuffer.get();
+
+        for (uint32_t z = 0; z < depth; ++z) {
+            for (uint32_t y = 0; y < height; ++y) {
+                std::memcpy(dest, dataBuff, bytesPerRow);
+                dest += paddedBytesPerRow;
+                dataBuff += bytesPerRow;
+            }
+        }
+        dataBuff = paddedBuffer.get();
+        dataSize = paddedBufferSize;
+        bytesPerRow = paddedBytesPerRow;
+    }
+
+    auto layout = wgpu::TexelCopyBufferLayout{ .bytesPerRow = bytesPerRow, .rowsPerImage = height };
+
+    mQueue.WriteTexture(&copyInfo, dataBuff, dataSize, &layout, &extent);
+    scheduleDestroy(std::move(p));
 }

 void WebGPUDriver::setupExternalImage(void* image) {
@@ -778,56 +706,82 @@ void WebGPUDriver::compilePrograms(CompilerPriorityQueue priority,

 void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> rth, RenderPassParams const& params) {
    assert_invariant(mCommandEncoder);
-
    auto* renderTarget = handleCast<WGPURenderTarget>(rth);
-    // if (renderTarget == mDefaultRenderTarget) {
-    //     FWGPU_LOGW << "Default render target"
-    //                << utils::io::endl;
-    // } else {
-    //     FWGPU_LOGW << "Non Default render target"
-    //                << utils::io::endl;
-    // }
-    wgpu::RenderPassDescriptor renderPassDescriptor2;
-    wgpu::RenderPassDepthStencilAttachment depthStencilAttachment{
-        .view = mSwapChain->getDepthTextureView(),
-        .depthLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH),
-        .depthStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH),
-        .depthClearValue = static_cast<float>(params.clearDepth),
-        .depthReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0,
-        .stencilLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL),
-        .stencilStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL),
-        .stencilClearValue = params.clearStencil,
-        .stencilReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0
-    };
-    renderTarget->setUpRenderPassAttachments(renderPassDescriptor2, mTextureView, params);
-    renderPassDescriptor2.depthStencilAttachment = &depthStencilAttachment;
-    // TODO: Remove this code once WebGPU pipeline is implemented
-    static float red = 1.0f;
-    if (red - 0.01 > 0) {
-        red -= 0.01;
+
+    wgpu::TextureView defaultColorView = nullptr;
+    wgpu::TextureView defaultDepthStencilView = nullptr;
+
+    std::array<wgpu::TextureView, MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT> customColorViews{};
+    uint32_t customColorViewCount = 0;
+    wgpu::TextureView customDepthView = nullptr;
+    wgpu::TextureFormat customDepthFormat = wgpu::TextureFormat::Undefined;
+    wgpu::TextureFormat customStencilFormat = wgpu::TextureFormat::Undefined;
+    wgpu::TextureView customStencilView = nullptr;
+
+    mCurrentRenderTarget = renderTarget;
+    if (renderTarget->isDefaultRenderTarget()) {
+        assert_invariant(mSwapChain && mTextureView);
+        defaultColorView = mTextureView;
+        defaultDepthStencilView = mSwapChain->getDepthTextureView();
    } else {
-        red = 1.0f;
+        // Resolve views for custom render target
+        const auto& colorInfos = renderTarget->getColorAttachmentInfos();
+        for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; ++i) {
+            if (colorInfos[i].handle) {
+                auto* hwTexture = handleCast<WGPUTexture>(colorInfos[i].handle);
+                if (hwTexture) {
+                    // TODO: Consider colorInfos[i].level and colorInfos[i].layer for view creation
+                    // if WGPUTexture::getTextureView() isn't sufficient or needs parameters.
+                    customColorViews[customColorViewCount++] = hwTexture->getTextureView();
+
+                }
+            }
+        }
+
+        const auto& depthInfo = renderTarget->getDepthAttachmentInfo();
+        if (depthInfo.handle) {
+            auto* hwTexture = handleCast<WGPUTexture>(depthInfo.handle);
+            if (hwTexture) {
+                customDepthView = hwTexture->getTextureView();
+                customDepthFormat = hwTexture->getFormat();
+            }
+        }
+
+        const auto& stencilInfo = renderTarget->getStencilAttachmentInfo();
+        if (stencilInfo.handle) {
+            // If depth and stencil use the same texture handle, this will re-cast but that's fine.
+            auto* hwTexture = handleCast<WGPUTexture>(stencilInfo.handle);
+            if (hwTexture) {
+                customStencilView = hwTexture->getTextureView();
+                customStencilFormat = hwTexture->getFormat();
+            }
+        }
    }
-    assert_invariant(mTextureView);
-    wgpu::RenderPassColorAttachment renderPassColorAttachment = {
-        .view = mTextureView,
-        // TODO: remove this code once WebGPU Pipeline is implemented with render targets, pipeline and buffers.
-        .depthSlice = wgpu::kDepthSliceUndefined,
-        .loadOp = wgpu::LoadOp::Clear,
-        .storeOp = wgpu::StoreOp::Store,
-        .clearValue = wgpu::Color{red, 0 , 0 , 1},
-    };
+    wgpu::RenderPassDescriptor renderPassDescriptor{};
+    renderTarget->setUpRenderPassAttachments(renderPassDescriptor,
+            params,
+            defaultColorView,
+            defaultDepthStencilView,
+            customColorViews.data(),
+            customColorViewCount,
+            customDepthView,
+            customStencilView,
+            customDepthFormat,
+            customStencilFormat);

-    wgpu::RenderPassDescriptor renderPassDescriptor = {
-        .colorAttachmentCount = 1,
-        .colorAttachments = &renderPassColorAttachment,
-        .depthStencilAttachment = nullptr,
-        .timestampWrites = nullptr,
-    };
+    mRenderPassEncoder = mCommandEncoder.BeginRenderPass(&renderPassDescriptor);

-    mRenderPassEncoder = mCommandEncoder.BeginRenderPass(&renderPassDescriptor2);
-    mRenderPassEncoder.SetViewport(params.viewport.left, params.viewport.bottom,
-            params.viewport.width, params.viewport.height, params.depthRange.near, params.depthRange.far);
+    // Ensure viewport dimensions are not 0
+    FILAMENT_CHECK_POSTCONDITION(params.viewport.width > 0) << "viewport width is 0?";
+    FILAMENT_CHECK_POSTCONDITION(params.viewport.height > 0) << "viewport height is 0?";
+
+    mRenderPassEncoder.SetViewport(
+            static_cast<float>(params.viewport.left),
+            static_cast<float>(params.viewport.bottom),
+            static_cast<float>(params.viewport.width),
+            static_cast<float>(params.viewport.height),
+            params.depthRange.near,
+            params.depthRange.far);
 }

 void WebGPUDriver::endRenderPass(int /* dummy */) {
@@ -920,7 +874,7 @@ void WebGPUDriver::bindPipeline(PipelineState const& pipelineState) {
    // VulkanPipelineCache to handle this, may be missing nuance
    static auto pipleineStateHasher = utils::hash::MurmurHashFn<filament::backend::PipelineState>();
    auto hash = pipleineStateHasher(pipelineState);
-    if(mPipelineMap.find(hash) != mPipelineMap.end()){
+    if (mPipelineMap.find(hash) != mPipelineMap.end()) {
        mRenderPassEncoder.SetPipeline(mPipelineMap[hash]);
        return;
    }
@@ -956,42 +910,95 @@ void WebGPUDriver::bindPipeline(PipelineState const& pipelineState) {
            << layoutDescriptor.label;
    auto const* vertexBufferInfo = handleCast<WGPUVertexBufferInfo>(pipelineState.vertexBufferInfo);
    assert_invariant(vertexBufferInfo);
-    const wgpu::RenderPipeline pipeline = createWebGPURenderPipeline(mDevice, *program,
-            *vertexBufferInfo, layout, pipelineState.rasterState, pipelineState.stencilState,
-            pipelineState.polygonOffset, pipelineState.primitiveType, mSwapChain->getColorFormat(),
-            mSwapChain->getDepthFormat());
+
+    std::vector<wgpu::TextureFormat> pipelineColorFormats;
+    wgpu::TextureFormat pipelineDepthFormat = wgpu::TextureFormat::Undefined;
+    uint8_t pipelineSamples = 1;
+
+    if (mCurrentRenderTarget->isDefaultRenderTarget()) {
+        pipelineColorFormats.push_back(mSwapChain->getColorFormat());
+        pipelineDepthFormat = mSwapChain->getDepthFormat();
+        pipelineSamples =
+                mCurrentRenderTarget->getSamples();// Default RT should have samples (usually 1)
+    } else {
+        const auto& mrtColorAttachments = mCurrentRenderTarget->getColorAttachmentInfos();
+        for (size_t i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; ++i) {
+            if (mrtColorAttachments[i].handle) {
+                const auto* colorTexture = handleCast<WGPUTexture>(mrtColorAttachments[i].handle);
+                if (colorTexture) {
+                    pipelineColorFormats.push_back(colorTexture->getTexture().GetFormat());
+                }
+            }
+        }
+
+        const auto& depthInfo = mCurrentRenderTarget->getDepthAttachmentInfo();
+        const auto& stencilInfo = mCurrentRenderTarget->getStencilAttachmentInfo();
+        if (depthInfo.handle) {
+            FILAMENT_CHECK_POSTCONDITION(!stencilInfo.handle)
+                    << "depth and stencil attachments cannot both be provided for WebGPU";
+            const auto* dfTexture = handleCast<WGPUTexture>(depthInfo.handle);
+            if (dfTexture) pipelineDepthFormat = dfTexture->getTexture().GetFormat();
+        } else {
+            if (stencilInfo.handle) {
+                const auto* sfTexture = handleCast<WGPUTexture>(stencilInfo.handle);
+                // Assuming combined depth/stencil format if only stencil is present
+                if (sfTexture) {
+                    pipelineDepthFormat = sfTexture->getTexture().GetFormat();
+                }
+            }
+        }
+        pipelineSamples = mCurrentRenderTarget->getSamples();
+    }
+
+    if (program->fragmentShaderModule != nullptr) {
+        FILAMENT_CHECK_POSTCONDITION(!pipelineColorFormats.empty())
+                << "Render pipeline with fragment shader must have at least one color target "
+                   "format.";
+    }
+    wgpu::RenderPipeline pipeline = createWebGPURenderPipeline(mDevice, *program, *vertexBufferInfo,
+            layout, pipelineState.rasterState, pipelineState.stencilState,
+            pipelineState.polygonOffset, pipelineState.primitiveType, pipelineColorFormats,
+            pipelineDepthFormat, pipelineSamples);
+    assert_invariant(pipeline);
    mPipelineMap[hash] = pipeline;
    mRenderPassEncoder.SetPipeline(pipeline);
 }

 void WebGPUDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
    auto* renderPrimitive = handleCast<WGPURenderPrimitive>(rph);
-
-    // This *must* match the WGPUVertexBufferInfo that was bound in bindPipeline(). But we want
-    // to allow to call this before bindPipeline(), so the validation can only happen in draw()
    auto vbi = handleCast<WGPUVertexBufferInfo>(renderPrimitive->vertexBuffer->vbih);
-    assert_invariant(
-            vbi->getVertexBufferLayoutSize() == renderPrimitive->vertexBuffer->buffers.size());
-    for (uint32_t i = 0; i < vbi->getVertexBufferLayoutSize(); i++) {
-        mRenderPassEncoder.SetVertexBuffer(i, renderPrimitive->vertexBuffer->buffers[i]);
+    for (const auto& webGPUSlotBindings: vbi->getWebGPUSlotBindingInfos()) {
+        mRenderPassEncoder.SetVertexBuffer(webGPUSlotBindings.slot,
+                renderPrimitive->vertexBuffer->buffers[webGPUSlotBindings.sourceBuffer],
+                webGPUSlotBindings.bufferOffset);
    }

-    mRenderPassEncoder.SetIndexBuffer(renderPrimitive->indexBuffer->buffer,
+    mRenderPassEncoder.SetIndexBuffer(renderPrimitive->indexBuffer->getBuffer(),
            renderPrimitive->indexBuffer->indexFormat);
 }

 void WebGPUDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-    // Calling DrawIndexed with "firstInstance = 0" results in a NON spinning triangle
-    //    mRenderPassEncoder.DrawIndexed(indexCount, instanceCount, indexOffset, 0, 0);
-    // Calling DrawIndexed with "firstInstance = 1" results in a spinning triangle
-    mRenderPassEncoder.DrawIndexed(indexCount, instanceCount, indexOffset, 0, 1);
-    // Calling Draw with "firstInstance = 0" results in a NON spinning triangle
-    // Calling Draw with "firstInstance = 1" results in a spinning triangle
-    //    mRenderPassEncoder.Draw(indexCount, instanceCount, 0, 1);
+    // We defer actually binding until we actually draw
+    for (size_t i = 0; i < MAX_DESCRIPTOR_SET_COUNT; i++) {
+        auto& binding = mCurrentDescriptorSets[i];
+        if (binding.bindGroup) {
+            mRenderPassEncoder.SetBindGroup(i, binding.bindGroup, binding.offsetCount,
+                    binding.offsets.data());
+        }
+    }
+
+    mRenderPassEncoder.DrawIndexed(indexCount, instanceCount, indexOffset, 0, 0);
 }

-void WebGPUDriver::draw(PipelineState, Handle<HwRenderPrimitive>, uint32_t indexOffset,
-        uint32_t indexCount, uint32_t instanceCount) {
+void WebGPUDriver::draw(PipelineState pipelineState,
+        Handle<HwRenderPrimitive> renderPrimitiveHandle, uint32_t indexOffset, uint32_t indexCount,
+        uint32_t instanceCount) {
+    WGPURenderPrimitive const* const renderPrimitive =
+            handleCast<WGPURenderPrimitive>(renderPrimitiveHandle);
+    pipelineState.primitiveType = renderPrimitive->type;
+    pipelineState.vertexBufferInfo = renderPrimitive->vertexBuffer->vbih;
+    bindPipeline(pipelineState);
+    bindRenderPrimitive(renderPrimitiveHandle);
    draw2(indexOffset, indexCount, instanceCount);
 }

@@ -1018,8 +1025,11 @@ void WebGPUDriver::updateDescriptorSetBuffer(Handle<HwDescriptorSet> dsh,
    auto buffer = handleCast<WGPUBufferObject>(boh);
    if (!bindGroup->getIsLocked()) {
        // TODO making assumptions that size and offset mean the same thing here.
+        FILAMENT_CHECK_PRECONDITION(offset % mMinUniformBufferOffsetAlignment == 0)
+                << "Binding offset must be multiple of " << mMinUniformBufferOffsetAlignment
+                << "But requested offset is " << offset;
        wgpu::BindGroupEntry entry{ .binding = static_cast<uint32_t>(binding * 2),
-            .buffer = buffer->buffer,
+            .buffer = buffer->getBuffer(),
            .offset = offset,
            .size = size };
        bindGroup->addEntry(entry.binding, std::move(entry));
@@ -1037,7 +1047,7 @@ void WebGPUDriver::updateDescriptorSetTexture(Handle<HwDescriptorSet> dsh,
        auto sampler = makeSampler(params);
        // TODO making assumptions that size and offset mean the same thing here.
        wgpu::BindGroupEntry tEntry{ .binding = static_cast<uint32_t>(binding * 2),
-            .textureView = texture->getTexView() };
+            .textureView = texture->getTextureView() };
        bindGroup->addEntry(tEntry.binding, std::move(tEntry));

        wgpu::BindGroupEntry sEntry{ .binding = static_cast<uint32_t>(binding * 2 + 1),
@@ -1048,27 +1058,26 @@ void WebGPUDriver::updateDescriptorSetTexture(Handle<HwDescriptorSet> dsh,

 void WebGPUDriver::bindDescriptorSet(Handle<HwDescriptorSet> dsh,
        backend::descriptor_set_t setIndex, backend::DescriptorSetOffsetArray&& offsets) {
+    assert_invariant(setIndex < MAX_DESCRIPTOR_SET_COUNT);
    const auto bindGroup = handleCast<WebGPUDescriptorSet>(dsh);
    const auto wbg = bindGroup->lockAndReturn(mDevice);
-    assert_invariant(mRenderPassEncoder);
-    // TODO is this how we should be getting the dynamic offsets?
-    //      should we add offsets for unused entries or is the input already have them?
-    //      this implementation assumes unused entries are not provided, and adds dummy values.
-    //      The count also includes unused entities, as not doing so produces errors
-    const size_t dynamicOffsetCount = bindGroup->countEntitiesWithDynamicOffsets();
-    uint32_t const* const dynamicOffsetsWithUnused = bindGroup->setDynamicOffsets(offsets.data());
-    mRenderPassEncoder.SetBindGroup(setIndex, wbg, dynamicOffsetCount, dynamicOffsetsWithUnused);
+
+    mCurrentDescriptorSets[setIndex] = { .bindGroup = wbg,
+        .offsetCount = bindGroup->countEntitiesWithDynamicOffsets(),
+        .offsets = std::move(offsets) };
 }

 void WebGPUDriver::setDebugTag(HandleBase::HandleId handleId, utils::CString tag) {
 }
+
 wgpu::Sampler WebGPUDriver::makeSampler(SamplerParams const& params) {
-    wgpu::SamplerDescriptor desc;
+    wgpu::SamplerDescriptor desc{};

    desc.label = "TODO";
    desc.addressModeU = fWrapModeToWAddressMode(params.wrapS);
    desc.addressModeV = fWrapModeToWAddressMode(params.wrapR);
    desc.addressModeW = fWrapModeToWAddressMode(params.wrapT);
+
    switch (params.filterMag) {
        case SamplerMagFilter::NEAREST: {
            desc.magFilter = wgpu::FilterMode::Nearest;
@@ -1079,20 +1088,16 @@ wgpu::Sampler WebGPUDriver::makeSampler(SamplerParams const& params) {
            break;
        }
    }
+
    switch (params.filterMin) {
        case SamplerMinFilter::NEAREST: {
            desc.minFilter = wgpu::FilterMode::Nearest;
-            // Metal Driver uses an explicit not-mipmapped value webgpu lacks. Nearest should
-            // suffice
-            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Undefined;
            break;
        }
        case SamplerMinFilter::LINEAR: {
            desc.minFilter = wgpu::FilterMode::Linear;
-            // Metal Driver uses an explicit not-mipmapped value webgpu lacks. Nearest should
-            // suffice
-
-            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Undefined;
            break;
        }
        case SamplerMinFilter::NEAREST_MIPMAP_NEAREST: {
@@ -1103,13 +1108,11 @@ wgpu::Sampler WebGPUDriver::makeSampler(SamplerParams const& params) {
        case SamplerMinFilter::LINEAR_MIPMAP_NEAREST: {
            desc.minFilter = wgpu::FilterMode::Linear;
            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
-
            break;
        }
        case SamplerMinFilter::NEAREST_MIPMAP_LINEAR: {
            desc.minFilter = wgpu::FilterMode::Nearest;
            desc.mipmapFilter = wgpu::MipmapFilterMode::Linear;
-
            break;
        }
        case SamplerMinFilter::LINEAR_MIPMAP_LINEAR: {
@@ -1118,48 +1121,48 @@ wgpu::Sampler WebGPUDriver::makeSampler(SamplerParams const& params) {
            break;
        }
    }
-    switch (params.compareFunc) {
-        case SamplerCompareFunc::LE: {
-            desc.compare = wgpu::CompareFunction::LessEqual;
-            break;
-        }
-        case SamplerCompareFunc::GE: {
-            desc.compare = wgpu::CompareFunction::GreaterEqual;
-            break;
-        }
-        case SamplerCompareFunc::L: {
-            desc.compare = wgpu::CompareFunction::Less;
-            break;
-        }
-        case SamplerCompareFunc::G: {
-            desc.compare = wgpu::CompareFunction::Greater;
-            break;
-        }
-        case SamplerCompareFunc::E: {
-            desc.compare = wgpu::CompareFunction::Equal;
-            break;
-        }
-        case SamplerCompareFunc::NE: {
-            desc.compare = wgpu::CompareFunction::NotEqual;
-            break;
-        }
-        case SamplerCompareFunc::A: {
-            desc.compare = wgpu::CompareFunction::Always;
-            break;
-        }
-        case SamplerCompareFunc::N: {
-            desc.compare = wgpu::CompareFunction::Never;
-            break;
+    if (params.compareMode == SamplerCompareMode::COMPARE_TO_TEXTURE) {
+        switch (params.compareFunc) {
+            case SamplerCompareFunc::LE: {
+                desc.compare = wgpu::CompareFunction::LessEqual;
+                break;
+            }
+            case SamplerCompareFunc::GE: {
+                desc.compare = wgpu::CompareFunction::GreaterEqual;
+                break;
+            }
+            case SamplerCompareFunc::L: {
+                desc.compare = wgpu::CompareFunction::Less;
+                break;
+            }
+            case SamplerCompareFunc::G: {
+                desc.compare = wgpu::CompareFunction::Greater;
+                break;
+            }
+            case SamplerCompareFunc::E: {
+                desc.compare = wgpu::CompareFunction::Equal;
+                break;
+            }
+            case SamplerCompareFunc::NE: {
+                desc.compare = wgpu::CompareFunction::NotEqual;
+                break;
+            }
+            case SamplerCompareFunc::A: {
+                desc.compare = wgpu::CompareFunction::Always;
+                break;
+            }
+            case SamplerCompareFunc::N: {
+                desc.compare = wgpu::CompareFunction::Never;
+                break;
+            }
        }
    }

    desc.maxAnisotropy = 1u << params.anisotropyLog2;

+    // Unused: WGPU lodMinClamp/lodMaxClamp unnecessary

-    // Unused: Filament's compareMode, WGPU lodMinClamp/lodMaxClamp
-
-    //TODO Once we can properly map to descriptorsetlayout use the sampler.
-    return mDevice.CreateSampler(/*&desc*/);
+    return mDevice.CreateSampler(&desc);
 }
 wgpu::AddressMode WebGPUDriver::fWrapModeToWAddressMode(const SamplerWrapMode& fWrapMode) {
    switch (fWrapMode) {
@@ -1179,5 +1182,4 @@ wgpu::AddressMode WebGPUDriver::fWrapModeToWAddressMode(const SamplerWrapMode& f
    return wgpu::AddressMode::Undefined;
 }

-
 } // namespace filament
@@ -58,32 +58,13 @@ private:
    [[nodiscard]] ShaderLanguage getShaderLanguage() const noexcept final;
    [[nodiscard]] wgpu::Sampler makeSampler(SamplerParams const& params);
    [[nodiscard]] static wgpu::AddressMode fWrapModeToWAddressMode(const filament::backend::SamplerWrapMode& fUsage);
-    template<typename GPUBufferObject>
-    void updateGPUBuffer(GPUBufferObject* gpuBufferObject, BufferDescriptor&& bufferDescriptor,
-            uint32_t byteOffset) {
-        FILAMENT_CHECK_PRECONDITION(bufferDescriptor.buffer)
-                << "copyIntoBuffer called with a null buffer";
-        FILAMENT_CHECK_PRECONDITION(
-                bufferDescriptor.size + byteOffset <= gpuBufferObject->buffer.GetSize())
-                << "Attempting to copy " << bufferDescriptor.size << " bytes into a buffer of size "
-                << gpuBufferObject->buffer.GetSize() << " at offset " << byteOffset;
-
-        // TODO: All buffer objects are created with CopyDst usage.
-        // This may have some performance implications. That should be investigated later.
-        assert_invariant(gpuBufferObject->buffer.GetUsage() & wgpu::BufferUsage::CopyDst);
-
-        // WriteBuffer is an async call. But cpu buffer data is already written to the staging
-        // buffer on return from the WriteBuffer.
-        mQueue.WriteBuffer(gpuBufferObject->buffer, byteOffset, bufferDescriptor.buffer,
-                bufferDescriptor.size);
-        scheduleDestroy(std::move(bufferDescriptor));
-    }

    // the platform (e.g. OS) specific aspects of the WebGPU backend are strictly only
    // handled in the WebGPUPlatform
    WebGPUPlatform& mPlatform;
    wgpu::Adapter mAdapter = nullptr;
    wgpu::Device mDevice = nullptr;
+    uint32_t mMinUniformBufferOffsetAlignment;
    wgpu::Queue mQueue = nullptr;
    void* mNativeWindow = nullptr;
    WebGPUSwapChain* mSwapChain = nullptr;
@@ -93,8 +74,16 @@ private:
    wgpu::RenderPassEncoder mRenderPassEncoder = nullptr;
    wgpu::CommandBuffer mCommandBuffer = nullptr;
    WGPURenderTarget* mDefaultRenderTarget = nullptr;
+    WGPURenderTarget* mCurrentRenderTarget = nullptr;

    tsl::robin_map<uint32_t, wgpu::RenderPipeline> mPipelineMap;
+
+    struct DescriptorSetBindingInfo{
+        wgpu::BindGroup bindGroup;
+        size_t offsetCount;
+        backend::DescriptorSetOffsetArray offsets;
+    };
+    std::array<DescriptorSetBindingInfo,MAX_DESCRIPTOR_SET_COUNT> mCurrentDescriptorSets;
    /*
     * Driver interface
     */
@@ -19,7 +19,8 @@
 #include <backend/DriverEnums.h>

 #include <utils/BitmaskEnum.h>
-
+#include <utils/Panic.h>
+#include <private/backend/BackendUtils.h>
 #include <webgpu/webgpu_cpp.h>

 #include <algorithm>
@@ -40,15 +41,6 @@ constexpr wgpu::BufferUsage getBufferObjectUsage(
    }
 }

-wgpu::Buffer createBuffer(wgpu::Device const& device, wgpu::BufferUsage usage, uint32_t size,
-        char const* label) {
-    wgpu::BufferDescriptor descriptor{ .label = label,
-        .usage = usage,
-        .size = size,
-        .mappedAtCreation = false };
-    return device.CreateBuffer(&descriptor);
-}
-
 wgpu::VertexFormat getVertexFormat(filament::backend::ElementType type, bool normalized, bool integer) {
    using ElementType = filament::backend::ElementType;
    using VertexFormat = wgpu::VertexFormat;
@@ -76,7 +68,7 @@ wgpu::VertexFormat getVertexFormat(filament::backend::ElementType type, bool nor
            case ElementType::BYTE4: return VertexFormat::Snorm8x4;
            case ElementType::UBYTE4: return VertexFormat::Unorm8x4;
            case ElementType::SHORT4: return VertexFormat::Snorm16x4;
-            case ElementType::USHORT4: return VertexFormat::Unorm8x4;
+            case ElementType::USHORT4: return VertexFormat::Unorm16x4;
            default:
                FILAMENT_CHECK_POSTCONDITION(false) << "Normalized format does not exist.";
                return VertexFormat::Float32x3;
@@ -134,7 +126,7 @@ wgpu::StringView getUserTextureLabel(filament::backend::SamplerType target) {
        case SamplerType::SAMPLER_3D:
            return "a_3D_user_texture";
        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            return "a_cube_mape_array_user_texture";
+            return "a_cube_map_array_user_texture";
    }
 }

@@ -153,7 +145,7 @@ wgpu::StringView getUserTextureViewLabel(filament::backend::SamplerType target)
        case SamplerType::SAMPLER_3D:
            return "a_3D_user_texture_view";
        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            return "a_cube_mape_array_user_texture_view";
+            return "a_cube_map_array_user_texture_view";
    }
 }

@@ -161,51 +153,142 @@ wgpu::StringView getUserTextureViewLabel(filament::backend::SamplerType target)

 namespace filament::backend {

+void WGPUBufferBase::createBuffer(const wgpu::Device& device, wgpu::BufferUsage usage,
+        uint32_t size, const char* label) {
+    // Write size must be divisible by 4. If the whole buffer is written to as is common, so must
+    // the buffer size.
+    size += (4 - (size % 4)) % 4;
+    wgpu::BufferDescriptor descriptor{ .label = label,
+        .usage = usage,
+        .size = size,
+        .mappedAtCreation = false };
+    buffer = device.CreateBuffer(&descriptor);
+}
+
+void WGPUBufferBase::updateGPUBuffer(BufferDescriptor& bufferDescriptor, uint32_t byteOffset,
+        wgpu::Queue queue) {
+    FILAMENT_CHECK_PRECONDITION(bufferDescriptor.buffer)
+            << "copyIntoBuffer called with a null buffer";
+    FILAMENT_CHECK_PRECONDITION(bufferDescriptor.size + byteOffset <= buffer.GetSize())
+            << "Attempting to copy " << bufferDescriptor.size << " bytes into a buffer of size "
+            << buffer.GetSize() << " at offset " << byteOffset;
+    FILAMENT_CHECK_PRECONDITION(byteOffset % 4 == 0)
+            << "Byte offset must be a multiple of 4 but is " << byteOffset;
+
+    // TODO: All buffer objects are created with CopyDst usage.
+    // This may have some performance implications. That should be investigated later.
+    assert_invariant(buffer.GetUsage() & wgpu::BufferUsage::CopyDst);
+
+    size_t remainder = bufferDescriptor.size % 4;
+
+    // WriteBuffer is an async call. But cpu buffer data is already written to the staging
+    // buffer on return from the WriteBuffer.
+    auto legalSize = bufferDescriptor.size - remainder;
+    queue.WriteBuffer(buffer, byteOffset, bufferDescriptor.buffer, legalSize);
+    if (remainder != 0) {
+        const uint8_t* remainderStart =
+                static_cast<const uint8_t*>(bufferDescriptor.buffer) + legalSize;
+        memcpy(mRemainderChunk.data(), remainderStart, remainder);
+        // Pad the remainder with zeros to ensure deterministic behavior, though GPU shouldn't
+        // access this
+        std::memset(mRemainderChunk.data() + remainder, 0, 4 - remainder);
+
+        queue.WriteBuffer(buffer, byteOffset + legalSize, &mRemainderChunk, 4);
+    }
+}
+
+static constexpr uint32_t DUMMY_WEBGPU_SLOT = 0;
+
 WGPUVertexBufferInfo::WGPUVertexBufferInfo(uint8_t bufferCount, uint8_t attributeCount,
        AttributeArray const& attributes)
    : HwVertexBufferInfo(bufferCount, attributeCount),
-      mVertexBufferLayout(bufferCount),
-      mAttributes(bufferCount) {
-    assert_invariant(attributeCount > 0);
-    assert_invariant(bufferCount > 0);
-    for (uint32_t attribIndex = 0; attribIndex < attributes.size(); attribIndex++) {
-        Attribute const& attrib = attributes[attribIndex];
-        // Ignore the attributes which are not bind to vertex buffers.
-        if (attrib.buffer == Attribute::BUFFER_UNUSED) {
+      // TODO: max limits may not be supported by webgpu driver. This should be addressed in the
+      // hardening part.
+      mVertexBufferLayouts(MAX_VERTEX_BUFFER_COUNT),
+      mVertexAttributes(MAX_VERTEX_BUFFER_COUNT) {
+
+    // It starts from 1 because slot 0 is now reserved for the dummy.
+    uint32_t currentWebGPUSlotIndex = 1;
+    // A reasonable dummy stride (e.g., for vec4)
+    const uint32_t DUMMY_STRIDE = 16;
+
+    // Initialize the layout for the dummy slot (slot 0)
+    mVertexBufferLayouts[DUMMY_WEBGPU_SLOT].arrayStride = DUMMY_STRIDE;
+    mVertexBufferLayouts[DUMMY_WEBGPU_SLOT].stepMode = wgpu::VertexStepMode::Vertex;
+    mVertexBufferLayouts[DUMMY_WEBGPU_SLOT].attributeCount = 0;
+
+    mWebGPUSlotBindingInfos.push_back({
+        .sourceBuffer = 0,
+        .slot = DUMMY_WEBGPU_SLOT,
+        .bufferOffset = 0,
+        .stride = DUMMY_STRIDE,
+    });
+
+    for (uint32_t attributeIndex = 0; attributeIndex < attributes.size(); ++attributeIndex) {
+        const auto& attribute = attributes[attributeIndex];
+
+        bool const isInteger = attribute.flags & Attribute::FLAG_INTEGER_TARGET;
+        bool const isNormalized = attribute.flags & Attribute::FLAG_NORMALIZED;
+        wgpu::VertexFormat vertexFormat = getVertexFormat(attribute.type, isNormalized, isInteger);
+
+        if (attribute.buffer == Attribute::BUFFER_UNUSED) {
+            // Use some dummy format
+            vertexFormat = isInteger ? wgpu::VertexFormat::Uint8x4 : wgpu::VertexFormat::Unorm8x4;
+            mVertexAttributes[DUMMY_WEBGPU_SLOT].push_back({
+                .format = vertexFormat,
+                .offset = 0,
+                .shaderLocation = attributeIndex,
+            });
+            mVertexBufferLayouts[DUMMY_WEBGPU_SLOT].attributeCount++;
            continue;
        }

-        assert_invariant(attrib.buffer < bufferCount);
-        bool const isInteger = attrib.flags & Attribute::FLAG_INTEGER_TARGET;
-        bool const isNormalized = attrib.flags & Attribute::FLAG_NORMALIZED;
-        wgpu::VertexFormat vertexFormat = getVertexFormat(attrib.type, isNormalized, isInteger);
+        auto it = std::find_if(mWebGPUSlotBindingInfos.begin(), mWebGPUSlotBindingInfos.end(),
+                [&](const auto& info) {
+                    return info.sourceBuffer == attribute.buffer && info.stride == attribute.stride;
+                });

-        // Attributes are sequential per buffer
-        mAttributes[attrib.buffer].push_back({
-            .format = vertexFormat,
-            .offset = attrib.offset,
-            .shaderLocation = attribIndex,
-        });
-
-        mVertexBufferLayout[attrib.buffer].stepMode = wgpu::VertexStepMode::Vertex;
-        if (mVertexBufferLayout[attrib.buffer].arrayStride == 0) {
-            mVertexBufferLayout[attrib.buffer].arrayStride = attrib.stride;
+        uint32_t assignedSlot;
+        if (it != mWebGPUSlotBindingInfos.end()) {
+            assignedSlot = it->slot;
        } else {
-            assert_invariant(mVertexBufferLayout[attrib.buffer].arrayStride == attrib.stride);
+            // New combination, allocate a new WebGPU slot
+            assert_invariant(currentWebGPUSlotIndex < MAX_VERTEX_BUFFER_COUNT);
+            assignedSlot = currentWebGPUSlotIndex++;
+
+            mWebGPUSlotBindingInfos.push_back({
+                .sourceBuffer = attribute.buffer,
+                .slot = assignedSlot,
+                .bufferOffset = attribute.offset - (attribute.offset % attribute.stride),
+                .stride = attribute.stride,
+            });
+
+            mVertexBufferLayouts[assignedSlot].arrayStride = attribute.stride;
+            mVertexBufferLayouts[assignedSlot].stepMode = wgpu::VertexStepMode::Vertex;
+            mVertexBufferLayouts[assignedSlot].attributeCount = 0;
        }
+
+        mVertexAttributes[assignedSlot].push_back({
+            .format = vertexFormat,
+            .offset = attribute.offset % attribute.stride,
+            .shaderLocation = attributeIndex,
+        });
+        mVertexBufferLayouts[assignedSlot].attributeCount++;
    }

-    for (uint32_t bufferIndex = 0; bufferIndex < bufferCount; bufferIndex++) {
-        mVertexBufferLayout[bufferIndex].attributeCount = mAttributes[bufferIndex].size();
-        mVertexBufferLayout[bufferIndex].attributes = mAttributes[bufferIndex].data();
+    mVertexBufferLayouts.resize(currentWebGPUSlotIndex);
+
+    for (const auto& info: mWebGPUSlotBindingInfos) {
+        mVertexBufferLayouts[info.slot].attributes = mVertexAttributes[info.slot].data();
    }
 }

 WGPUIndexBuffer::WGPUIndexBuffer(wgpu::Device const& device, uint8_t elementSize,
        uint32_t indexCount)
-    : buffer(createBuffer(device, wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Index,
-              elementSize * indexCount, "index_buffer")),
-      indexFormat(elementSize == 2 ? wgpu::IndexFormat::Uint16 : wgpu::IndexFormat::Uint32) {}
+    : indexFormat(elementSize == 2 ? wgpu::IndexFormat::Uint16 : wgpu::IndexFormat::Uint32) {
+    createBuffer(device, wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Index,
+            elementSize * indexCount, "index_buffer");
+}


 WGPUVertexBuffer::WGPUVertexBuffer(wgpu::Device const& device, uint32_t vertexCount,
@@ -216,10 +299,10 @@ WGPUVertexBuffer::WGPUVertexBuffer(wgpu::Device const& device, uint32_t vertexCo

 WGPUBufferObject::WGPUBufferObject(wgpu::Device const& device, BufferObjectBinding bindingType,
        uint32_t byteCount)
-    : HwBufferObject(byteCount),
-      buffer(createBuffer(device, wgpu::BufferUsage::CopyDst | getBufferObjectUsage(bindingType),
-              byteCount, "buffer_object")),
-      bufferObjectBinding(bindingType) {}
+    : HwBufferObject(byteCount) {
+    createBuffer(device, wgpu::BufferUsage::CopyDst | getBufferObjectUsage(bindingType), byteCount,
+            "buffer_object");
+}

 wgpu::ShaderStage WebGPUDescriptorSetLayout::filamentStageToWGPUStage(ShaderStageFlags fFlags) {
    wgpu::ShaderStage retStages = wgpu::ShaderStage::None;
@@ -254,8 +337,7 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&

    unsigned int samplerCount =
            std::count_if(layout.bindings.begin(), layout.bindings.end(), [](auto& fEntry) {
-                return fEntry.type == DescriptorType::SAMPLER ||
-                       fEntry.type == DescriptorType::SAMPLER_EXTERNAL;
+                return DescriptorSetLayoutBinding::isSampler(fEntry.type);
            });


@@ -271,26 +353,45 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&
        entryInfo.binding = wEntry.binding;

        switch (fEntry.type) {
-            case DescriptorType::SAMPLER_EXTERNAL:
-            case DescriptorType::SAMPLER: {
+            case DescriptorType::SAMPLER_2D_FLOAT:
+            case DescriptorType::SAMPLER_2D_INT:
+            case DescriptorType::SAMPLER_2D_UINT:
+            case DescriptorType::SAMPLER_2D_DEPTH:
+            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
+            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_INT:
+            case DescriptorType::SAMPLER_CUBE_UINT:
+            case DescriptorType::SAMPLER_CUBE_DEPTH:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
+            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
+            case DescriptorType::SAMPLER_3D_FLOAT:
+            case DescriptorType::SAMPLER_3D_INT:
+            case DescriptorType::SAMPLER_3D_UINT:
+            case DescriptorType::SAMPLER_2D_MS_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_INT:
+            case DescriptorType::SAMPLER_2D_MS_UINT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
+            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT: {
                auto& samplerEntry = wEntries.emplace_back();
                auto& samplerEntryInfo = mBindGroupEntries.emplace_back();
                samplerEntry.binding = fEntry.binding * 2 + 1;
                samplerEntryInfo.binding = samplerEntry.binding;
-                samplerEntryInfo.type = WebGPUDescriptorSetLayout::BindGroupEntryType::SAMPLER;
                samplerEntry.visibility = wEntry.visibility;
-                // We are simply hoping that undefined and defaults suffices here.
-                samplerEntry.sampler.type = wgpu::SamplerBindingType::NonFiltering; // Example default
-                wEntry.texture.sampleType = wgpu::TextureSampleType::Float;      // Example default
-                // TODO: FIX! THIS IS HACK FOR HELLO-TRIANGLE!
-                if (baseLabel.find("Skybox") != std::string::npos ||
-                        (baseLabel == "Filament Default Material_perView" && wEntry.binding == 22)) {
-                    wEntry.texture.viewDimension = wgpu::TextureViewDimension::Cube;
+                wEntry.texture.multisampled = isMultiSampledTypeDescriptor(fEntry.type);
+                // TODO: Set once we have the filtering values
+                if (isDepthDescriptor(fEntry.type)) {
+                    samplerEntry.sampler.type = wgpu::SamplerBindingType::Comparison;
+                } else if (isIntDescriptor(fEntry.type)) {
+                    samplerEntry.sampler.type = wgpu::SamplerBindingType::NonFiltering;
                } else {
-                    wEntry.texture.viewDimension =
-                            wgpu::TextureViewDimension::e2D;// Example default
+                    samplerEntry.sampler.type = wgpu::SamplerBindingType::Filtering;
                }
-                entryInfo.type = WebGPUDescriptorSetLayout::BindGroupEntryType::TEXTURE_VIEW;
                break;
            }
            case DescriptorType::UNIFORM_BUFFER: {
@@ -301,7 +402,6 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&
                // TODO: Ideally we fill minBindingSize
                break;
            }
-
            case DescriptorType::INPUT_ATTACHMENT: {
                PANIC_POSTCONDITION("Input Attachment is not supported");
                break;
@@ -310,6 +410,48 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&
                PANIC_POSTCONDITION("Shader storage is not supported");
                break;
            }
+            case DescriptorType::SAMPLER_EXTERNAL: {
+                PANIC_POSTCONDITION("External Sampler is not supported");
+                break;
+            }
+        }
+        if (isDepthDescriptor(fEntry.type))
+        {
+            wEntry.texture.sampleType = wgpu::TextureSampleType::Depth;
+        }
+        else if (isFloatDescriptor(fEntry.type))
+        {
+            // TODO: Set once we have the filtering values
+            wEntry.texture.sampleType = wgpu::TextureSampleType::Float;
+        }
+        else if (isIntDescriptor(fEntry.type))
+        {
+            wEntry.texture.sampleType = wgpu::TextureSampleType::Sint;
+        }
+        else if (isUnsignedIntDescriptor(fEntry.type))
+        {
+            wEntry.texture.sampleType = wgpu::TextureSampleType::Uint;
+        }
+
+        if (is3dTypeDescriptor(fEntry.type))
+        {
+            wEntry.texture.viewDimension = wgpu::TextureViewDimension::e3D;
+        }
+        else if (is2dTypeDescriptor(fEntry.type))
+        {
+            wEntry.texture.viewDimension = wgpu::TextureViewDimension::e2D;
+        }
+        else if (is2dArrayTypeDescriptor(fEntry.type))
+        {
+            wEntry.texture.viewDimension = wgpu::TextureViewDimension::e2DArray;
+        }
+        else if (isCubeTypeDescriptor(fEntry.type))
+        {
+            wEntry.texture.viewDimension = wgpu::TextureViewDimension::Cube;
+        }
+        else if (isCubeArrayTypeDescriptor(fEntry.type))
+        {
+            wEntry.texture.viewDimension = wgpu::TextureViewDimension::CubeArray;
        }
        // fEntry.count is unused currently
    }
@@ -324,114 +466,26 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&

 WebGPUDescriptorSetLayout::~WebGPUDescriptorSetLayout() {}

-wgpu::Buffer WebGPUDescriptorSet::sDummyUniformBuffer = nullptr;
-wgpu::Texture WebGPUDescriptorSet::sDummyTexture = nullptr;
-wgpu::TextureView WebGPUDescriptorSet::sDummyTextureView = nullptr;
-wgpu::Sampler WebGPUDescriptorSet::sDummySampler = nullptr;
-
-void WebGPUDescriptorSet::initializeDummyResourcesIfNotAlready(wgpu::Device const& device,
-        wgpu::TextureFormat aColorFormat) {
-    if (!sDummyUniformBuffer) {
-        wgpu::BufferDescriptor bufferDescriptor{
-            .label = "dummy_uniform_not_to_be_used",
-            .usage = wgpu::BufferUsage::Uniform,
-            .size = 4
-        };
-        sDummyUniformBuffer = device.CreateBuffer(&bufferDescriptor);
-        FILAMENT_CHECK_POSTCONDITION(sDummyUniformBuffer)
-                << "Failed to create dummy uniform buffer?";
-    }
-    if (!sDummyTexture || !sDummyTextureView) {
-        wgpu::TextureDescriptor textureDescriptor{
-            .label = "dummy_texture_not_to_be_used",
-            .usage = wgpu::TextureUsage::TextureBinding,
-            .dimension = wgpu::TextureDimension::e2D,
-            .size = wgpu::Extent3D{ .width = 4, .height = 4, .depthOrArrayLayers = 1 },
-            .format = aColorFormat,
-        };
-        if (!sDummyTexture) {
-            sDummyTexture = device.CreateTexture(&textureDescriptor);
-            FILAMENT_CHECK_POSTCONDITION(sDummyUniformBuffer) << "Failed to create dummy texture?";
-        }
-        if (!sDummyTextureView) {
-            wgpu::TextureViewDescriptor textureViewDescriptor{
-                .label = "dummy_texture_view_not_to_be_used"
-            };
-            sDummyTextureView = sDummyTexture.CreateView(&textureViewDescriptor);
-            FILAMENT_CHECK_POSTCONDITION(sDummyUniformBuffer)
-                    << "Failed to create dummy texture view?";
-        }
-    }
-    if (!sDummySampler) {
-        wgpu::SamplerDescriptor samplerDescriptor{
-            .label = "dummy_sampler_not_to_be_used"
-        };
-        sDummySampler = device.CreateSampler(&samplerDescriptor);
-        FILAMENT_CHECK_POSTCONDITION(sDummyUniformBuffer) << "Failed to create dummy sampler?";
-    }
-}
-
-std::vector<wgpu::BindGroupEntry> WebGPUDescriptorSet::createDummyEntriesSortedByBinding(
-        std::vector<filament::backend::WebGPUDescriptorSetLayout::BindGroupEntryInfo> const&
-                bindGroupEntries) {
-    assert_invariant(WebGPUDescriptorSet::sDummyUniformBuffer &&
-                     "Dummy uniform buffer must have been created before "
-                     "creating dummy bind group entries.");
-    assert_invariant(
-            WebGPUDescriptorSet::sDummyTexture &&
-            "Dummy texture must have been created before creating dummy bind group entries.");
-    assert_invariant(
-            WebGPUDescriptorSet::sDummyTextureView &&
-            "Dummy texture view must have been created before creating dummy bind group entries.");
-    assert_invariant(
-            WebGPUDescriptorSet::sDummySampler &&
-            "Dummy sampler must have been created before creating dummy bind group entries.");
-    using filament::backend::WebGPUDescriptorSetLayout;
-    std::vector<wgpu::BindGroupEntry> entries;
-    entries.reserve(bindGroupEntries.size());
-    for (auto const& entryInfo: bindGroupEntries) {
-        auto& entry = entries.emplace_back();
-        entry.binding = entryInfo.binding;
-        switch (entryInfo.type) {
-            case WebGPUDescriptorSetLayout::BindGroupEntryType::UNIFORM_BUFFER:
-                entry.buffer = WebGPUDescriptorSet::sDummyUniformBuffer;
-                break;
-            case WebGPUDescriptorSetLayout::BindGroupEntryType::TEXTURE_VIEW:
-                entry.textureView = WebGPUDescriptorSet::sDummyTextureView;
-                break;
-            case WebGPUDescriptorSetLayout::BindGroupEntryType::SAMPLER:
-                entry.sampler = WebGPUDescriptorSet::sDummySampler;
-                break;
-        }
-    }
-    std::sort(entries.begin(), entries.end(),
-            [](wgpu::BindGroupEntry const& a, wgpu::BindGroupEntry const& b) {
-                return a.binding < b.binding;
-            });
-    return entries;
-}
-
 WebGPUDescriptorSet::WebGPUDescriptorSet(wgpu::BindGroupLayout const& layout,
        std::vector<WebGPUDescriptorSetLayout::BindGroupEntryInfo> const& bindGroupEntries)
    : mLayout(layout),
-      mEntriesSortedByBinding(createDummyEntriesSortedByBinding(bindGroupEntries)) {
+      mEntriesWithDynamicOffsetsCount(std::count_if(bindGroupEntries.begin(),
+              bindGroupEntries.end(), [](auto const& entry) { return entry.hasDynamicOffset; })) {
+
+    mEntries.resize(bindGroupEntries.size());
+    for (size_t i = 0; i < bindGroupEntries.size(); ++i) {
+        mEntries[i].binding = bindGroupEntries[i].binding;
+    }
    // Establish the size of entries based on the layout. This should be reliable and efficient.
    assert_invariant(INVALID_INDEX > mEntryIndexByBinding.size());
    for (size_t i = 0; i < mEntryIndexByBinding.size(); i++) {
        mEntryIndexByBinding[i] = INVALID_INDEX;
    }
-    for (size_t index = 0; index < mEntriesSortedByBinding.size(); index++) {
-        wgpu::BindGroupEntry const& entry = mEntriesSortedByBinding[index];
+    for (size_t index = 0; index < mEntries.size(); index++) {
+        wgpu::BindGroupEntry const& entry = mEntries[index];
        assert_invariant(entry.binding < mEntryIndexByBinding.size());
        mEntryIndexByBinding[entry.binding] = static_cast<uint8_t>(index);
    }
-    for (auto const& entry : bindGroupEntries) {
-        if (entry.hasDynamicOffset) {
-            assert_invariant(entry.binding < mEntriesByBindingWithDynamicOffsets.size());
-            mEntriesByBindingWithDynamicOffsets[entry.binding] = true;
-        }
-    }
-    mDynamicOffsets.reserve(mEntriesSortedByBinding.size());
 }

 WebGPUDescriptorSet::~WebGPUDescriptorSet() {
@@ -446,15 +500,15 @@ wgpu::BindGroup WebGPUDescriptorSet::lockAndReturn(const wgpu::Device& device) {
    // TODO label? Should we just copy layout label?
    wgpu::BindGroupDescriptor desc{
        .layout = mLayout,
-        .entryCount = mEntriesSortedByBinding.size(),
-        .entries = mEntriesSortedByBinding.data()
+        .entryCount = mEntries.size(),
+        .entries = mEntries.data()
    };
    mBindGroup = device.CreateBindGroup(&desc);
    FILAMENT_CHECK_POSTCONDITION(mBindGroup) << "Failed to create bind group?";
    // once we have created the bind group itself we should no longer need any other state
    mLayout = nullptr;
-    mEntriesSortedByBinding.clear();
-    mEntriesSortedByBinding.shrink_to_fit();
+    mEntries.clear();
+    mEntries.shrink_to_fit();
    return mBindGroup;
 }

@@ -472,37 +526,16 @@ void WebGPUDescriptorSet::addEntry(unsigned int index, wgpu::BindGroupEntry&& en
            << index;
    uint8_t entryIndex = mEntryIndexByBinding[index];
    FILAMENT_CHECK_POSTCONDITION(
-            entryIndex != INVALID_INDEX && entryIndex < mEntriesSortedByBinding.size())
+            entryIndex != INVALID_INDEX && entryIndex < mEntries.size())
            << "Invalid binding " << index;
    entry.binding = index;
-    mEntriesSortedByBinding[entryIndex] = std::move(entry);
-    mEntriesByBindingAdded[index] = true;
-}
-
-uint32_t const* WebGPUDescriptorSet::setDynamicOffsets(uint32_t const* offsets) {
-    // mDynamicOffsets already reserves enough memory for the number of entries in the set
-    mDynamicOffsets.clear();
-    // this implementation copies the offsets to mDynamicOffsets, but also adds values for
-    // unused entries TODO: is this necessary?
-    size_t inputIndex = 0;
-    size_t outputIndex = 0;
-    for (auto const& entry : mEntriesSortedByBinding) {
-        if (mEntriesByBindingWithDynamicOffsets[entry.binding]) {
-            if (mEntriesByBindingAdded[entry.binding]) {
-                mDynamicOffsets[outputIndex++] = offsets[inputIndex++];
-            } else {
-                mDynamicOffsets[outputIndex++] = 0; // dummy offset, as it was never added
-            }
-        }
-    }
-    return mDynamicOffsets.data();
+    mEntries[entryIndex] = std::move(entry);
 }

 size_t WebGPUDescriptorSet::countEntitiesWithDynamicOffsets() const {
-    return mEntriesByBindingWithDynamicOffsets.count();
+    return mEntriesWithDynamicOffsetsCount;
 }

-// From createTextureR
 WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat format, uint8_t samples,
        uint32_t width, uint32_t height, uint32_t depth, TextureUsage usage,
        wgpu::Device const& device) noexcept {
@@ -514,8 +547,11 @@ WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat forma
                    "the spec. See https://www.w3.org/TR/webgpu/#texture-creation or "
                    "https://gpuweb.github.io/gpuweb/#multisample-state");
    // First, the texture aspect, starting with the defaults/basic configuration
-    mUsage = fToWGPUTextureUsage(usage, device.HasFeature(wgpu::FeatureName::TransientAttachments));
+    mUsage = fToWGPUTextureUsage(usage);
    mFormat = fToWGPUTextureFormat(format);
+    mAspect = fToWGPUTextureViewAspect(usage, format);
+    mBlockWidth = filament::backend::getBlockWidth(format);
+    mBlockHeight = filament::backend::getBlockHeight(format);
    wgpu::TextureDescriptor textureDescriptor{
        .label = getUserTextureLabel(target),
        .usage = mUsage,
@@ -557,17 +593,19 @@ WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat forma
    FILAMENT_CHECK_POSTCONDITION(mTexture)
            << "Failed to create texture for " << textureDescriptor.label;
    // Second, the texture view aspect
-    mTexView = makeTextureView(0, levels, target);
+    mTexureView = makeTextureView(0, levels, target);
 }

-// From createTextureViewR
 WGPUTexture::WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept {
    mTexture = src->mTexture;
-    mTexView = makeTextureView(baseLevel, levelCount, target);
+    mAspect = src->mAspect;
+    mBlockWidth = src->mBlockWidth;
+    mBlockHeight = src->mBlockHeight;
+
+    mTexureView = makeTextureView(baseLevel, levelCount, target);
 }

-wgpu::TextureUsage WGPUTexture::fToWGPUTextureUsage(const TextureUsage& fUsage,
-        const bool supportsTransientAttachment) {
+wgpu::TextureUsage WGPUTexture::fToWGPUTextureUsage(TextureUsage const& fUsage) {
    wgpu::TextureUsage retUsage = wgpu::TextureUsage::None;

    // Basing this mapping off of VulkanTexture.cpp's getUsage func and suggestions from Gemini
@@ -593,7 +631,6 @@ wgpu::TextureUsage WGPUTexture::fToWGPUTextureUsage(const TextureUsage& fUsage,
    // This is from Vulkan logic- if there are any issues try disabling this first, allows perf
    // benefit though
    const bool useTransientAttachment =
-            supportsTransientAttachment &&
            // Usage consists of attachment flags only.
            none(fUsage & ~TextureUsage::ALL_ATTACHMENTS) &&
            // Usage contains at least one attachment flag.
@@ -616,8 +653,9 @@ wgpu::TextureUsage WGPUTexture::fToWGPUTextureUsage(const TextureUsage& fUsage,
    //  PROTECTED
    return retUsage;
 }
-wgpu::TextureFormat WGPUTexture::fToWGPUTextureFormat(const TextureFormat& fUsage) {
-    switch (fUsage) {
+
+wgpu::TextureFormat WGPUTexture::fToWGPUTextureFormat(TextureFormat const& fFormat) {
+    switch (fFormat) {
        case filament::backend::TextureFormat::R8:
            return wgpu::TextureFormat::R8Unorm;
        case filament::backend::TextureFormat::R8_SNORM:
@@ -856,24 +894,57 @@ wgpu::TextureFormat WGPUTexture::fToWGPUTextureFormat(const TextureFormat& fUsag
    }
 }

+wgpu::TextureAspect WGPUTexture::fToWGPUTextureViewAspect(TextureUsage const& fUsage,
+        TextureFormat const& fFormat) {
+
+    const bool isDepth = any(fUsage & TextureUsage::DEPTH_ATTACHMENT);
+    const bool isStencil = any(fUsage & TextureUsage::STENCIL_ATTACHMENT);
+    const bool isColor = any(fUsage & TextureUsage::COLOR_ATTACHMENT);
+    const bool isSample = (fUsage == TextureUsage::SAMPLEABLE);
+
+    if (isDepth && !isColor && !isStencil) {
+        return wgpu::TextureAspect::DepthOnly;
+    }
+
+    if (isStencil && !isColor && !isDepth) {
+        return wgpu::TextureAspect::StencilOnly;
+    }
+
+    if (fFormat == filament::backend::TextureFormat::DEPTH32F ||
+            fFormat == filament::backend::TextureFormat::DEPTH24 ||
+            fFormat == filament::backend::TextureFormat::DEPTH16) {
+        return wgpu::TextureAspect::DepthOnly;
+    }
+
+    if (fFormat == filament::backend::TextureFormat::STENCIL8) {
+        return wgpu::TextureAspect::StencilOnly;
+    }
+
+    if (fFormat == filament::backend::TextureFormat::DEPTH24_STENCIL8 ||
+            fFormat == filament::backend::TextureFormat::DEPTH32F_STENCIL8) {
+        if (isSample) {
+            return wgpu::TextureAspect::DepthOnly;
+        }
+    }
+
+    return wgpu::TextureAspect::All;
+}
+
 wgpu::TextureView WGPUTexture::makeTextureView(const uint8_t& baseLevel, const uint8_t& levelCount,
        SamplerType target) {
-    // starting with the defaults/basic configuration
+
    wgpu::TextureViewDescriptor textureViewDescriptor{
        .label = getUserTextureViewLabel(target),
        .format = mFormat,
-        // dimension depends on target and is set below
        .baseMipLevel = baseLevel,
        .mipLevelCount = levelCount,
-        // baseArrayLayer is required, making a guess
+        // TODO: check if this baseArrayLayer assumption is correct
        .baseArrayLayer = 0,
        .arrayLayerCount = mArrayLayerCount,
-        // Have not found an analog to aspect in other drivers, but ALL should be unrestrictive.
-        // TODO Can we make this better?
-        .aspect = wgpu::TextureAspect::All,
+        .aspect = mAspect,
        .usage = mUsage
    };
-    // adjust for specific cases
+
    switch (target) {
        case SamplerType::SAMPLER_2D:
            textureViewDescriptor.dimension = wgpu::TextureViewDimension::e2D;
@@ -900,58 +971,153 @@ wgpu::TextureView WGPUTexture::makeTextureView(const uint8_t& baseLevel, const u
    return textureView;
 }

-WGPURenderTarget::Attachment WGPURenderTarget::getDrawColorAttachment(size_t index) {
-    assert_invariant( index < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
-    auto result = color[index];
-    if (index == 0 && defaultRenderTarget) {
-
-    }
-
-    return result;
+WGPURenderTarget::WGPURenderTarget(uint32_t width, uint32_t height, uint8_t samples,
+        const MRT& colorAttachmentsMRT,
+        const Attachment& depthAttachmentInfo,
+        const Attachment& stencilAttachmentInfo)
+    : HwRenderTarget(width, height),
+      defaultRenderTarget(false),
+      samples(samples),
+      mColorAttachments(colorAttachmentsMRT),
+      mDepthAttachment(depthAttachmentInfo),
+      mStencilAttachment(stencilAttachmentInfo) {
+    // TODO Make this an array
+    mColorAttachmentDescriptors.reserve(MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
 }

 wgpu::LoadOp WGPURenderTarget::getLoadOperation(RenderPassParams const& params,
-                                             TargetBufferFlags buffer) {
-    auto clearFlags = params.flags.clear;
-    auto discardStartFlags = params.flags.discardStart;
-    if (any(clearFlags & buffer)) {
-        return wgpu::LoadOp::Clear;
-    } else if (any(discardStartFlags & buffer)) {
+                                                TargetBufferFlags bufferToOperateOn) {
+    if (any(params.flags.clear & bufferToOperateOn)) {
        return wgpu::LoadOp::Clear;
    }
+    if (any(params.flags.discardStart & bufferToOperateOn)) {
+        return wgpu::LoadOp::Clear; // Or wgpu::LoadOp::Undefined if clear is not desired on discard
+    }
    return wgpu::LoadOp::Load;
 }

 wgpu::StoreOp WGPURenderTarget::getStoreOperation(RenderPassParams const& params,
-                                               TargetBufferFlags buffer) {
-    const auto discardEndFlags = params.flags.discardEnd;
-    if (any(discardEndFlags & buffer)) {
+                                                  TargetBufferFlags bufferToOperateOn) {
+    if (any(params.flags.discardEnd & bufferToOperateOn)) {
        return wgpu::StoreOp::Discard;
    }
    return wgpu::StoreOp::Store;
 }
+
 void WGPURenderTarget::setUpRenderPassAttachments(wgpu::RenderPassDescriptor& descriptor,
-        wgpu::TextureView const& textureView, RenderPassParams const& params) {
-    // auto discardFlags = params.flags.discardEnd;
-    // (void) discardFlags;
-    // std::vector<wgpu::RenderPassColorAttachment> colorAttachments;
-    colorAttachments.clear();
-    for (size_t i = 0; i < 1/*MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT*/; i++) {
-        // auto attachment = getDrawColorAttachment(i);
-        // if (attachment) {
-            wgpu::RenderPassColorAttachment colorAttachment;
-            colorAttachment.view = textureView;
-            colorAttachment.loadOp  = getLoadOperation(params, getTargetBufferFlagsAt(i));
-            colorAttachment.storeOp = getStoreOperation(params, getTargetBufferFlagsAt(i));
-            colorAttachment.clearValue = { params.clearColor.r, params.clearColor.g, params.clearColor.b, params.clearColor.a };
-            colorAttachments.emplace_back(colorAttachment);
-        // }
+        RenderPassParams const& params, wgpu::TextureView const& defaultColorTextureView,
+        wgpu::TextureView const& defaultDepthStencilTextureView,
+        wgpu::TextureView const* customColorTextureViews, uint32_t customColorTextureViewCount,
+        wgpu::TextureView const& customDepthTextureView,
+        wgpu::TextureView const& customStencilTextureView, wgpu::TextureFormat customDepthFormat,
+        wgpu::TextureFormat customStencilFormat) {
+    mColorAttachmentDescriptors.clear();
+    mHasDepthStencilAttachment = false;
+
+    if (defaultRenderTarget) {
+        assert_invariant(defaultColorTextureView);
+        mColorAttachmentDescriptors.push_back({ .view = defaultColorTextureView,
+            .resolveTarget = nullptr,
+            .loadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::COLOR0),
+            .storeOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::COLOR0),
+            .clearValue = { params.clearColor.r, params.clearColor.g, params.clearColor.b,
+                params.clearColor.a } });
+
+        if (defaultDepthStencilTextureView) {
+            mDepthStencilAttachmentDescriptor = {
+                .view = defaultDepthStencilTextureView,
+                .depthLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH),
+                .depthStoreOp =
+                        WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH),
+                .depthClearValue = static_cast<float>(params.clearDepth),
+                .depthReadOnly =
+                        (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0,
+                .stencilLoadOp =
+                        WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL),
+                .stencilStoreOp =
+                        WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL),
+                .stencilClearValue = params.clearStencil,
+                .stencilReadOnly =
+                        (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0,
+            };
+            mHasDepthStencilAttachment = true;
+        }
+    } else {// Custom Render Target
+        for (uint32_t i = 0; i < customColorTextureViewCount; ++i) {
+            if (customColorTextureViews[i]) {
+                mColorAttachmentDescriptors.push_back({ .view = customColorTextureViews[i],
+                    // .resolveTarget = nullptr; // TODO: MSAA resolve for custom RT
+                    .loadOp = WGPURenderTarget::getLoadOperation(params, getTargetBufferFlagsAt(i)),
+                    .storeOp =
+                            WGPURenderTarget::getStoreOperation(params, getTargetBufferFlagsAt(i)),
+                    .clearValue = { .r = params.clearColor.r,
+                        .g = params.clearColor.g,
+                        .b = params.clearColor.b,
+                        .a = params.clearColor.a } });
+            }
+        }
+
+        FILAMENT_CHECK_POSTCONDITION(!(customDepthTextureView && customStencilTextureView))
+                << "WebGPU CANNOT support separate texture views for depth + stencil. depth + "
+                   "stencil needs to be in one texture view";
+
+        const bool hasStencil =
+                customStencilTextureView ||
+                (customDepthFormat == wgpu::TextureFormat::Depth24PlusStencil8 ||
+                        customDepthFormat == wgpu::TextureFormat::Depth32FloatStencil8);
+
+        const bool hasDepth =
+                customDepthTextureView ||
+                (customStencilFormat == wgpu::TextureFormat::Depth24PlusStencil8 ||
+                        customDepthFormat == wgpu::TextureFormat::Depth32FloatStencil8);
+
+        if (customDepthTextureView || customStencilTextureView) {
+            assert_invariant((hasDepth || hasStencil) &&
+                             "Depth or Texture view without a valid texture format");
+            mDepthStencilAttachmentDescriptor = {};
+            mDepthStencilAttachmentDescriptor.view =
+                    customDepthTextureView ? customDepthTextureView : customStencilTextureView;
+
+            if (hasDepth) {
+                mDepthStencilAttachmentDescriptor.depthLoadOp =
+                        WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH);
+                mDepthStencilAttachmentDescriptor.depthStoreOp =
+                        WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH);
+                mDepthStencilAttachmentDescriptor.depthClearValue =
+                        static_cast<float>(params.clearDepth);
+                mDepthStencilAttachmentDescriptor.depthReadOnly =
+                        (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0;
+            } else {
+                mDepthStencilAttachmentDescriptor.depthLoadOp = wgpu::LoadOp::Undefined;
+                mDepthStencilAttachmentDescriptor.depthStoreOp = wgpu::StoreOp::Undefined;
+                mDepthStencilAttachmentDescriptor.depthReadOnly = true;
+            }
+
+            if (hasStencil) {
+                mDepthStencilAttachmentDescriptor.stencilLoadOp =
+                        WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL);
+                mDepthStencilAttachmentDescriptor.stencilStoreOp =
+                        WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL);
+                mDepthStencilAttachmentDescriptor.stencilClearValue = params.clearStencil;
+                mDepthStencilAttachmentDescriptor.stencilReadOnly =
+                        (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0;
+            } else {
+                mDepthStencilAttachmentDescriptor.stencilLoadOp = wgpu::LoadOp::Undefined;
+                mDepthStencilAttachmentDescriptor.stencilStoreOp = wgpu::StoreOp::Undefined;
+                mDepthStencilAttachmentDescriptor.stencilReadOnly = true;
+            }
+            mHasDepthStencilAttachment = true;
+        }
    }
-    descriptor.colorAttachments = colorAttachments.data();
-    descriptor.colorAttachmentCount = colorAttachments.size();
-    descriptor.depthStencilAttachment = nullptr;
-    descriptor.timestampWrites = nullptr;
+
+    descriptor.colorAttachmentCount = mColorAttachmentDescriptors.size();
+    descriptor.colorAttachments = mColorAttachmentDescriptors.data();
+    descriptor.depthStencilAttachment =
+            mHasDepthStencilAttachment ? &mDepthStencilAttachmentDescriptor : nullptr;
+
+    // descriptor.sampleCount was removed from the core spec. If your webgpu.h still has it,
+    // and your Dawn version expects it, you might need to set it here based on this->samples.
+    // e.g., descriptor.sampleCount = this->samples;
 }

-
 }// namespace filament::backend
@@ -28,7 +28,6 @@
 #include <webgpu/webgpu_cpp.h>

 #include <array>
-#include <bitset>
 #include <cstdint>
 #include <vector>

@@ -44,38 +43,47 @@ public:
    std::vector<wgpu::ConstantEntry> constants;
 };

-struct WGPUBufferObject;

-// VertexBufferInfo contains layout info for Vertex Buffer based on WebGPU structs. In WebGPU each
-// VertexBufferLayout is associated with a single vertex buffer. So number of mVertexBufferLayout
-// is equal to bufferCount. Each VertexBufferLayout can contain multiple VertexAttribute. Bind index
-// of vertex buffer is implicitly calculated by the position of VertexBufferLayout in an array.
+// WGPUVertexBufferInfo maps Filament vertex attributes to WebGPU buffer binding model.
 class WGPUVertexBufferInfo : public HwVertexBufferInfo {
 public:
    WGPUVertexBufferInfo(uint8_t bufferCount, uint8_t attributeCount,
            AttributeArray const& attributes);
-    inline  wgpu::VertexBufferLayout const* getVertexBufferLayout() const {
-        return mVertexBufferLayout.data();
+
+    inline wgpu::VertexBufferLayout const* getVertexBufferLayouts() const {
+        return mVertexBufferLayouts.data();
+    }
+    inline uint32_t getVertexBufferLayoutCount() const {
+        return static_cast<uint32_t>(mVertexBufferLayouts.size());
    }

-    inline uint32_t getVertexBufferLayoutSize() const {
-        return mVertexBufferLayout.size();
+    inline wgpu::VertexAttribute const* getVertexAttributes(uint32_t i) const {
+        return mVertexAttributes[i].data();
+    }
+    inline uint32_t getVertexAttributeCount(uint32_t i) const {
+        return static_cast<uint32_t>(mVertexAttributes[i].size());
    }

-    inline wgpu::VertexAttribute const* getVertexAttributeForIndex(uint32_t index) const {
-        assert_invariant(index < mAttributes.size());
-        return mAttributes[index].data();
-    }
-
-    inline uint32_t getVertexAttributeSize(uint32_t index) const {
-        assert_invariant(index < mAttributes.size());
-        return mAttributes[index].size();
+    struct WebGPUSlotBindingInfo {
+        uint8_t sourceBuffer;
+        uint32_t slot;
+        uint64_t bufferOffset;
+        uint32_t stride;
+    };
+    inline const std::vector<WebGPUSlotBindingInfo>& getWebGPUSlotBindingInfos() const {
+        return mWebGPUSlotBindingInfos;
    }

 private:
-    // TODO: can we do better in terms on heap management.
-    std::vector<wgpu::VertexBufferLayout> mVertexBufferLayout {};
-    std::vector<std::vector<wgpu::VertexAttribute>> mAttributes {};
+    // This stores the final wgpu::VertexBufferLayout objects, one per WebGPU slot.
+    std::vector<wgpu::VertexBufferLayout> mVertexBufferLayouts;
+
+    // This stores all wgpu::VertexAttribute structs, indexed by their original
+    // Filament attributeIndex.
+    std::vector<std::vector<wgpu::VertexAttribute>> mVertexAttributes;
+
+    // Stores information for the driver to perform setVertexBuffer calls
+    std::vector<WebGPUSlotBindingInfo> mWebGPUSlotBindingInfos;
 };

 struct WGPUVertexBuffer : public HwVertexBuffer {
@@ -86,33 +94,37 @@ struct WGPUVertexBuffer : public HwVertexBuffer {
    utils::FixedCapacityVector<wgpu::Buffer> buffers;
 };

-struct WGPUIndexBuffer : public HwIndexBuffer {
+class WGPUBufferBase {
+public:
+    void createBuffer(wgpu::Device const& device, wgpu::BufferUsage usage, uint32_t size,
+            char const* label);
+    void updateGPUBuffer(BufferDescriptor& bufferDescriptor, uint32_t byteOffset,
+            wgpu::Queue queue);
+    const wgpu::Buffer& getBuffer() const { return buffer; }
+protected:
+    wgpu::Buffer buffer;
+private:
+    // 4 bytes to hold any extra chunk we need.
+    std::array<uint8_t,4> mRemainderChunk;
+};
+
+class WGPUIndexBuffer : public HwIndexBuffer, public WGPUBufferBase {
+public:
    WGPUIndexBuffer(wgpu::Device const &device, uint8_t elementSize,
                    uint32_t indexCount);
-
-    wgpu::Buffer buffer;
    wgpu::IndexFormat indexFormat;
 };

-struct WGPUBufferObject : HwBufferObject {
+class WGPUBufferObject : public HwBufferObject, public WGPUBufferBase {
+public:
    WGPUBufferObject(wgpu::Device const &device, BufferObjectBinding bindingType, uint32_t byteCount);
-
-    wgpu::Buffer buffer = nullptr;
-    const BufferObjectBinding bufferObjectBinding;
 };

 class WebGPUDescriptorSetLayout final : public HwDescriptorSetLayout {
 public:

-    enum class BindGroupEntryType : uint8_t {
-        UNIFORM_BUFFER,
-        TEXTURE_VIEW,
-        SAMPLER
-    };
-
    struct BindGroupEntryInfo final {
        uint8_t binding = 0;
-        BindGroupEntryType type = BindGroupEntryType::UNIFORM_BUFFER;
        bool hasDynamicOffset = false;
    };

@@ -125,7 +137,7 @@ public:

 private:
    // TODO: If this is useful elsewhere, remove it from this class
-    // Convert Filament Shader Stage Flags bitmask to webgpu equivilant
+    // Convert Filament Shader Stage Flags bitmask to webgpu equivalent
    static wgpu::ShaderStage filamentStageToWGPUStage(ShaderStageFlags fFlags);
    std::vector<BindGroupEntryInfo> mBindGroupEntries;
    wgpu::BindGroupLayout mLayout;
@@ -133,8 +145,6 @@ private:

 class WebGPUDescriptorSet final : public HwDescriptorSet {
 public:
-    static void initializeDummyResourcesIfNotAlready(wgpu::Device const&,
-            wgpu::TextureFormat aColorFormat);

    WebGPUDescriptorSet(wgpu::BindGroupLayout const& layout,
            std::vector<WebGPUDescriptorSetLayout::BindGroupEntryInfo> const& bindGroupEntries);
@@ -142,30 +152,18 @@ public:

    wgpu::BindGroup lockAndReturn(wgpu::Device const&);
    void addEntry(unsigned int index, wgpu::BindGroupEntry&& entry);
-    [[nodiscard]] uint32_t const* setDynamicOffsets(uint32_t const* offsets);
    [[nodiscard]] bool getIsLocked() const { return mBindGroup != nullptr; }
    [[nodiscard]] size_t countEntitiesWithDynamicOffsets() const;
+
+    // May be nullptr. Use lockAndReturn to create the bind group when appropriate
+    [[nodiscard]] const wgpu::BindGroup& getBindGroup() const { return mBindGroup; }
+
 private:
-
-    static wgpu::Buffer sDummyUniformBuffer;
-    static wgpu::Texture sDummyTexture;
-    static wgpu::TextureView sDummyTextureView;
-    static wgpu::Sampler sDummySampler;
-
-    static std::vector<wgpu::BindGroupEntry> createDummyEntriesSortedByBinding(
-            std::vector<filament::backend::WebGPUDescriptorSetLayout::BindGroupEntryInfo> const&);
-
-    // TODO: Consider storing what we used to make the layout. However we need to essentially
-    // Recreate some of the info (Sampler in slot X with the actual sampler) so letting Dawn confirm
-    // there isn't a mismatch may be easiest.
-    // Also storing the wgpu ObjectBase takes care of ownership challenges in theory
    wgpu::BindGroupLayout mLayout = nullptr;
    static constexpr uint8_t INVALID_INDEX = MAX_DESCRIPTOR_COUNT + 1;
-    std::array<uint8_t, MAX_DESCRIPTOR_COUNT> mEntryIndexByBinding {};
-    std::vector<wgpu::BindGroupEntry> mEntriesSortedByBinding;
-    std::bitset<MAX_DESCRIPTOR_COUNT> mEntriesByBindingWithDynamicOffsets {};
-    std::bitset<MAX_DESCRIPTOR_COUNT> mEntriesByBindingAdded {};
-    std::vector<uint32_t> mDynamicOffsets;
+    std::array<uint8_t, MAX_DESCRIPTOR_COUNT> mEntryIndexByBinding{};
+    std::vector<wgpu::BindGroupEntry> mEntries;
+    const size_t mEntriesWithDynamicOffsetsCount;
    wgpu::BindGroup mBindGroup = nullptr;
 };

@@ -176,12 +174,19 @@ public:
            wgpu::Device const& device) noexcept;

    WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept;
+    wgpu::TextureAspect getAspect() const { return mAspect; }
+    size_t getBlockWidth() const { return mBlockWidth; }
+    size_t getBlockHeight() const { return mBlockHeight; }

-    const wgpu::Texture& getTexture() const { return mTexture; }
-    const wgpu::TextureView& getTexView() const { return mTexView; }
+    [[nodiscard]] const wgpu::Texture& getTexture() const { return mTexture; }
+    [[nodiscard]] const wgpu::TextureView& getTextureView() const { return mTexureView; }
+    [[nodiscard]] wgpu::TextureFormat getFormat() const { return mFormat; }

-    // Public to allow checking for support of a texture format
-    static wgpu::TextureFormat fToWGPUTextureFormat(const filament::backend::TextureFormat& fUsage);
+    static wgpu::TextureFormat fToWGPUTextureFormat(
+            filament::backend::TextureFormat const& fFormat);
+    static wgpu::TextureAspect fToWGPUTextureViewAspect(
+            filament::backend::TextureUsage const& fUsage,
+            filament::backend::TextureFormat const& fFormat);

 private:
    wgpu::TextureView makeTextureView(const uint8_t& baseLevel, const uint8_t& levelCount,
@@ -192,10 +197,12 @@ private:
    wgpu::Texture mTexture = nullptr;
    wgpu::TextureUsage mUsage = wgpu::TextureUsage::None;
    wgpu::TextureFormat mFormat = wgpu::TextureFormat::Undefined;
+    wgpu::TextureAspect mAspect = wgpu::TextureAspect::Undefined;
    uint32_t mArrayLayerCount = 1;
-    wgpu::TextureView mTexView = nullptr;
-    wgpu::TextureUsage fToWGPUTextureUsage(const filament::backend::TextureUsage& fUsage,
-            const bool supportsTransientAttachment);
+    wgpu::TextureView mTexureView = nullptr;
+    wgpu::TextureUsage fToWGPUTextureUsage(filament::backend::TextureUsage const& fUsage);
+    size_t mBlockWidth;
+    size_t mBlockHeight;
 };

 struct WGPURenderPrimitive : public HwRenderPrimitive {
@@ -206,55 +213,60 @@ struct WGPURenderPrimitive : public HwRenderPrimitive {

 class WGPURenderTarget : public HwRenderTarget {
 public:
-    class Attachment {
-    public:
-        friend class WGPURenderTarget;
-
-        Attachment() = default;
-        Attachment(WGPUTexture* gpuTexture, uint8_t level = 0, uint16_t layer = 0)
-            : level(level),
-              layer(layer),
-              texture(gpuTexture->getTexture()),
-              mWGPUTexture(gpuTexture) {}
-        operator bool() const {
-            return mWGPUTexture != nullptr;
-        }
-
-        uint8_t level = 0;
-        uint16_t layer = 0;
-
-    private:
-        wgpu::Texture texture = nullptr;
-        WGPUTexture* mWGPUTexture = nullptr;
-    };
+    using Attachment = TargetBufferInfo; // Using TargetBufferInfo directly for attachments

    WGPURenderTarget(uint32_t width, uint32_t height, uint8_t samples,
-            Attachment colorAttachments[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT]);
+            const MRT& colorAttachments,
+            const Attachment& depthAttachment,
+            const Attachment& stencilAttachment);
+
+    // Default constructor for the default render target
    WGPURenderTarget()
        : HwRenderTarget(0, 0),
-          defaultRenderTarget(true) {}
+          defaultRenderTarget(true),
+          samples(1) {}

-    void setUpRenderPassAttachments(wgpu::RenderPassDescriptor& descriptor,
-            wgpu::TextureView const& textureView, RenderPassParams const& params);
+    // Updated signature: takes resolved views for custom RTs, and default views for default RT
+    void setUpRenderPassAttachments(
+            wgpu::RenderPassDescriptor& descriptor,
+            RenderPassParams const& params,
+            // For default render target:
+            wgpu::TextureView const& defaultColorTextureView,
+            wgpu::TextureView const& defaultDepthStencilTextureView,
+            // For custom render targets:
+            wgpu::TextureView const* customColorTextureViews, // Array of views
+            uint32_t customColorTextureViewCount,
+            wgpu::TextureView const& customDepthTextureView,
+            wgpu::TextureView const& customStencilTextureView,
+            wgpu::TextureFormat customDepthFormat,
+            wgpu::TextureFormat customStencilFormat);

-    math::uint2 getAttachmentSize() noexcept;

    bool isDefaultRenderTarget() const { return defaultRenderTarget; }
    uint8_t getSamples() const { return samples; }

-    Attachment getDrawColorAttachment(size_t index);
-    Attachment getReadColorAttachment(size_t index);
+    // Accessors for the driver to get stored attachment info
+    const MRT& getColorAttachmentInfos() const { return mColorAttachments; }
+    const Attachment& getDepthAttachmentInfo() const { return mDepthAttachment; }
+    const Attachment& getStencilAttachmentInfo() const { return mStencilAttachment; }

+    // Static helpers for load/store operations
    static wgpu::LoadOp getLoadOperation(const RenderPassParams& params, TargetBufferFlags buffer);
    static wgpu::StoreOp getStoreOperation(const RenderPassParams& params, TargetBufferFlags buffer);
+
 private:
    bool defaultRenderTarget = false;
    uint8_t samples = 1;

-    Attachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT] = {};
-    math::uint2 attachmentSize = {};
-    std::vector<wgpu::RenderPassColorAttachment> colorAttachments {};
-};
+    MRT mColorAttachments{};
+    // TODO WebGPU only supports a DepthStencil attachment, should this be just mDepthStencilAttachment?
+    Attachment mDepthAttachment{};
+    Attachment mStencilAttachment{};

+    // Cached descriptors for the render pass
+    std::vector<wgpu::RenderPassColorAttachment> mColorAttachmentDescriptors;
+    wgpu::RenderPassDepthStencilAttachment mDepthStencilAttachmentDescriptor{};
+    bool mHasDepthStencilAttachment = false;
+};
 }// namespace filament::backend
 #endif// TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H
@@ -154,9 +154,9 @@ constexpr wgpu::BlendFactor toWebGPU(BlendFunction blendFunction) {
 wgpu::RenderPipeline createWebGPURenderPipeline(wgpu::Device const& device,
        WGPUProgram const& program, WGPUVertexBufferInfo const& vertexBufferInfo,
        wgpu::PipelineLayout const& layout, RasterState const& rasterState,
-        StencilState const& stencilState, PolygonOffset const& polygonOffset,
-        PrimitiveType primitiveType, wgpu::TextureFormat colorFormat,
-        wgpu::TextureFormat depthFormat) {
+        StencilState const& stencilState, PolygonOffset const& polygonOffset, PrimitiveType primitiveType,
+        std::vector<wgpu::TextureFormat> const& colorFormats,
+        wgpu::TextureFormat depthFormat, uint8_t samplesCount) {
    assert_invariant(program.vertexShaderModule);
    const wgpu::DepthStencilState depthStencilState {
        .format = depthFormat,
@@ -191,8 +191,8 @@ wgpu::RenderPipeline createWebGPURenderPipeline(wgpu::Device const& device,
            .entryPoint = "main",
            .constantCount = program.constants.size(),
            .constants = program.constants.data(),
-            .bufferCount = vertexBufferInfo.getVertexBufferLayoutSize(),
-            .buffers = vertexBufferInfo.getVertexBufferLayout()
+            .bufferCount = vertexBufferInfo.getVertexBufferLayoutCount(),
+            .buffers = vertexBufferInfo.getVertexBufferLayouts()
        },
        .primitive = {
            .topology = toWebGPU(primitiveType),
@@ -207,9 +207,9 @@ wgpu::RenderPipeline createWebGPURenderPipeline(wgpu::Device const& device,
            .unclippedDepth = !rasterState.depthClamp &&
                              device.HasFeature(wgpu::FeatureName::DepthClipControl)
        },
-        .depthStencil = &depthStencilState,
+        .depthStencil = depthFormat != wgpu::TextureFormat::Undefined ? &depthStencilState: nullptr,
        .multisample = {
-            .count = 1, // TODO need to get this from the render target
+            .count = samplesCount,
            .mask = 0xFFFFFFFF,
            .alphaToCoverageEnabled = rasterState.alphaToCoverage
        },
@@ -234,12 +234,15 @@ wgpu::RenderPipeline createWebGPURenderPipeline(wgpu::Device const& device,
        fragmentState.entryPoint = "main";
        fragmentState.constantCount = program.constants.size(),
        fragmentState.constants = program.constants.data(),
-        fragmentState.targetCount = 1; // TODO need to get this from the render target
+        fragmentState.targetCount = colorFormats.size();
        fragmentState.targets = colorTargets.data();
        assert_invariant(fragmentState.targetCount <= MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
+        // A fragment shader implies at least one color target if it outputs color.
+        // This should be guaranteed by the caller ensuring colorFormats is not empty.
+        assert_invariant(fragmentState.targetCount > 0);
        for (size_t targetIndex = 0; targetIndex < fragmentState.targetCount; targetIndex++) {
            auto& colorTarget = colorTargets[targetIndex];
-            colorTarget.format = colorFormat;
+            colorTarget.format = colorFormats[targetIndex];
            colorTarget.blend = rasterState.hasBlending() ? &blendState : nullptr;
            colorTarget.writeMask =
                    rasterState.colorWrite ? wgpu::ColorWriteMask::All : wgpu::ColorWriteMask::None;
@@ -18,6 +18,7 @@
 #define TNT_FILAMENT_BACKEND_WEBGPUPIPELINECREATION_H

 #include <cstdint>
+#include <vector>

 namespace wgpu {
 class Device;
@@ -38,8 +39,9 @@ class WGPUProgram;

 [[nodiscard]] wgpu::RenderPipeline createWebGPURenderPipeline(wgpu::Device const&,
        WGPUProgram const&, WGPUVertexBufferInfo const&, wgpu::PipelineLayout const&,
-        RasterState const&, StencilState const&, PolygonOffset const&, PrimitiveType,
-        wgpu::TextureFormat colorFormat, wgpu::TextureFormat depthFormat);
+        RasterState const&, StencilState const&, PolygonOffset const&, PrimitiveType primitiveType,
+        std::vector<wgpu::TextureFormat> const& colorFormats,
+        wgpu::TextureFormat depthFormat, uint8_t samplesCount);

 }// namespace filament::backend

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Sungun Park	07356a2949	tmp - testing edge cases	2025-06-02 20:02:21 -07:00
Juan Caldas	c73d11858e	Webgpu: Move Filter mode check (#8804 ) BUGS=[397432947]	2025-06-02 14:10:33 +00:00
Powei Feng	23b67be41a	Fix always bind uniform logic in MaterialInstance (#8801 ) The logic for duplicating UBO was omitted after #8739	2025-06-01 23:27:55 -07:00
bridgewaterrobbie	7d53baad5c	Add float32 filtering feature, so that we can safely assume non-int non-depth types are filtering.	2025-05-30 17:53:04 -04:00
doriswu	1ae33a23fe	Use highp for square distance	2025-05-30 13:52:44 -07:00
Rafael Dominguez	351d9287af	Update the clang-format rule for comments Make sure theres a space before the comment So now instead of getting #endif// comment it will be #endif // comment	2025-05-30 13:52:01 -07:00
Mathias Agopian	e7e5004946	attempt to fix external streams with protected context There was several issues: 1) when we're switching contexts (e.g. between protect and regular) we needed up reattach all SurfaceView (i.e. streams), because they need to be attached on currently active context. 2) reattaching, because it's implemented as detach + attach, would destroy the current gl texture id and create a new one. However, because of the way descriptor-sets were implemented, that GL texture id was kept inside the descriptor, later leading to using a destroyed texture id. The fix here is to store texture handles in descriptors, so that we can update the id independently. 3) we also needed to invalidate all bound descriptor sets because it's now possible for descriptor sets to have outdated descriptors	2025-05-30 13:15:40 -07:00
Juan Caldas	b9be9b4f2d	Set Render Pipeline	2025-05-30 15:06:50 -05:00
Powei Feng	ce88a56579	Fix leaking dummy depth array texture (#8796 )	2025-05-30 17:19:55 +00:00
Powei Feng	689e769f9a	utils: Fix FixedCircularBufferTest.Exceptions (#8794 ) Switching from assert_invariant to assert produced a different error message.	2025-05-30 10:02:31 -07:00
Jeremy Nelson	2f0a8b19b5	use params in draw call	2025-05-30 11:49:05 -05:00
Andy Hovingh	1bed68afb7	webgpu: support user-defined spec constants in addition to native Filament ones	2025-05-30 11:33:14 -05:00
Konrad Piascik	130e02da5c	Add helper script to linux documentation (#8783 )	2025-05-30 14:16:36 +00:00
bridgewaterrobbie	8e06a68446	Relocate calling mRenderPassEncoder.SetBindGroup to draw call, deferring it to handle non-default render targets being used.	2025-05-29 20:23:06 -04:00
bridgewaterrobbie	656b50b304	Manually remove Tint annotations that Dawn complains about when consuming. Dawn complains when consuming these lines with WebGPU device error: ErrorType::Validation Error while parsing WGSL: :24:4 error: expected attribute Did you mean 'size'? Possible values: 'align', 'binding', 'blend_src', 'builtin', 'color', 'compute', 'diagnostic', 'fragment', 'group', 'id', 'input_attachment_index', 'interpolate', 'invariant', 'location', 'must_use', 'size', 'vertex', 'workgroup_size' @stride(16) @internal(disable_validation__ignore_stride) And we don't see a better workaround at this time.	2025-05-29 17:59:12 -04:00
Mathias Agopian	880db4ec43	fix a buffer overflow during init the default cubemap has RGBA pixels (4 bytes per pixel).	2025-05-29 14:27:38 -07:00
Syed Idris Shah	2ce294720d	vertex buffer info hardening. Implement vertexbufferinfo taking both interleaved and block attributes into account. Handle the unused buffers by dedicating a slot for that. Update the usage of vertexbufferinfo for setVertexBuffer call	2025-05-29 15:51:55 -05:00
Juan Caldas	eb07decb4b	wgpu: Ignore spec constants greater than 10 (#8789 )	2025-05-29 15:58:35 -04:00
Mathias Agopian	47930edf70	don't use assert_invariant in public headers this is to eventually suppress the dependency on utils/debug.h from public headers	2025-05-29 09:56:52 -07:00
Mathias Agopian	05b89905d8	fix a use after free of texture data during init (#8786 )	2025-05-28 22:32:24 -07:00
Powei Feng	3e0df36c1c	Add option to disable GTAO (#8785 )	2025-05-28 22:35:14 +00:00
Powei Feng	c9ce384f14	vk: add missing header (#8781 )	2025-05-28 22:17:55 +00:00
Sungun Park	6a6bdd5be7	Fix broken android samples (#8784 ) that use DescriptorType::SAMPLER_EXTERNAL.	2025-05-28 20:56:20 +00:00
Sungun Park	d56ade924e	Add checks for MSAA (#8782 )	2025-05-28 19:48:12 +00:00
Andy Hovingh	fe561e3e27	webgpu: support selection from multiple adapters/graphics devices	2025-05-28 12:52:04 -05:00
Jeremy Nelson	1d98e350e4	Set stencil ops to undefined if nonexistent	2025-05-27 16:28:01 -07:00
Matthew Hoffman	d34e018acb	Replace 512 magic number in backend tests. (#8775 )	2025-05-27 21:39:50 +00:00
Mathias Agopian	169c8d57ff	assert vertex attribute alignment offset and size must now be a multiple of 4	2025-05-27 10:19:53 -07:00
Mathias Agopian	a1e0cfa33c	fix a few noexcept through out the code base	2025-05-27 10:18:12 -07:00
Sungun Park	6d44db3ca0	Fix a compile error This is a fix for the compile error caused by https://github.com/google/filament/commit/86a500c8465cfac76cdc4dcc86ab184e9edeac19	2025-05-23 10:33:14 -07:00
Sungun Park	a261429d06	Add multiview MSAA support for custom swapchain (#8767 ) BUGS=[417311684]	2025-05-23 00:42:04 +00:00
Matthew Hoffman	69d0de3c6d	In backend tests replace calls to draw with draw2. (#8765 ) BUGS=[398199600]	2025-05-22 13:14:52 -05:00
bridgewaterrobbie	1305303f2e	Fix typo in getVertexFormat	2025-05-20 18:13:19 -04:00
bridgewaterrobbie	8532511107	Add enforced check for compressed texture block width/height offset	2025-05-20 16:10:17 -04:00
bridgewaterrobbie	b762ccb78c	Use the aspect to skip drawing for depth only. TODO is why this is even coming up?	2025-05-20 16:10:17 -04:00
bridgewaterrobbie	3296eb153c	If necessary, apply padding to uploaded texture.	2025-05-20 16:10:17 -04:00
bridgewaterrobbie	ae6d1028f7	Initial update3DImage implementation for webgpu	2025-05-20 16:10:17 -04:00
bridgewaterrobbie	92579b6307	Expose bytes per pixel function separately from computeDataSize	2025-05-20 16:10:17 -04:00
Benjamin Doherty	315b53c339	Release Filament 1.60.1	2025-05-20 12:42:33 -07:00
Andy Hovingh	c55d459986	webgpu: samples/hellopbr.cpp CLI allows for selecting webgpu backend api	2025-05-20 14:40:48 -05:00
Andy Hovingh	7876695545	webgpu: add CLI to texturedquad.cpp sample to select backend + updated WebGPU warning message.	2025-05-20 14:40:48 -05:00
Matthew Hoffman	e1a1464c5d	Add helpers for creating RenderPipelineParams for backend tests (#8751 ) * Add helpers for creating RenderPipelineParams for backend tests BUGS=[398199600] * Move all backend tests over to use cyan as the clear color	2025-05-20 19:17:12 +00:00
bridgewaterrobbie	67ed5141bf	Avoid using paramater name type which is reserved in WGSL and thus can't be compiled for WebGPU	2025-05-20 14:09:23 -04:00
Juan Caldas	b9d7a25b91	webgpu: remove Dummies and set layouts (#8746 ) * Remove dummies, set sample types and do minor cleanup	2025-05-19 13:51:08 -04:00
Matthew Hoffman	ba63ac63a0	Add a helper for creating a standard PipelineState to backend tests. (#8750 ) BUGS=[398199600]	2025-05-19 16:58:54 +00:00
Sungun Park	1e77947758	Add glFramebufferTextureMultisampleMultiviewOVR for multiview MSAA (#8755 ) This commit adds the `glFramebufferTextureMultisampleMultiviewOVR` function, enabling MSAA to work in conjunction with the multiview extension. The function's declaration is present in the latest main branch of the Khronos GLES2 API headers. While directly pulling these updated headers is the ideal approach, it would necessitate a significant reorganization of Filament's current header file structure and incorporate more files than currently needed. To minimize immediate changes and limit scope, this change adopts only the necessary function declaration by copying it directly. BUGS=[417311684]	2025-05-16 23:50:12 +00:00
bridgewaterrobbie	53df4012fe	Enforce buffer offset rules for UBO and regular copies.	2025-05-16 17:40:45 -04:00
bridgewaterrobbie	d880fab93f	Rearrange buffer logic, and handle buffer writes not divisible by 4	2025-05-16 17:40:45 -04:00
bridgewaterrobbie	fb8030b80a	Revert "Dawn change to enable writeBuffer for size != multiple of 4" This reverts commit `b94c802076`.	2025-05-16 17:40:45 -04:00
David Neto	e2d009ff2a	Update glslang (#8734 ) Update glslang/tnt/README to point to updated commit hash Glslang switched from using spirv.hpp to using spirv.hpp11 which collides with spirv.hpp when used in the same .cpp file. This change requires https://github.com/google/filament/pull/8729 before it can compile. That has already landed.	2025-05-16 20:35:54 +00:00
Mathias Agopian	0a67ef4d80	Add multisampled descriptor types	2025-05-16 13:06:04 -07:00
Mathias Agopian	79d6f46f1a	enforce offsets to be a multiple of 4 bytes this affects VerteBuffer, BufferObject and IndexBuffer, this restriction already existed in the Metal backend, it is now promoted to all backends.	2025-05-16 13:05:40 -07:00
rafadevai	6481fa2acf	GL: Fix the format of an ExternalImage being uninitialized (#8727 ) When creating a new ExternalImage in EGLAndroid the format was not set, causing random crashes when creating new textures.	2025-05-16 19:29:20 +00:00
Mathias Agopian	7638b3ddd9	fix typo in SamplerParams comparison operator FIXES=8740	2025-05-16 11:28:13 -07:00
Doris Wu	fe474a9d7e	Add GTAO shader support (#8688 ) * Add GTAO options into the struct * Add gtao mat and shader * Set type specific parameters in ppm * Fix inconsistent name * Fix incorrect param type * Add bent normal calculation * Fix the gui * Adjust precision * Use mix * Add some comments * Refactoring * Update comments * Add comments for aoOptions * Update * Update * Address the comments * Split .mat into bent and non-bent * Update * Update * Use sqrt on mobile * Omit default case * Commit beamsplitter generated changes * Use built-in acosFast * Remove unused function * Fix the mismatched parameter type * Some optimizations * Commit beamsplitter results * Update the comment * Update default value * Commit beamsplitter changes * Extract common parameters out	2025-05-16 00:13:12 +00:00
Powei Feng	81008abe06	backend-test: fix push constant test for vk (#8732 ) FIXES=417477740	2025-05-15 23:02:28 +00:00
Juan Caldas	ef1d079c53	Update Descriptor Types (#8743 )	2025-05-15 15:39:31 -07:00
Mathias AgopianandPowei Feng	5286dec70b	Make sure that all descriptors are always initialized (#8739 ) * Make sure that all descriptors are always initialized * improvements to committing material instances - from now on, only MaterialDomain::SURFACE material instances are automatically committed by FEngine at the beginning of a frame. COMPUTE and POST_PROCESS domains must be committed manually via a new API on MaterialInstance. Both domains are not public APIs so this shouldn't have an impact anywhere. - DescriptorSet now validates that all descriptors are set and emits an error in the log if not. - these changes prevent PostProcess material instances to be committed before all descriptors are set. * Update filament/src/details/Engine.cpp Co-authored-by: Powei Feng <powei@google.com> --------- Co-authored-by: Powei Feng <powei@google.com>	2025-05-15 15:38:16 -07:00
bridgewaterrobbie	d748dc590e	Use WebGPU platform explicitly in shaders rather than rely on the mostly similar cases to Vulkan, with the exception of flipping the Y axis where they are different	2025-05-15 18:02:29 -04:00
Jeremy Nelson	93a0aec246	Resize metal layer for webgpu (#8738 )	2025-05-15 13:40:50 -07:00
Powei Feng	f3fa734793	vk: Clean up image layout - transitions and definitions (#8724 ) We rename and modify the mapping form the backend layouts to VK version of the layouts. We fix some of the barrier definitions which were inaccurate. Also fix and clarify some of the VulkanBuffer barrier related details.	2025-05-15 20:06:35 +00:00
Juan Caldas	33d3c3a897	webgpu: Adjust dynamic offset to fix the draw calls (#8736 ) BUGS=[407961733]	2025-05-15 12:53:49 +00:00
Mathias AgopianandPowei Feng	bbabf3480b	re-do "Use the Perfetto SDK instead of ATRACE" (#8701 ) (#8728 ) * re-do "Use the Perfetto SDK instead of ATRACE" (#8701) This time we create an entirely new private header: Tracing.h which uses the perfetto SDK instead of ATRACE. The old Systrace.h is unchanged to presever backward compatibility but is essentially deprecated and no longer used within the filament repo. The new TRACING_ macros use an explicit CATEGORY parameter, which is declared in Tracing.h. Moreover, tracing can be compiled out by defining FILAMENT_TRACING_ENABLED to false before including Tracing.h iOS tracing is still supported and still controlled via FILAMENT_APPLE_SYSTRACE. There are three perfetto categories defined: - "filament/filament" - "filament/jobsystem" - "filament/gltfio" The "filament/jobsystem" category is compiled out by default. And they can be enabled in AGI / perfetto by adding: ``` data_sources { config { name: "track_event" track_event_config { disabled_categories: "" enabled_categories: "filament/filament" enabled_categories: "filament/jobsystem" enabled_categories: "filament/gltfio" } } } ``` Update libs/utils/include/private/utils/Tracing.h Co-authored-by: Powei Feng <powei@google.com> * Update libs/utils/src/android/Tracing.cpp Co-authored-by: Powei Feng <powei@google.com> * remove all references to SYSTRACE_TAG --------- Co-authored-by: Powei Feng <powei@google.com>	2025-05-14 20:51:57 -07:00
Mathias Agopian	e7a8f471a1	add sampler type in DescriptorSetLayout (#8705 ) * add sampler type in DescriptorSetLayout [New Material Version] * select the proper descriptor set layout in the rendering loop Now that the per-view layout can be different based on the type of shadow, we need to make sure we set the proper layout in the pipeline and use the corresponding descriptor set. There are now 16 "per-view" layouts and their corresponding descriptor set. There are two sets of 8, the current set is determined by the shadow type on the view. Then during rendering, when we set the pipeline we need to select the corresponding layout; each material now offers both versions of the layout and we just pick the right one. DescriptorSet::setBuffer and setSampler now need the layout in order to do some validation that the correct type of descriptor is used. This will help catch problems earlier. * DescriptorType now includes the "dimension" of the texture DescriptorType now also encodes wether the descriptor expects a 2D, 3D, Cubemap and/or Array. This is needed by both Metal and WebGPU. [New Material Version] * Fix typos. * fix fog sampler descriptor type	2025-05-14 17:02:17 -07:00
Ben Doherty	d45a5cc926	Add documentation on using Instruments (#8737 )	2025-05-14 14:53:12 -07:00
Powei Feng	361ba2afea	renderdiff: separate comparison from rendering (#8733 ) - Move the comparison logic into its own script - Add entry point bash script to generate the renderings - Separate the preamble bash logic into its own file	2025-05-14 09:48:16 -07:00
Ben Doherty	78419cd992	Add initialize method to PlatformMetal (#8708 )	2025-05-13 14:30:02 -07:00
Sungun Park	cc7361dba5	Release Filament 1.60.0	2025-05-13 21:27:27 +00:00
Powei Feng	5c0841ff56	Update release note after cherry-pick	2025-05-13 14:26:13 -07:00
Matthew Hoffman	10af183756	Document which vulkan tests have issues with associated bugs. (#8731 ) BUGS=[409100093]	2025-05-13 21:10:34 +00:00
David Neto	56e0e9a424	Move calls to SPV remapper to another .cpp file (#8729 )	2025-05-13 20:33:49 +00:00
Mathias Agopian	86a500c846	clean public header dependencies (#8725 ) * remove io::ostream dependency from CString.h + clang tidy * remove ostream.h dependency from Invocable.h * remove Panic.h dependency from FixedCapacityVector.h * remove ostream.h dependency from backend/ headers * clang tidy Panic.h/Panic.cpp	2025-05-13 11:32:45 -07:00
Sungun Park	5b3f13fc1d	Revert "Add getter functions for settings to build ColorGrading object (#8699 )" This reverts commit `f10d226565`.	2025-05-13 11:22:33 -07:00
Powei Feng	1b1dfaa57c	build.sh ndk version fix again (#8726 ) Fix again after #8717	2025-05-13 06:44:21 +00:00
Powei Feng	bf8c84bbe5	Clean-up build.sh android (#8722 ) Failed to build android when using CMake >= 4.0. Remove a no longer required check for the android build. This check should be covered by the cmake_minimum_required() call, which is present in relevant CMakeLists.txts.	2025-05-13 06:29:17 +00:00
Jeremy Nelson	fb179cabbc	Using usage and format from filament	2025-05-12 16:15:21 -07:00
Jeremy Nelson	a80ea743e8	Simplifying aspect cases	2025-05-12 16:15:21 -07:00
Jeremy Nelson	97f8106909	removing duplicate return	2025-05-12 16:15:21 -07:00
Jeremy Nelson	d455899b93	Simplify cases and default to All	2025-05-12 16:15:21 -07:00
Jeremy Nelson	63fe439a5e	Infer TextureView Aspect from format and usage Picks an appropriate aspect based on formate and usage.	2025-05-12 16:15:21 -07:00
Ben Doherty	7847220aba	Materials: allow specifying the shader stages for samplers (#8720 )	2025-05-12 14:20:11 -07:00
Matthew Hoffman	d76ae4395b	Mark ExternalImageCocoaGL as final not just its destructor. (#8719 ) This is necessary to build on MacOS with homebrew's llvm as opposed to Apple's.	2025-05-12 19:43:30 +00:00
Powei Feng	f994cb58ce	gl: add invalidate_framebuffer workaround for Mesa+Intel (#8706 ) FIXES=405252622	2025-05-12 18:18:13 +00:00
Sungun Park	52eb682498	Update MATERIAL_VERSION to 60	2025-05-12 16:45:36 +00:00
Mathias Agopian	5a5168a191	CString tidy cleanup and rvalue methods We add rvalue version of append/insert/replace so that calling those on a temporary yields to a temporary. Also add string literal versions of those so that we can append/insert/replace a literal without allocation, e.g.: `CString foo = CString{ bar }.append("baz");` This will not end-up creating a temporary CString for "baz".	2025-05-09 16:14:01 -07:00
Powei Feng	e85dfe75c8	github: move test script to /test and same for /build (#8714 ) - Moved get_mesa.sh to build/common/get-mesa.sh - Moved check-headers.sh to test/check-headers/test.sh - Moved check-metal-shaders.sh to test/check-metal-shaders/test.sh	2025-05-09 22:35:18 +00:00
Logan Lawrence	6beb40b0a1	Update release.yml to include native android build files (#8694 )	2025-05-09 17:25:00 +00:00