Experiment: Avoid << on non uint to make tint happy

- Some tests require textures larger than 2048. Change the minimum
  to 4096 for now, and file proper bugs for tests.
- The introduction of uint8_t to DescriptorSetLayoutBinding
  caused unintended padding with using this struct as a hash key.
  We comment out the relevent code for now.

.dir-locals.el

@@ -1,15 +1,7 @@
 ;;; Directory Local Variables            -*- no-byte-compile: t -*-
 ;;; For more information see (info "(emacs) Directory Variables")
 
-((c++-mode . ((eval . (progn
-                        (make-local-variable 'eglot-ignored-server-capabilities)
-                        (add-to-list 'eglot-ignored-server-capabilities
-                                     :documentOnTypeFormattingProvider)))
-              (c-file-style . "filament")
+((c++-mode . ((c-file-style . "filament")
               (apheleia-inhibit . t)))
- (c-mode . ((eval . (progn
-                      (make-local-variable 'eglot-ignored-server-capabilities)
-                      (add-to-list 'eglot-ignored-server-capabilities
-                                   :documentOnTypeFormattingProvider)))
-            (c-file-style . "filament")
+ (c-mode . ((c-file-style . "filament")
             (apheleia-inhibit . t))))

.editorconfig

@@ -5,7 +5,7 @@ end_of_line = lf
 insert_final_newline = true
 charset = utf-8
 
-[*.{c,cpp,h,inc,kt,java,js,md,fs,vs}]
+[*.{c,cpp,h,inc,kt,java,js,md}]
 indent_style = space
 indent_size = 4
 max_line_length = 100

.github/workflows/presubmit.yml

@@ -92,26 +92,33 @@ jobs:
 
   test-renderdiff:
     name: test-renderdiff
-    runs-on: ubuntu-22.04-16core
-
+    runs-on: macos-14-xlarge
     steps:
       - uses: actions/checkout@v4.1.6
-      - uses: ./.github/actions/ubuntu-apt-add-src
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+      - name: Install python prereqs
+        run: pip install mako setuptools pyyaml
       - name: Run script
         run: |
-          source ./build/linux/ci-common.sh && bash test/renderdiff/test.sh
+          bash test/renderdiff/test.sh
       - uses: actions/upload-artifact@v4
         with:
           name: presubmit-renderdiff-result
           path: ./out/renderdiff_tests
 
-  validate-wgsl-pipeline:
-    name: validate-wgsl-pipeline
-    runs-on: macos-14-xlarge
+  validate-wgsl-webgpu:
+    name: validate-wgsl-webgpu
+    runs-on: ubuntu-22.04-8core
 
     steps:
       - uses: actions/checkout@v4.1.6
       - name: Run build script
-        run: ./build.sh -W debug test_filamat
+        run: source ./build/linux/ci-common.sh && ./build.sh -W debug test_filamat filament
       - name: Run test
-        run: ./out/cmake-debug/libs/filamat/test_filamat --gtest_filter=MaterialCompiler.Wgsl*
+        run: ./out/cmake-debug/libs/filamat/test_filamat --gtest_filter=MaterialCompiler.Wgsl*

CMakeLists.txt

@@ -139,14 +139,14 @@ else()
     set(LINUX FALSE)
 endif()
 
-if (LINUX)
-    if (NOT FILAMENT_OSMESA_PATH STREQUAL "")
-        if (NOT EXISTS ${FILAMENT_OSMESA_PATH}/)
-            message(FATAL_ERROR "Cannot find specified OSMesa build directory: ${FILAMENT_OSMESA_PATH}")
-        endif()
-        set(FILAMENT_SUPPORTS_OSMESA TRUE)
+if (NOT FILAMENT_OSMESA_PATH STREQUAL "")
+    if (NOT EXISTS ${FILAMENT_OSMESA_PATH}/)
+        message(FATAL_ERROR "Cannot find specified OSMesa build directory: ${FILAMENT_OSMESA_PATH}")
     endif()
+    set(FILAMENT_SUPPORTS_OSMESA TRUE)
+endif()
 
+if (LINUX)
     if (FILAMENT_SUPPORTS_WAYLAND)
         add_definitions(-DFILAMENT_SUPPORTS_WAYLAND)
         set(FILAMENT_SUPPORTS_X11 FALSE)
@@ -184,6 +184,12 @@ if (NOT ANDROID AND NOT WEBGL AND NOT IOS AND NOT FILAMENT_LINUX_IS_MOBILE)
     set(IS_HOST_PLATFORM TRUE)
 endif()
 
+if (APPLE)
+    if (FILAMENT_SUPPORTS_OSMESA)
+        add_definitions(-DFILAMENT_SUPPORTS_OSMESA)
+    endif()
+endif()
+
 if (WIN32)
     # Link statically against c/c++ lib to avoid missing redistriburable such as
     # "VCRUNTIME140.dll not found. Try reinstalling the app.", but give users
@@ -601,6 +607,14 @@ if (FILAMENT_SUPPORTS_METAL)
     set(MATC_API_FLAGS ${MATC_API_FLAGS} -a metal)
 endif()
 
+# With WebGPU, push constants are not supported. Skinning uses them.
+# WebGPU has a proposal to add push constants at https://github.com/gpuweb/gpuweb/blob/main/proposals/push-constants.md
+# With WebGPU, Tint does not support ClipDistance which is used in Stereo.  Mentioned in comment
+# https://github.com/google/dawn/blob/855d17b08abdf02f9142bf5a8f14d0ea088810a4/src/tint/lang/spirv/reader/ast_parser/function.cc#L4434
+if (FILAMENT_SUPPORTS_WEBGPU)
+    set(MATC_API_FLAGS ${MATC_API_FLAGS} -a webgpu --variant-filter=skinning,stereo)
+endif()
+
 # Disable ESSL 1.0 code generation.
 if (NOT FILAMENT_ENABLE_FEATURE_LEVEL_0)
     set(MATC_API_FLAGS ${MATC_API_FLAGS} -1)

NEW_RELEASE_NOTES.md

@@ -7,3 +7,6 @@ for next branch cut* header.
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).
 
 ## Release notes for next branch cut
+
+- materials: five custom variables (varyings) are now available on the condition that the `color` attribute is not requested (b/404930099). [⚠️ **New Material Version**]
+

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.58.0'
+    implementation 'com.google.android.filament:filament-android:1.58.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.58.0'
+pod 'Filament', '~> 1.58.1'
 ```
 
 ## Documentation

RELEASE_NOTES.md

@@ -7,6 +7,10 @@ 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.58.2
+
+- engine: Generate 1D instead of 3D LUTs for color grading whenever possible.
+
 ## v1.58.1
 
 

android/filamat-android/CMakeLists.txt

@@ -12,12 +12,12 @@ if (FILAMENT_SUPPORTS_VULKAN)
 endif()
 
 if (FILAMENT_SUPPORTS_WEBGPU)
-    add_library(webgpu_dawn STATIC IMPORTED)
-    set_target_properties(webgpu_dawn PROPERTIES IMPORTED_LOCATION
-            ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libwebgpu_dawn.a)
+    # See third_party/dawn/tnt/CMakeLists.txt and libs/filamat/CMakeLists.txt
+    add_library(tint STATIC IMPORTED)
+    set_target_properties(tint PROPERTIES IMPORTED_LOCATION
+            ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libtint_combined.a)
 endif()
 
-
 add_library(${FILAMAT_FLAVOR} STATIC IMPORTED)
 set_target_properties(${FILAMAT_FLAVOR} PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/lib${FILAMAT_FLAVOR}.a)
@@ -57,5 +57,5 @@ target_link_libraries(filamat-jni
         utils
         log
         smol-v
-        $<$<STREQUAL:${FILAMENT_SUPPORTS_WEBGPU},ON>:webgpu_dawn> # for tint
+        $<$<STREQUAL:${FILAMENT_SUPPORTS_WEBGPU},ON>:tint>
 )

android/filament-android/CMakeLists.txt

@@ -29,10 +29,6 @@ add_library(filaflat STATIC IMPORTED)
 set_target_properties(filaflat PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfilaflat.a)
 
-add_library(filamat STATIC IMPORTED)
-set_target_properties(filamat PROPERTIES IMPORTED_LOCATION
-        ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfilamat.a)
-
 add_library(geometry STATIC IMPORTED)
 set_target_properties(geometry PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libgeometry.a)
@@ -59,11 +55,11 @@ add_library(smol-v STATIC IMPORTED)
 set_target_properties(smol-v PROPERTIES IMPORTED_LOCATION
         ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libsmol-v.a)
 
- if (FILAMENT_ENABLE_FGVIEWER)
-     add_library(fgviewer STATIC IMPORTED)
-     set_target_properties(fgviewer PROPERTIES IMPORTED_LOCATION
-             ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfgviewer.a)
- endif()
+if (FILAMENT_ENABLE_FGVIEWER)
+    add_library(fgviewer STATIC IMPORTED)
+    set_target_properties(fgviewer PROPERTIES IMPORTED_LOCATION
+            ${FILAMENT_DIR}/lib/${ANDROID_ABI}/libfgviewer.a)
+endif()
 
 if (FILAMENT_ENABLE_MATDBG)
     add_library(matdbg STATIC IMPORTED)

android/filament-android/src/main/cpp/Texture.cpp

@@ -68,6 +68,21 @@ Java_com_google_android_filament_Texture_nIsTextureSwizzleSupported(JNIEnv*, jcl
     return (jboolean) Texture::isTextureSwizzleSupported(*engine);
 }
 
+
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_Texture_nGetMaxTextureSize(JNIEnv *, jclass,
+        jlong nativeEngine, jint sampler) {
+    Engine *engine = (Engine *) nativeEngine;
+    return Texture::getMaxTextureSize(*engine, (Texture::Sampler)sampler);
+}
+
+extern "C" JNIEXPORT jint JNICALL
+Java_com_google_android_filament_Texture_nGetMaxArrayTextureLayers(JNIEnv *, jclass,
+        jlong nativeEngine) {
+    Engine *engine = (Engine *) nativeEngine;
+    return Texture::getMaxArrayTextureLayers(*engine);
+}
+
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Texture_nValidatePixelFormatAndType(JNIEnv*, jclass,
         jint internalFormat, jint pixelDataFormat, jint pixelDataType) {

android/filament-android/src/main/java/com/google/android/filament/ColorGrading.java

@@ -46,9 +46,8 @@ import static com.google.android.filament.Asserts.assertFloat4In;
  *
  * <h1>Performance</h1>
  *
- * Creating a new ColorGrading object may be more expensive than other Filament objects as a
- * 3D LUT may need to be generated. The generation of a 3D LUT, if necessary, may happen on
- * the CPU.
+ * Creating a new ColorGrading object may be more expensive than other Filament objects as a LUT may
+ * need to be generated. The generation of this LUT, if necessary, may happen on the CPU.
  *
  * <h1>Ordering</h1>
  *
@@ -160,6 +159,10 @@ public class ColorGrading {
          * quality level will use a 32x32x32 10 bit LUT, a high quality will use a 32x32x32 16 bit
          * LUT, and a ultra quality will use a 64x64x64 16 bit LUT.
          *
+         * This setting has no effect if generating a 1D LUT.
+         *
+         * This overrides the values set by format() and dimensions().
+         *
          * The default quality is {@link QualityLevel#MEDIUM}.
          *
          * @param qualityLevel The desired quality of the color grading process
@@ -175,6 +178,8 @@ public class ColorGrading {
          * When color grading is implemented using a 3D LUT, this sets the texture format of
          * of the LUT. This overrides the value set by quality().
          *
+         * This setting has no effect if generating a 1D LUT.
+         *
          * The default is INTEGER
          *
          * @param format The desired format of the 3D LUT.
@@ -190,6 +195,8 @@ public class ColorGrading {
          * When color grading is implemented using a 3D LUT, this sets the dimension of the LUT.
          * This overrides the value set by quality().
          *
+         * This setting has no effect if generating a 1D LUT.
+         *
          * The default is 32
          *
          * @param dim The desired dimension of the LUT. Between 16 and 64.
@@ -616,4 +623,3 @@ public class ColorGrading {
 
     private static native long nBuilderBuild(long nativeBuilder, long nativeEngine);
 }
-

android/filament-android/src/main/java/com/google/android/filament/Texture.java

@@ -691,6 +691,24 @@ public class Texture {
                 pixelDataType.ordinal());
     }
 
+    /**
+     * @param engine {@link Engine}
+     * @param type Texture sampler type
+     * @return The maximum size in texels of a texture of type \p type. At least 2048 for
+     *         2D textures, 256 for 3D textures
+     */
+    public static int getMaxTextureSize(@NonNull Engine engine, Sampler type) {
+        return nGetMaxTextureSize(engine.getNativeObject(), type.ordinal());
+    }
+
+    /**
+     * @param engine {@link Engine}
+     * @return The maximum number of layers supported by texture arrays. At least 256.
+     */
+    public static int getMaxArrayTextureLayers(@NonNull Engine engine) {
+        return nGetMaxArrayTextureLayers(engine.getNativeObject());
+    }
+
     /**
      * Use <code>Builder</code> to construct a <code>Texture</code> object instance.
      */
@@ -1289,6 +1307,8 @@ public class Texture {
     private static native boolean nIsTextureFormatSupported(long nativeEngine, int internalFormat);
     private static native boolean nIsTextureFormatMipmappable(long nativeEngine, int internalFormat);
     private static native boolean nIsTextureSwizzleSupported(long nativeEngine);
+    private static native int nGetMaxTextureSize(long nativeObject, int ordinal);
+    private static native int nGetMaxArrayTextureLayers(long nativeObject);
 
     private static native boolean nValidatePixelFormatAndType(int internalFormat, int pixelDataFormat,
             int pixelDataType);

android/filament-android/src/main/java/com/google/android/filament/ToneMapper.java

@@ -31,8 +31,6 @@ package com.google.android.filament;
  *   <li>DisplayRangeToneMapper</li>
  * </ul>
  * </ul>
- *
- * You can create custom tone mapping operators by subclassing ToneMapper.
  */
 public class ToneMapper {
     private final long mNativeObject;

android/gradle.properties

@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.58.0
+VERSION_NAME=1.58.1
 
 POM_DESCRIPTION=Real-time physically based rendering engine for Android.
 

build.sh

@@ -200,8 +200,9 @@ WEBGPU_ANDROID_GRADLE_OPTION=""
 EGL_ON_LINUX_OPTION="-DFILAMENT_SUPPORTS_EGL_ON_LINUX=OFF"
 
 MATDBG_OPTION="-DFILAMENT_ENABLE_MATDBG=OFF"
-FGVIEWER_OPTION="-DFILAMENT_ENABLE_FGVIEWER=OFF"
 MATDBG_GRADLE_OPTION=""
+FGVIEWER_OPTION="-DFILAMENT_ENABLE_FGVIEWER=OFF"
+FGVIEWER_GRADLE_OPTION=""
 
 MATOPT_OPTION=""
 MATOPT_GRADLE_OPTION=""
@@ -533,6 +534,7 @@ function build_android {
             ${VULKAN_ANDROID_GRADLE_OPTION} \
             ${WEBGPU_ANDROID_GRADLE_OPTION} \
             ${MATDBG_GRADLE_OPTION} \
+            ${FGVIEWER_GRADLE_OPTION} \
             ${MATOPT_GRADLE_OPTION} \
             :filament-android:assembleDebug \
             :gltfio-android:assembleDebug \
@@ -584,6 +586,7 @@ function build_android {
             ${VULKAN_ANDROID_GRADLE_OPTION} \
             ${WEBGPU_ANDROID_GRADLE_OPTION} \
             ${MATDBG_GRADLE_OPTION} \
+            ${FGVIEWER_GRADLE_OPTION} \
             ${MATOPT_GRADLE_OPTION} \
             :filament-android:assembleRelease \
             :gltfio-android:assembleRelease \

build/linux/ci-common.sh

@@ -30,6 +30,9 @@ if [[ "$GITHUB_WORKFLOW" ]]; then
     sudo apt-get install clang-$GITHUB_CLANG_VERSION libc++-$GITHUB_CLANG_VERSION-dev libc++abi-$GITHUB_CLANG_VERSION-dev
     sudo apt-get install mesa-common-dev libxi-dev libxxf86vm-dev
 
+    # For dawn
+    sudo apt-get install libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libx11-xcb-dev
+
     sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang-${GITHUB_CLANG_VERSION} 100
     sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++-${GITHUB_CLANG_VERSION} 100
 fi

docs/Materials.md.html

@@ -13,7 +13,7 @@ This document is part of the [Filament project](https://github.com/google/filame
 ## Authors
 
 - [Romain Guy](https://github.com/romainguy), [@romainguy](https://twitter.com/romainguy)
-- [Mathias Agopian](https://github.com/pixelflinger), [@darthmoosious](https://twitter.com/darthmoosious)
+- [Mathias Agopian](https://github.com/pixelflinger), [@pixelflinger](https://bsky.app/profile/pixelflinger.bsky.social)
 
 # Overview
 
@@ -78,26 +78,27 @@ in table [standardProperties].
         Property        |      Definition
 -----------------------:|:---------------------
 **baseColor**           | Diffuse albedo for non-metallic surfaces, and specular color for metallic surfaces
-**metallic**            | Whether a surface appears to be dielectric (0.0) or conductor (1.0). Often used as a binary value (0 or 1)
 **roughness**           | Perceived smoothness (1.0) or roughness (0.0) of a surface. Smooth surfaces exhibit sharp reflections
+**metallic**            | Whether a surface appears to be dielectric (0.0) or conductor (1.0). Often used as a binary value (0 or 1)
 **reflectance**         | Fresnel reflectance at normal incidence for dielectric surfaces. This directly controls the strength of the reflections
-**sheenColor**          | Strength of the sheen layer
-**sheenRoughness**      | Perceived smoothness or roughness of the sheen layer
+**ambientOcclusion**    | Defines how much of the ambient light is accessible to a surface point. It is a per-pixel shadowing factor between 0.0 and 1.0
 **clearCoat**           | Strength of the clear coat layer
 **clearCoatRoughness**  | Perceived smoothness or roughness of the clear coat layer
+**clearCoatNormal**     | A detail normal used to perturb the clear coat layer using _bump mapping_ (_normal mapping_)
 **anisotropy**          | Amount of anisotropy in either the tangent or bitangent direction
 **anisotropyDirection** | Local surface direction in tangent space
-**ambientOcclusion**    | Defines how much of the ambient light is accessible to a surface point. It is a per-pixel shadowing factor between 0.0 and 1.0
-**normal**              | A detail normal used to perturb the surface using _bump mapping_ (_normal mapping_)
-**bentNormal**          | A normal pointing in the average unoccluded direction. Can be used to improve indirect lighting quality
-**clearCoatNormal**     | A detail normal used to perturb the clear coat layer using _bump mapping_ (_normal mapping_)
-**emissive**            | Additional diffuse albedo to simulate emissive surfaces (such as neons, etc.) This property is mostly useful in an HDR pipeline with a bloom pass
-**postLightingColor**   | Additional color that can be blended with the result of the lighting computations. See `postLightingBlending`
-**ior**                 | Index of refraction, either for refractive objects or as an alternative to reflectance
-**transmission**        | Defines how much of the diffuse light of a dielectric is transmitted through the object, in other words this defines how transparent an object is
-**absorption**          | Absorption factor for refractive objects
-**microThickness**      | Thickness of the thin layer of refractive objects
 **thickness**           | Thickness of the solid volume of refractive objects
+**sheenColor**          | Strength of the sheen layer
+**sheenRoughness**      | Perceived smoothness or roughness of the sheen layer
+**emissive**            | Additional diffuse albedo to simulate emissive surfaces (such as neons, etc.) This property is mostly useful in an HDR pipeline with a bloom pass
+**normal**              | A detail normal used to perturb the surface using _bump mapping_ (_normal mapping_)
+**postLightingColor**   | Additional color that can be blended with the result of the lighting computations. See `postLightingBlending`
+**absorption**          | Absorption factor for refractive objects
+**transmission**        | Defines how much of the diffuse light of a dielectric is transmitted through the object, in other words this defines how transparent an object is
+**ior**                 | Index of refraction, either for refractive objects or as an alternative to reflectance
+**microThickness**      | Thickness of the thin layer of refractive objects
+**bentNormal**          | A normal pointing in the average unoccluded direction. Can be used to improve indirect lighting quality
+**shadowStrength**      | Strength factor between 0 and 1 for all shadows received by this material
 [Table [standardProperties]: Properties of the standard model]
 
 The type and range of each property is described in table [standardPropertiesTypes].
@@ -1272,6 +1273,9 @@ Description
       when selecting any shading model that is not `unlit`. See the shader sections of this document
       for more information on how to access these attributes from the shaders.
 
+!!! Note: Interaction with custom variables
+    When the `color` attribute is specified, only four custom variables are available instead of five.
+
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
 material {
     parameters : [
@@ -1302,7 +1306,7 @@ Type
 :    array of `string`
 
 Value
-:     Up to 4 strings, each must be a valid GLSL identifier.
+:     Up to 5 strings, each must be a valid GLSL identifier.
 
 Description
 :     Defines custom interpolants (or variables) that are output by the material's vertex shader.
@@ -1318,6 +1322,10 @@ Description
       particular if `default` is specified the default precision is used is the fragment shader
       (`mediump`) and in the vertex shader (`highp`).
 
+!!! Warning: Interaction with required attributes
+    If the `color` attribute is specified in the `required` list, then only four variables can be used
+    instead of five.
+
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
 material {
     name : Skybox,

filament/backend/CMakeLists.txt

@@ -108,8 +108,12 @@ if (FILAMENT_SUPPORTS_OPENGL AND NOT FILAMENT_USE_EXTERNAL_GLES3)
         list(APPEND SRCS src/opengl/platforms/PlatformCocoaTouchGL.mm)
         list(APPEND SRCS src/opengl/platforms/CocoaTouchExternalImage.mm)
     elseif (APPLE)
-        list(APPEND SRCS src/opengl/platforms/PlatformCocoaGL.mm)
-        list(APPEND SRCS src/opengl/platforms/CocoaExternalImage.mm)
+        if (FILAMENT_SUPPORTS_OSMESA)
+            list(APPEND SRCS src/opengl/platforms/PlatformOSMesa.cpp)
+        else()
+            list(APPEND SRCS src/opengl/platforms/PlatformCocoaGL.mm)
+            list(APPEND SRCS src/opengl/platforms/CocoaExternalImage.mm)
+        endif()
     elseif (WEBGL)
         list(APPEND SRCS src/opengl/platforms/PlatformWebGL.cpp)
     elseif (LINUX)
@@ -173,10 +177,12 @@ endif()
 if (FILAMENT_SUPPORTS_VULKAN)
     list(APPEND SRCS
             include/backend/platforms/VulkanPlatform.h
-            src/vulkan/caching/VulkanDescriptorSetManager.cpp
-            src/vulkan/caching/VulkanDescriptorSetManager.h
-            src/vulkan/caching/VulkanPipelineLayoutCache.cpp
-            src/vulkan/caching/VulkanPipelineLayoutCache.h
+            src/vulkan/VulkanDescriptorSetCache.cpp
+            src/vulkan/VulkanDescriptorSetCache.h
+            src/vulkan/VulkanDescriptorSetLayoutCache.cpp
+            src/vulkan/VulkanDescriptorSetLayoutCache.h
+            src/vulkan/VulkanPipelineLayoutCache.cpp
+            src/vulkan/VulkanPipelineLayoutCache.h
             src/vulkan/memory/ResourceManager.cpp
             src/vulkan/memory/ResourceManager.h
             src/vulkan/memory/ResourcePointer.h
@@ -242,11 +248,31 @@ endif()
 
 if (FILAMENT_SUPPORTS_WEBGPU)
     list(APPEND SRCS
+            include/backend/platforms/WebGPUPlatform.h
+            src/webgpu/platform/WebGPUPlatform.cpp
+            src/webgpu/WebGPUConstants.h
             src/webgpu/WebGPUDriver.cpp
             src/webgpu/WebGPUDriver.h
-            src/webgpu/WebGPUPlatform.cpp
-            src/webgpu/WebGPUPlatform.h
     )
+    if (WIN32)
+        list(APPEND SRCS src/webgpu/platform/WebGPUPlatformWindows.cpp)
+    elseif (LINUX)
+        list(APPEND SRCS src/webgpu/platform/WebGPUPlatformLinux.cpp)
+    elseif (APPLE OR IOS)
+        list(APPEND SRCS src/webgpu/platform/WebGPUPlatformApple.mm)
+    elseif (ANDROID)
+        list(APPEND SRCS src/webgpu/platform/WebGPUPlatformAndroid.cpp)
+    endif()
+
+    if (TNT_DEV)
+        set(FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING_DEFAULT ON)
+    else()
+        set(FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING_DEFAULT OFF)
+    endif()
+
+    option(FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING
+            "Enable immediate_error_handling for the WebGPU backend Dawn implementation"
+            ${FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING_DEFAULT})
 endif()
 
 if (ANDROID)
@@ -396,9 +422,12 @@ set(LINUX_LINKER_OPTIMIZATION_FLAGS
         -Wl,--exclude-libs,bluegl
 )
 
-if (LINUX AND FILAMENT_SUPPORTS_OSMESA)
-    set(OSMESA_COMPILE_FLAGS
-        -I${FILAMENT_OSMESA_PATH}/include/GL)
+if (FILAMENT_SUPPORTS_OSMESA)
+    if (LINUX)
+        set(OSMESA_COMPILE_FLAGS -I${FILAMENT_OSMESA_PATH}/include/GL)
+    elseif (APPLE)
+        set(OSMESA_COMPILE_FLAGS -I${FILAMENT_OSMESA_PATH}/include)
+    endif()
 endif()
 
 if (MSVC)
@@ -433,6 +462,10 @@ if (FILAMENT_SUPPORTS_METAL)
     target_compile_definitions(${TARGET} PRIVATE $<$<BOOL:${FILAMENT_METAL_PROFILING}>:FILAMENT_METAL_PROFILING>)
 endif()
 
+if (FILAMENT_SUPPORTS_WEBGPU)
+    target_compile_definitions(${TARGET} PRIVATE $<$<BOOL:${FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING}>:FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING>)
+endif()
+
 target_link_libraries(${TARGET} PRIVATE
         ${OSMESA_LINKER_FLAGS}
         $<$<AND:$<PLATFORM_ID:Linux>,$<CONFIG:Release>>:${LINUX_LINKER_OPTIMIZATION_FLAGS}>

filament/backend/include/backend/DriverEnums.h

@@ -126,6 +126,10 @@ static_assert(MAX_VERTEX_BUFFER_COUNT <= MAX_VERTEX_ATTRIBUTE_COUNT,
 static constexpr size_t CONFIG_UNIFORM_BINDING_COUNT = 9;   // This is guaranteed by OpenGL ES.
 static constexpr size_t CONFIG_SAMPLER_BINDING_COUNT = 4;   // This is guaranteed by OpenGL ES.
 
+static constexpr uint8_t EXTERNAL_SAMPLER_DATA_INDEX_UNUSED =
+        uint8_t(-1);// Case where the descriptor set binding isnt using any external sampler state
+                     // and therefore doesn't have a valid entry.
+
 /**
  * Defines the backend's feature levels.
  */
@@ -252,21 +256,21 @@ struct DescriptorSetLayoutBinding {
     DescriptorFlags flags = DescriptorFlags::NONE;
     uint16_t count = 0;
 
-    friend inline bool operator==(
-            DescriptorSetLayoutBinding const& lhs,
+    //  TODO: uncomment when needed.  Note that this class is used as hash key.  We need to ensure
+    //  no uninitialized padding bytes.
+    //    uint8_t externalSamplerDataIndex = EXTERNAL_SAMPLER_DATA_INDEX_UNUSED;
+
+    friend inline bool operator==(DescriptorSetLayoutBinding const& lhs,
             DescriptorSetLayoutBinding const& rhs) noexcept {
         return lhs.type == rhs.type &&
                lhs.flags == rhs.flags &&
                lhs.count == rhs.count &&
                lhs.stageFlags == rhs.stageFlags;
+//               lhs.stageFlags == rhs.stageFlags &&
+//               lhs.externalSamplerDataIndex == rhs.externalSamplerDataIndex;
     }
 };
 
-struct DescriptorSetLayout {
-    utils::FixedCapacityVector<DescriptorSetLayoutBinding> bindings;
-};
-
-
 /**
  * Bitmask for selecting render buffers
  */
@@ -968,8 +972,28 @@ enum class SamplerCompareFunc : uint8_t {
     N           //!< Never. The depth / stencil test always fails.
 };
 
+//! this API is copied from (and only applies to) the Vulkan spec.
+//! These specify YUV to RGB conversions.
+enum class SamplerYcbcrModelConversion : uint8_t {
+    RGB_IDENTITY = 0,
+    YCBCR_IDENTITY = 1,
+    YCBCR_709 = 2,
+    YCBCR_601 = 3,
+    YCBCR_2020 = 4,
+};
+
+enum class SamplerYcbcrRange : uint8_t {
+    ITU_FULL = 0,
+    ITU_NARROW = 1,
+};
+
+enum class ChromaLocation : uint8_t {
+    COSITED_EVEN = 0,
+    MIDPOINT = 1,
+};
+
 //! Sampler parameters
-struct SamplerParams { // NOLINT
+struct SamplerParams {             // NOLINT
     SamplerMagFilter filterMag      : 1;    //!< magnification filter (NEAREST)
     SamplerMinFilter filterMin      : 3;    //!< minification filter  (NEAREST)
     SamplerWrapMode wrapS           : 2;    //!< s-coordinate wrap mode (CLAMP_TO_EDGE)
@@ -1024,6 +1048,7 @@ private:
         return SamplerParams::LessThan{}(lhs, rhs);
     }
 };
+
 static_assert(sizeof(SamplerParams) == 4);
 
 // The limitation to 64-bits max comes from how we store a SamplerParams in our JNI code
@@ -1031,6 +1056,95 @@ static_assert(sizeof(SamplerParams) == 4);
 static_assert(sizeof(SamplerParams) <= sizeof(uint64_t),
         "SamplerParams must be no more than 64 bits");
 
+//! Sampler parameters
+struct SamplerYcbcrConversion {// NOLINT
+    SamplerYcbcrModelConversion ycbcrModel : 4;
+    TextureSwizzle r : 4;
+    TextureSwizzle g : 4;
+    TextureSwizzle b : 4;
+    TextureSwizzle a : 4;
+    SamplerYcbcrRange ycbcrRange : 1;
+    ChromaLocation xChromaOffset : 1;
+    ChromaLocation yChromaOffset : 1;
+    SamplerMagFilter chromaFilter : 1;
+    uint8_t padding;
+
+    struct Hasher {
+        size_t operator()(const SamplerYcbcrConversion p) const noexcept {
+            // we don't use std::hash<> here, so we don't have to include <functional>
+            return *reinterpret_cast<uint32_t const*>(reinterpret_cast<char const*>(&p));
+        }
+    };
+
+    struct EqualTo {
+        bool operator()(SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs) const noexcept {
+            assert_invariant(lhs.padding == 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;
+        }
+    };
+
+    struct LessThan {
+        bool operator()(SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs) const noexcept {
+            assert_invariant(lhs.padding == 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;
+        }
+    };
+
+private:
+    friend inline bool operator == (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+            noexcept {
+        return SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
+    }
+    friend inline bool operator != (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+            noexcept {
+        return  !SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
+    }
+    friend inline bool operator < (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+            noexcept {
+        return SamplerYcbcrConversion::LessThan{}(lhs, rhs);
+    }
+};
+
+static_assert(sizeof(SamplerYcbcrConversion) == 4);
+
+static_assert(sizeof(SamplerYcbcrConversion) <= sizeof(uint64_t),
+        "SamplerYcbcrConversion must be no more than 64 bits");
+
+struct ExternalSamplerDatum {
+    ExternalSamplerDatum(SamplerYcbcrConversion ycbcr, SamplerParams spm, uint32_t extFmt)
+        : YcbcrConversion(ycbcr),
+          samplerParams(spm),
+          externalFormat(extFmt) {}
+    bool operator==(ExternalSamplerDatum const& rhs) const {
+        return (YcbcrConversion == rhs.YcbcrConversion && samplerParams == rhs.samplerParams &&
+                externalFormat == rhs.externalFormat);
+    }
+    struct EqualTo {
+        bool operator()(const ExternalSamplerDatum& lhs,
+                const ExternalSamplerDatum& rhs) const noexcept {
+            return (lhs.YcbcrConversion == rhs.YcbcrConversion &&
+                lhs.samplerParams == rhs.samplerParams &&
+                lhs.externalFormat == rhs.externalFormat);
+        }
+    };
+    SamplerYcbcrConversion YcbcrConversion;
+    SamplerParams samplerParams;
+    uint32_t externalFormat;
+};
+// No implicit padding allowed due to it being a hash key.
+static_assert(sizeof(ExternalSamplerDatum) == 12);
+
+struct DescriptorSetLayout {
+    utils::FixedCapacityVector<DescriptorSetLayoutBinding> bindings;
+
+//  TODO: uncomment when needed
+//    utils::FixedCapacityVector<ExternalSamplerDatum> externalSamplerData;
+};
+
 //! blending equation function
 enum class BlendEquation : uint8_t {
     ADD,                    //!< the fragment is added to the color buffer

filament/backend/include/backend/platforms/PlatformCocoaGL.h

@@ -33,7 +33,7 @@ public:
     PlatformCocoaGL();
     ~PlatformCocoaGL() noexcept override;
 
-    ExternalImageHandle createExternalImage(void* cvPixelBuffer) noexcept;
+    ExternalImageHandle UTILS_PUBLIC createExternalImage(void* cvPixelBuffer) noexcept;
 
 protected:
     // --------------------------------------------------------------------------------------------

filament/backend/include/backend/platforms/PlatformCocoaTouchGL.h

@@ -32,7 +32,7 @@ public:
     PlatformCocoaTouchGL();
     ~PlatformCocoaTouchGL() noexcept override;
 
-    ExternalImageHandle createExternalImage(void* cvPixelBuffer) noexcept;
+    ExternalImageHandle UTILS_PUBLIC createExternalImage(void* cvPixelBuffer) noexcept;
 
     // --------------------------------------------------------------------------------------------
     // Platform Interface

filament/backend/include/backend/platforms/PlatformEGL.h

@@ -50,7 +50,7 @@ public:
     /**
      * Creates an ExternalImage from a EGLImageKHR
      */
-    ExternalImageHandle createExternalImage(EGLImageKHR eglImage) noexcept;
+    ExternalImageHandle UTILS_PUBLIC createExternalImage(EGLImageKHR eglImage) noexcept;
 
 protected:
     // --------------------------------------------------------------------------------------------

filament/backend/include/backend/platforms/PlatformEGLAndroid.h

@@ -23,6 +23,7 @@
 #include <backend/platforms/PlatformEGL.h>
 
 #include <utils/android/PerformanceHintManager.h>
+#include <utils/compiler.h>
 
 #include <chrono>
 
@@ -43,8 +44,21 @@ public:
     PlatformEGLAndroid() noexcept;
     ~PlatformEGLAndroid() noexcept override;
 
-protected:
+    /**
+     * Creates an ExternalImage from a EGLImageKHR
+     */
+    ExternalImageHandle UTILS_PUBLIC createExternalImage(AHardwareBuffer const* buffer, bool sRGB) noexcept;
 
+    struct UTILS_PUBLIC ExternalImageDescAndroid {
+        uint32_t width;      // Texture width
+        uint32_t height;     // Texture height
+        TextureFormat format;// Texture format
+        TextureUsage usage;  // Texture usage flags
+    };
+
+    ExternalImageDescAndroid UTILS_PUBLIC getExternalImageDesc(ExternalImageHandle externalImage) noexcept;
+
+protected:
     // --------------------------------------------------------------------------------------------
     // Platform Interface
 
@@ -57,11 +71,6 @@ protected:
     Driver* createDriver(void* sharedContext,
             const Platform::DriverConfig& driverConfig) noexcept override;
 
-    /**
-     * Creates an ExternalImage from a EGLImageKHR
-     */
-    ExternalImageHandle createExternalImage(AHardwareBuffer const *buffer, bool sRGB) noexcept;
-
     // --------------------------------------------------------------------------------------------
     // OpenGLPlatform Interface
 
@@ -95,15 +104,26 @@ protected:
      */
     AcquiredImage transformAcquiredImage(AcquiredImage source) noexcept override;
 
-    bool setExternalImage(ExternalImageHandleRef externalImage, ExternalTexture* texture) noexcept override;
+    OpenGLPlatform::ExternalTexture* createExternalImageTexture() noexcept override;
+    void destroyExternalImageTexture(ExternalTexture* texture) noexcept override;
 
     struct ExternalImageEGLAndroid : public ExternalImageEGL {
         AHardwareBuffer* aHardwareBuffer = nullptr;
+        uint32_t width;      // Texture width
+        uint32_t height;     // Texture height
+        TextureFormat format;// Texture format
+        TextureUsage usage;  // Texture usage flags
         bool sRGB = false;
+
     protected:
         ~ExternalImageEGLAndroid() override;
     };
 
+    bool setExternalImage(ExternalImageHandleRef externalImage,
+            ExternalTexture* texture) noexcept override;
+    bool setImage(ExternalImageEGLAndroid const* eglExternalImage,
+            ExternalTexture* texture) noexcept;
+
 protected:
     bool makeCurrent(ContextType type,
             SwapChain* drawSwapChain,

filament/backend/include/backend/platforms/PlatformOSMesa.h

@@ -21,7 +21,12 @@
 
 #include "bluegl/BlueGL.h"
 
+#if defined(__linux__)
 #include <osmesa.h>
+#elif defined(__APPLE__)
+#undef GLAPI
+#include <GL/osmesa.h>
+#endif
 
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/DriverEnums.h>

filament/backend/include/backend/platforms/VulkanPlatform.h

@@ -18,6 +18,7 @@
 #define TNT_FILAMENT_BACKEND_PLATFORMS_VULKANPLATFORM_H
 
 #include <backend/Platform.h>
+#include <backend/DriverEnums.h>
 
 #include <bluevk/BlueVK.h>
 
@@ -317,6 +318,11 @@ public:
          */
         uint32_t layers;
 
+        /**
+         * The numbers of samples per texel
+         */
+        VkSampleCountFlagBits samples;
+
         /**
          * The format of the external image
          */
@@ -351,20 +357,44 @@ public:
 
     using ImageData = std::pair<VkImage, VkDeviceMemory>;
     virtual ImageData createExternalImageData(ExternalImageHandleRef externalImage,
-            const ExternalImageMetadata& metadata);
+            const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
+            VkImageUsageFlags usage);
+
+    virtual VkSampler createExternalSampler(SamplerYcbcrConversion chroma,
+            SamplerParams sampler,
+            uint32_t internalFormat);
+
+    virtual VkImageView createExternalImageView(SamplerYcbcrConversion chroma,
+            uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
+            VkImageViewType viewType, VkComponentMapping swizzle);
+
+protected:
+    virtual ExtensionSet getSwapchainInstanceExtensions() const;
+
+    using SurfaceBundle = std::tuple<VkSurfaceKHR, VkExtent2D>;
+    virtual SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
+            uint64_t flags) const noexcept;
 
 private:
-    static ExtensionSet getSwapchainInstanceExtensions();
+    // Platform dependent helper methods
+    static ExtensionSet getSwapchainInstanceExtensionsImpl();
 
     static ExternalImageMetadata getExternalImageMetadataImpl(ExternalImageHandleRef externalImage,
             VkDevice device);
 
     static ImageData createExternalImageDataImpl(ExternalImageHandleRef externalImage,
-            VkDevice device, const ExternalImageMetadata& metadata);
+            VkDevice device, const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
+            VkImageUsageFlags usage);
+    static VkSampler createExternalSamplerImpl(VkDevice device,
+            SamplerYcbcrConversion chroma, SamplerParams sampler,
+            uint32_t internalFormat);
+    static VkImageView createExternalImageViewImpl(VkDevice device,
+            SamplerYcbcrConversion chroma, uint32_t internalFormat, VkImage image,
+            VkImageSubresourceRange range, VkImageViewType viewType,
+            VkComponentMapping swizzle);
 
     // Platform dependent helper methods
-    using SurfaceBundle = std::tuple<VkSurfaceKHR, VkExtent2D>;
-    static SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
+    static SurfaceBundle createVkSurfaceKHRImpl(void* nativeWindow, VkInstance instance,
             uint64_t flags) noexcept;
 
     friend struct VulkanPlatformPrivate;

filament/backend/include/backend/platforms/VulkanPlatformAndroid.h

@@ -17,27 +17,55 @@
 #ifndef TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H
 #define TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H
 
-#include <backend/Platform.h>
+#include <backend/DriverEnums.h>
+#include <backend/platforms/VulkanPlatform.h>
 
 #include <android/hardware_buffer.h>
 
-namespace filament::backend::fvkandroid {
+namespace filament::backend {
 
-struct ExternalImageVulkanAndroid : public Platform::ExternalImage {
-    AHardwareBuffer* aHardwareBuffer = nullptr;
-    bool sRGB = false;
-    unsigned int width;   // Texture width
-    unsigned int height;  // Texture height
-    TextureFormat format; // Texture format
-    TextureUsage usage;   // Texture usage flags
+class VulkanPlatformAndroid : public VulkanPlatform {
+public:
+    Platform::ExternalImageHandle UTILS_PUBLIC createExternalImage(AHardwareBuffer const* buffer,
+            bool sRGB) noexcept;
+
+    struct UTILS_PUBLIC ExternalImageDescAndroid {
+        uint32_t width;      // Texture width
+        uint32_t height;     // Texture height
+        TextureFormat format;// Texture format
+        TextureUsage usage;  // Texture usage flags
+    };
+
+    ExternalImageDescAndroid UTILS_PUBLIC getExternalImageDesc(
+            ExternalImageHandleRef externalImage) const noexcept;
 
 protected:
-    ~ExternalImageVulkanAndroid() override;
+    struct ExternalImageVulkanAndroid : public Platform::ExternalImage {
+        AHardwareBuffer* aHardwareBuffer = nullptr;
+        bool sRGB = false;
+        unsigned int width;  // Texture width
+        unsigned int height; // Texture height
+        TextureFormat format;// Texture format
+        TextureUsage usage;  // Texture usage flags
+
+    protected:
+        ~ExternalImageVulkanAndroid() override;
+    };
+
+    virtual ExternalImageMetadata getExternalImageMetadata(ExternalImageHandleRef externalImage);
+
+    using ImageData = VulkanPlatform::ImageData;
+    virtual ImageData createExternalImageData(ExternalImageHandleRef externalImage,
+            const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex,
+            VkImageUsageFlags usage);
+
+    virtual ExtensionSet getSwapchainInstanceExtensions() const;
+
+    using SurfaceBundle = VulkanPlatform::SurfaceBundle;
+    virtual SurfaceBundle createVkSurfaceKHR(void* nativeWindow, VkInstance instance,
+            uint64_t flags) const noexcept;
 };
 
-Platform::ExternalImageHandle createExternalImage(AHardwareBuffer const* buffer,
-        bool sRGB) noexcept;
+}// namespace filament::backend
 
-} // namespace filament::backend::fvkandroid
-
-#endif // TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H
+#endif// TNT_FILAMENT_BACKEND_PLATFORMS_VULKAN_PLATFORM_ANDROID_H

filament/backend/include/backend/platforms/WebGPUPlatform.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TNT_FILAMENT_BACKEND_PLATFORMS_WEBGPUPLATFORM_H
+#define TNT_FILAMENT_BACKEND_PLATFORMS_WEBGPUPLATFORM_H
+
+#include <backend/Platform.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstdint>
+
+namespace filament::backend {
+
+/**
+ * A Platform interface, handling the environment-specific concerns, e.g. OS, for creating a WebGPU
+ * driver (backend).
+ */
+class WebGPUPlatform final : public Platform {
+public:
+    WebGPUPlatform();
+    ~WebGPUPlatform() override = default;
+
+    [[nodiscard]] int getOSVersion() const noexcept final { return 0; }
+
+    [[nodiscard]] wgpu::Instance& getInstance() noexcept { return mInstance; }
+
+    // either returns a valid surface or panics
+    [[nodiscard]] wgpu::Surface createSurface(void* nativeWindow, uint64_t flags);
+    // either returns a valid adapter or panics
+    [[nodiscard]] wgpu::Adapter requestAdapter(wgpu::Surface const& surface);
+    // either returns a valid device or panics
+    [[nodiscard]] wgpu::Device requestDevice(wgpu::Adapter const& adapter);
+
+protected:
+    [[nodiscard]] Driver* createDriver(void* sharedContext,
+            const Platform::DriverConfig& driverConfig) noexcept override;
+
+private:
+    // we may consider having the driver own this in the future
+    wgpu::Instance mInstance;
+};
+
+}// namespace filament::backend
+
+#endif// TNT_FILAMENT_BACKEND_PLATFORMS_WEBGPUPLATFORM_H

filament/backend/include/private/backend/DriverAPI.inc

@@ -362,6 +362,8 @@ DECL_DRIVER_API_SYNCHRONOUS_0(bool, isProtectedTexturesSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(bool, isDepthClampSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(uint8_t, getMaxDrawBuffers)
 DECL_DRIVER_API_SYNCHRONOUS_0(size_t, getMaxUniformBufferSize)
+DECL_DRIVER_API_SYNCHRONOUS_N(size_t, getMaxTextureSize, backend::SamplerType, target)
+DECL_DRIVER_API_SYNCHRONOUS_0(size_t, getMaxArrayTextureLayers)
 DECL_DRIVER_API_SYNCHRONOUS_0(math::float2, getClipSpaceParams)
 DECL_DRIVER_API_SYNCHRONOUS_N(void, setupExternalImage2, backend::Platform::ExternalImageHandleRef, image)
 DECL_DRIVER_API_SYNCHRONOUS_N(void, setupExternalImage, void*, image)

filament/backend/src/PlatformFactory.cpp

@@ -19,6 +19,11 @@
 #include <utils/Systrace.h>
 #include <utils/debug.h>
 
+// We need to keep this up top for the linux (X11) name collisions.
+#if defined(FILAMENT_SUPPORTS_WEBGPU)
+    #include "backend/platforms/WebGPUPlatform.h"
+#endif
+
 #if defined(__ANDROID__)
     #include <sys/system_properties.h>
     #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3)
@@ -30,7 +35,11 @@
     #endif
 #elif defined(__APPLE__)
     #if defined(FILAMENT_SUPPORTS_OPENGL) && !defined(FILAMENT_USE_EXTERNAL_GLES3)
-        #include <backend/platforms/PlatformCocoaGL.h>
+        #if defined(FILAMENT_SUPPORTS_OSMESA)
+            #include <backend/platforms/PlatformOSMesa.h>
+        #else
+            #include <backend/platforms/PlatformCocoaGL.h>
+        #endif
     #endif
 #elif defined(__linux__)
     #if defined(FILAMENT_SUPPORTS_X11)
@@ -55,7 +64,11 @@
 #endif
 
 #if defined(FILAMENT_DRIVER_SUPPORTS_VULKAN)
-    #include "backend/platforms/VulkanPlatform.h"
+    #if defined(__ANDROID__)
+        #include "backend/platforms/VulkanPlatformAndroid.h"
+    #else
+        #include "backend/platforms/VulkanPlatform.h"
+    #endif
 #endif
 
 #if defined (FILAMENT_SUPPORTS_METAL)
@@ -65,9 +78,6 @@ filament::backend::Platform* createDefaultMetalPlatform();
 #endif
 
 #include "noop/PlatformNoop.h"
-#if defined(FILAMENT_SUPPORTS_WEBGPU)
-    #include "webgpu/WebGPUPlatform.h"
-#endif
 
 namespace filament::backend {
 
@@ -104,7 +114,11 @@ Platform* PlatformFactory::create(Backend* backend) noexcept {
     }
     if (*backend == Backend::VULKAN) {
         #if defined(FILAMENT_DRIVER_SUPPORTS_VULKAN)
-            return new VulkanPlatform();
+            #if defined(__ANDROID__)
+                return new VulkanPlatformAndroid();
+            #else
+                return new VulkanPlatform();
+            #endif
         #else
             return nullptr;
         #endif
@@ -132,7 +146,11 @@ Platform* PlatformFactory::create(Backend* backend) noexcept {
         #elif defined(FILAMENT_IOS)
             return new PlatformCocoaTouchGL();
         #elif defined(__APPLE__)
-            return new PlatformCocoaGL();
+            #if defined(FILAMENT_SUPPORTS_OSMESA)
+                return new PlatformOSMesa();
+            #else
+                return new PlatformCocoaGL();
+            #endif
         #elif defined(__linux__)
             #if defined(FILAMENT_SUPPORTS_X11)
                 return new PlatformGLX();

filament/backend/src/metal/MetalDriver.mm

@@ -1177,6 +1177,16 @@ size_t MetalDriver::getMaxUniformBufferSize() {
     return 256 * 1024 * 1024;   // TODO: return the actual size instead of hardcoding the minspec
 }
 
+size_t MetalDriver::getMaxTextureSize(SamplerType) {
+    // TODO: return the actual size instead of hardcoding the minspec
+    return 2048;
+}
+
+size_t MetalDriver::getMaxArrayTextureLayers() {
+    // TODO: return the actual size instead of hardcoding the minspec
+    return 256;
+}
+
 void MetalDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor&& data,
         uint32_t byteOffset) {
     FILAMENT_CHECK_PRECONDITION(data.buffer)

filament/backend/src/noop/NoopDriver.cpp

@@ -240,6 +240,14 @@ size_t NoopDriver::getMaxUniformBufferSize() {
     return 16384u;
 }
 
+size_t NoopDriver::getMaxTextureSize(SamplerType target) {
+    return 4096u;
+}
+
+size_t NoopDriver::getMaxArrayTextureLayers() {
+    return 256u;
+}
+
 void NoopDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor&& p,
         uint32_t byteOffset) {
     scheduleDestroy(std::move(p));

filament/backend/src/noop/PlatformNoop.cpp

@@ -20,7 +20,7 @@
 
 namespace filament::backend {
 
-Driver* PlatformNoop::createDriver(void* const sharedGLContext, const Platform::DriverConfig& driverConfig) noexcept {
+Driver* PlatformNoop::createDriver(void* sharedGLContext, const Platform::DriverConfig& driverConfig) noexcept {
     return NoopDriver::create();
 }
 

filament/backend/src/opengl/OpenGLContext.cpp

@@ -94,18 +94,22 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
     }
     #endif
 
-    OpenGLContext::initExtensions(&ext, state.major, state.minor);
+    initExtensions(&ext, state.major, state.minor);
 
-    OpenGLContext::initProcs(&procs, ext, state.major, state.minor);
+    initProcs(&procs, ext, state.major, state.minor);
 
-    OpenGLContext::initBugs(&bugs, ext, state.major, state.minor,
+    initBugs(&bugs, ext, state.major, state.minor,
             state.vendor, state.renderer, state.version, state.shader);
 
     glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE,             &gets.max_renderbuffer_size);
     glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,           &gets.max_texture_image_units);
     glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,  &gets.max_combined_texture_image_units);
+    glGetIntegerv(GL_MAX_TEXTURE_SIZE,                  &gets.max_texture_size);
+    glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE,         &gets.max_cubemap_texture_size);
+    glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE,               &gets.max_3d_texture_size);
+    glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS,          &gets.max_array_texture_layers);
 
-    mFeatureLevel = OpenGLContext::resolveFeatureLevel(state.major, state.minor, ext, gets, bugs);
+    mFeatureLevel = resolveFeatureLevel(state.major, state.minor, ext, gets, bugs);
 
 #ifdef BACKEND_OPENGL_VERSION_GLES
     mShaderModel = ShaderModel::MOBILE;
@@ -177,6 +181,14 @@ OpenGLContext::OpenGLContext(OpenGLPlatform& platform,
                     << gets.max_anisotropy << '\n'
             << "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = "
                     << gets.max_combined_texture_image_units << '\n'
+            << "GL_MAX_TEXTURE_SIZE = "
+                    << gets.max_texture_size << '\n'
+            << "GL_MAX_CUBE_MAP_TEXTURE_SIZE = "
+                    << gets.max_cubemap_texture_size << '\n'
+            << "GL_MAX_3D_TEXTURE_SIZE = "
+                    << gets.max_3d_texture_size << '\n'
+            << "GL_MAX_ARRAY_TEXTURE_LAYERS = "
+                    << gets.max_array_texture_layers << '\n'
             << "GL_MAX_DRAW_BUFFERS = "
                     << gets.max_draw_buffers << '\n'
             << "GL_MAX_RENDERBUFFER_SIZE = "

filament/backend/src/opengl/OpenGLContext.h

@@ -203,6 +203,10 @@ public:
         GLint max_renderbuffer_size;
         GLint max_samples;
         GLint max_texture_image_units;
+        GLint max_texture_size;
+        GLint max_cubemap_texture_size;
+        GLint max_3d_texture_size;
+        GLint max_array_texture_layers;
         GLint max_transform_feedback_separate_attribs;
         GLint max_uniform_block_size;
         GLint max_uniform_buffer_bindings;

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -148,8 +148,8 @@ using namespace utils;
 namespace filament::backend {
 
 Driver* OpenGLDriverFactory::create(
-        OpenGLPlatform* const platform,
-        void* const sharedGLContext,
+        OpenGLPlatform* platform,
+        void* sharedGLContext,
         const Platform::DriverConfig& driverConfig) noexcept {
     return OpenGLDriver::create(platform, sharedGLContext, driverConfig);
 }
@@ -159,10 +159,10 @@ using namespace GLUtils;
 // ------------------------------------------------------------------------------------------------
 
 UTILS_NOINLINE
-OpenGLDriver* OpenGLDriver::create(OpenGLPlatform* const platform,
-        void* const /*sharedGLContext*/, const Platform::DriverConfig& driverConfig) noexcept {
+OpenGLDriver* OpenGLDriver::create(OpenGLPlatform* platform,
+        void* /*sharedGLContext*/, const Platform::DriverConfig& driverConfig) noexcept {
     assert_invariant(platform);
-    OpenGLPlatform* const ec = platform;
+    OpenGLPlatform* ec = platform;
 
 #if 0
     // this is useful for development, but too verbose even for debug builds
@@ -230,7 +230,7 @@ OpenGLDriver* OpenGLDriver::create(OpenGLPlatform* const platform,
     constexpr size_t defaultSize = FILAMENT_OPENGL_HANDLE_ARENA_SIZE_IN_MB * 1024U * 1024U;
     Platform::DriverConfig validConfig{ driverConfig };
     validConfig.handleArenaSize = std::max(driverConfig.handleArenaSize, defaultSize);
-    OpenGLDriver* const driver = new(std::nothrow) OpenGLDriver(ec, validConfig);
+    OpenGLDriver* driver = new(std::nothrow) OpenGLDriver(ec, validConfig);
     return driver;
 }
 
@@ -2460,6 +2460,26 @@ size_t OpenGLDriver::getMaxUniformBufferSize() {
     return mContext.gets.max_uniform_block_size;
 }
 
+size_t OpenGLDriver::getMaxTextureSize(SamplerType target) {
+    switch (target) {
+        case SamplerType::SAMPLER_2D:
+        case SamplerType::SAMPLER_2D_ARRAY:
+        case SamplerType::SAMPLER_EXTERNAL:
+            return mContext.gets.max_texture_size;
+        case SamplerType::SAMPLER_CUBEMAP:
+            return mContext.gets.max_cubemap_texture_size;
+        case SamplerType::SAMPLER_3D:
+            return mContext.gets.max_3d_texture_size;
+        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
+            return mContext.gets.max_cubemap_texture_size;
+    }
+    return 0;
+}
+
+size_t OpenGLDriver::getMaxArrayTextureLayers() {
+    return mContext.gets.max_array_texture_layers;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Swap chains
 // ------------------------------------------------------------------------------------------------

filament/backend/src/opengl/platforms/PlatformCocoaTouchGL.mm

@@ -64,7 +64,7 @@ PlatformCocoaTouchGL::~PlatformCocoaTouchGL() noexcept {
     delete pImpl;
 }
 
-Driver* PlatformCocoaTouchGL::createDriver(void* const sharedGLContext, const Platform::DriverConfig& driverConfig) noexcept {
+Driver* PlatformCocoaTouchGL::createDriver(void* sharedGLContext, const Platform::DriverConfig& driverConfig) noexcept {
     EAGLSharegroup* sharegroup = (__bridge EAGLSharegroup*) sharedGLContext;
 
     EAGLContext *context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3 sharegroup:sharegroup];

filament/backend/src/opengl/platforms/PlatformEGLAndroid.cpp

@@ -19,6 +19,7 @@
 #include <backend/platforms/PlatformEGL.h>
 #include <backend/platforms/PlatformEGLAndroid.h>
 
+#include <private/backend/BackendUtilsAndroid.h>
 #include <private/backend/VirtualMachineEnv.h>
 
 #include "opengl/GLUtils.h"
@@ -34,6 +35,8 @@
 #include <utils/ostream.h>
 #include <utils/Panic.h>
 #include <utils/Log.h>
+#include <utils/compiler.h>
+#include <utils/ostream.h>
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
@@ -231,26 +234,133 @@ Driver* PlatformEGLAndroid::createDriver(void* sharedContext,
     return driver;
 }
 
-PlatformEGLAndroid::ExternalImageEGLAndroid::~ExternalImageEGLAndroid() = default;
+PlatformEGLAndroid::ExternalImageEGLAndroid::~ExternalImageEGLAndroid() {
+    if (__builtin_available(android 26, *)) {
+        if (aHardwareBuffer) {
+            AHardwareBuffer_release(aHardwareBuffer);
+        }
+    }
+}
 
-Platform::ExternalImageHandle PlatformEGLAndroid::createExternalImage(AHardwareBuffer const* buffer, bool sRGB) noexcept {
-    auto* const p = new(std::nothrow) ExternalImageEGLAndroid;
-    p->aHardwareBuffer = const_cast<AHardwareBuffer*>(buffer);
-    p->sRGB = sRGB;
-    return ExternalImageHandle{ p };
+Platform::ExternalImageHandle PlatformEGLAndroid::createExternalImage(AHardwareBuffer const* buffer,
+        bool sRGB) noexcept {
+    if (__builtin_available(android 26, *)) {
+        auto* const p = new (std::nothrow) ExternalImageEGLAndroid;
+        auto hardwareBuffer = const_cast<AHardwareBuffer*>(buffer);
+        AHardwareBuffer_acquire(hardwareBuffer);
+        p->aHardwareBuffer = hardwareBuffer;
+        p->sRGB = sRGB;
+        AHardwareBuffer_Desc hardwareBufferDescription = {};
+        AHardwareBuffer_describe(hardwareBuffer, &hardwareBufferDescription);
+        p->height = hardwareBufferDescription.height;
+        p->width = hardwareBufferDescription.width;
+        auto textureFormat = mapToFilamentFormat(hardwareBufferDescription.format, sRGB);
+        p->usage = mapToFilamentUsage(hardwareBufferDescription.usage, textureFormat);
+        return ExternalImageHandle{ p };
+    }
+
+    return Platform::ExternalImageHandle{};
+}
+
+PlatformEGLAndroid::ExternalImageDescAndroid PlatformEGLAndroid::getExternalImageDesc(
+        ExternalImageHandle externalImage) noexcept {
+    auto const* const eglExternalImage =
+            static_cast<ExternalImageEGLAndroid const*>(externalImage.get());
+    ExternalImageDescAndroid metadata = {};
+    if (!eglExternalImage) {
+        return metadata;
+    }
+    metadata.height = eglExternalImage->height;
+    metadata.width = eglExternalImage->width;
+    metadata.format = eglExternalImage->format;
+    metadata.usage = eglExternalImage->usage;
+    return metadata;
 }
 
 bool PlatformEGLAndroid::setExternalImage(ExternalImageHandleRef externalImage,
         UTILS_UNUSED_IN_RELEASE ExternalTexture* texture) noexcept {
-    auto const* const eglExternalImage = static_cast<ExternalImageEGLAndroid const*>(externalImage.get());
+    auto const* const eglExternalImage =
+            static_cast<ExternalImageEGLAndroid const*>(externalImage.get());
     if (eglExternalImage->aHardwareBuffer) {
-        // TODO: implement PlatformEGLAndroid::setExternalImage w/ AHardwareBuffer
-        return true;
+        return PlatformEGLAndroid::setImage(eglExternalImage, texture);
     }
     // not a AHardwareBuffer, fallback to the inherited version
     return PlatformEGL::setExternalImage(externalImage, texture);
 }
 
+OpenGLPlatform::ExternalTexture* PlatformEGLAndroid::createExternalImageTexture() noexcept {
+    ExternalTexture* outTexture = new (std::nothrow) ExternalTexture{};
+    glGenTextures(1, &outTexture->id);
+    return outTexture;
+}
+
+void PlatformEGLAndroid::destroyExternalImageTexture(ExternalTexture* texture) noexcept {
+    glDeleteTextures(1, &texture->id);
+    delete texture;
+}
+
+bool PlatformEGLAndroid::setImage(ExternalImageEGLAndroid const* eglExternalImage,
+        UTILS_UNUSED_IN_RELEASE ExternalTexture* texture) noexcept {
+    AHardwareBuffer* hardwareBuffer = eglExternalImage->aHardwareBuffer;
+
+    // Get the EGL client buffer from AHardwareBuffer
+    EGLClientBuffer clientBuffer = eglGetNativeClientBufferANDROID(hardwareBuffer);
+    EGLint imageAttrs[] = {
+        EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
+        EGL_NONE, EGL_NONE,  // Reserve space
+        EGL_NONE, EGL_NONE,  // Reserve space
+        EGL_NONE             // Ensure the list always ends with EGL_NONE
+    };
+    int attrIndex = 2;
+    if (eglExternalImage->sRGB) {
+        imageAttrs[attrIndex++] = EGL_GL_COLORSPACE;
+        imageAttrs[attrIndex++] = EGL_GL_COLORSPACE_SRGB;
+    }
+
+    if (static_cast<bool>(eglExternalImage->usage & TextureUsage::PROTECTED)) {
+        imageAttrs[attrIndex++] = EGL_PROTECTED_CONTENT_EXT;
+        imageAttrs[attrIndex++] = EGL_TRUE;
+    }
+    // Create an EGLImage from the client buffer
+    EGLImageKHR eglImage = eglCreateImageKHR(eglGetCurrentDisplay(), EGL_NO_CONTEXT,
+            EGL_NATIVE_BUFFER_ANDROID, clientBuffer, imageAttrs);
+    if (eglImage == EGL_NO_IMAGE_KHR) {
+        // Handle error
+        slog.e << "Failed to create EGL image" << io::endl;
+        glDeleteTextures(1, &texture->id);
+        return false;
+    }
+
+    // Create and bind the OpenGL texture
+    GLint prevActiveTexture, prevTexture;
+    glGetIntegerv(GL_ACTIVE_TEXTURE, &prevActiveTexture);
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &prevTexture);
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(texture->target, texture->id);
+    GLenum error = glGetError();
+    if (UTILS_UNLIKELY(error != GL_NO_ERROR)) {
+        slog.e << "Error after glBindTexture: " << error << io::endl;
+        glDeleteTextures(1, &texture->id);
+        eglDestroyImageKHR(eglGetCurrentDisplay(), eglImage);
+        glActiveTexture(prevActiveTexture);
+        glBindTexture(GL_TEXTURE_2D, prevTexture);
+        return false;
+    }
+    glEGLImageTargetTexture2DOES(texture->target, static_cast<GLeglImageOES>(eglImage));
+    error = glGetError();
+    if (UTILS_UNLIKELY(error != GL_NO_ERROR)) {
+        slog.e << "Error after glEGLImageTargetTexture2DOES: " << error << io::endl;
+        glDeleteTextures(1, &texture->id);
+        eglDestroyImageKHR(eglGetCurrentDisplay(), eglImage);
+        glActiveTexture(prevActiveTexture);
+        glBindTexture(GL_TEXTURE_2D, prevTexture);
+        return false;
+    }
+    glActiveTexture(prevActiveTexture);
+    glBindTexture(GL_TEXTURE_2D, prevTexture);
+    return true;
+}
+
 void PlatformEGLAndroid::setPresentationTime(int64_t presentationTimeInNanosecond) noexcept {
     EGLSurface currentDrawSurface = eglGetCurrentSurface(EGL_DRAW);
     if (currentDrawSurface != EGL_NO_SURFACE) {

filament/backend/src/opengl/platforms/PlatformGLX.cpp

@@ -128,7 +128,7 @@ namespace filament::backend {
 
 using namespace backend;
 
-Driver* PlatformGLX::createDriver(void* const sharedGLContext,
+Driver* PlatformGLX::createDriver(void* sharedGLContext,
         const DriverConfig& driverConfig) noexcept {
     loadLibraries();
     // Get the display device

filament/backend/src/opengl/platforms/PlatformOSMesa.cpp

@@ -22,9 +22,11 @@
 #include <dlfcn.h>
 #include <memory>
 
+#if defined(__linux__)
 // This is to ensure that linking during compilation will not fail even if
 // OSMesaGetProcAddress is not linked.
 __attribute__((weak)) OSMESAproc OSMesaGetProcAddress(char const*);
+#endif
 
 namespace filament::backend {
 
@@ -48,20 +50,27 @@ struct OSMesaSwapchain {
 
 struct OSMesaAPI {
 private:
-    using CreateContextFunc = OSMesaContext (*)(GLenum format, OSMesaContext);
+    using CreateContextAttribsFunc = OSMesaContext (*)(const int *, OSMesaContext);
     using DestroyContextFunc = GLboolean (*)(OSMesaContext);
     using MakeCurrentFunc = GLboolean (*)(OSMesaContext ctx, void* buffer, GLenum type,
             GLsizei width, GLsizei height);
     using GetProcAddressFunc = OSMESAproc (*)(const char* funcName);
 
 public:
-    CreateContextFunc fOSMesaCreateContext;
+    CreateContextAttribsFunc fOSMesaCreateContextAttribs;
     DestroyContextFunc fOSMesaDestroyContext;
     MakeCurrentFunc fOSMesaMakeCurrent;
     GetProcAddressFunc fOSMesaGetProcAddress;
 
     OSMesaAPI() {
-        constexpr char const* libraryNames[] = {"libOSMesa.so", "libosmesa.so"};
+        static constexpr char const* libraryNames[] = {
+#if defined(__linux__)
+            "libOSMesa.so",
+            "libosmesa.so",
+#elif defined(__APPLE__)
+            "libOSMesa.dylib",
+#endif
+        };
         for (char const* libName: libraryNames) {
             mLib = dlopen(libName, RTLD_GLOBAL | RTLD_NOW);
             if (mLib) {
@@ -71,22 +80,24 @@ public:
         if (mLib) {
             // Loading from a libosmesa.os
             fOSMesaGetProcAddress = (GetProcAddressFunc) dlsym(mLib, "OSMesaGetProcAddress");
-        } else {
+        }
+#if defined(__linux__)
+        else {
             // Filament is built into a .so
             fOSMesaGetProcAddress = (GetProcAddressFunc) dlsym(RTLD_LOCAL, "OSMesaGetProcAddress");
         }
-
         if (!fOSMesaGetProcAddress) {
             // Statically linking osmesa
             fOSMesaGetProcAddress = OSMesaGetProcAddress;
         }
+#endif // __linux__
 
         FILAMENT_CHECK_PRECONDITION(fOSMesaGetProcAddress)
                 << "Unable to link against libOSMesa to create a software GL context";
 
-        fOSMesaCreateContext = (CreateContextFunc) fOSMesaGetProcAddress("OSMesaCreateContext");
-        fOSMesaDestroyContext =
-                (DestroyContextFunc) fOSMesaGetProcAddress("OSMesaDestroyContext");
+        fOSMesaCreateContextAttribs =
+                (CreateContextAttribsFunc) fOSMesaGetProcAddress("OSMesaCreateContextAttribs");
+        fOSMesaDestroyContext = (DestroyContextFunc) fOSMesaGetProcAddress("OSMesaDestroyContext");
         fOSMesaMakeCurrent = (MakeCurrentFunc) fOSMesaGetProcAddress("OSMesaMakeCurrent");
     }
 
@@ -101,14 +112,24 @@ private:
 
 }// anonymous namespace
 
-Driver* PlatformOSMesa::createDriver(void* const sharedGLContext,
+Driver* PlatformOSMesa::createDriver(void* sharedGLContext,
         const DriverConfig& driverConfig) noexcept {
+
     OSMesaAPI* api = new OSMesaAPI();
     mOsMesaApi = api;
 
+    static constexpr int attribs[] = {
+        OSMESA_FORMAT, GL_RGBA,
+        OSMESA_DEPTH_BITS, 24,
+        OSMESA_STENCIL_BITS, 8,
+        OSMESA_ACCUM_BITS, 0,
+        OSMESA_PROFILE, OSMESA_CORE_PROFILE,
+        0,
+    };
+
     FILAMENT_CHECK_PRECONDITION(sharedGLContext == nullptr)
             << "shared GL context is not supported with PlatformOSMesa";
-    mContext = api->fOSMesaCreateContext(GL_RGBA, NULL);
+    mContext = api->fOSMesaCreateContextAttribs(attribs, NULL);
 
     // We need to do a no-op makecurrent here so that the context will be in a correct state before
     // any GL calls.

filament/backend/src/opengl/platforms/PlatformWGL.cpp

@@ -75,7 +75,7 @@ struct WGLSwapChain {
 
 static PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribs = nullptr;
 
-Driver* PlatformWGL::createDriver(void* const sharedGLContext,
+Driver* PlatformWGL::createDriver(void* sharedGLContext,
         const Platform::DriverConfig& driverConfig) noexcept {
     int result = 0;
     int pixelFormat = 0;

filament/backend/src/opengl/platforms/PlatformWebGL.cpp

@@ -20,7 +20,7 @@ namespace filament::backend {
 
 using namespace backend;
 
-Driver* PlatformWebGL::createDriver(void* const sharedGLContext,
+Driver* PlatformWebGL::createDriver(void* sharedGLContext,
         const Platform::DriverConfig& driverConfig) noexcept {
     return OpenGLPlatform::createDefaultDriver(this, sharedGLContext, driverConfig);
 }

filament/backend/src/vulkan/VulkanDescriptorSetCache.cpp

@@ -14,35 +14,25 @@
  * limitations under the License.
  */
 
-#include "VulkanDescriptorSetManager.h"
+#include "VulkanDescriptorSetCache.h"
 
-#include "vulkan/VulkanCommands.h"
-#include "vulkan/VulkanHandles.h"
-#include "vulkan/VulkanConstants.h"
+#include "VulkanCommands.h"
+#include "VulkanHandles.h"
+#include "VulkanConstants.h"
 
 #include <utils/FixedCapacityVector.h>
 #include <utils/Panic.h>
 
-#include <math.h>
-
 #include <algorithm>
 #include <memory>
-#include <type_traits>
 #include <vector>
 
 namespace filament::backend {
 
 namespace {
 
-using BitmaskGroup = VulkanDescriptorSetLayout::Bitmask;
 using DescriptorCount = VulkanDescriptorSetLayout::Count;
-using DescriptorSetLayoutArray = VulkanDescriptorSetManager::DescriptorSetLayoutArray;
-using BitmaskGroupHashFn = utils::hash::MurmurHashFn<BitmaskGroup>;
-struct BitmaskGroupEqual {
-    bool operator()(BitmaskGroup const& k1, BitmaskGroup const& k2) const {
-        return k1 == k2;
-    }
-};
+using DescriptorSetLayoutArray = VulkanDescriptorSetCache::DescriptorSetLayoutArray;
 
 // We create a pool for each layout as defined by the number of descriptors of each type. For
 // example, a layout of
@@ -199,72 +189,12 @@ struct Equal {
     }
 };
 
-template<typename Bitmask>
-uint32_t createBindings(VkDescriptorSetLayoutBinding* toBind, uint32_t count, VkDescriptorType type,
-        Bitmask const& mask) {
-    Bitmask alreadySeen;
-    mask.forEachSetBit([&](size_t index) {
-        VkShaderStageFlags stages = 0;
-        uint32_t binding = 0;
-        if (index < fvkutils::getFragmentStageShift<Bitmask>()) {
-            binding = (uint32_t) index;
-            stages |= VK_SHADER_STAGE_VERTEX_BIT;
-            auto fragIndex = index + fvkutils::getFragmentStageShift<Bitmask>();
-            if (mask.test(fragIndex)) {
-                stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
-                alreadySeen.set(fragIndex);
-            }
-        } else if (!alreadySeen.test(index)) {
-            // We are in fragment stage bits
-            binding = (uint32_t) (index - fvkutils::getFragmentStageShift<Bitmask>());
-            stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
-        }
-
-        if (stages) {
-            toBind[count++] = {
-                .binding = binding,
-                .descriptorType = type,
-                .descriptorCount = 1,
-                .stageFlags = stages,
-            };
-        }
-    });
-    return count;
-}
-
-inline VkDescriptorSetLayout createLayout(VkDevice device, BitmaskGroup const& bitmaskGroup) {
-    // Note that the following *needs* to be static so that VkDescriptorSetLayoutCreateInfo will not
-    // refer to stack memory.
-    VkDescriptorSetLayoutBinding toBind[VulkanDescriptorSetLayout::MAX_BINDINGS];
-    uint32_t count = 0;
-
-    count = createBindings(toBind, count, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
-            bitmaskGroup.dynamicUbo);
-    count = createBindings(toBind, count, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, bitmaskGroup.ubo);
-    count = createBindings(toBind, count, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-            bitmaskGroup.sampler);
-    count = createBindings(toBind, count, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
-            bitmaskGroup.inputAttachment);
-
-    assert_invariant(count != 0 && "Need at least one binding for descriptor set layout.");
-    VkDescriptorSetLayoutCreateInfo dlinfo = {
-            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-            .pNext = nullptr,
-            .bindingCount = count,
-            .pBindings = toBind,
-    };
-
-    VkDescriptorSetLayout layout;
-    vkCreateDescriptorSetLayout(device, &dlinfo, VKALLOC, &layout);
-    return layout;
-}
-
 } // anonymous namespace
 
 // This is an ever-expanding pool of sets where it
 //    1. Keeps a list of smaller pools of different layout-dimensions.
 //    2. Will add a pool if existing pool are not compatible with the requested layout o runs out.
-class VulkanDescriptorSetManager::DescriptorInfinitePool {
+class VulkanDescriptorSetCache::DescriptorInfinitePool {
 private:
     static constexpr uint16_t EXPECTED_SET_COUNT = 10;
     static constexpr float SET_COUNT_GROWTH_FACTOR = 1.5;
@@ -319,61 +249,34 @@ private:
     std::vector<std::unique_ptr<DescriptorPool>> mPools;
 };
 
-class VulkanDescriptorSetManager::DescriptorSetLayoutManager {
-public:
-    DescriptorSetLayoutManager(VkDevice device)
-        : mDevice(device) {}
 
-    VkDescriptorSetLayout getVkLayout(VulkanDescriptorSetLayout::Bitmask const& bitmasks) {
-        if (auto itr = mVkLayouts.find(bitmasks); itr != mVkLayouts.end()) {
-            return itr->second;
-        }
-        auto vklayout = createLayout(mDevice, bitmasks);
-        mVkLayouts[bitmasks] = vklayout;
-        return vklayout;
-    }
-
-    ~DescriptorSetLayoutManager() {
-        for (auto& itr: mVkLayouts) {
-            vkDestroyDescriptorSetLayout(mDevice, itr.second, VKALLOC);
-        }
-    }
-
-private:
-    VkDevice mDevice;
-    tsl::robin_map<BitmaskGroup, VkDescriptorSetLayout, BitmaskGroupHashFn, BitmaskGroupEqual>
-            mVkLayouts;
-};
-
-VulkanDescriptorSetManager::VulkanDescriptorSetManager(VkDevice device,
+VulkanDescriptorSetCache::VulkanDescriptorSetCache(VkDevice device,
         fvkmemory::ResourceManager* resourceManager)
     : mDevice(device),
       mResourceManager(resourceManager),
-      mLayoutManager(std::make_unique<DescriptorSetLayoutManager>(device)),
       mDescriptorPool(std::make_unique<DescriptorInfinitePool>(device)) {}
 
-VulkanDescriptorSetManager::~VulkanDescriptorSetManager() = default;
+VulkanDescriptorSetCache::~VulkanDescriptorSetCache() = default;
 
-void VulkanDescriptorSetManager::terminate() noexcept{
-    mLayoutManager.reset();
+void VulkanDescriptorSetCache::terminate() noexcept{
     mDescriptorPool.reset();
     clearHistory();
 }
 
 // bind() is not really binding the set but just stashing until we have all the info
 // (pipelinelayout).
-void VulkanDescriptorSetManager::bind(uint8_t setIndex,
+void VulkanDescriptorSetCache::bind(uint8_t setIndex,
         fvkmemory::resource_ptr<VulkanDescriptorSet> set,
         backend::DescriptorSetOffsetArray&& offsets) {
     set->setOffsets(std::move(offsets));
     mStashedSets[setIndex] = set;
 }
 
-void VulkanDescriptorSetManager::unbind(uint8_t setIndex) {
+void VulkanDescriptorSetCache::unbind(uint8_t setIndex) {
     mStashedSets[setIndex] = {};
 }
 
-void VulkanDescriptorSetManager::commit(VulkanCommandBuffer* commands,
+void VulkanDescriptorSetCache::commit(VulkanCommandBuffer* commands,
         VkPipelineLayout pipelineLayout, fvkutils::DescriptorSetMask const& setMask) {
     // setMask indicates the set of descriptor sets the driver wants to bind, curMask is the
     // actual set of sets that *needs* to be bound.
@@ -412,7 +315,7 @@ void VulkanDescriptorSetManager::commit(VulkanCommandBuffer* commands,
     };
 }
 
-void VulkanDescriptorSetManager::updateBuffer(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
+void VulkanDescriptorSetCache::updateBuffer(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
         uint8_t binding, fvkmemory::resource_ptr<VulkanBufferObject> bufferObject,
         VkDeviceSize offset, VkDeviceSize size) noexcept {
     VkDescriptorBufferInfo const info = {
@@ -438,7 +341,7 @@ void VulkanDescriptorSetManager::updateBuffer(fvkmemory::resource_ptr<VulkanDesc
     set->acquire(bufferObject);
 }
 
-void VulkanDescriptorSetManager::updateSampler(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
+void VulkanDescriptorSetCache::updateSampler(fvkmemory::resource_ptr<VulkanDescriptorSet> set,
         uint8_t binding, fvkmemory::resource_ptr<VulkanTexture> texture,
         VkSampler sampler) noexcept {
     VkDescriptorImageInfo info{
@@ -470,13 +373,13 @@ void VulkanDescriptorSetManager::updateSampler(fvkmemory::resource_ptr<VulkanDes
     set->acquire(texture);
 }
 
-void VulkanDescriptorSetManager::updateInputAttachment(
+void VulkanDescriptorSetCache::updateInputAttachment(
         fvkmemory::resource_ptr<VulkanDescriptorSet> set,
         VulkanAttachment const& attachment) noexcept {
-    // TOOD: fill-in this region
+    // TOOD: fill this in.
 }
 
-fvkmemory::resource_ptr<VulkanDescriptorSet> VulkanDescriptorSetManager::createSet(
+fvkmemory::resource_ptr<VulkanDescriptorSet> VulkanDescriptorSetCache::createSet(
         Handle<HwDescriptorSet> handle, fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout) {
     auto const vkSet = mDescriptorPool->obtainSet(layout);
     auto const& count = layout->count;
@@ -492,12 +395,7 @@ fvkmemory::resource_ptr<VulkanDescriptorSet> VulkanDescriptorSetManager::createS
             });
 }
 
-void VulkanDescriptorSetManager::initVkLayout(
-        fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout) {
-    layout->setVkLayout(mLayoutManager->getVkLayout(layout->bitmask));
-}
-
-void VulkanDescriptorSetManager::clearHistory() {
+void VulkanDescriptorSetCache::clearHistory() {
     mStashedSets = {};
 }
 

filament/backend/src/vulkan/VulkanDescriptorSetCache.h

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#ifndef TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETMANAGER_H
-#define TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETMANAGER_H
+#ifndef TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETCACHE_H
+#define TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETCACHE_H
 
-#include "vulkan/VulkanHandles.h"
+#include "VulkanHandles.h"
 #include "vulkan/memory/ResourcePointer.h"
 #include "vulkan/utils/Definitions.h"  // For DescriptorSetMask
 
@@ -34,20 +34,16 @@
 
 namespace filament::backend {
 
-// [GDSR]: Great-Descriptor-Set-Refactor: As of 03/20/24, the Filament frontend is planning to
-// introduce descriptor set. This PR will arrive before that change is complete. As such, some of
-// the methods introduced here will be obsolete, and certain logic will be generalized.
-
-// Abstraction over the pool and the layout cache.
-class VulkanDescriptorSetManager {
+// Abstraction over the descriptor set pool.
+class VulkanDescriptorSetCache {
 public:
     static constexpr uint8_t UNIQUE_DESCRIPTOR_SET_COUNT =
             VulkanDescriptorSetLayout::UNIQUE_DESCRIPTOR_SET_COUNT;
 
     using DescriptorSetLayoutArray = VulkanDescriptorSetLayout::DescriptorSetLayoutArray;
 
-    VulkanDescriptorSetManager(VkDevice device, fvkmemory::ResourceManager* resourceManager);
-    ~VulkanDescriptorSetManager();
+    VulkanDescriptorSetCache(VkDevice device, fvkmemory::ResourceManager* resourceManager);
+    ~VulkanDescriptorSetCache();
 
     void terminate() noexcept;
 
@@ -72,12 +68,9 @@ public:
     fvkmemory::resource_ptr<VulkanDescriptorSet> createSet(Handle<HwDescriptorSet> handle,
             fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);
 
-    void initVkLayout(fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout);
-
     void clearHistory();
 
 private:
-    class DescriptorSetLayoutManager;
     class DescriptorInfinitePool;
 
     using DescriptorSetArray =
@@ -85,7 +78,6 @@ private:
 
     VkDevice mDevice;
     fvkmemory::ResourceManager* mResourceManager;
-    std::unique_ptr<DescriptorSetLayoutManager> mLayoutManager;
     std::unique_ptr<DescriptorInfinitePool> mDescriptorPool;
     std::pair<VulkanAttachment, VkDescriptorImageInfo> mInputAttachment;
     DescriptorSetArray mStashedSets = {};
@@ -99,4 +91,4 @@ private:
 
 }// namespace filament::backend
 
-#endif// TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETMANAGER_H
+#endif// TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETCACHE_H

filament/backend/src/vulkan/VulkanDescriptorSetLayoutCache.cpp

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "VulkanDescriptorSetLayoutCache.h"
+
+#include "VulkanHandles.h"
+
+namespace filament::backend {
+
+namespace {
+
+using BitmaskGroup = VulkanDescriptorSetLayout::Bitmask;
+
+template<typename Bitmask>
+uint32_t appendBindings(VkDescriptorSetLayoutBinding* toBind, VkDescriptorType type,
+        Bitmask const& mask) {
+    uint32_t count = 0;
+    Bitmask alreadySeen;
+    mask.forEachSetBit([&](size_t index) {
+        VkShaderStageFlags stages = 0;
+        uint32_t binding = 0;
+        if (index < fvkutils::getFragmentStageShift<Bitmask>()) {
+            binding = (uint32_t) index;
+            stages |= VK_SHADER_STAGE_VERTEX_BIT;
+            auto fragIndex = index + fvkutils::getFragmentStageShift<Bitmask>();
+            if (mask.test(fragIndex)) {
+                stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
+                alreadySeen.set(fragIndex);
+            }
+        } else if (!alreadySeen.test(index)) {
+            // We are in fragment stage bits
+            binding = (uint32_t) (index - fvkutils::getFragmentStageShift<Bitmask>());
+            stages |= VK_SHADER_STAGE_FRAGMENT_BIT;
+        }
+
+        if (stages) {
+            toBind[count++] = {
+                .binding = binding,
+                .descriptorType = type,
+                .descriptorCount = 1,
+                .stageFlags = stages,
+            };
+        }
+    });
+    return count;
+}
+
+} // anonymous namespace
+
+VulkanDescriptorSetLayoutCache::VulkanDescriptorSetLayoutCache(VkDevice device,
+        fvkmemory::ResourceManager* resourceManager)
+    : mDevice(device),
+      mResourceManager(resourceManager) {}
+
+VulkanDescriptorSetLayoutCache::~VulkanDescriptorSetLayoutCache() = default;
+
+void VulkanDescriptorSetLayoutCache::terminate() noexcept {
+    for (auto& itr: mVkLayouts) {
+        vkDestroyDescriptorSetLayout(mDevice, itr.second, VKALLOC);
+    }
+}
+
+fvkmemory::resource_ptr<VulkanDescriptorSetLayout> VulkanDescriptorSetLayoutCache::createLayout(
+        Handle<HwDescriptorSetLayout> handle, backend::DescriptorSetLayout&& info) {
+    auto layout = fvkmemory::resource_ptr<VulkanDescriptorSetLayout>::make(mResourceManager, handle,
+            info);
+    VkDescriptorSetLayout vklayout = VK_NULL_HANDLE;
+    auto const& bitmasks = layout->bitmask;
+    if (auto itr = mVkLayouts.find(bitmasks); itr != mVkLayouts.end()) {
+        vklayout = itr->second;
+    } else {
+        VkDescriptorSetLayoutBinding toBind[VulkanDescriptorSetLayout::MAX_BINDINGS];
+        uint32_t count = 0;
+        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+                bitmasks.dynamicUbo);
+        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, bitmasks.ubo);
+        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                bitmasks.sampler);
+        count += appendBindings(&toBind[count], VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+                bitmasks.inputAttachment);
+
+        assert_invariant(count != 0 && "Need at least one binding for descriptor set layout.");
+        VkDescriptorSetLayoutCreateInfo dlinfo = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+            .pNext = nullptr,
+            .bindingCount = count,
+            .pBindings = toBind,
+        };
+
+        vkCreateDescriptorSetLayout(mDevice, &dlinfo, VKALLOC, &vklayout);
+        mVkLayouts[bitmasks] = vklayout;
+    }
+    layout->setVkLayout(vklayout);
+    return layout;
+}
+
+} // namespace filament::backend

filament/backend/src/vulkan/VulkanDescriptorSetLayoutCache.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETLAYOUTCACHE_H
+#define TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETLAYOUTCACHE_H
+
+#include "VulkanHandles.h"
+
+#include "vulkan/memory/ResourcePointer.h"
+
+#include <backend/DriverEnums.h>
+#include <backend/Program.h>
+#include <backend/TargetBufferInfo.h>
+
+#include <utils/bitset.h>
+
+#include <bluevk/BlueVK.h>
+#include <tsl/robin_map.h>
+
+#include <memory>
+
+namespace filament::backend {
+
+class VulkanDescriptorSetLayoutCache {
+public:
+    VulkanDescriptorSetLayoutCache(VkDevice device, fvkmemory::ResourceManager* resourceManager);
+    ~VulkanDescriptorSetLayoutCache();
+
+    void terminate() noexcept;
+
+    fvkmemory::resource_ptr<VulkanDescriptorSetLayout> createLayout(
+            Handle<HwDescriptorSetLayout> handle, backend::DescriptorSetLayout&& info);
+
+private:
+    VkDevice mDevice;
+    fvkmemory::ResourceManager* mResourceManager;
+
+    using BitmaskGroup = VulkanDescriptorSetLayout::Bitmask;
+    using BitmaskGroupHashFn = utils::hash::MurmurHashFn<BitmaskGroup>;
+    struct BitmaskGroupEqual {
+        bool operator()(BitmaskGroup const& k1, BitmaskGroup const& k2) const { return k1 == k2; }
+    };
+
+    tsl::robin_map<BitmaskGroup, VkDescriptorSetLayout, BitmaskGroupHashFn, BitmaskGroupEqual>
+            mVkLayouts;
+};
+
+} // namespace filament::backend
+
+#endif// TNT_FILAMENT_BACKEND_CACHING_VULKANDESCRIPTORSETLAYOUTCACHE_H

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -17,7 +17,6 @@
 #include "VulkanDriver.h"
 
 #include "CommandStreamDispatcher.h"
-#include "DataReshaper.h"
 #include "SystraceProfile.h"
 #include "VulkanAsyncHandles.h"
 #include "VulkanBuffer.h"
@@ -35,7 +34,6 @@
 #include <backend/platforms/VulkanPlatform.h>
 
 #include <utils/CString.h>
-#include <utils/FixedCapacityVector.h>
 #include <utils/Panic.h>
 
 #ifndef NDEBUG
@@ -44,8 +42,6 @@
 
 using namespace bluevk;
 
-using utils::FixedCapacityVector;
-
 #if defined(__clang__)
 // Vulkan functions often immediately dereference pointers, so it's fine to pass in a pointer
 // to a stack-allocated variable.
@@ -219,7 +215,8 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
       mSamplerCache(mPlatform->getDevice()),
       mBlitter(mPlatform->getPhysicalDevice(), &mCommands),
       mReadPixels(mPlatform->getDevice()),
-      mDescriptorSetManager(mPlatform->getDevice(), &mResourceManager),
+      mDescriptorSetLayoutCache(mPlatform->getDevice(), &mResourceManager),
+      mDescriptorSetCache(mPlatform->getDevice(), &mResourceManager),
       mQueryManager(mPlatform->getDevice()),
       mIsSRGBSwapChainSupported(mPlatform->getCustomization().isSRGBSwapChainSupported),
       mStereoscopicType(driverConfig.stereoscopicType) {
@@ -329,7 +326,8 @@ void VulkanDriver::terminate() {
     mPipelineCache.terminate();
     mFramebufferCache.reset();
     mSamplerCache.terminate();
-    mDescriptorSetManager.terminate();
+    mDescriptorSetLayoutCache.terminate();
+    mDescriptorSetCache.terminate();
     mPipelineLayoutCache.terminate();
 
     // Before terminating ResourceManager, we must make sure all of the resource_ptrs have been unset.
@@ -365,7 +363,7 @@ void VulkanDriver::collectGarbage() {
     FVK_SYSTRACE_SCOPE();
     // Command buffers need to be submitted and completed before other resources can be gc'd.
     mCommands.gc();
-    mDescriptorSetManager.clearHistory();
+    mDescriptorSetCache.clearHistory();
     mStagePool.gc();
     mFramebufferCache.gc();
     mPipelineCache.gc();
@@ -408,7 +406,7 @@ void VulkanDriver::updateDescriptorSetBuffer(
     FVK_SYSTRACE_SCOPE();
     auto set = resource_ptr<VulkanDescriptorSet>::cast(&mResourceManager, dsh);
     auto buffer = resource_ptr<VulkanBufferObject>::cast(&mResourceManager, boh);
-    mDescriptorSetManager.updateBuffer(set, binding, buffer, offset, size);
+    mDescriptorSetCache.updateBuffer(set, binding, buffer, offset, size);
 }
 
 void VulkanDriver::updateDescriptorSetTexture(
@@ -421,7 +419,7 @@ void VulkanDriver::updateDescriptorSetTexture(
     auto texture = resource_ptr<VulkanTexture>::cast(&mResourceManager, th);
 
     VkSampler const vksampler = mSamplerCache.getSampler(params);
-    mDescriptorSetManager.updateSampler(set, binding, texture, vksampler);
+    mDescriptorSetCache.updateSampler(set, binding, texture, vksampler);
 }
 
 void VulkanDriver::flush(int) {
@@ -554,26 +552,43 @@ void VulkanDriver::createTextureViewSwizzleR(Handle<HwTexture> th, Handle<HwText
    texture.inc();
 }
 
-void VulkanDriver::createTextureExternalImage2R(Handle<HwTexture> th,
-        backend::SamplerType target,  backend::TextureFormat format,
-        uint32_t width, uint32_t height, backend::TextureUsage usage,
+void VulkanDriver::createTextureExternalImage2R(Handle<HwTexture> th, backend::SamplerType target,
+        backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
         Platform::ExternalImageHandleRef externalImage) {
     FVK_SYSTRACE_SCOPE();
-
     const auto& metadata = mPlatform->getExternalImageMetadata(externalImage);
     if (metadata.isProtected) {
         usage |= backend::TextureUsage::PROTECTED;
     }
 
+    VkImageUsageFlags vkUsage = metadata.usage;
+    if (any(usage & TextureUsage::BLIT_SRC)) {
+        vkUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    }
+
+    if (any(usage & (TextureUsage::BLIT_DST & TextureUsage::UPLOADABLE))) {
+        vkUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    }
+
     assert_invariant(width == metadata.width);
     assert_invariant(height == metadata.height);
     assert_invariant(fvkutils::getVkFormat(format) == metadata.format);
 
-    const auto& data = mPlatform->createExternalImageData(externalImage, metadata);
+    VkMemoryPropertyFlags const requiredMemoryFlags = any(usage & TextureUsage::UPLOADABLE)
+                                                              ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
+                                                              : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+    uint32_t const memoryTypeIndex =
+            mContext.selectMemoryType(metadata.memoryTypeBits, requiredMemoryFlags);
+    FILAMENT_CHECK_POSTCONDITION(memoryTypeIndex != VK_MAX_MEMORY_TYPES)
+            << "failed to find a valid memory type for external image memory.";
 
-    auto texture = resource_ptr<VulkanTexture>::make(&mResourceManager, th,
-            mPlatform->getDevice(), mAllocator, &mResourceManager, &mCommands, data.first, data.second, metadata.format,
-            1, metadata.width, metadata.height, /*depth=*/1, usage, mStagePool);
+    const auto& data =
+            mPlatform->createExternalImageData(externalImage, metadata, memoryTypeIndex, vkUsage);
+
+    auto texture = resource_ptr<VulkanTexture>::make(&mResourceManager, th, mPlatform->getDevice(),
+            mAllocator, &mResourceManager, &mCommands, data.first, data.second, metadata.format,
+            metadata.samples, metadata.width, metadata.height, metadata.layerCount, usage,
+            mStagePool);
 
     texture.inc();
 }
@@ -761,8 +776,7 @@ void VulkanDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {
 
 void VulkanDriver::createDescriptorSetLayoutR(Handle<HwDescriptorSetLayout> dslh,
         backend::DescriptorSetLayout&& info) {
-    auto layout = resource_ptr<VulkanDescriptorSetLayout>::make(&mResourceManager, dslh, info);
-    mDescriptorSetManager.initVkLayout(layout);
+    auto layout = mDescriptorSetLayoutCache.createLayout(dslh, std::move(info));
     layout.inc();
 }
 
@@ -771,7 +785,7 @@ void VulkanDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
     FVK_SYSTRACE_SCOPE();
     fvkmemory::resource_ptr<VulkanDescriptorSetLayout> layout =
             fvkmemory::resource_ptr<VulkanDescriptorSetLayout>::cast(&mResourceManager, dslh);
-    auto set = mDescriptorSetManager.createSet(dsh, layout);
+    auto set = mDescriptorSetCache.createSet(dsh, layout);
     set.inc();
 }
 
@@ -1043,7 +1057,7 @@ bool VulkanDriver::isDepthStencilBlitSupported(TextureFormat format) {
            formats.end();
 }
 
-bool VulkanDriver::isProtectedTexturesSupported() { return false; }
+bool VulkanDriver::isProtectedTexturesSupported() { return isProtectedContentSupported(); }
 
 bool VulkanDriver::isDepthClampSupported() {
     return mContext.isDepthClampSupported();
@@ -1130,6 +1144,16 @@ size_t VulkanDriver::getMaxUniformBufferSize() {
     return 32768;
 }
 
+size_t VulkanDriver::getMaxTextureSize(SamplerType) {
+    // TODO: return the actual size instead of hardcoded value
+    return 4096;
+}
+
+size_t VulkanDriver::getMaxArrayTextureLayers() {
+    // TODO: return the actual size instead of hardcoded value
+    return 256;
+}
+
 void VulkanDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh, uint32_t index,
         Handle<HwBufferObject> boh) {
     auto vb = resource_ptr<VulkanVertexBuffer>::cast(&mResourceManager, vbh);
@@ -1466,7 +1490,7 @@ void VulkanDriver::nextSubpass(int) {
 
     if (mCurrentRenderPass.params.subpassMask & 0x1) {
         VulkanAttachment& subpassInput = renderTarget->getColor0();
-        mDescriptorSetManager.updateInputAttachment({}, subpassInput);
+        mDescriptorSetCache.updateInputAttachment({}, subpassInput);
     }
 }
 
@@ -1793,9 +1817,9 @@ void VulkanDriver::bindDescriptorSet(
         backend::DescriptorSetOffsetArray&& offsets) {
     if (dsh) {
         auto set = resource_ptr<VulkanDescriptorSet>::cast(&mResourceManager, dsh);
-        mDescriptorSetManager.bind(setIndex, set, std::move(offsets));
+        mDescriptorSetCache.bind(setIndex, set, std::move(offsets));
     } else {
-        mDescriptorSetManager.unbind(setIndex);
+        mDescriptorSetCache.unbind(setIndex);
     }
 }
 
@@ -1803,7 +1827,7 @@ void VulkanDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
     FVK_SYSTRACE_SCOPE();
     VkCommandBuffer cmdbuffer = mCurrentRenderPass.commandBuffer->buffer();
 
-    mDescriptorSetManager.commit(mCurrentRenderPass.commandBuffer,
+    mDescriptorSetCache.commit(mCurrentRenderPass.commandBuffer,
             mBoundPipeline.pipelineLayout,
             mBoundPipeline.descriptorSetMask);
 

filament/backend/src/vulkan/VulkanDriver.h

@@ -27,8 +27,9 @@
 #include "VulkanSamplerCache.h"
 #include "VulkanStagePool.h"
 #include "VulkanQueryManager.h"
-#include "vulkan/caching/VulkanDescriptorSetManager.h"
-#include "vulkan/caching/VulkanPipelineLayoutCache.h"
+#include "vulkan/VulkanDescriptorSetCache.h"
+#include "vulkan/VulkanDescriptorSetLayoutCache.h"
+#include "vulkan/VulkanPipelineLayoutCache.h"
 #include "vulkan/memory/ResourceManager.h"
 #include "vulkan/memory/ResourcePointer.h"
 #include "vulkan/utils/Definitions.h"
@@ -137,7 +138,8 @@ private:
     VulkanSamplerCache mSamplerCache;
     VulkanBlitter mBlitter;
     VulkanReadPixels mReadPixels;
-    VulkanDescriptorSetManager mDescriptorSetManager;
+    VulkanDescriptorSetLayoutCache mDescriptorSetLayoutCache;
+    VulkanDescriptorSetCache mDescriptorSetCache;
     VulkanQueryManager mQueryManager;
 
     // This is necessary for us to write to push constants after binding a pipeline.

filament/backend/src/vulkan/VulkanPipelineCache.cpp

@@ -15,15 +15,12 @@
  */
 
 #include "VulkanPipelineCache.h"
-#include "VulkanMemory.h"
-#include "caching/VulkanDescriptorSetManager.h"
 
 #include <utils/Log.h>
 #include <utils/Panic.h>
 
 #include "VulkanConstants.h"
 #include "VulkanHandles.h"
-#include "VulkanTexture.h"
 #include "vulkan/utils/Conversion.h"
 
 #if defined(__clang__)

filament/backend/src/vulkan/VulkanPipelineLayoutCache.h

@@ -17,7 +17,8 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANPIPELINELAYOUTCACHE_H
 #define TNT_FILAMENT_BACKEND_VULKANPIPELINELAYOUTCACHE_H
 
-#include <vulkan/VulkanHandles.h>
+#include "VulkanHandles.h"
+
 #include <bluevk/BlueVK.h>
 
 #include <utils/Hash.h>

filament/backend/src/vulkan/VulkanSamplerCache.cpp

@@ -23,79 +23,6 @@ using namespace bluevk;
 
 namespace filament::backend {
 
-constexpr inline VkSamplerAddressMode getWrapMode(SamplerWrapMode mode) noexcept {
-    switch (mode) {
-        case SamplerWrapMode::REPEAT:
-            return VK_SAMPLER_ADDRESS_MODE_REPEAT;
-        case SamplerWrapMode::CLAMP_TO_EDGE:
-            return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-        case SamplerWrapMode::MIRRORED_REPEAT:
-            return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
-    }
-}
-
-constexpr inline VkFilter getFilter(SamplerMinFilter filter) noexcept {
-    switch (filter) {
-        case SamplerMinFilter::NEAREST:
-            return VK_FILTER_NEAREST;
-        case SamplerMinFilter::LINEAR:
-            return VK_FILTER_LINEAR;
-        case SamplerMinFilter::NEAREST_MIPMAP_NEAREST:
-            return VK_FILTER_NEAREST;
-        case SamplerMinFilter::LINEAR_MIPMAP_NEAREST:
-            return VK_FILTER_LINEAR;
-        case SamplerMinFilter::NEAREST_MIPMAP_LINEAR:
-            return VK_FILTER_NEAREST;
-        case SamplerMinFilter::LINEAR_MIPMAP_LINEAR:
-            return VK_FILTER_LINEAR;
-    }
-}
-
-constexpr inline VkFilter getFilter(SamplerMagFilter filter) noexcept {
-    switch (filter) {
-        case SamplerMagFilter::NEAREST:
-            return VK_FILTER_NEAREST;
-        case SamplerMagFilter::LINEAR:
-            return VK_FILTER_LINEAR;
-    }
-}
-
-constexpr inline VkSamplerMipmapMode getMipmapMode(SamplerMinFilter filter) noexcept {
-    switch (filter) {
-        case SamplerMinFilter::NEAREST:
-            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
-        case SamplerMinFilter::LINEAR:
-            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
-        case SamplerMinFilter::NEAREST_MIPMAP_NEAREST:
-            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
-        case SamplerMinFilter::LINEAR_MIPMAP_NEAREST:
-            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
-        case SamplerMinFilter::NEAREST_MIPMAP_LINEAR:
-            return VK_SAMPLER_MIPMAP_MODE_LINEAR;
-        case SamplerMinFilter::LINEAR_MIPMAP_LINEAR:
-            return VK_SAMPLER_MIPMAP_MODE_LINEAR;
-    }
-}
-
-constexpr inline float getMaxLod(SamplerMinFilter filter) noexcept {
-    switch (filter) {
-        case SamplerMinFilter::NEAREST:
-        case SamplerMinFilter::LINEAR:
-            // The Vulkan spec recommends a max LOD of 0.25 to "disable" mipmapping.
-            // See "Mapping of OpenGL to Vulkan filter modes" in the VK Spec.
-            return 0.25f;
-        case SamplerMinFilter::NEAREST_MIPMAP_NEAREST:
-        case SamplerMinFilter::LINEAR_MIPMAP_NEAREST:
-        case SamplerMinFilter::NEAREST_MIPMAP_LINEAR:
-        case SamplerMinFilter::LINEAR_MIPMAP_LINEAR:
-            return VK_LOD_CLAMP_NONE;
-    }
-}
-
-constexpr inline VkBool32 getCompareEnable(SamplerCompareMode mode) noexcept {
-    return mode == SamplerCompareMode::NONE ? VK_FALSE : VK_TRUE;
-}
-
 VulkanSamplerCache::VulkanSamplerCache(VkDevice device)
     : mDevice(device) {}
 
@@ -106,18 +33,18 @@ VkSampler VulkanSamplerCache::getSampler(SamplerParams params) noexcept {
     }
     VkSamplerCreateInfo samplerInfo {
         .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-        .magFilter = getFilter(params.filterMag),
-        .minFilter = getFilter(params.filterMin),
-        .mipmapMode = getMipmapMode(params.filterMin),
-        .addressModeU = getWrapMode(params.wrapS),
-        .addressModeV = getWrapMode(params.wrapT),
-        .addressModeW = getWrapMode(params.wrapR),
-        .anisotropyEnable = params.anisotropyLog2 == 0 ? 0u : 1u,
+        .magFilter = fvkutils::getFilter(params.filterMag),
+        .minFilter = fvkutils::getFilter(params.filterMin),
+        .mipmapMode = fvkutils::getMipmapMode(params.filterMin),
+        .addressModeU = fvkutils::getWrapMode(params.wrapS),
+        .addressModeV = fvkutils::getWrapMode(params.wrapT),
+        .addressModeW = fvkutils::getWrapMode(params.wrapR),
+        .anisotropyEnable = params.anisotropyLog2 == 0 ? VK_FALSE : VK_TRUE,
         .maxAnisotropy = (float)(1u << params.anisotropyLog2),
-        .compareEnable = getCompareEnable(params.compareMode),
+        .compareEnable = fvkutils::getCompareEnable(params.compareMode),
         .compareOp = fvkutils::getCompareOp(params.compareFunc),
         .minLod = 0.0f,
-        .maxLod = getMaxLod(params.filterMin),
+        .maxLod = fvkutils::getMaxLod(params.filterMin),
         .borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
         .unnormalizedCoordinates = VK_FALSE
     };

filament/backend/src/vulkan/VulkanTexture.cpp

@@ -55,63 +55,61 @@ VkComponentMapping composeSwizzle(VkComponentMapping const& prev, VkComponentMap
         VK_COMPONENT_SWIZZLE_A,
     };
 
-    auto const compose = [](VkComponentSwizzle out, VkComponentMapping const& prev,
-                                 uint8_t channelIndex) {
-        // We need to first change all identities to its equivalent channel.
-        if (out == VK_COMPONENT_SWIZZLE_IDENTITY) {
-            out = IDENTITY[channelIndex];
+    auto const compose = [](VkComponentMapping const& prev,
+                                 VkComponentMapping const& next) -> VkComponentMapping {
+        VkComponentSwizzle vals[4] = { next.r, next.g, next.b, next.a };
+        for (auto& out: vals) {
+            switch (out) {
+                case VK_COMPONENT_SWIZZLE_R:
+                    out = prev.r;
+                    break;
+                case VK_COMPONENT_SWIZZLE_G:
+                    out = prev.g;
+                    break;
+                case VK_COMPONENT_SWIZZLE_B:
+                    out = prev.b;
+                    break;
+                case VK_COMPONENT_SWIZZLE_A:
+                    out = prev.a;
+                    break;
+                // Do not modify the value
+                case VK_COMPONENT_SWIZZLE_IDENTITY:
+                case VK_COMPONENT_SWIZZLE_ZERO:
+                case VK_COMPONENT_SWIZZLE_ONE:
+                // Below is not exposed in Vulkan's API, but needs to be there for compilation.
+                case VK_COMPONENT_SWIZZLE_MAX_ENUM:
+                    break;
+            }
         }
-        switch (out) {
-            case VK_COMPONENT_SWIZZLE_R:
-                out = prev.r;
-                break;
-            case VK_COMPONENT_SWIZZLE_G:
-                out = prev.g;
-                break;
-            case VK_COMPONENT_SWIZZLE_B:
-                out = prev.b;
-                break;
-            case VK_COMPONENT_SWIZZLE_A:
-                out = prev.a;
-                break;
-            case VK_COMPONENT_SWIZZLE_IDENTITY:
-            case VK_COMPONENT_SWIZZLE_ZERO:
-            case VK_COMPONENT_SWIZZLE_ONE:
-                return out;
-            // Below is not exposed in Vulkan's API, but needs to be there for compilation.
-            case VK_COMPONENT_SWIZZLE_MAX_ENUM:
-                break;
-        }
-        // If the result correctly corresponds to the identity, just return identity.
-        if (IDENTITY[channelIndex] == out) {
-            return VK_COMPONENT_SWIZZLE_IDENTITY;
-        }
-        return out;
+        return { vals[0], vals[1], vals[2], vals[3] };
     };
 
-    auto const identityToChannel = [](VkComponentSwizzle val, uint8_t channelIndex) {
-        if (val != VK_COMPONENT_SWIZZLE_IDENTITY) {
-            return val;
+    auto const identityToChannel = [](VkComponentMapping const& mapping) -> VkComponentMapping {
+        VkComponentSwizzle vals[4] = { mapping.r, mapping.g, mapping.b, mapping.a };
+        for (uint8_t i = 0; i < 4; i++) {
+            if (vals[i] != VK_COMPONENT_SWIZZLE_IDENTITY) {
+                continue;
+            }
+            vals[i] = IDENTITY[i];
         }
-        return IDENTITY[channelIndex];
+        return { vals[0], vals[1], vals[2], vals[3] };
+    };
+    auto const channelToIdentity = [](VkComponentMapping const& mapping) -> VkComponentMapping {
+        VkComponentSwizzle vals[4] = { mapping.r, mapping.g, mapping.b, mapping.a };
+        for (uint8_t i = 0; i < 4; i++) {
+            if (IDENTITY[i] != vals[i]) {
+                continue;
+            }
+            vals[i] = VK_COMPONENT_SWIZZLE_IDENTITY;
+        }
+        return { vals[0], vals[1], vals[2], vals[3] };
     };
 
     // We make sure all all identities are mapped into respective channels so that actual channel
     // mapping will be passed onto the output.
-    VkComponentMapping const prevExplicit = {
-            identityToChannel(prev.r, 0),
-            identityToChannel(prev.g, 1),
-            identityToChannel(prev.b, 2),
-            identityToChannel(prev.a, 3),
-    };
-
-    // Note that the channel index corresponds to the VkComponentMapping struct layout.
-    return {
-        compose(next.r, prevExplicit, 0),
-        compose(next.g, prevExplicit, 1),
-        compose(next.b, prevExplicit, 2),
-        compose(next.a, prevExplicit, 3),
-    };
+    VkComponentMapping const prevExplicit = identityToChannel(prev);
+    VkComponentMapping const nextExplicit = identityToChannel(next);
+    return channelToIdentity(compose(prevExplicit, nextExplicit));
 }
 
 inline VulkanLayout getDefaultLayoutImpl(TextureUsage usage) {
@@ -153,7 +151,6 @@ uint8_t getLayerCountFromDepth(uint32_t const depth) {
     return getLayerCount(getSamplerTypeFromDepth(depth), depth);
 }
 
-
 } // anonymous namespace
 
 VulkanTextureState::VulkanTextureState(VkDevice device, VmaAllocator allocator,
@@ -249,12 +246,19 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
 
     // Determine if we can use the transient usage flag combined with lazily allocated memory.
     const bool useTransientAttachment =
-        // Lazily allocated memory is available.
-        context.isLazilyAllocatedMemorySupported() &&
-        // Usage consists of attachment flags only.
-        none(tusage & ~TextureUsage::ALL_ATTACHMENTS) &&
-        // Usage contains at least one attachment flag.
-        any(tusage & TextureUsage::ALL_ATTACHMENTS);
+            // Lazily allocated memory is available.
+            context.isLazilyAllocatedMemorySupported() &&
+            // Usage consists of attachment flags only.
+            none(tusage & ~TextureUsage::ALL_ATTACHMENTS) &&
+            // Usage contains at least one attachment flag.
+            any(tusage & TextureUsage::ALL_ATTACHMENTS) &&
+            // Depth resolve cannot use transient attachment because it uses a custom shader.
+            // TODO: see VulkanDriver::isDepthStencilResolveSupported() to know when to remove this
+            // restriction.
+            // Note that the custom shader does not resolve stencil. We do need to move to vk 1.2
+            // and above to be able to support stencil resolve (along with depth).
+            !(any(usage & TextureUsage::DEPTH_ATTACHMENT) && samples > 1);
+
     mState->mIsTransientAttachment = useTransientAttachment;
 
     const VkImageUsageFlags transientFlag =

filament/backend/src/vulkan/platform/VulkanPlatform.cpp

@@ -736,10 +736,6 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
     chainStruct(&context.mPhysicalDeviceFeatures, &queryProtectedMemoryFeatures);
     chainStruct(&context.mPhysicalDeviceProperties, &protectedMemoryProperties);
 
-    // We know we need to allocate the protected version of the VK objects
-    context.mProtectedMemorySupported =
-            static_cast<bool>(queryProtectedMemoryFeatures.protectedMemory);
-
     // Initialize the following fields: physicalDeviceProperties, memoryProperties,
     // physicalDeviceFeatures, graphicsQueueFamilyIndex.
     vkGetPhysicalDeviceProperties2(mImpl->mPhysicalDevice, &context.mPhysicalDeviceProperties);
@@ -759,6 +755,10 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
         mImpl->mGraphicsQueueIndex = 0;
     }
 
+    // We know we need to allocate the protected version of the VK objects
+    context.mProtectedMemorySupported =
+            static_cast<bool>(queryProtectedMemoryFeatures.protectedMemory);
+
     if (context.mProtectedMemorySupported) {
         mImpl->mProtectedGraphicsQueueFamilyIndex = identifyGraphicsQueueFamilyIndex(
                 mImpl->mPhysicalDevice, (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_PROTECTED_BIT));
@@ -983,10 +983,32 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadata(
 }
 
 VulkanPlatform::ImageData VulkanPlatform::createExternalImageData(
-        ExternalImageHandleRef externalImage, const ExternalImageMetadata& metadata) {
-    return createExternalImageDataImpl(externalImage, mImpl->mDevice, metadata);
+        ExternalImageHandleRef externalImage, const ExternalImageMetadata& metadata,
+        uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+    return createExternalImageDataImpl(externalImage, mImpl->mDevice, metadata, memoryTypeIndex,
+            usage);
 }
 
+VkSampler VulkanPlatform::createExternalSampler(SamplerYcbcrConversion chroma,
+        SamplerParams sampler, uint32_t internalFormat) {
+    return createExternalSamplerImpl(mImpl->mDevice, chroma, sampler, internalFormat);
+}
+
+VkImageView VulkanPlatform::createExternalImageView(SamplerYcbcrConversion chroma,
+        uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
+        VkImageViewType viewType, VkComponentMapping swizzle) {
+    return createExternalImageViewImpl(mImpl->mDevice, chroma, internalFormat, image, range,
+            viewType, swizzle);
+}
+
+ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() const {
+    return getSwapchainInstanceExtensionsImpl();
+}
+
+VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWindow,
+        VkInstance instance, uint64_t flags) const noexcept {
+    return createVkSurfaceKHRImpl(nativeWindow, instance, flags);
+}
 #undef SWAPCHAIN_RET_FUNC
 
 }// namespace filament::backend

filament/backend/src/vulkan/platform/VulkanPlatformAndroid.cpp

@@ -13,15 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <backend/platforms/VulkanPlatform.h>
+#include <backend/platforms/VulkanPlatformAndroid.h>
 
 #include <backend/DriverEnums.h>
-#include <backend/platforms/VulkanPlatformAndroid.h>
 #include <private/backend/BackendUtilsAndroid.h>
 
 #include "vulkan/VulkanConstants.h"
 
 #include <utils/Panic.h>
+#include "vulkan/utils/Image.h"
+#include "vulkan/utils/Conversion.h"
 
 #include <bluevk/BlueVK.h>
 
@@ -136,7 +137,8 @@ std::pair<VkFormat, VkImageUsageFlags> getVKFormatAndUsage(const AHardwareBuffer
 }
 
 VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevice device,
-        VulkanPlatform::ExternalImageMetadata const& metadata) {
+        VulkanPlatform::ExternalImageMetadata const& metadata, uint32_t memoryTypeIndex,
+        VkImageUsageFlags usage) {
     VulkanPlatform::ImageData data;
 
     // if external format we need to specifiy it in the allocation
@@ -145,8 +147,8 @@ VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevic
     const VkExternalFormatANDROID externalFormat = {
         .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
         .pNext = nullptr,
-        .externalFormat = metadata
-                .externalFormat,// pass down the format (external means we don't have it VK defined)
+        // pass down the format (external means we don't have it VK defined)
+        .externalFormat = metadata.externalFormat,
     };
     const VkExternalMemoryImageCreateInfo externalCreateInfo = {
         .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
@@ -154,7 +156,7 @@ VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevic
         .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
     };
 
-    VkImageCreateInfo imageInfo{.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
+    VkImageCreateInfo imageInfo{ .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
     imageInfo.pNext = &externalCreateInfo;
     imageInfo.format = metadata.format;
     imageInfo.imageType = VK_IMAGE_TYPE_2D;
@@ -165,10 +167,8 @@ VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevic
     };
     imageInfo.mipLevels = 1;
     imageInfo.arrayLayers = metadata.layers;
-    imageInfo.usage = metadata.usage;
-    // In the unprotected case add R/W capabilities
-    if (metadata.isProtected == false)
-        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    imageInfo.samples = metadata.samples;
+    imageInfo.usage = usage;
 
     VkResult result = vkCreateImage(device, &imageInfo, VKALLOC, &data.first);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
@@ -186,10 +186,12 @@ VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevic
         .image = data.first,
         .buffer = VK_NULL_HANDLE,
     };
-    VkMemoryAllocateInfo allocInfo = {.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+    VkMemoryAllocateInfo allocInfo = {
+        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
         .pNext = &memoryDedicatedAllocateInfo,
         .allocationSize = metadata.allocationSize,
-        .memoryTypeIndex = metadata.memoryTypeBits};
+        .memoryTypeIndex = memoryTypeIndex,
+    };
     result = vkAllocateMemory(device, &allocInfo, VKALLOC, &data.second);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
             << "vkAllocateMemory failed with error=" << static_cast<int32_t>(result);
@@ -197,14 +199,12 @@ VulkanPlatform::ImageData allocateExternalImage(AHardwareBuffer* buffer, VkDevic
     return data;
 }
 
-} // namespace
+}// namespace
 
-namespace fvkandroid {
+VulkanPlatformAndroid::ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid() = default;
 
-ExternalImageVulkanAndroid::~ExternalImageVulkanAndroid() = default;
-
-Platform::ExternalImageHandle createExternalImage(AHardwareBuffer const* buffer,
-        bool sRGB) noexcept {
+Platform::ExternalImageHandle VulkanPlatformAndroid::createExternalImage(
+        AHardwareBuffer const* buffer, bool sRGB) noexcept {
     if (__builtin_available(android 26, *)) {
         AHardwareBuffer_Desc hardwareBufferDescription = {};
         AHardwareBuffer_describe(buffer, &hardwareBufferDescription);
@@ -223,12 +223,23 @@ Platform::ExternalImageHandle createExternalImage(AHardwareBuffer const* buffer,
     return Platform::ExternalImageHandle{};
 }
 
-} // namespace fvkandroid
-
-VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataImpl(
-        ExternalImageHandleRef externalImage, VkDevice device) {
+VulkanPlatformAndroid::ExternalImageDescAndroid VulkanPlatformAndroid::getExternalImageDesc(
+        ExternalImageHandleRef externalImage) const noexcept {
     auto const* fvkExternalImage =
-            static_cast<fvkandroid::ExternalImageVulkanAndroid const*>(externalImage.get());
+            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
+
+    return {
+        .width = fvkExternalImage->width,
+        .height = fvkExternalImage->height,
+        .format = fvkExternalImage->format,
+        .usage = fvkExternalImage->usage,
+    };
+}
+
+VulkanPlatform::ExternalImageMetadata VulkanPlatformAndroid::getExternalImageMetadata(
+        ExternalImageHandleRef externalImage) {
+    auto const* fvkExternalImage =
+            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
 
     ExternalImageMetadata metadata;
     AHardwareBuffer* buffer = fvkExternalImage->aHardwareBuffer;
@@ -242,10 +253,8 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataIm
         std::tie(metadata.format, metadata.usage) =
                 getVKFormatAndUsage(bufferDesc, fvkExternalImage->sRGB);
     }
-    // In the unprotected case add R/W capabilities
-    if (metadata.isProtected == false) {
-        metadata.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-    }
+
+    metadata.samples = VK_SAMPLE_COUNT_1_BIT;
 
     VkAndroidHardwareBufferFormatPropertiesANDROID formatInfo = {
         .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
@@ -255,11 +264,11 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataIm
         .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
         .pNext = &formatInfo,
     };
-    VkResult result = vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, &properties);
+    VkResult result = vkGetAndroidHardwareBufferPropertiesANDROID(getDevice(), buffer, &properties);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-        << "vkGetAndroidHardwareBufferProperties failed with error="
-        << static_cast<int32_t>(result);
-                            
+            << "vkGetAndroidHardwareBufferProperties failed with error="
+            << static_cast<int32_t>(result);
+
     VkFormat bufferPropertiesFormat = transformVkFormat(formatInfo.format, fvkExternalImage->sRGB);
     FILAMENT_CHECK_POSTCONDITION(metadata.format == bufferPropertiesFormat)
             << "mismatched image format( " << metadata.format << ") and queried format("
@@ -270,26 +279,140 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataIm
     return metadata;
 }
 
-VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
-        ExternalImageHandleRef externalImage, VkDevice device,
-        const ExternalImageMetadata& metadata) {
+VulkanPlatformAndroid::ImageData VulkanPlatformAndroid::createExternalImageData(
+        ExternalImageHandleRef externalImage, const ExternalImageMetadata& metadata,
+        uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
     auto const* fvkExternalImage =
-            static_cast<fvkandroid::ExternalImageVulkanAndroid const*>(externalImage.get());
-    ImageData data = allocateExternalImage(fvkExternalImage->aHardwareBuffer, device, metadata);
-    VkResult result = vkBindImageMemory(device, data.first, data.second, 0);
+            static_cast<ExternalImageVulkanAndroid const*>(externalImage.get());
+    ImageData data = allocateExternalImage(fvkExternalImage->aHardwareBuffer, getDevice(), metadata,
+            memoryTypeIndex, usage);
+    VkResult result = vkBindImageMemory(getDevice(), data.first, data.second, 0);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-            << "vkBindImageMemory error=" << static_cast<int32_t>(result);
+        << "vkBindImageMemory error=" << static_cast<int32_t>(result);
     return data;
 }
 
-VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
+VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device, SamplerYcbcrConversion chroma,
+            uint32_t internalFormat, VkImage image, VkImageSubresourceRange range,
+            VkImageViewType viewType, VkComponentMapping swizzle){
+        VkExternalFormatANDROID externalFormat = {
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
+        .pNext = nullptr,
+        .externalFormat = internalFormat,
+    };
+
+    TextureSwizzle const swizzleArray[] = {chroma.r, chroma.g, chroma.b, chroma.a};
+    VkSamplerYcbcrConversionCreateInfo conversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+        .pNext = &externalFormat,
+        .format = VK_FORMAT_UNDEFINED,
+        .ycbcrModel = fvkutils::getYcbcrModelConversion(chroma.ycbcrModel),
+        .ycbcrRange = fvkutils::getYcbcrRange(chroma.ycbcrRange),
+        .components = fvkutils::getSwizzleMap(swizzleArray),
+        .xChromaOffset = fvkutils::getChromaLocation(chroma.xChromaOffset),
+        .yChromaOffset = fvkutils::getChromaLocation(chroma.yChromaOffset),
+        .chromaFilter = fvkutils::getFilter(chroma.chromaFilter),
+    };
+    VkSamplerYcbcrConversion conversion = VK_NULL_HANDLE;
+    VkResult result = vkCreateSamplerYcbcrConversion(device, &conversionInfo,
+                                                     nullptr, &conversion);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+        << "Unable to create Ycbcr Conversion."
+        << " error=" << static_cast<int32_t>(result);
+
+    VkSamplerYcbcrConversionInfo samplerYcbcrConversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+        .pNext = nullptr,
+        .conversion = conversion,
+    };
+
+    VkImageViewCreateInfo viewInfo = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+        .pNext = &samplerYcbcrConversionInfo,
+        .flags = 0,
+        .image = image,
+        .viewType = viewType,
+        .format = VK_FORMAT_UNDEFINED,
+        .components = swizzle,
+        .subresourceRange = range,
+    };
+    VkImageView imageView;
+    result = vkCreateImageView(device, &viewInfo, VKALLOC, &imageView);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+        << "Unable to create VkImageView."
+        << " error=" << static_cast<int32_t>(result);
+
+    return imageView;
+}
+
+VkSampler VulkanPlatform::createExternalSamplerImpl(
+        VkDevice device, SamplerYcbcrConversion chroma, SamplerParams params,
+        uint32_t internalFormat) {
+    VkExternalFormatANDROID externalFormat = {
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
+        .pNext = nullptr,
+        .externalFormat = internalFormat,
+    };
+
+    TextureSwizzle const swizzleArray[] = {chroma.r, chroma.g, chroma.b, chroma.a};
+    VkSamplerYcbcrConversionCreateInfo conversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+        .pNext = &externalFormat,
+        .format = VK_FORMAT_UNDEFINED,
+        .ycbcrModel = fvkutils::getYcbcrModelConversion(chroma.ycbcrModel),
+        .ycbcrRange = fvkutils::getYcbcrRange(chroma.ycbcrRange),
+        .components = fvkutils::getSwizzleMap(swizzleArray),
+        .xChromaOffset = fvkutils::getChromaLocation(chroma.xChromaOffset),
+        .yChromaOffset = fvkutils::getChromaLocation(chroma.yChromaOffset),
+        .chromaFilter = fvkutils::getFilter(chroma.chromaFilter),
+    };
+    VkSamplerYcbcrConversion conversion = VK_NULL_HANDLE;
+    VkResult result = vkCreateSamplerYcbcrConversion(device, &conversionInfo,
+                                                     nullptr, &conversion);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+        << "Unable to create Ycbcr Conversion."
+        << " error=" << static_cast<int32_t>(result);
+
+    VkSamplerYcbcrConversionInfo samplerYcbcrConversionInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+        .pNext = nullptr,
+        .conversion = conversion,
+    };
+
+    VkSamplerCreateInfo samplerInfo = {
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+        .pNext = &samplerYcbcrConversionInfo,
+        .magFilter = fvkutils::getFilter(params.filterMag),
+        .minFilter = fvkutils::getFilter(params.filterMin),
+        .mipmapMode = fvkutils::getMipmapMode(params.filterMin),
+        .addressModeU = fvkutils::getWrapMode(params.wrapS),
+        .addressModeV = fvkutils::getWrapMode(params.wrapT),
+        .addressModeW = fvkutils::getWrapMode(params.wrapR),
+        .anisotropyEnable = params.anisotropyLog2 == 0 ? VK_FALSE : VK_TRUE,
+        .maxAnisotropy = (float)(1u << params.anisotropyLog2),
+        .compareEnable = fvkutils::getCompareEnable(params.compareMode),
+        .compareOp = fvkutils::getCompareOp(params.compareFunc),
+        .minLod = 0.0f,
+        .maxLod = fvkutils::getMaxLod(params.filterMin),
+        .borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
+        .unnormalizedCoordinates = VK_FALSE,
+    };
+    VkSampler sampler;
+    result = vkCreateSampler(device, &samplerInfo, VKALLOC, &sampler);
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
+        << "Unable to create sampler."
+        << " error=" << static_cast<int32_t>(result);
+    return sampler;
+}
+
+VulkanPlatform::ExtensionSet VulkanPlatformAndroid::getSwapchainInstanceExtensions() const {
     return {
         VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
     };
 }
 
-VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWindow,
-    VkInstance instance, uint64_t flags) noexcept {
+VulkanPlatform::SurfaceBundle VulkanPlatformAndroid::createVkSurfaceKHR(void* nativeWindow,
+        VkInstance instance, uint64_t flags) const noexcept {
     VkSurfaceKHR surface;
     VkExtent2D extent;
 
@@ -301,6 +424,26 @@ VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWin
             vkCreateAndroidSurfaceKHR(instance, &createInfo, VKALLOC, (VkSurfaceKHR*) &surface);
     FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
             << "vkCreateAndroidSurfaceKHR with error=" << static_cast<int32_t>(result);
-    return {surface, extent};
+    return { surface, extent };
 }
+
+// Deprecated platform dependent helper methods
+VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() { return {}; }
+
+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device) {
+    return ExternalImageMetadata{};
 }
+
+VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
+        ExternalImageHandleRef externalImage, VkDevice device,
+        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
+    return ImageData{};
+}
+
+VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
+        VkInstance instance, uint64_t flags) noexcept {
+    return SurfaceBundle{};
+}
+
+}// namespace filament::backend

filament/backend/src/vulkan/platform/VulkanPlatformApple.mm

@@ -52,7 +52,7 @@ using namespace bluevk;
 
 namespace filament::backend {
 
-VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
+VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() {
     ExtensionSet const ret = {
     #if defined(__APPLE__)
         VK_MVK_MACOS_SURFACE_EXTENSION_NAME,  // TODO: replace with VK_EXT_metal_surface
@@ -70,11 +70,24 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataIm
 
 VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
         ExternalImageHandleRef externalImage, VkDevice device,
-        const ExternalImageMetadata& metadata) {
+        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
     return {};
 }
 
-VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWindow,
+VkSampler VulkanPlatform::createExternalSamplerImpl(VkDevice device,
+    SamplerYcbcrConversion chroma,
+    SamplerParams sampler,
+    uint32_t internalFormat) {
+    return VK_NULL_HANDLE;
+}
+
+VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
+        SamplerYcbcrConversion chroma, uint32_t internalFormat, VkImage image,
+        VkImageSubresourceRange range, VkImageViewType viewType, VkComponentMapping swizzle) {
+    return VK_NULL_HANDLE;
+}
+
+VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
         VkInstance instance, uint64_t flags) noexcept {
     VkSurfaceKHR surface;
     #if defined(__APPLE__)

filament/backend/src/vulkan/platform/VulkanPlatformLinuxWindows.cpp

@@ -91,11 +91,24 @@ VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadataIm
 
 VulkanPlatform::ImageData VulkanPlatform::createExternalImageDataImpl(
         ExternalImageHandleRef externalImage, VkDevice device,
-        const ExternalImageMetadata& metadata) {
+        const ExternalImageMetadata& metadata, uint32_t memoryTypeIndex, VkImageUsageFlags usage) {
     return {};
 }
 
-VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
+VkSampler VulkanPlatform::createExternalSamplerImpl(VkDevice device,
+    SamplerYcbcrConversion chroma,
+    SamplerParams sampler,
+    uint32_t internalFormat) {
+    return VK_NULL_HANDLE;
+}
+
+VkImageView VulkanPlatform::createExternalImageViewImpl(VkDevice device,
+        SamplerYcbcrConversion chroma, uint32_t internalFormat, VkImage image,
+        VkImageSubresourceRange range, VkImageViewType viewType, VkComponentMapping swizzle) {
+    return VK_NULL_HANDLE;
+}
+
+VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensionsImpl() {
     VulkanPlatform::ExtensionSet const ret = {
 #if defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
         VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
@@ -113,7 +126,7 @@ VulkanPlatform::ExtensionSet VulkanPlatform::getSwapchainInstanceExtensions() {
     return ret;
 }
 
-VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHR(void* nativeWindow,
+VulkanPlatform::SurfaceBundle VulkanPlatform::createVkSurfaceKHRImpl(void* nativeWindow,
         VkInstance instance, uint64_t flags) noexcept {
     VkSurfaceKHR surface;
 

filament/backend/src/vulkan/utils/Conversion.cpp

@@ -588,6 +588,79 @@ VkComponentMapping getSwizzleMap(TextureSwizzle const swizzle[4]) {
     return map;
 }
 
+VkFilter getFilter(SamplerMinFilter filter) {
+    switch (filter) {
+    case SamplerMinFilter::NEAREST:
+        return VK_FILTER_NEAREST;
+    case SamplerMinFilter::LINEAR:
+        return VK_FILTER_LINEAR;
+    case SamplerMinFilter::NEAREST_MIPMAP_NEAREST:
+        return VK_FILTER_NEAREST;
+    case SamplerMinFilter::LINEAR_MIPMAP_NEAREST:
+        return VK_FILTER_LINEAR;
+    case SamplerMinFilter::NEAREST_MIPMAP_LINEAR:
+        return VK_FILTER_NEAREST;
+    case SamplerMinFilter::LINEAR_MIPMAP_LINEAR:
+        return VK_FILTER_LINEAR;
+    }
+}
+
+VkFilter getFilter(SamplerMagFilter filter) {
+    switch (filter) {
+    case SamplerMagFilter::NEAREST:
+        return VK_FILTER_NEAREST;
+    case SamplerMagFilter::LINEAR:
+        return VK_FILTER_LINEAR;
+    }
+}
+
+VkSamplerMipmapMode getMipmapMode(SamplerMinFilter filter) {
+    switch (filter) {
+    case SamplerMinFilter::NEAREST:
+        return VK_SAMPLER_MIPMAP_MODE_NEAREST;
+    case SamplerMinFilter::LINEAR:
+        return VK_SAMPLER_MIPMAP_MODE_NEAREST;
+    case SamplerMinFilter::NEAREST_MIPMAP_NEAREST:
+        return VK_SAMPLER_MIPMAP_MODE_NEAREST;
+    case SamplerMinFilter::LINEAR_MIPMAP_NEAREST:
+        return VK_SAMPLER_MIPMAP_MODE_NEAREST;
+    case SamplerMinFilter::NEAREST_MIPMAP_LINEAR:
+        return VK_SAMPLER_MIPMAP_MODE_LINEAR;
+    case SamplerMinFilter::LINEAR_MIPMAP_LINEAR:
+        return VK_SAMPLER_MIPMAP_MODE_LINEAR;
+    }
+}
+
+VkSamplerAddressMode getWrapMode(SamplerWrapMode mode) {
+    switch (mode) {
+    case SamplerWrapMode::REPEAT:
+        return VK_SAMPLER_ADDRESS_MODE_REPEAT;
+    case SamplerWrapMode::CLAMP_TO_EDGE:
+        return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    case SamplerWrapMode::MIRRORED_REPEAT:
+        return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
+    }
+}
+
+VkBool32 getCompareEnable(SamplerCompareMode mode) {
+    return mode == SamplerCompareMode::NONE ? VK_FALSE : VK_TRUE;
+}
+
+float getMaxLod(SamplerMinFilter filter) {
+    switch (filter) {
+    case SamplerMinFilter::NEAREST:
+    case SamplerMinFilter::LINEAR:
+        // The Vulkan spec recommends a max LOD of 0.25 to "disable" mipmapping.
+        // See "Mapping of OpenGL to Vulkan filter modes" in the VK Spec.
+        return 0.25f;
+    case SamplerMinFilter::NEAREST_MIPMAP_NEAREST:
+    case SamplerMinFilter::LINEAR_MIPMAP_NEAREST:
+    case SamplerMinFilter::NEAREST_MIPMAP_LINEAR:
+    case SamplerMinFilter::LINEAR_MIPMAP_LINEAR:
+        return VK_LOD_CLAMP_NONE;
+    }
+}
+
 VkShaderStageFlags getShaderStageFlags(ShaderStageFlags stageFlags) {
     VkShaderStageFlags flags = 0x0;
     if (any(stageFlags & ShaderStageFlags::VERTEX))     flags |= VK_SHADER_STAGE_VERTEX_BIT;

filament/backend/src/vulkan/utils/Conversion.h

@@ -56,6 +56,19 @@ uint32_t getComponentCount(VkFormat format);
 VkComponentMapping getSwizzleMap(TextureSwizzle const swizzle[4]);
 VkShaderStageFlags getShaderStageFlags(ShaderStageFlags stageFlags);
 
+// Needed by the Platform for external sampler creation
+VkFilter getFilter(SamplerMinFilter filter);
+VkFilter getFilter(SamplerMagFilter filter);
+VkSamplerMipmapMode getMipmapMode(SamplerMinFilter filter);
+VkSamplerAddressMode getWrapMode(SamplerWrapMode mode);
+VkBool32 getCompareEnable(SamplerCompareMode mode);
+float getMaxLod(SamplerMinFilter filter);
+
+// Ycbcr related functions
+VkSamplerYcbcrModelConversion getYcbcrModelConversion(SamplerYcbcrModelConversion model);
+VkSamplerYcbcrRange getYcbcrRange(SamplerYcbcrRange range);
+VkChromaLocation getChromaLocation(ChromaLocation loc);
+
 inline VkImageViewType getViewType(SamplerType target) {
     switch (target) {
         case SamplerType::SAMPLER_CUBEMAP:

filament/backend/src/vulkan/utils/Image.cpp

@@ -193,6 +193,49 @@ uint8_t reduceSampleCount(uint8_t sampleCount, VkSampleCountFlags mask) {
     return mostSignificantBit((sampleCount - 1) & mask);
 }
 
+VkSamplerYcbcrModelConversion getYcbcrModelConversion(
+    SamplerYcbcrModelConversion model) {
+    switch (model) {
+    case SamplerYcbcrModelConversion::RGB_IDENTITY:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
+    case SamplerYcbcrModelConversion::YCBCR_IDENTITY:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY;
+    case SamplerYcbcrModelConversion::YCBCR_709:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709;
+    case SamplerYcbcrModelConversion::YCBCR_601:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601;
+    case SamplerYcbcrModelConversion::YCBCR_2020:
+        return VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020;
+    default:
+        assert_invariant(false &&
+            "Unknown data type, conversion is not supported.");
+    }
+}
+
+VkSamplerYcbcrRange getYcbcrRange(SamplerYcbcrRange range) {
+    switch (range) {
+    case SamplerYcbcrRange::ITU_FULL:
+        return VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
+    case SamplerYcbcrRange::ITU_NARROW:
+        return VK_SAMPLER_YCBCR_RANGE_ITU_NARROW;
+    default:
+        assert_invariant(false &&
+            "Unknown data type, conversion is not supported.");
+    }
+}
+
+VkChromaLocation getChromaLocation(ChromaLocation loc) {
+    switch (loc) {
+    case ChromaLocation::COSITED_EVEN:
+        return VK_CHROMA_LOCATION_COSITED_EVEN;
+    case ChromaLocation::MIDPOINT:
+        return VK_CHROMA_LOCATION_MIDPOINT;
+    default:
+        assert_invariant(false &&
+            "Unknown data type, conversion is not supported.");
+    }
+}
+
 } // namespace filament::backend::fvkutils
 
 bool operator<(const VkImageSubresourceRange& a, const VkImageSubresourceRange& b) {

filament/backend/src/webgpu/WebGPUConstants.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TNT_FILAMENT_BACKEND_WEBGPUCONSTANTS_H
+#define TNT_FILAMENT_BACKEND_WEBGPUCONSTANTS_H
+
+#include <utils/Log.h>
+
+#include <cstdint>
+
+// FWGPU is short for Filament WebGPU
+
+// turn on runtime validation, namely for debugging, that would normally not run (for release)
+#define FWGPU_DEBUG_VALIDATION     0x00000001
+// print/log system component details to the console, e.g. about the
+// instance, surface, adapter, device, etc.
+#define FWGPU_PRINT_SYSTEM         0x00000002
+
+// Set this to enable logging "only" to one output stream. This is useful in the case where we want
+// to debug with print statements and want ordered logging (e.g slog.i and slog.e will not appear in
+// order of calls).
+#define FWGPU_DEBUG_FORCE_LOG_TO_I 0x00000004
+
+// Useful default combinations
+#define FWGPU_DEBUG_EVERYTHING     0xFFFFFFFF
+
+#if defined(FILAMENT_BACKEND_DEBUG_FLAG)
+    #define FWGPU_DEBUG_FORWARDED_FLAG (FILAMENT_BACKEND_DEBUG_FLAG & FWGPU_DEBUG_EVERYTHING)
+#else
+    #define FWGPU_DEBUG_FORWARDED_FLAG 0
+#endif
+
+#ifndef NDEBUG
+    #define FWGPU_DEBUG_FLAGS FWGPU_DEBUG_FORWARDED_FLAG
+#else
+    #define FWGPU_DEBUG_FLAGS 0
+#endif
+
+#define FWGPU_ENABLED(flags) (((FWGPU_DEBUG_FLAGS) & (flags)) == (flags))
+
+#if FWGPU_ENABLED(FWGPU_DEBUG_FORCE_LOG_TO_I)
+    #define FWGPU_LOGI (utils::slog.i)
+    #define FWGPU_LOGD FWGPU_LOGI
+    #define FWGPU_LOGE FWGPU_LOGI
+    #define FWGPU_LOGW FWGPU_LOGI
+#else
+    #define FWGPU_LOGE (utils::slog.e)
+    #define FWGPU_LOGW (utils::slog.w)
+    #define FWGPU_LOGD (utils::slog.d)
+    #define FWGPU_LOGI (utils::slog.i)
+#endif
+
+#endif// TNT_FILAMENT_BACKEND_WEBGPUCONSTANTS_H

filament/backend/src/webgpu/WebGPUDriver.cpp

@@ -14,21 +14,254 @@
  * limitations under the License.
  */
 
+#include "webgpu/WebGPUDriver.h"
+
+#include "webgpu/WebGPUConstants.h"
+#include <backend/platforms/WebGPUPlatform.h>
+
+#include "CommandStreamDispatcher.h"
+#include "DriverBase.h"
+#include "private/backend/Dispatcher.h"
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>
 
-#include "webgpu/WebGPUDriver.h"
-#include "CommandStreamDispatcher.h"
+#include <math/mat3.h>
+#include <utils/CString.h>
+#include <utils/ostream.h>
 
-#include <stdint.h>
+#include <dawn/webgpu_cpp_print.h>
+#include <webgpu/webgpu_cpp.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <sstream>
+#include <string_view>
+#include <utility>
+#include <variant>
 
 namespace filament::backend {
 
-Driver* WebGPUDriver::create() {
-    return new WebGPUDriver();
+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("maxInterStageShaderComponents", limits.maxInterStageShaderComponents);
+    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 << "  compatibility mode: " << bool(adapterInfo.compatibilityMode)
+                   << 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::SupportedLimits 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.limits);
+    }
+}
+#endif
+
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+void printSurfaceCapabilitiesDetails(wgpu::SurfaceCapabilities const& capabilities) {
+    std::stringstream usages_stream{};
+    usages_stream << capabilities.usages;
+    FWGPU_LOGI << "WebGPU surface capabilities:" << utils::io::endl;
+    FWGPU_LOGI << "  surface usages: " << usages_stream.str().data() << utils::io::endl;
+    FWGPU_LOGI << "  surface formats (" << capabilities.formatCount << "):" << utils::io::endl;
+    if (capabilities.formatCount > 0 && capabilities.formats != nullptr) {
+        std::for_each(capabilities.formats, capabilities.formats + capabilities.formatCount,
+                [](wgpu::TextureFormat const format) {
+                    std::stringstream format_stream{};
+                    format_stream << format;
+                    FWGPU_LOGI << "    " << format_stream.str().data() << utils::io::endl;
+                });
+    }
+    FWGPU_LOGI << "  surface present modes (" << capabilities.presentModeCount
+               << "):" << utils::io::endl;
+    if (capabilities.presentModeCount > 0 && capabilities.presentModes != nullptr) {
+        std::for_each(capabilities.presentModes,
+                capabilities.presentModes + capabilities.presentModeCount,
+                [](wgpu::PresentMode const presentMode) {
+                    std::stringstream present_mode_stream{};
+                    present_mode_stream << presentMode;
+                    FWGPU_LOGI << "    " << present_mode_stream.str().data() << utils::io::endl;
+                });
+    }
+    FWGPU_LOGI << "  surface alpha modes (" << capabilities.alphaModeCount
+               << "):" << utils::io::endl;
+    if (capabilities.alphaModeCount > 0 && capabilities.alphaModes != nullptr) {
+        std::for_each(capabilities.alphaModes,
+                capabilities.alphaModes + capabilities.alphaModeCount,
+                [](wgpu::CompositeAlphaMode const alphaMode) {
+                    std::stringstream alpha_mode_stream{};
+                    alpha_mode_stream << alphaMode;
+                    FWGPU_LOGI << "    " << alpha_mode_stream.str().data() << utils::io::endl;
+                });
+    }
+}
+#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::SupportedLimits 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.limits);
+    }
+}
+#endif
+
+}// namespace
+
+Driver* WebGPUDriver::create(WebGPUPlatform& platform) noexcept {
+    return new WebGPUDriver(platform);
 }
 
-WebGPUDriver::WebGPUDriver() noexcept = default;
+WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform) noexcept
+    : mPlatform(platform) {
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printInstanceDetails(mPlatform.getInstance());
+#endif
+}
 
 WebGPUDriver::~WebGPUDriver() noexcept = default;
 
@@ -123,6 +356,188 @@ void WebGPUDriver::destroyDescriptorSetLayout(Handle<HwDescriptorSetLayout> tqh)
 void WebGPUDriver::destroyDescriptorSet(Handle<HwDescriptorSet> tqh) {
 }
 
+Handle<HwSwapChain> WebGPUDriver::createSwapChainS() noexcept {
+    return Handle<HwSwapChain>((Handle<HwSwapChain>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwSwapChain> WebGPUDriver::createSwapChainHeadlessS() noexcept {
+    return Handle<HwSwapChain>((Handle<HwSwapChain>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwTexture> WebGPUDriver::createTextureS() noexcept {
+    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwTexture> WebGPUDriver::importTextureS() noexcept {
+    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwProgram> WebGPUDriver::createProgramS() noexcept {
+    return Handle<HwProgram>((Handle<HwProgram>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwFence> WebGPUDriver::createFenceS() noexcept {
+    return Handle<HwFence>((Handle<HwFence>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwTimerQuery> WebGPUDriver::createTimerQueryS() noexcept {
+    return Handle<HwTimerQuery>((Handle<HwTimerQuery>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwIndexBuffer> WebGPUDriver::createIndexBufferS() noexcept {
+    return Handle<HwIndexBuffer>((Handle<HwIndexBuffer>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwTexture> WebGPUDriver::createTextureViewS() noexcept {
+    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwBufferObject> WebGPUDriver::createBufferObjectS() noexcept {
+    return Handle<HwBufferObject>((Handle<HwBufferObject>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwRenderTarget> WebGPUDriver::createRenderTargetS() noexcept {
+    return Handle<HwRenderTarget>((Handle<HwRenderTarget>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwVertexBuffer> WebGPUDriver::createVertexBufferS() noexcept {
+    return Handle<HwVertexBuffer>((Handle<HwVertexBuffer>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwDescriptorSet> WebGPUDriver::createDescriptorSetS() noexcept {
+    return Handle<HwDescriptorSet>((Handle<HwDescriptorSet>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwRenderPrimitive> WebGPUDriver::createRenderPrimitiveS() noexcept {
+    return Handle<HwRenderPrimitive>((Handle<HwRenderPrimitive>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwVertexBufferInfo> WebGPUDriver::createVertexBufferInfoS() noexcept {
+    return Handle<HwVertexBufferInfo>((Handle<HwVertexBufferInfo>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwTexture> WebGPUDriver::createTextureViewSwizzleS() noexcept {
+    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwRenderTarget> WebGPUDriver::createDefaultRenderTargetS() noexcept {
+    return Handle<HwRenderTarget>((Handle<HwRenderTarget>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwDescriptorSetLayout> WebGPUDriver::createDescriptorSetLayoutS() noexcept {
+    return Handle<HwDescriptorSetLayout>(
+            (Handle<HwDescriptorSetLayout>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwTexture> WebGPUDriver::createTextureExternalImageS() noexcept {
+    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwTexture> WebGPUDriver::createTextureExternalImage2S() noexcept {
+    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+}
+
+Handle<HwTexture> WebGPUDriver::createTextureExternalImagePlaneS() noexcept {
+    return Handle<HwTexture>((Handle<HwTexture>::HandleId) mNextFakeHandle++);
+}
+
+void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
+    mSurface= mPlatform.createSurface(nativeWindow, flags);
+    mAdapter = mPlatform.requestAdapter(mSurface);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printAdapterDetails(mAdapter);
+    wgpu::SurfaceCapabilities surfaceCapabilities{};
+    if (!mSurface.GetCapabilities(mAdapter, &surfaceCapabilities)) {
+        FWGPU_LOGW << "Failed to get WebGPU surface capabilities" << utils::io::endl;
+    } else {
+        printSurfaceCapabilitiesDetails(surfaceCapabilities);
+    }
+#endif
+    mDevice = mPlatform.requestDevice(mAdapter);
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    printDeviceDetails(mDevice);
+#endif
+    mQueue = mDevice.GetQueue();
+    // TODO configure the surface (maybe before or after creating the swapchain?
+    //                             how do we get the surface extent?)
+    // TODO actually create the swapchain
+    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."
+               << 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
+               << FWGPU_PRINT_SYSTEM << utils::io::dec
+               << " bit flag on during build time the application would print system details "
+                  "about the selected graphics device, surface, etc. To see this try "
+                  "rebuilding Filament with that flag, e.g. ./build.sh -x "
+               << FWGPU_PRINT_SYSTEM << " ..." << utils::io::endl;
+#endif
+}
+
+void WebGPUDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch, uint32_t width,
+        uint32_t height, uint64_t flags) {}
+
+void WebGPUDriver::createVertexBufferInfoR(Handle<HwVertexBufferInfo> vbih, uint8_t bufferCount,
+        uint8_t attributeCount, AttributeArray attributes) {}
+
+void WebGPUDriver::createVertexBufferR(Handle<HwVertexBuffer> vbh, uint32_t vertexCount,
+        Handle<HwVertexBufferInfo> vbih) {}
+
+void WebGPUDriver::createIndexBufferR(Handle<HwIndexBuffer> ibh, ElementType elementType,
+        uint32_t indexCount, BufferUsage usage) {}
+
+void WebGPUDriver::createBufferObjectR(Handle<HwBufferObject> boh, uint32_t byteCount,
+        BufferObjectBinding bindingType, BufferUsage usage) {}
+
+void WebGPUDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint8_t levels,
+        TextureFormat format, uint8_t samples, uint32_t w, uint32_t h, uint32_t depth,
+        TextureUsage usage) {}
+
+void WebGPUDriver::createTextureViewR(Handle<HwTexture> th, Handle<HwTexture> srch,
+        uint8_t baseLevel, uint8_t levelCount) {}
+
+void WebGPUDriver::createTextureViewSwizzleR(Handle<HwTexture> th, Handle<HwTexture> srch,
+        backend::TextureSwizzle r, backend::TextureSwizzle g, backend::TextureSwizzle b,
+        backend::TextureSwizzle a) {}
+
+void WebGPUDriver::createTextureExternalImage2R(Handle<HwTexture> th, backend::SamplerType target,
+        backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
+        Platform::ExternalImageHandleRef externalImage) {}
+
+void WebGPUDriver::createTextureExternalImageR(Handle<HwTexture> th, backend::SamplerType target,
+        backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
+        void* externalImage) {}
+
+void WebGPUDriver::createTextureExternalImagePlaneR(Handle<HwTexture> th,
+        backend::TextureFormat format, uint32_t width, uint32_t height, backend::TextureUsage usage,
+        void* image, uint32_t plane) {}
+
+void WebGPUDriver::importTextureR(Handle<HwTexture> th, intptr_t id, SamplerType target,
+        uint8_t levels, TextureFormat format, uint8_t samples, uint32_t w, uint32_t h,
+        uint32_t depth, TextureUsage usage) {}
+
+void WebGPUDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph, Handle<HwVertexBuffer> vbh,
+        Handle<HwIndexBuffer> ibh, PrimitiveType pt) {}
+
+void WebGPUDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {}
+
+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) {}
+
+void WebGPUDriver::createFenceR(Handle<HwFence> fh, int) {}
+
+void WebGPUDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {}
+
+void WebGPUDriver::createDescriptorSetLayoutR(Handle<HwDescriptorSetLayout> dslh,
+        backend::DescriptorSetLayout&& info) {}
+
+void WebGPUDriver::createDescriptorSetR(Handle<HwDescriptorSet> dsh,
+        Handle<HwDescriptorSetLayout> dslh) {}
+
 Handle<HwStream> WebGPUDriver::createStreamNative(void* nativeStream) {
     return {};
 }
@@ -240,6 +655,14 @@ size_t WebGPUDriver::getMaxUniformBufferSize() {
     return 16384u;
 }
 
+size_t WebGPUDriver::getMaxTextureSize(SamplerType target) {
+    return 2048u;
+}
+
+size_t WebGPUDriver::getMaxArrayTextureLayers() {
+    return 256u;
+}
+
 void WebGPUDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor&& p,
         uint32_t byteOffset) {
     scheduleDestroy(std::move(p));

filament/backend/src/webgpu/WebGPUDriver.h

@@ -17,26 +17,44 @@
 #ifndef TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
 #define TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
 
-#include "private/backend/Driver.h"
+#include <backend/platforms/WebGPUPlatform.h>
+
 #include "DriverBase.h"
+#include "private/backend/Dispatcher.h"
+#include "private/backend/Driver.h"
+#include <backend/DriverEnums.h>
 
 #include <utils/compiler.h>
 
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstdint>
+
 namespace filament::backend {
 
+/**
+ * WebGPU backend (driver) implementation
+ */
 class WebGPUDriver final : public DriverBase {
-    WebGPUDriver() noexcept;
-    ~WebGPUDriver() noexcept override;
-    Dispatcher getDispatcher() const noexcept final;
-
 public:
-    static Driver* create();
+    ~WebGPUDriver() noexcept override;
+
+    [[nodiscard]] Dispatcher getDispatcher() const noexcept final;
+    [[nodiscard]] static Driver* create(WebGPUPlatform& platform) noexcept;
 
 private:
-    ShaderModel getShaderModel() const noexcept final;
-    ShaderLanguage getShaderLanguage() const noexcept final;
+    explicit WebGPUDriver(WebGPUPlatform& platform) noexcept;
+    [[nodiscard]] ShaderModel getShaderModel() const noexcept final;
+    [[nodiscard]] ShaderLanguage getShaderLanguage() const noexcept final;
 
-    uint64_t nextFakeHandle = 1;
+    // the platform (e.g. OS) specific aspects of the WebGPU backend are strictly only
+    // handled in the WebGPUPlatform
+    WebGPUPlatform& mPlatform;
+    wgpu::Surface mSurface = nullptr;
+    wgpu::Adapter mAdapter = nullptr;
+    wgpu::Device mDevice = nullptr;
+    wgpu::Queue mQueue = nullptr;
+    uint64_t mNextFakeHandle = 1;
 
     /*
      * Driver interface
@@ -45,20 +63,19 @@ private:
     template<typename T>
     friend class ConcreteDispatcher;
 
-#define DECL_DRIVER_API(methodName, paramsDecl, params) \
+#define DECL_DRIVER_API(methodName, paramsDecl, params)                                            \
     UTILS_ALWAYS_INLINE inline void methodName(paramsDecl);
 
-#define DECL_DRIVER_API_SYNCHRONOUS(RetType, methodName, paramsDecl, params) \
+#define DECL_DRIVER_API_SYNCHRONOUS(RetType, methodName, paramsDecl, params)                       \
     RetType methodName(paramsDecl) override;
 
-#define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params) \
-    RetType methodName##S() noexcept override { \
-        return RetType((RetType::HandleId)nextFakeHandle++); } \
-    UTILS_ALWAYS_INLINE inline void methodName##R(RetType, paramsDecl) { }
+#define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params)                            \
+    RetType methodName##S() noexcept override;                                                     \
+    UTILS_ALWAYS_INLINE inline void methodName##R(RetType, paramsDecl);
 
 #include "private/backend/DriverAPI.inc"
 };
 
-} // namespace filament
+}// namespace filament::backend
 
-#endif // TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H
+#endif// TNT_FILAMENT_BACKEND_WEBGPUDRIVER_H

filament/backend/src/webgpu/WebGPUPlatform.cpp

@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "webgpu/WebGPUPlatform.h"
-#include "webgpu/WebGPUDriver.h"
-
-#include "utils/Log.h"
-
-namespace filament::backend {
-
-Driver* WebGPUPlatform::createDriver(void* const sharedContext , const Platform::DriverConfig& driverConfig) noexcept {
-    wgpu::InstanceDescriptor instance_descriptor {};
-    wgpu::Instance instance = wgpu::CreateInstance(&instance_descriptor);
-    if (instance) {
-        utils::slog.i << " WebGPU instance created\n";
-    } else {
-        utils::slog.e << " WebGPU instance failed to create\n";
-        return nullptr;
-    }
-    return WebGPUDriver::create();
-}
-
-} // namespace filament

filament/backend/src/webgpu/WebGPUPlatform.h

@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2025 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef TNT_FILAMENT_BACKEND_WEBGPUPLATFORM_H
-#define TNT_FILAMENT_BACKEND_WEBGPUPLATFORM_H
-
-#include <backend/DriverEnums.h>
-#include <backend/Platform.h>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace filament::backend {
-
-class WebGPUPlatform
-    final : public Platform {
-public:
-
-    int getOSVersion() const noexcept final { return 0; }
-
-    ~WebGPUPlatform() noexcept override = default;
-
-protected:
-
-    Driver* createDriver(void* sharedContext, const Platform::DriverConfig& driverConfig) noexcept override;
-};
-
-} // namespace filament
-
-#endif // TNT_FILAMENT_BACKEND_WEBGPUPLATFORM_H

filament/backend/src/webgpu/platform/WebGPUPlatform.cpp

@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <backend/platforms/WebGPUPlatform.h>
+
+#include "webgpu/WebGPUConstants.h"
+#include "webgpu/WebGPUDriver.h"
+
+#include <backend/Platform.h>
+#include <utils/Panic.h>
+#include <utils/ostream.h>
+
+#include <dawn/webgpu_cpp_print.h>
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstdint>
+#include <sstream>
+
+/**
+ * WebGPU Backend implementation common across platforms or operating systems (at least for now).
+ * Some of these functions may likely be refactored to platform/OS-specific implementations
+ * over time as needed. The caller of the WebGPUPlatform doesn't need to care which is the case.
+ */
+
+namespace filament::backend {
+
+namespace {
+
+//either returns a valid instance or panics
+[[nodiscard]] wgpu::Instance createInstance() {
+    wgpu::DawnTogglesDescriptor dawnTogglesDescriptor{};
+#if defined(FILAMENT_WEBGPU_IMMEDIATE_ERROR_HANDLING)
+#if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
+    FWGPU_LOGI << "setting on toggle enable_immediate_error_handling" << utils::io::endl;
+#endif
+    /**
+     * Have the un-captured error callback invoked immediately when an error occurs, rather than
+     * waiting for the next Tick. This enables using the stack trace in which the un-captured error
+     * occurred when breaking into the un-captured error callback.
+     * https://crbug.com/dawn/1789
+     */
+    static const char* toggleName = "enable_immediate_error_handling";
+    dawnTogglesDescriptor.enabledToggleCount = 1;
+    dawnTogglesDescriptor.enabledToggles = &toggleName;
+#endif
+    wgpu::InstanceDescriptor instanceDescriptor{
+        .nextInChain = &dawnTogglesDescriptor,
+        .capabilities = {
+            .timedWaitAnyEnable = true// TODO consider using pure async instead
+        }
+    };
+    wgpu::Instance instance = wgpu::CreateInstance(&instanceDescriptor);
+    FILAMENT_CHECK_POSTCONDITION(instance != nullptr) << "Unable to create webgpu instance.";
+    return instance;
+}
+
+}// namespace
+
+wgpu::Adapter WebGPUPlatform::requestAdapter(wgpu::Surface const& surface) {
+    // TODO consider power preference etc. (can be custom preferences passed to the platform or
+    //                                      based on whether this is a Mobile or Desktop system,
+    //                                      etc...)
+    wgpu::RequestAdapterOptions adaptorOptions{ .compatibleSurface = surface };
+    // note this just gets the first adapter
+    wgpu::Adapter adapter = nullptr;
+    wgpu::WaitStatus status = mInstance.WaitAny(
+            mInstance.RequestAdapter(&adaptorOptions, wgpu::CallbackMode::WaitAnyOnly,
+                    [&adapter](wgpu::RequestAdapterStatus const status,
+                            wgpu::Adapter const& readyAdapter, wgpu::StringView const message) {
+                        // TODO consider more robust error handling
+                        FILAMENT_CHECK_POSTCONDITION(status == wgpu::RequestAdapterStatus::Success)
+                                << "Unable to request a WebGPU adapter. Status "
+                                << static_cast<uint32_t>(status)
+                                << " with message: " << message.data;
+                        adapter = readyAdapter;
+                    }),
+            UINT16_MAX);// TODO define reasonable timeout (or do this asynchronously)
+    FILAMENT_CHECK_POSTCONDITION(status == wgpu::WaitStatus::Success)
+            << "Non-successful wait status requesting a WebGPU adapter "
+            << static_cast<uint32_t>(status);
+    FILAMENT_CHECK_POSTCONDITION(adapter != nullptr)
+            << "Failed to get a WebGPU adapter for the platform";
+    // TODO consider validating adapter has required features and/or limits
+    return adapter;
+}
+
+wgpu::Device WebGPUPlatform::requestDevice(wgpu::Adapter const& adapter) {
+    // TODO consider passing required features and/or limits
+    wgpu::DeviceDescriptor deviceDescriptor{};
+    deviceDescriptor.label = "graphics_device";
+    deviceDescriptor.defaultQueue.label = "default_queue";
+    deviceDescriptor.SetDeviceLostCallback(wgpu::CallbackMode::AllowSpontaneous,
+            [](wgpu::Device const&, wgpu::DeviceLostReason const& reason,
+                    wgpu::StringView message) {
+                if (reason == wgpu::DeviceLostReason::Destroyed) {
+                    FWGPU_LOGD << "WebGPU device lost due to being destroyed (expected)"
+                               << utils::io::endl;
+                    return;
+                }
+                // TODO try recreating the device instead of just panicking
+                std::stringstream reasonStream{};
+                reasonStream << reason;
+                FILAMENT_CHECK_POSTCONDITION(reason != wgpu::DeviceLostReason::Destroyed)
+                        << "WebGPU device lost: " << reasonStream.str() << " " << message.data;
+            });
+    deviceDescriptor.SetUncapturedErrorCallback(
+            [](wgpu::Device const&, wgpu::ErrorType errorType, wgpu::StringView message) {
+                std::stringstream typeStream{};
+                typeStream << errorType;
+                FWGPU_LOGE << "WebGPU device error: " << typeStream.str() << " " << message.data
+                           << utils::io::endl;
+            });
+    wgpu::Device device = nullptr;
+    wgpu::WaitStatus status = mInstance.WaitAny(
+            adapter.RequestDevice(&deviceDescriptor, wgpu::CallbackMode::WaitAnyOnly,
+                    [&device](wgpu::RequestDeviceStatus const status,
+                            wgpu::Device const& readyDevice, wgpu::StringView const message) {
+                        FILAMENT_CHECK_POSTCONDITION(status == wgpu::RequestDeviceStatus::Success)
+                                << "Unable to request a WebGPU device. Status: "
+                                << static_cast<uint32_t>(status)
+                                << " with message: " << message.data;
+                        device = readyDevice;
+                    }),
+            UINT64_MAX);// TODO define reasonable timeout (or do this asynchronously)
+    FILAMENT_CHECK_POSTCONDITION(status == wgpu::WaitStatus::Success)
+            << "Non-successful wait status requesting a WebGPU device "
+            << static_cast<uint32_t>(status);
+    FILAMENT_CHECK_POSTCONDITION(device != nullptr)
+            << "Failed to get a WebGPU device for the platform.";
+    return device;
+}
+
+Driver* WebGPUPlatform::createDriver(void* sharedContext,
+        const Platform::DriverConfig& /*driverConfig*/) noexcept {
+    if (sharedContext) {
+        FWGPU_LOGW << "sharedContext is ignored/unused in the WebGPU backend. A non-null "
+                      "sharedContext was provided, but it will be ignored."
+                   << utils::io::endl;
+    }
+    return WebGPUDriver::create(*this);
+}
+
+WebGPUPlatform::WebGPUPlatform()
+    : mInstance(createInstance()) {}
+
+}// namespace filament::backend

filament/backend/src/webgpu/platform/WebGPUPlatformAndroid.cpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <backend/platforms/WebGPUPlatform.h>
+
+#include <utils/Panic.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstdint>
+
+/**
+ * Android OS specific implementation aspects of the WebGPU backend
+ */
+
+namespace filament::backend {
+
+wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
+    wgpu::SurfaceSourceAndroidNativeWindow surfaceSourceAndroidWindow{};
+    surfaceSourceAndroidWindow.window = nativeWindow;
+    wgpu::SurfaceDescriptor surfaceDescriptor{
+        .nextInChain = &surfaceSourceAndroidWindow,
+        .label = "android_surface"
+    };
+    wgpu::Surface surface = mInstance.CreateSurface(&surfaceDescriptor);
+    FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Android-backed surface.";
+    return surface;
+}
+
+}// namespace filament::backend

filament/backend/src/webgpu/platform/WebGPUPlatformApple.mm

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <backend/platforms/WebGPUPlatform.h>
+
+#include <utils/Panic.h>
+#include <utils/ostream.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstdint>
+
+// Platform specific includes and defines
+#if defined(__APPLE__)
+    #include <Cocoa/Cocoa.h>
+    #import <QuartzCore/CAMetalLayer.h>
+#elif defined(FILAMENT_IOS)
+    // Metal is not available when building for the iOS simulator on Desktop.
+    #define METAL_AVAILABLE __has_include(<QuartzCore/CAMetalLayer.h>)
+    #if METAL_AVAILABLE
+        #import <Metal/Metal.h>
+        #import <QuartzCore/CAMetalLayer.h>
+    #endif
+    // is this needed?
+    #define METALVIEW_TAG 255
+#else
+    #error Not a supported Apple + WebGPU platform
+#endif
+
+/**
+ * Apple (Mac OS and IOS) specific implementation aspects of the WebGPU backend
+ */
+
+namespace filament::backend {
+
+wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
+    wgpu::Surface surface = nullptr;
+#if defined(__APPLE__)
+    auto nsView = (__bridge NSView*) nativeWindow;
+    FILAMENT_CHECK_POSTCONDITION(nsView) << "Unable to obtain Metal-backed NSView.";
+    [nsView setWantsLayer:YES];
+    id metalLayer = [CAMetalLayer layer];
+    [nsView setLayer:metalLayer];
+    wgpu::SurfaceSourceMetalLayer surfaceSourceMetalLayer{};
+    surfaceSourceMetalLayer.layer = (__bridge void*) metalLayer;
+    wgpu::SurfaceDescriptor surfaceDescriptor = {
+        .nextInChain = &surfaceSourceMetalLayer,
+        .label = "metal_surface",
+    };
+    surface = mInstance.CreateSurface(&surfaceDescriptor);
+    FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Metal-backed surface.";
+#elif defined(FILAMENT_IOS)
+    CAMetalLayer* metalLayer = (CAMetalLayer*) nativeWindow;
+    wgpu::SurfaceSourceMetalLayer surfaceSourceMetalLayer{};
+    surfaceSourceMetalLayer.layer = (__bridge void*) metalLayer;
+    wgpu::SurfaceDescriptor surfaceDescriptor = {
+        .nextInChain = &surfaceSourceMetalLayer,
+        .label = "metal_surface",
+    };
+    surface = mInstance.CreateSurface(&surfaceDescriptor);
+    FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Metal-backed surface.";
+#else
+    #error Not a supported Apple + WebGPU platform
+#endif
+    return surface;
+}
+
+}// namespace filament::backend

filament/backend/src/webgpu/platform/WebGPUPlatformLinux.cpp

@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <backend/platforms/WebGPUPlatform.h>
+
+#include <backend/DriverEnums.h>
+
+#include <utils/Panic.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstddef>
+#include <cstdint>
+
+#if defined(__linux__) || defined(__FreeBSD__)
+    #define LINUX_OR_FREEBSD 1
+#endif
+
+// Platform specific includes and defines
+#if defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
+    #include <dlfcn.h>
+    namespace {
+    typedef struct _wl {
+        struct wl_display* display;
+        struct wl_surface* surface;
+        uint32_t width;
+        uint32_t height;
+    } wl;
+    }// namespace
+#elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
+    // TODO: we should allow for headless on Linux explicitly. Right now this is the headless path
+    // (with no FILAMENT_SUPPORTS_XCB or FILAMENT_SUPPORTS_XLIB).
+    #include <dlfcn.h>
+    #if defined(FILAMENT_SUPPORTS_XCB)
+        #include <xcb/xcb.h>
+        namespace {
+        typedef xcb_connection_t* (*XCB_CONNECT)(const char* displayname, int* screenp);
+        }// namespace
+    #endif
+    #if defined(FILAMENT_SUPPORTS_XLIB)
+        #include <X11/Xlib.h>
+        namespace {
+        typedef Display* (*X11_OPEN_DISPLAY)(const char*);
+        }// namespace
+    #endif
+    static constexpr const char* LIBRARY_X11 = "libX11.so.6";
+    namespace {
+    struct XEnv {
+    #if defined(FILAMENT_SUPPORTS_XCB)
+        XCB_CONNECT xcbConnect;
+        xcb_connection_t* connection;
+    #endif
+    #if defined(FILAMENT_SUPPORTS_XLIB)
+        X11_OPEN_DISPLAY openDisplay;
+        Display* display;
+    #endif
+        void* library = nullptr;
+    } g_x11;
+    }// namespace
+#else
+    #error Not a supported Linux or FeeBSD + WebGPU platform
+#endif
+
+/**
+ * Linux OS specific implementation aspects of the WebGPU Backend
+ */
+
+namespace filament::backend {
+
+wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t flags) {
+    wgpu::Surface surface = nullptr;
+#if defined(__linux__) && defined(FILAMENT_SUPPORTS_WAYLAND)
+    wl* ptrval = reinterpret_cast<wl*>(nativeWindow);
+    wgpu::SurfaceSourceWaylandSurface surfaceSourceWayland{};
+    surfaceSourceWayland.display = ptrval->display;
+    surfaceSourceWayland.surface = ptrval->surface;
+    wgpu::SurfaceDescriptor surfaceDescriptor{
+        .nextInChain = &surfaceSourceWayland,
+        .label = "linux_wayland_surface"
+    };
+    surface = mInstance.CreateSurface(&surfaceDescriptor);
+    FILAMENT_CHECK_POSTCONDITION(surface != nullptr)
+            << "Unable to create Linux Wayland-backed surface.";
+#elif defined(LINUX_OR_FREEBSD) && defined(FILAMENT_SUPPORTS_X11)
+    if (g_x11.library == nullptr) {
+        g_x11.library = dlopen(LIBRARY_X11, RTLD_LOCAL | RTLD_NOW);
+        FILAMENT_CHECK_PRECONDITION(g_x11.library) << "Unable to open X11 library.";
+        #if defined(FILAMENT_SUPPORTS_XCB)
+            g_x11.xcbConnect = (XCB_CONNECT) dlsym(g_x11.library, "xcb_connect");
+            int screen = 0;
+            g_x11.connection = g_x11.xcbConnect(nullptr, &screen);
+        #endif
+        #if defined(FILAMENT_SUPPORTS_XLIB)
+            g_x11.openDisplay = (X11_OPEN_DISPLAY) dlsym(g_x11.library, "XOpenDisplay");
+            g_x11.display = g_x11.openDisplay(NULL);
+            FILAMENT_CHECK_PRECONDITION(g_x11.display) << "Unable to open X11 display.";
+        #endif
+    }
+    #if defined(FILAMENT_SUPPORTS_XCB) || defined(FILAMENT_SUPPORTS_XLIB)
+        bool useXcb = false;
+    #endif
+    #if defined(FILAMENT_SUPPORTS_XCB)
+        #if defined(FILAMENT_SUPPORTS_XLIB)
+            useXcb = (flags & SWAP_CHAIN_CONFIG_ENABLE_XCB) != 0;
+        #else
+            useXcb = true;
+        #endif
+        if (useXcb) {
+            wgpu::SurfaceSourceXCBWindow surfaceSourceXcb{};
+            surfaceSourceXcb.connection = g_x11.connection;
+
+            // TODO: this looks really wrong, please fix!!
+            surfaceSourceXcb.window = *((uint32_t*) nativeWindow);
+            wgpu::SurfaceDescriptor surfaceDescriptor{
+                .nextInChain = &surfaceSourceXcb,
+                .label = "linux_xcb_surface"
+            };
+            surface = mInstance.CreateSurface(&surfaceDescriptor);
+            FILAMENT_CHECK_POSTCONDITION(surface != nullptr)
+                    << "Unable to create Linux (or FreeBSD) XCB-backed surface.";
+        }
+    #endif
+    #if defined(FILAMENT_SUPPORTS_XLIB)
+        if (!useXcb) {
+            wgpu::SurfaceSourceXlibWindow surfaceSourceXlib{};
+            surfaceSourceXlib.display = g_x11.display;
+            surfaceSourceXlib.window = reinterpret_cast<uint64_t>(nativeWindow);
+            wgpu::SurfaceDescriptor surfaceDescriptor{
+                .nextInChain = &surfaceSourceXlib,
+                .label = "linux_xlib_surface"
+            };
+            surface = mInstance.CreateSurface(&surfaceDescriptor);
+            FILAMENT_CHECK_POSTCONDITION(surface != nullptr)
+                    << "Unable to create Linux (or FreeBSD) XLib-backed surface.";
+        }
+    #endif
+    FILAMENT_CHECK_POSTCONDITION(surface != nullptr)
+            << "Cannot create WebGPU X11 surface for Linux (or FreeBSD) OS "
+               "(not built with support for XCB or XLIB?)";
+#elif defined(__linux__)
+    FILAMENT_CHECK_POSTCONDITION(surface != nullptr)
+            << "Cannot create WebGPU surface for Linux (or FreeBSD) OS "
+               "(not built with support for Wayland or X11?)";
+#else
+    FILAMENT_CHECK_POSTCONDITION(surface != nullptr)
+            << "Not a supported (Linux) OS + WebGPU platform";
+#endif
+    return surface;
+}
+
+}// namespace filament::backend

filament/backend/src/webgpu/platform/WebGPUPlatformWindows.cpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <backend/platforms/WebGPUPlatform.h>
+
+#include <utils/Panic.h>
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <cstdint>
+
+/**
+ * Windows OS specific implementation aspects of the WebGPU backend
+ */
+
+namespace filament::backend {
+
+wgpu::Surface WebGPUPlatform::createSurface(void* nativeWindow, uint64_t /*flags*/) {
+    // TODO verify this is necessary for Dawn implementation as well:
+    // On (at least) NVIDIA drivers, the Vulkan implementation (specifically the call to
+    // vkGetPhysicalDeviceSurfaceCapabilitiesKHR()) does not correctly handle the fact that
+    // each native window has its own DPI_AWARENESS_CONTEXT, and erroneously uses the context
+    // of the calling thread. As a workaround, we set the current thread's DPI_AWARENESS_CONTEXT
+    // to that of the native window we've been given. This isn't a perfect solution, because an
+    // application could create swap chains on multiple native windows with varying DPI-awareness,
+    // but even then, at least one of the windows would be guaranteed to work correctly.
+    SetThreadDpiAwarenessContext(GetWindowDpiAwarenessContext((HWND) nativeWindow));
+    wgpu::SurfaceSourceWindowsHWND surfaceSourceWin{};
+    surfaceSourceWin.hinstance = GetModuleHandle(nullptr);
+    surfaceSourceWin.hwnd = nativeWindow;
+    wgpu::SurfaceDescriptor surfaceDescriptor{
+        .nextInChain = &surfaceSourceWin,
+        .label = "windows_surface"
+    };
+    wgpu::Surface surface = mInstance.CreateSurface(&surfaceDescriptor);
+    FILAMENT_CHECK_POSTCONDITION(surface != nullptr) << "Unable to create Windows-backed surface.";
+    return surface;
+}
+
+}// namespace filament::backend

filament/include/filament/ColorGrading.h

@@ -64,9 +64,8 @@ class ColorSpace;
  * Performance
  * ===========
  *
- * Creating a new ColorGrading object may be more expensive than other Filament objects as a
- * 3D LUT may need to be generated. The generation of a 3D LUT, if necessary, may happen on
- * the CPU.
+ * Creating a new ColorGrading object may be more expensive than other Filament objects as a LUT may
+ * need to be generated. The generation of this LUT, if necessary, may happen on the CPU.
  *
  * Ordering
  * ========
@@ -155,6 +154,9 @@ public:
          * 3D texture. For instance, a low quality level will use a 16x16x16 10 bit LUT, a medium
          * quality level will use a 32x32x32 10 bit LUT, a high quality will use a 32x32x32 16 bit
          * LUT, and a ultra quality will use a 64x64x64 16 bit LUT.
+         *
+         * This setting has no effect if generating a 1D LUT.
+         *
          * This overrides the values set by format() and dimensions().
          *
          * The default quality is medium.
@@ -169,6 +171,8 @@ public:
          * When color grading is implemented using a 3D LUT, this sets the texture format of
          * of the LUT. This overrides the value set by quality().
          *
+         * This setting has no effect if generating a 1D LUT.
+         *
          * The default is INTEGER
          *
          * @param format The desired format of the 3D LUT.
@@ -181,6 +185,8 @@ public:
          * When color grading is implemented using a 3D LUT, this sets the dimension of the LUT.
          * This overrides the value set by quality().
          *
+         * This setting has no effect if generating a 1D LUT.
+         *
          * The default is 32
          *
          * @param dim The desired dimension of the LUT. Between 16 and 64.

filament/include/filament/Texture.h

@@ -106,6 +106,13 @@ public:
     /** @return Whether a combination of texture format, pixel format and type is valid. */
     static bool validatePixelFormatAndType(InternalFormat internalFormat, Format format, Type type) noexcept;
 
+    /** @return the maximum size in texels of a texture of type \p type. At least 2048 for
+     * 2D textures, 256 for 3D textures. */
+    static size_t getMaxTextureSize(Engine& engine, Sampler type) noexcept;
+
+    /** @return the maximum number of layers supported by texture arrays. At least 256. */
+    static size_t getMaxArrayTextureLayers(Engine& engine) noexcept;
+
     /**
      * Options for environment prefiltering into reflection map
      *

filament/include/filament/ToneMapper.h

@@ -68,6 +68,21 @@ struct UTILS_PUBLIC ToneMapper {
      *         function applied ("linear")
      */
     virtual math::float3 operator()(math::float3 c) const noexcept = 0;
+
+    /**
+     * If true, then this function holds that f(x) = vec3(f(x.r), f(x.g), f(x.b))
+     *
+     * This may be used to indicate that the color grading's LUT only requires a 1D texture instead
+     * of a 3D texture, potentially saving a significant amount of memory and generation time.
+     */
+    virtual bool isOneDimensional() const noexcept { return false; }
+
+    /**
+     * True if this tonemapper only works in low-dynamic-range.
+     *
+     * This may be used to indicate that the color grading's LUT doesn't need to be log encoded.
+     */
+    virtual bool isLDR() const noexcept { return false; }
 };
 
 /**
@@ -79,6 +94,8 @@ struct UTILS_PUBLIC LinearToneMapper final : public ToneMapper {
     ~LinearToneMapper() noexcept final;
 
     math::float3 operator()(math::float3 c) const noexcept override;
+    bool isOneDimensional() const noexcept override { return true; }
+    bool isLDR() const noexcept override { return true; }
 };
 
 /**
@@ -91,6 +108,8 @@ struct UTILS_PUBLIC ACESToneMapper final : public ToneMapper {
     ~ACESToneMapper() noexcept final;
 
     math::float3 operator()(math::float3 c) const noexcept override;
+    bool isOneDimensional() const noexcept override { return false; }
+    bool isLDR() const noexcept override { return false; }
 };
 
 /**
@@ -104,6 +123,8 @@ struct UTILS_PUBLIC ACESLegacyToneMapper final : public ToneMapper {
     ~ACESLegacyToneMapper() noexcept final;
 
     math::float3 operator()(math::float3 c) const noexcept override;
+    bool isOneDimensional() const noexcept override { return false; }
+    bool isLDR() const noexcept override { return false; }
 };
 
 /**
@@ -117,6 +138,8 @@ struct UTILS_PUBLIC FilmicToneMapper final : public ToneMapper {
     ~FilmicToneMapper() noexcept final;
 
     math::float3 operator()(math::float3 x) const noexcept override;
+    bool isOneDimensional() const noexcept override { return true; }
+    bool isLDR() const noexcept override { return false; }
 };
 
 /**
@@ -129,6 +152,8 @@ struct UTILS_PUBLIC PBRNeutralToneMapper final : public ToneMapper {
     ~PBRNeutralToneMapper() noexcept final;
 
     math::float3 operator()(math::float3 x) const noexcept override;
+    bool isOneDimensional() const noexcept override { return false; }
+    bool isLDR() const noexcept override { return false; }
 };
 
 /**
@@ -150,6 +175,8 @@ struct UTILS_PUBLIC AgxToneMapper final : public ToneMapper {
     ~AgxToneMapper() noexcept final;
 
     math::float3 operator()(math::float3 x) const noexcept override;
+    bool isOneDimensional() const noexcept override { return false; }
+    bool isLDR() const noexcept override { return false; }
 
     AgxLook look;
 };
@@ -194,6 +221,8 @@ struct UTILS_PUBLIC GenericToneMapper final : public ToneMapper {
     GenericToneMapper& operator=(GenericToneMapper&& rhs) noexcept;
 
     math::float3 operator()(math::float3 x) const noexcept override;
+    bool isOneDimensional() const noexcept override { return true; }
+    bool isLDR() const noexcept override { return false; }
 
     /** Returns the contrast of the curve as a strictly positive value. */
     float getContrast() const noexcept;
@@ -256,6 +285,8 @@ struct UTILS_PUBLIC DisplayRangeToneMapper final : public ToneMapper {
     ~DisplayRangeToneMapper() noexcept override;
 
     math::float3 operator()(math::float3 c) const noexcept override;
+    bool isOneDimensional() const noexcept override { return false; }
+    bool isLDR() const noexcept override { return false; }
 };
 
 } // namespace filament

filament/src/PostProcessManager.cpp

@@ -2306,36 +2306,11 @@ void PostProcessManager::colorGradingPrepareSubpass(DriverApi& driver,
         const FColorGrading* colorGrading, ColorGradingConfig const& colorGradingConfig,
         VignetteOptions const& vignetteOptions, uint32_t const width, uint32_t const height) noexcept {
 
-    float4 const vignetteParameters = getVignetteParameters(vignetteOptions, width, height);
-
-    auto const& material = getPostProcessMaterial("colorGradingAsSubpass");
-    FMaterialInstance* const mi = PostProcessMaterial::getMaterialInstance(mEngine, material);
-
-    mi->setParameter("lut", colorGrading->getHwHandle(), {
-            .filterMag = SamplerMagFilter::LINEAR,
-            .filterMin = SamplerMinFilter::LINEAR,
-            .wrapS = SamplerWrapMode::CLAMP_TO_EDGE,
-            .wrapT = SamplerWrapMode::CLAMP_TO_EDGE,
-            .wrapR = SamplerWrapMode::CLAMP_TO_EDGE,
-            .anisotropyLog2 = 0
-    });
-    const float lutDimension = float(colorGrading->getDimension());
-    mi->setParameter("lutSize", float2{
-        0.5f / lutDimension, (lutDimension - 1.0f) / lutDimension,
-    });
-
-    const float temporalNoise = mUniformDistribution(mEngine.getRandomEngine());
-
-    mi->setParameter("vignette", vignetteParameters);
-    mi->setParameter("vignetteColor", vignetteOptions.color);
-    mi->setParameter("dithering", colorGradingConfig.dithering);
-    mi->setParameter("outputLuminance", colorGradingConfig.outputLuminance);
-    mi->setParameter("temporalNoise", temporalNoise);
+    auto& material = getPostProcessMaterial("colorGradingAsSubpass");
+    FMaterialInstance* const mi =
+            configureColorGradingMaterial(material, colorGrading, colorGradingConfig,
+                    vignetteOptions, width, height);
     mi->commit(driver);
-
-    // load both variants
-    material.getMaterial(mEngine, PostProcessVariant::OPAQUE);
-    material.getMaterial(mEngine, PostProcessVariant::TRANSLUCENT);
 }
 
 void PostProcessManager::colorGradingSubpass(DriverApi& driver,
@@ -2487,22 +2462,14 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::colorGrading(FrameGraph& fg,
 
                 auto const& out = resources.getRenderPassInfo();
 
-                auto const& material = getPostProcessMaterial("colorGrading");
-
-                PostProcessVariant const variant = colorGradingConfig.translucent ?
-                        PostProcessVariant::TRANSLUCENT : PostProcessVariant::OPAQUE;
+                auto const& input = resources.getDescriptor(data.input);
+                auto const& output = resources.getDescriptor(data.output);
 
+                auto& material = getPostProcessMaterial("colorGrading");
                 FMaterialInstance* const mi =
-                        PostProcessMaterial::getMaterialInstance(mEngine, material, variant);
+                        configureColorGradingMaterial(material, colorGrading, colorGradingConfig,
+                                vignetteOptions, output.width, output.height);
 
-                mi->setParameter("lut", colorGrading->getHwHandle(), {
-                        .filterMag = SamplerMagFilter::LINEAR,
-                        .filterMin = SamplerMinFilter::LINEAR
-                });
-                const float lutDimension = float(colorGrading->getDimension());
-                mi->setParameter("lutSize", float2{
-                        0.5f / lutDimension, (lutDimension - 1.0f) / lutDimension,
-                });
                 mi->setParameter("colorBuffer", colorTexture, { /* shader uses texelFetch */ });
                 mi->setParameter("bloomBuffer", bloomTexture, {
                         .filterMag = SamplerMagFilter::LINEAR,
@@ -2534,19 +2501,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::colorGrading(FrameGraph& fg,
                     bloomParameters.y = 1.0f - bloomParameters.x;
                 }
 
-                auto const& input = resources.getDescriptor(data.input);
-                auto const& output = resources.getDescriptor(data.output);
-                float4 const vignetteParameters = getVignetteParameters(
-                        vignetteOptions, output.width, output.height);
-
-                const float temporalNoise = mUniformDistribution(mEngine.getRandomEngine());
-
-                mi->setParameter("dithering", colorGradingConfig.dithering);
                 mi->setParameter("bloom", bloomParameters);
-                mi->setParameter("vignette", vignetteParameters);
-                mi->setParameter("vignetteColor", vignetteOptions.color);
-                mi->setParameter("outputLuminance", colorGradingConfig.outputLuminance);
-                mi->setParameter("temporalNoise", temporalNoise);
                 mi->setParameter("viewport", float4{
                         float(vp.left)   / input.width,
                         float(vp.bottom) / input.height,
@@ -2554,7 +2509,9 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::colorGrading(FrameGraph& fg,
                         float(vp.height) / input.height
                 });
 
-                commitAndRenderFullScreenQuad(driver, out, mi, variant);
+                commitAndRenderFullScreenQuad(driver, out, mi,
+                        colorGradingConfig.translucent
+                        ? PostProcessVariant::TRANSLUCENT : PostProcessVariant::OPAQUE);
             }
     );
 
@@ -2692,11 +2649,70 @@ void PostProcessManager::configureTemporalAntiAliasingMaterial(
     setConstantParameter(ma, "varianceGamma", taaOptions.varianceGamma);
     if (dirty) {
         ma->invalidate();
-        // TODO: call Material::compile(), we can't si that now because it works only
+        // TODO: call Material::compile(), we can't do that now because it works only
         //       with surface materials
     }
 }
 
+FMaterialInstance* PostProcessManager::configureColorGradingMaterial(
+        PostProcessMaterial& material, FColorGrading const* colorGrading,
+        ColorGradingConfig const& colorGradingConfig, VignetteOptions const& vignetteOptions,
+        uint32_t const width, uint32_t const height) noexcept {
+    FMaterial* const ma = material.getMaterial(mEngine);
+    bool dirty = false;
+
+    auto setConstantParameter =
+            [&dirty](FMaterial* const material, std::string_view const name, auto value) noexcept {
+        auto id = material->getSpecializationConstantId(name);
+        if (id.has_value()) {
+            if (material->setConstant(id.value(), value)) {
+                dirty = true;
+            }
+        }
+    };
+
+    setConstantParameter(ma, "isOneDimensional", colorGrading->isOneDimensional());
+    setConstantParameter(ma, "isLDR", colorGrading->isLDR());
+
+    if (dirty) {
+        ma->invalidate();
+        // TODO: call Material::compile(), we can't do that now because it works only
+        //       with surface materials
+    }
+
+    PostProcessVariant const variant = colorGradingConfig.translucent ?
+            PostProcessVariant::TRANSLUCENT : PostProcessVariant::OPAQUE;
+    FMaterialInstance* const mi =
+            PostProcessMaterial::getMaterialInstance(mEngine, material, variant);
+
+    const SamplerParams params = {
+            .filterMag = SamplerMagFilter::LINEAR,
+            .filterMin = SamplerMinFilter::LINEAR,
+            .wrapS = SamplerWrapMode::CLAMP_TO_EDGE,
+            .wrapT = SamplerWrapMode::CLAMP_TO_EDGE,
+            .wrapR = SamplerWrapMode::CLAMP_TO_EDGE,
+            .anisotropyLog2 = 0
+    };
+
+    mi->setParameter("lut", colorGrading->getHwHandle(), params);
+
+    const float lutDimension = float(colorGrading->getDimension());
+    mi->setParameter("lutSize", float2{
+        0.5f / lutDimension, (lutDimension - 1.0f) / lutDimension,
+    });
+
+    const float temporalNoise = mUniformDistribution(mEngine.getRandomEngine());
+
+    float4 const vignetteParameters = getVignetteParameters(vignetteOptions, width, height);
+    mi->setParameter("vignette", vignetteParameters);
+    mi->setParameter("vignetteColor", vignetteOptions.color);
+    mi->setParameter("dithering", colorGradingConfig.dithering);
+    mi->setParameter("outputLuminance", colorGradingConfig.outputLuminance);
+    mi->setParameter("temporalNoise", temporalNoise);
+
+    return mi;
+}
+
 FrameGraphId<FrameGraphTexture> PostProcessManager::taa(FrameGraph& fg,
         FrameGraphId<FrameGraphTexture> input,
         FrameGraphId<FrameGraphTexture> const depth,

filament/src/PostProcessManager.h

@@ -401,6 +401,13 @@ public:
             FMaterialInstance const* mi,
             PostProcessVariant variant = PostProcessVariant::OPAQUE) const noexcept;
 
+    // Sets the necessary spec constants and uniforms common to both colorGrading.mat and
+    // colorGradingAsSubpass.mat.
+    FMaterialInstance* configureColorGradingMaterial(
+            PostProcessMaterial& material, FColorGrading const* colorGrading,
+            ColorGradingConfig const& colorGradingConfig, VignetteOptions const& vignetteOptions,
+            uint32_t const width, uint32_t const height) noexcept;
+
 private:
     backend::RenderPrimitiveHandle mFullScreenQuadRph;
     backend::VertexBufferInfoHandle mFullScreenQuadVbih;

filament/src/Texture.cpp

@@ -108,4 +108,12 @@ bool Texture::validatePixelFormatAndType(InternalFormat internalFormat, Format f
     return FTexture::validatePixelFormatAndType(internalFormat, format, type);
 }
 
+size_t Texture::getMaxTextureSize(Engine& engine, Sampler type) noexcept {
+    return FTexture::getMaxTextureSize(downcast(engine), type);
+
+}
+size_t Texture::getMaxArrayTextureLayers(Engine& engine) noexcept {
+    return FTexture::getMaxArrayTextureLayers(downcast(engine));
+}
+
 } // namespace filament

filament/src/details/ColorGrading.cpp

@@ -35,7 +35,6 @@
 
 #include <cmath>
 #include <cstdlib>
-#include <mutex>
 #include <tuple>
 
 namespace filament {
@@ -581,8 +580,11 @@ static float3 luminanceScaling(float3 x,
 // Quality
 //------------------------------------------------------------------------------
 
-static std::tuple<TextureFormat, PixelDataFormat, PixelDataType>
-        selectLutTextureParams(ColorGrading::LutFormat const lutFormat) noexcept {
+static std::tuple<TextureFormat, PixelDataFormat, PixelDataType> selectLutTextureParams(
+        ColorGrading::LutFormat const lutFormat, const bool isOneDimensional) noexcept {
+    if (isOneDimensional) {
+        return { TextureFormat::R16F, PixelDataFormat::R, PixelDataType::HALF };
+    }
     // We use RGBA16F for high quality modes instead of RGB16F because RGB16F
     // is not supported everywhere
     switch (lutFormat) {
@@ -658,27 +660,44 @@ FColorGrading::FColorGrading(FEngine& engine, const Builder& builder) {
 
     DriverApi& driver = engine.getDriverApi();
 
-    Config c;
-    // This lock protects the data inside Config, which is written to by the Filament thread,
-    // and read from multiple Job threads.
-    Mutex configLock;
-    {
-        std::lock_guard<Mutex> const lock(configLock);
-        c.lutDimension          = builder->dimension;
-        c.adaptationTransform   = adaptationTransform(builder->whiteBalance);
-        c.colorGradingIn        = selectColorGradingTransformIn(builder->toneMapping);
-        c.colorGradingOut       = selectColorGradingTransformOut(builder->toneMapping);
-        c.colorGradingLuminance = selectColorGradingLuminance(builder->toneMapping);
-        c.oetf                  = selectOETF(builder->outputColorSpace);
+    // XXX: The following two conditions also only hold true as long as the input and output color
+    // spaces are the same, but we currently don't check that. We must revise these conditions if we
+    // ever handle this case.
+    mIsOneDimensional = !builder->hasAdjustments && !builder->luminanceScaling
+            && builder->toneMapper->isOneDimensional()
+            && engine.features.engine.color_grading.use_1d_lut;
+    mIsLDR = mIsOneDimensional && builder->toneMapper->isLDR();
+
+    const Config config = {
+            mIsOneDimensional ? 512u : builder->dimension,
+            adaptationTransform(builder->whiteBalance),
+            selectColorGradingTransformIn(builder->toneMapping),
+            selectColorGradingTransformOut(builder->toneMapping),
+            selectColorGradingLuminance(builder->toneMapping),
+            selectOETF(builder->outputColorSpace),
+    };
+
+    mDimension = config.lutDimension;
+
+    uint32_t width;
+    uint32_t height;
+    uint32_t depth;
+    if (mIsOneDimensional) {
+        width = config.lutDimension;
+        height = 1;
+        depth = 1;
+    } else {
+        width = config.lutDimension;
+        height = config.lutDimension;
+        depth = config.lutDimension;
     }
 
-    mDimension = c.lutDimension;
-
-    size_t lutElementCount = c.lutDimension * c.lutDimension * c.lutDimension;
-    size_t elementSize = sizeof(half4);
+    size_t lutElementCount = width * height * depth;
+    size_t elementSize = mIsOneDimensional ? sizeof(half) : sizeof(half4);
     void* data = malloc(lutElementCount * elementSize);
 
-    auto [textureFormat, format, type] = selectLutTextureParams(builder->format);
+    auto [textureFormat, format, type] =
+            selectLutTextureParams(builder->format, mIsOneDimensional);
     assert_invariant(FTexture::isTextureFormatSupported(engine, textureFormat));
     assert_invariant(FTexture::validatePixelFormatAndType(textureFormat, format, type));
 
@@ -688,170 +707,185 @@ FColorGrading::FColorGrading(FEngine& engine, const Builder& builder) {
         converted = malloc(lutElementCount * sizeof(uint32_t));
     }
 
+    auto hdrColorAt = [builder, config](size_t r, size_t g, size_t b) {
+        float3 v = float3{r, g, b} * (1.0f / float(config.lutDimension - 1u));
+
+        // LogC encoding
+        v = LogC_to_linear(v);
+
+        // Kill negative values near 0.0f due to imprecision in the log conversion
+        v = max(v, 0.0f);
+
+        if (builder->hasAdjustments) {
+            // Exposure
+            v = adjustExposure(v, builder->exposure);
+
+            // Purkinje shift ("low-light" vision)
+            v = scotopicAdaptation(v, builder->nightAdaptation);
+        }
+
+        // Move to color grading color space
+        v = config.colorGradingIn * v;
+
+        if (builder->hasAdjustments) {
+            // White balance
+            v = chromaticAdaptation(v, config.adaptationTransform);
+
+            // Kill negative values before the next transforms
+            v = max(v, 0.0f);
+
+            // Channel mixer
+            v = channelMixer(v, builder->outRed, builder->outGreen, builder->outBlue);
+
+            // Shadows/mid-tones/highlights
+            v = tonalRanges(v, config.colorGradingLuminance,
+                    builder->shadows, builder->midtones, builder->highlights,
+                    builder->tonalRanges);
+
+            // The adjustments below behave better in log space
+            v = linear_to_LogC(v);
+
+            // ASC CDL
+            v = colorDecisionList(v, builder->slope, builder->offset, builder->power);
+
+            // Contrast in log space
+            v = contrast(v, builder->contrast);
+
+            // Back to linear space
+            v = LogC_to_linear(v);
+
+            // Vibrance in linear space
+            v = vibrance(v, config.colorGradingLuminance, builder->vibrance);
+
+            // Saturation in linear space
+            v = saturation(v, config.colorGradingLuminance, builder->saturation);
+
+            // Kill negative values before curves
+            v = max(v, 0.0f);
+
+            // RGB curves
+            v = curves(v,
+                    builder->shadowGamma, builder->midPoint, builder->highlightScale);
+        }
+
+        // Tone mapping
+        if (builder->luminanceScaling) {
+            v = luminanceScaling(v, *builder->toneMapper, config.colorGradingLuminance);
+        } else {
+            v = (*builder->toneMapper)(v);
+        }
+
+        // Go back to display color space
+        v = config.colorGradingOut * v;
+
+        // Apply gamut mapping
+        if (builder->gamutMapping) {
+            // TODO: This should depend on the output color space
+            v = gamutMapping_sRGB(v);
+        }
+
+        // TODO: We should convert to the output color space if we use a working
+        //       color space that's not sRGB
+        // TODO: Allow the user to customize the output color space
+
+        // We need to clamp for the output transfer function
+        v = saturate(v);
+
+        // Apply OETF
+        v = config.oetf(v);
+
+        return v;
+    };
+
     //auto now = std::chrono::steady_clock::now();
 
-    // Multithreadedly generate the tone mapping 3D look-up table using 32 jobs
-    // Slices are 8 KiB (128 cache lines) apart.
-    // This takes about 3-6ms on Android in Release
-    JobSystem& js = engine.getJobSystem();
-    auto *slices = js.createJob();
-    for (size_t b = 0; b < c.lutDimension; b++) {
-        auto *job = js.createJob(slices,
-                [data, converted, b, &c, &configLock, builder](JobSystem&, JobSystem::Job*) {
-            Config config;
-            {
-                std::lock_guard<Mutex> lock(configLock);
-                config = c;
+    if (mIsOneDimensional) {
+        half* UTILS_RESTRICT p = (half*) data;
+        if (mIsLDR) {
+            for (size_t rgb = 0; rgb < config.lutDimension; rgb++) {
+                float3 v = float3(rgb) * (1.0f / float(config.lutDimension - 1u));
+
+                v = (*builder->toneMapper)(float3(v));
+
+                // We need to clamp for the output transfer function
+                v = saturate(v);
+
+                // Apply OETF
+                v = config.oetf(v);
+
+                *p++ = half(v.r);
             }
-            half4* UTILS_RESTRICT p = (half4*) data + b * config.lutDimension * config.lutDimension;
-            for (size_t g = 0; g < config.lutDimension; g++) {
-                for (size_t r = 0; r < config.lutDimension; r++) {
-                    float3 v = float3{r, g, b} * (1.0f / float(config.lutDimension - 1u));
-
-                    // LogC encoding
-                    v = LogC_to_linear(v);
-
-                    // Kill negative values near 0.0f due to imprecision in the log conversion
-                    v = max(v, 0.0f);
-
-                    if (builder->hasAdjustments) {
-                        // Exposure
-                        v = adjustExposure(v, builder->exposure);
-
-                        // Purkinje shift ("low-light" vision)
-                        v = scotopicAdaptation(v, builder->nightAdaptation);
+        } else {
+            for (size_t rgb = 0; rgb < config.lutDimension; rgb++) {
+                *p++ = half(hdrColorAt(rgb, rgb, rgb).r);
+            }
+        }
+    } else {
+        // Multithreadedly generate the tone mapping 3D look-up table using 32 jobs
+        // Slices are 8 KiB (128 cache lines) apart.
+        // This takes about 3-6ms on Android in Release
+        JobSystem& js = engine.getJobSystem();
+        auto *slices = js.createJob();
+        for (size_t b = 0; b < config.lutDimension; b++) {
+            auto* job = js.createJob(slices,
+                    [data, converted, b, &config, builder, &hdrColorAt](
+                            JobSystem&, JobSystem::Job*) {
+                half4* UTILS_RESTRICT p =
+                        (half4*) data + b * config.lutDimension * config.lutDimension;
+                for (size_t g = 0; g < config.lutDimension; g++) {
+                    for (size_t r = 0; r < config.lutDimension; r++) {
+                        *p++ = half4{hdrColorAt(r, g, b), 0.0f};
                     }
-
-                    // Move to color grading color space
-                    v = c.colorGradingIn * v;
-
-                    if (builder->hasAdjustments) {
-                        // White balance
-                        v = chromaticAdaptation(v, config.adaptationTransform);
-
-                        // Kill negative values before the next transforms
-                        v = max(v, 0.0f);
-
-                        // Channel mixer
-                        v = channelMixer(v, builder->outRed, builder->outGreen, builder->outBlue);
-
-                        // Shadows/mid-tones/highlights
-                        v = tonalRanges(v, c.colorGradingLuminance,
-                                builder->shadows, builder->midtones, builder->highlights,
-                                builder->tonalRanges);
-
-                        // The adjustments below behave better in log space
-                        v = linear_to_LogC(v);
-
-                        // ASC CDL
-                        v = colorDecisionList(v, builder->slope, builder->offset, builder->power);
-
-                        // Contrast in log space
-                        v = contrast(v, builder->contrast);
-
-                        // Back to linear space
-                        v = LogC_to_linear(v);
-
-                        // Vibrance in linear space
-                        v = vibrance(v, c.colorGradingLuminance, builder->vibrance);
-
-                        // Saturation in linear space
-                        v = saturation(v, c.colorGradingLuminance, builder->saturation);
-
-                        // Kill negative values before curves
-                        v = max(v, 0.0f);
-
-                        // RGB curves
-                        v = curves(v,
-                                builder->shadowGamma, builder->midPoint, builder->highlightScale);
-                    }
-
-                    // Tone mapping
-                    if (builder->luminanceScaling) {
-                        v = luminanceScaling(v, *builder->toneMapper, c.colorGradingLuminance);
-                    } else {
-                        v = (*builder->toneMapper)(v);
-                    }
-
-                    // Go back to display color space
-                    v = c.colorGradingOut * v;
-
-                    // Apply gamut mapping
-                    if (builder->gamutMapping) {
-                        // TODO: This should depend on the output color space
-                        v = gamutMapping_sRGB(v);
-                    }
-
-                    // TODO: We should convert to the output color space if we use a working
-                    //       color space that's not sRGB
-                    // TODO: Allow the user to customize the output color space
-
-                    // We need to clamp for the output transfer function
-                    v = saturate(v);
-
-                    // Apply OETF
-                    v = c.oetf(v);
-
-                    *p++ = half4{v, 0.0f};
                 }
-            }
 
-            if (converted) {
-                uint32_t* const UTILS_RESTRICT dst = (uint32_t*) converted +
-                        b * config.lutDimension * config.lutDimension;
-                half4* UTILS_RESTRICT src = (half4*) data +
-                        b * config.lutDimension * config.lutDimension;
-                // we use a vectorize width of 8 because, on ARMv8 it allows the compiler to write eight
-                // 32-bits results in one go.
-                const size_t count = (config.lutDimension * config.lutDimension) & ~0x7u; // tell the compiler that we're a multiple of 8
+                if (converted) {
+                    uint32_t* const UTILS_RESTRICT dst = (uint32_t*) converted +
+                            b * config.lutDimension * config.lutDimension;
+                    half4* UTILS_RESTRICT src = (half4*) data +
+                            b * config.lutDimension * config.lutDimension;
+                    // we use a vectorize width of 8 because, on ARMv8 it allows the compiler to
+                    // write eight 32-bits results in one go.
+                    const size_t count = (config.lutDimension * config.lutDimension) & ~0x7u; // tell the compiler that we're a multiple of 8
 #if defined(__clang__)
-                #pragma clang loop vectorize_width(8)
+#pragma clang loop vectorize_width(8)
 #endif
-                for (size_t i = 0; i < count; ++i) {
-                    float4 v{src[i]};
-                    uint32_t pr = uint32_t(std::floor(v.x * 1023.0f + 0.5f));
-                    uint32_t pg = uint32_t(std::floor(v.y * 1023.0f + 0.5f));
-                    uint32_t pb = uint32_t(std::floor(v.z * 1023.0f + 0.5f));
-                    dst[i] = (pb << 20u) | (pg << 10u) | pr;
+                    for (size_t i = 0; i < count; ++i) {
+                        float4 v{src[i]};
+                        uint32_t pr = uint32_t(std::floor(v.x * 1023.0f + 0.5f));
+                        uint32_t pg = uint32_t(std::floor(v.y * 1023.0f + 0.5f));
+                        uint32_t pb = uint32_t(std::floor(v.z * 1023.0f + 0.5f));
+                        dst[i] = (pb << 20u) | (pg << 10u) | pr;
+                    }
                 }
-            }
+            });
+            js.run(job);
+        }
 
-        });
-        js.run(job);
+        // TODO: Should we do a runAndRetain() and defer the wait() + texture creation until
+        //       getHwHandle() is invoked?
+        js.runAndWait(slices);
     }
 
-    // TODO: Should we do a runAndRetain() and defer the wait() + texture creation until
-    //       getHwHandle() is invoked?
-    js.runAndWait(slices);
-
     //std::chrono::duration<float, std::milli> duration = std::chrono::steady_clock::now() - now;
     //slog.d << "LUT generation time: " << duration.count() << " ms" << io::endl;
 
-    mLutHandle = driver.createTexture(
-            SamplerType::SAMPLER_3D,
-            1,
-            textureFormat,
-            1,
-            c.lutDimension,
-            c.lutDimension,
-            c.lutDimension,
-            TextureUsage::DEFAULT
-    );
-
     if (converted) {
         free(data);
         data = converted;
         elementSize = sizeof(uint32_t);
     }
 
+    // Create texture.
+    mLutHandle = driver.createTexture(SamplerType::SAMPLER_3D, 1, textureFormat, 1,
+            width, height, depth, TextureUsage::DEFAULT);
+
     driver.update3DImage(mLutHandle, 0,
             0, 0, 0,
-            c.lutDimension, c.lutDimension, c.lutDimension,
+            width, height, depth,
             PixelBufferDescriptor{
-                    data, lutElementCount * elementSize,format, type,
-                    [](void* buffer, size_t, void*) { free(buffer); }
-            }
-    );
+                data, lutElementCount * elementSize, format, type,
+                        [](void* buffer, size_t, void*) { free(buffer); }
+                        });
 }
 
 FColorGrading::~FColorGrading() noexcept = default;

filament/src/details/ColorGrading.h

@@ -42,12 +42,15 @@ public:
     void terminate(FEngine& engine);
 
     backend::TextureHandle getHwHandle() const noexcept { return mLutHandle; }
-
     uint32_t getDimension() const noexcept { return mDimension; }
+    bool isOneDimensional() const noexcept { return mIsOneDimensional; }
+    bool isLDR() const noexcept { return mIsLDR; }
 
 private:
     backend::TextureHandle mLutHandle;
     uint32_t mDimension;
+    bool mIsOneDimensional;
+    bool mIsLDR;
 };
 
 FILAMENT_DOWNCAST(ColorGrading)

filament/src/details/Engine.h

@@ -687,6 +687,9 @@ public:
 
     struct {
         struct {
+            struct {
+                bool use_1d_lut = false;
+            } color_grading;
             struct {
                 bool use_shadow_atlas = false;
             } shadows;
@@ -719,6 +722,9 @@ public:
             { "backend.opengl.assert_native_window_is_valid",
               "Asserts that the ANativeWindow is valid when rendering starts.",
               &features.backend.opengl.assert_native_window_is_valid, true },
+            { "engine.color_grading.use_1d_lut",
+              "Uses a 1D LUT for color grading.",
+              &features.engine.color_grading.use_1d_lut, false },
             { "engine.shadows.use_shadow_atlas",
               "Uses an array of atlases to store shadow maps.",
               &features.engine.shadows.use_shadow_atlas, false },

filament/src/details/Texture.cpp

@@ -153,9 +153,10 @@ Texture::Builder& Texture::Builder::name(const char* name, size_t const len) noe
 }
 
 Texture* Texture::Builder::build(Engine& engine) {
-    FILAMENT_CHECK_PRECONDITION(Texture::isTextureFormatSupported(engine, mImpl->mFormat))
-            << "Texture format " << uint16_t(mImpl->mFormat) << " not supported on this platform";
-
+    if (mImpl->mTarget != SamplerType::SAMPLER_EXTERNAL) {
+        FILAMENT_CHECK_PRECONDITION(Texture::isTextureFormatSupported(engine, mImpl->mFormat))
+                << "Texture format " << uint16_t(mImpl->mFormat) << " not supported on this platform";
+    }
     const bool isProtectedTexturesSupported =
             downcast(engine).getDriverApi().isProtectedTexturesSupported();
     const bool useProtectedMemory = bool(mImpl->mUsage & TextureUsage::PROTECTED);
@@ -164,6 +165,20 @@ Texture* Texture::Builder::build(Engine& engine) {
             (isProtectedTexturesSupported && useProtectedMemory) || !useProtectedMemory)
             << "Texture is PROTECTED but protected textures are not supported";
 
+    size_t const maxTextureDimension = getMaxTextureSize(engine, mImpl->mTarget);
+    size_t const maxTextureDepth = (mImpl->mTarget == Sampler::SAMPLER_2D_ARRAY ||
+                                    mImpl->mTarget == Sampler::SAMPLER_CUBEMAP_ARRAY)
+                                       ? getMaxArrayTextureLayers(engine)
+                                       : maxTextureDimension;
+
+    FILAMENT_CHECK_PRECONDITION(
+            mImpl->mWidth <= maxTextureDimension &&
+            mImpl->mHeight <= maxTextureDimension &&
+            mImpl->mDepth <= maxTextureDepth) << "Texture dimensions out of range: "
+                    << "width= " << mImpl->mWidth << " (>" << maxTextureDimension << ")"
+                    <<", height= " << mImpl->mHeight << " (>" << maxTextureDimension << ")"
+                    << ", depth= " << mImpl->mDepth << " (>" << maxTextureDepth << ")";
+
     const auto validateSamplerType = [&engine = downcast(engine)](SamplerType const sampler) -> bool {
         switch (sampler) {
             case SamplerType::SAMPLER_2D:
@@ -672,6 +687,14 @@ bool FTexture::isTextureSwizzleSupported(FEngine& engine) noexcept {
     return engine.getDriverApi().isTextureSwizzleSupported();
 }
 
+size_t FTexture::getMaxTextureSize(FEngine& engine, Sampler type) noexcept {
+    return engine.getDriverApi().getMaxTextureSize(type);
+}
+
+size_t FTexture::getMaxArrayTextureLayers(FEngine& engine) noexcept {
+    return engine.getDriverApi().getMaxArrayTextureLayers();
+}
+
 size_t FTexture::computeTextureDataSize(Format const format, Type const type,
         size_t const stride, size_t const height, size_t const alignment) noexcept {
     return PixelBufferDescriptor::computeDataSize(format, type, stride, height, alignment);

filament/src/details/Texture.h

@@ -124,6 +124,10 @@ public:
     static bool validatePixelFormatAndType(backend::TextureFormat internalFormat,
             backend::PixelDataFormat format, backend::PixelDataType type) noexcept;
 
+    static size_t getMaxTextureSize(FEngine& engine, Sampler type) noexcept;
+
+    static size_t getMaxArrayTextureLayers(FEngine& engine) noexcept;
+
     bool textureHandleCanMutate() const noexcept;
     void updateLodRange(uint8_t level) noexcept;
 

filament/src/materials/colorGrading/colorGrading.fs

@@ -1,13 +1,29 @@
-vec3 colorGrade(mediump sampler3D lut, const vec3 x) {
+vec3 LogC_to_linear(const vec3 x) {
     // Alexa LogC EI 1000
     const float a = 5.555556;
     const float b = 0.047996;
     const float c = 0.244161 / log2(10.0);
     const float d = 0.386036;
-    vec3 logc = c * log2(a * x + b) + d;
+    return c * log2(a * x + b) + d;
+}
 
-    // Remap to sample pixel centers
-    logc = materialParams.lutSize.x + logc * materialParams.lutSize.y;
+vec3 colorGrade3D(mediump sampler3D lut, const vec3 v) {
+    return textureLod(lut, v, 0.0).rgb;
+}
 
-    return textureLod(lut, logc, 0.0).rgb;
+vec3 colorGrade1D(mediump sampler3D lut, const vec3 v) {
+    return vec3(
+        textureLod(lut, vec3(v.r, 0.5, 0.5), 0.0).r,
+        textureLod(lut, vec3(v.g, 0.5, 0.5), 0.0).r,
+        textureLod(lut, vec3(v.b, 0.5, 0.5), 0.0).r);
+}
+
+vec3 colorGrade(mediump sampler3D lut, vec3 v) {
+    if (!materialConstants_isLDR) {
+        v = LogC_to_linear(v);
+    }
+    // Remap to sample pixel centers.
+    v = materialParams.lutSize.x + v * materialParams.lutSize.y;
+    return materialConstants_isOneDimensional
+            ? colorGrade1D(lut, v) : colorGrade3D(lut, v);
 }

filament/src/materials/colorGrading/colorGrading.mat

@@ -66,6 +66,16 @@ material {
             precision : high
         }
     ],
+    constants : [
+        {
+            type : bool,
+            name : isOneDimensional
+        },
+        {
+            type : bool,
+            name : isLDR
+        }
+    ],
     variables : [
         vertex
     ],
@@ -154,7 +164,7 @@ void postProcess(inout PostProcessInputs postProcess) {
     }
 
     // Color grading
-    color.rgb  = colorGrade(materialParams_lut, color.rgb);
+    color.rgb = colorGrade(materialParams_lut, color.rgb);
 
     // output in premultiplied alpha
 #if !POST_PROCESS_OPAQUE

filament/src/materials/colorGrading/colorGradingAsSubpass.mat

@@ -32,6 +32,16 @@ material {
             name : vignetteColor
         }
     ],
+    constants : [
+        {
+            type : bool,
+            name : isOneDimensional
+        },
+        {
+            type : bool,
+            name : isLDR
+        }
+    ],
     subpasses : [
         {
             type : subpassInput,
@@ -78,6 +88,10 @@ fragment {
 void dummy(){}
 
 vec4 resolveFragment() {
+#ifdef TARGET_WEBGPU_ENVIRONMENT
+    //WebGPU Can not handle subpasses.
+    return vec4(0,0,0,1);
+#else
 #if POST_PROCESS_OPAQUE
     return vec4(subpassLoad(materialParams_colorBuffer).rgb, 1.0);
 #else
@@ -85,6 +99,7 @@ vec4 resolveFragment() {
     color.rgb *= 1.0 / (color.a + FLT_EPS);
     return color;
 #endif
+#endif
 }
 
 void postProcess(inout PostProcessInputs postProcess) {
@@ -98,7 +113,7 @@ void postProcess(inout PostProcessInputs postProcess) {
     }
 
     // Color grading
-    color.rgb  = colorGrade(materialParams_lut, color.rgb);
+    color.rgb = colorGrade(materialParams_lut, color.rgb);
 
     // output in premultiplied alpha
 #if !POST_PROCESS_OPAQUE

filament/src/materials/colorGrading/customResolveAsSubpass.mat

@@ -39,11 +39,16 @@ fragment {
     void dummy(){}
 
 vec4 resolveFragment() {
+#ifdef TARGET_WEBGPU_ENVIRONMENT
+    //WebGPU Can not handle subpasses.
+    return vec4(0,0,0,1);
+#else
 #if POST_PROCESS_OPAQUE
     return vec4(subpassLoad(materialParams_colorBuffer).rgb, 1.0);
 #else
     return subpassLoad(materialParams_colorBuffer);
 #endif
+#endif
 }
 
 void postProcess(inout PostProcessInputs postProcess) {

filament/src/materials/dof/dofMedian.mat

@@ -88,7 +88,12 @@ void minLeftMaxRight(inout vec4 a, inout vec4 b, inout vec4 c, inout vec4 d, ino
 
 // - we can't use a function because offset must be a constant expression
 // - we can't use line continuation because that's not supported on desktop
+#ifdef TARGET_WEBGPU_ENVIRONMENT
+//WebGPU can not handle texelFetchOffset without an error about "ConstOffset is only permitted...".
+#define makeSample(ij, o) vec4(texelFetch(materialParams_dof, ij+o, 0).rgb, texelFetch(materialParams_alpha, ij+o, 0).r)
+#else
 #define makeSample(ij, o) vec4(texelFetchOffset(materialParams_dof, ij, 0, o).rgb, texelFetchOffset(materialParams_alpha, ij, 0, o).r)
+#endif
 
 vec4 median(ivec2 ij) {
     vec4 v[9];

ios/CocoaPods/Filament.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
   spec.name = "Filament"
-  spec.version = "1.58.0"
+  spec.version = "1.58.1"
   spec.license = { :type => "Apache 2.0", :file => "LICENSE" }
   spec.homepage = "https://google.github.io/filament"
   spec.authors = "Google LLC."
   spec.summary = "Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WASM/WebGL."
   spec.platform = :ios, "11.0"
-  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.58.0/filament-v1.58.0-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.58.1/filament-v1.58.1-ios.tgz" }
 
   # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
   spec.pod_target_xcconfig = {

libs/bluegl/CMakeLists.txt

@@ -31,13 +31,17 @@ if (WIN32)
         set(SRCS ${SRCS} src/BlueGLCoreWindowsImpl.S)
     endif()
 elseif (APPLE AND NOT IOS)
-    set(SRCS ${SRCS} src/BlueGLDarwin.cpp)
+    if (FILAMENT_SUPPORTS_OSMESA)
+        set(SRCS ${SRCS} src/BlueGLOSMesa.cpp)
+    else()
+        set(SRCS ${SRCS} src/BlueGLDarwin.cpp)
+    endif()
     set(SRCS ${SRCS} src/BlueGLCoreDarwinUniversalImpl.S)
 elseif(LINUX)
-    if(FILAMENT_SUPPORTS_EGL_ON_LINUX)
+    if (FILAMENT_SUPPORTS_EGL_ON_LINUX)
         set(SRCS ${SRCS} src/BlueGLLinuxEGL.cpp)
-    elseif(FILAMENT_SUPPORTS_OSMESA)
-        set(SRCS ${SRCS} src/BlueGLLinuxOSMesa.cpp)
+    elseif (FILAMENT_SUPPORTS_OSMESA)
+        set(SRCS ${SRCS} src/BlueGLOSMesa.cpp)
     else()
         set(SRCS ${SRCS} src/BlueGLLinux.cpp)
     endif()
@@ -53,7 +57,11 @@ include_directories(${PUBLIC_HDR_DIR})
 add_library(${TARGET} STATIC ${PUBLIC_HDRS} ${SRCS})
 
 if(FILAMENT_SUPPORTS_OSMESA)
-    target_compile_options(${TARGET} PRIVATE -I${FILAMENT_OSMESA_PATH}/include/GL)
+    if (APPLE)
+        target_compile_options(${TARGET} PRIVATE -I${FILAMENT_OSMESA_PATH}/include)
+    else()
+        target_compile_options(${TARGET} PRIVATE -I${FILAMENT_OSMESA_PATH}/include/GL)
+    endif()
 endif()
 
 # specify where the public headers of this library are

libs/bluegl/src/BlueGLOSMesa.cpp

@@ -17,42 +17,64 @@
 #include <dlfcn.h>
 #include <string.h>
 
+#if defined(__linux__)
+
 #include <osmesa.h>
 
+// This is to ensure that linking during compilation will not fail even if
+// OSMesaGetProcAddress is not linked.
+__attribute__((weak)) OSMESAproc OSMesaGetProcAddress(char const*);
+
+#elif defined(__APPLE__)
+
+#include <GL/osmesa.h>
+
+#endif // __linux__
+
+#if defined(__linux__)
+#endif
+
 namespace bluegl {
 
 namespace {
 using ProcAddressFunc = void*(*)(char const* funcName);
 }
 
-// This is to ensure that linking during compilation will not fail even if
-// OSMesaGetProcAddress is not linked.
-__attribute__((weak)) OSMESAproc OSMesaGetProcAddress(char const*);
-
 struct Driver {
     ProcAddressFunc OSMesaGetProcAddress;
     void* library;
 } g_driver = {nullptr, nullptr};
 
 bool initBinder() {
-    constexpr char const* libraryNames[] = {"libOSMesa.so", "libosmesa.so"};
+    static constexpr char const* libraryNames[] = {
+#if defined(__linux__)
+        "libOSMesa.so",
+        "libosmesa.so",
+#elif defined(__APPLE__)
+        "libOSMesa.dylib",
+#endif
+    };
     for (char const* name: libraryNames) {
         g_driver.library = dlopen(name, RTLD_GLOBAL | RTLD_NOW);
         if (g_driver.library) {
             break;
         }
     }
-    if (!g_driver.library) {
-        // The library has been linked explicitly during compile.
-        g_driver.OSMesaGetProcAddress = (ProcAddressFunc) dlsym(RTLD_LOCAL, "OSMesaGetProcAddress");
-    } else {
+    if (g_driver.library) {
+        // Linking against a libosmesa.so.
         g_driver.OSMesaGetProcAddress =
                 (ProcAddressFunc) dlsym(g_driver.library, "OSMesaGetProcAddress");
     }
-
+#if defined(__linux__)
+    else {
+        // If Filament was built as a dynamic library.
+        g_driver.OSMesaGetProcAddress = (ProcAddressFunc) dlsym(RTLD_LOCAL, "OSMesaGetProcAddress");
+    }
     if (!g_driver.OSMesaGetProcAddress) {
+        // If statically linking OSMesa.
         g_driver.OSMesaGetProcAddress = (ProcAddressFunc) OSMesaGetProcAddress;
     }
+#endif
 
     return g_driver.OSMesaGetProcAddress;
 }

libs/fgviewer/README.md

@@ -12,7 +12,7 @@
 
 ## Capabilities
 
-fgviewer is a library and web application for real-time visualization of the frame graph in Filament.  
+fgviewer is a library and web application for real-time visualization of the frame graph in Filament.
 It displays active passes and resource usage, providing insights into the rendering pipeline.
 
 ## Setup for Desktop

libs/fgviewer/include/fgviewer/FrameGraphInfo.h

@@ -58,7 +58,7 @@ public:
             utils::CString name;
             utils::CString value;
         };
-        
+
         Resource(ResourceId id, utils::CString name,
                  std::vector<Property> properties);
 

libs/fgviewer/src/ApiHandler.cpp

@@ -17,14 +17,22 @@
 
 #include "ApiHandler.h"
 
+#include <__chrono/duration.h>
 #include <fgviewer/DebugServer.h>
 #include <fgviewer/JsonWriter.h>
 
 #include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
+#include <utils/ostream.h>
 
 #include <CivetServer.h>
 
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <mutex>
+#include <string>
+
 namespace filament::fgviewer {
 
 using namespace std::chrono_literals;

libs/fgviewer/src/DebugServer.cpp

@@ -21,36 +21,45 @@
 
 #include <CivetServer.h>
 
-#include <utils/FixedCapacityVector.h>
-#include <utils/Hash.h>
 #include <utils/Log.h>
+#include <utils/Mutex.h>
+#include <utils/ostream.h>
 
+#include <mutex>
 #include <string>
 #include <string_view>
 
-namespace filament::fgviewer {
 
 // If set to 0, this serves HTML from a resgen resource. Use 1 only during local development, which
 // serves files directly from the source code tree.
 #define SERVE_FROM_SOURCE_TREE 0
 
 #if SERVE_FROM_SOURCE_TREE
+
 namespace {
 std::string const BASE_URL = "libs/fgviewer/web";
 } // anonymous
+
 #else
+
 #include "fgviewer_resources.h"
 #include <unordered_map>
 
 namespace {
+
 struct Asset {
     std::string_view mime;
     std::string_view data;
 };
+
 std::unordered_map<std::string_view, Asset> ASSET_MAP;
+
 } // anonymous
+
 #endif // SERVE_FROM_SOURCE_TREE
 
+namespace filament::fgviewer {
+
 using namespace utils;
 
 std::string_view const DebugServer::kSuccessHeader =

libs/fgviewer/src/FrameGraphInfo.cpp

@@ -16,6 +16,11 @@
 
 #include <fgviewer/FrameGraphInfo.h>
 
+#include <utils/CString.h>
+
+#include <unordered_map>
+#include <vector>
+
 namespace filament::fgviewer {
 
 FrameGraphInfo::FrameGraphInfo(utils::CString viewName):

libs/fgviewer/src/JsonWriter.cpp

@@ -14,11 +14,15 @@
  * limitations under the License.
  */
 
-#include <fgviewer/JsonWriter.h>
 #include <fgviewer/FrameGraphInfo.h>
+#include <fgviewer/JsonWriter.h>
 
-#include <iomanip>
+#include <utils/CString.h>
+
+#include <cstddef>
+#include <ostream>
 #include <sstream>
+#include <vector>
 
 namespace filament::fgviewer {
 

libs/fgviewer/web/app.js

@@ -223,8 +223,8 @@ class FrameGraphSidePanel extends LitElement {
             return html`
                 <menu-section title="${title}">
                     ${this.framegraphs.map(({ fgid, name }) => html`
-                        <div class="framegraph" 
-                            @click="${() => this._handleFrameGraphClick(fgid)}" 
+                        <div class="framegraph"
+                            @click="${() => this._handleFrameGraphClick(fgid)}"
                             data-id="${fgid}">
                             ${fgid === this.selectedFrameGraph ? '● ' : ''}${name}
                         </div>
@@ -440,15 +440,15 @@ class FrameGraphTable extends LitElement {
         return html`
             <tr id="resource-${resourceIndex}">
                 <th class="sticky-col resource ${selectedStyle}" @click="${onClickResource}">
-                    ${hasSubresources 
+                    ${hasSubresources
                         ? html`
                             <span class="toggle-icon"
                                   @click="${(e) => { e.stopPropagation(); this._toggleCollapse(resourceIndex); }}">
                               ${isExpanded ? '▼' : '▶'}
-                            </span>` 
+                            </span>`
                         : nothing}
                     ${resource.name}
-                    ${hasSubresources && isExpanded ? nothing : html`(${subresourceIds.length})`}
+                    ${hasSubresources && !isExpanded ? html`(${subresourceIds.length})` : nothing}
                 </th>
                 ${this._renderResourceUsage(allPasses, resourceIds, DEFAULT_COLOR)}
             </tr>
@@ -592,12 +592,12 @@ class FrameGraphViewer extends LitElement {
         return html`
             <framegraph-sidepanel id="sidepanel"
                 ?connected="${this.connected}"
-                selected-framegraph="${this.selectedFrameGraph}" 
+                selected-framegraph="${this.selectedFrameGraph}"
                 selected-resource="${this.selectedResourceId}">
             </framegraph-sidepanel>
-            <framegraph-table id="table" 
+            <framegraph-table id="table"
                 ?connected="${this.connected}"
-                selected-framegraph="${this.selectedFrameGraph}" 
+                selected-framegraph="${this.selectedFrameGraph}"
                 selected-resource="${this.selectedResourceId}">
             </framegraph-table>
         `;

libs/filabridge/include/filament/MaterialEnums.h

@@ -28,7 +28,7 @@
 namespace filament {
 
 // update this when a new version of filament wouldn't work with older materials
-static constexpr size_t MATERIAL_VERSION = 57;
+static constexpr size_t MATERIAL_VERSION = 58;
 
 /**
  * Supported shading models
@@ -203,7 +203,7 @@ enum class ReflectionMode : uint8_t {
 // can't really use std::underlying_type<AttributeIndex>::type because the driver takes a uint32_t
 using AttributeBitset = utils::bitset32;
 
-static constexpr size_t MATERIAL_PROPERTIES_COUNT = 29;
+static constexpr size_t MATERIAL_PROPERTIES_COUNT = 30;
 enum class Property : uint8_t {
     BASE_COLOR,              //!< float4, all shading models
     ROUGHNESS,               //!< float,  lit shading models only
@@ -234,6 +234,7 @@ enum class Property : uint8_t {
     BENT_NORMAL,             //!< float3, all shading models only, except unlit
     SPECULAR_FACTOR,         //!< float, lit shading models only, except subsurface and cloth
     SPECULAR_COLOR_FACTOR,   //!< float3, lit shading models only, except subsurface and cloth
+    SHADOW_STRENGTH,         //!< float, [0, 1] strength of shadows received by this material
 
     // when adding new Properties, make sure to update MATERIAL_PROPERTIES_COUNT
 };

libs/filamat/CMakeLists.txt

@@ -144,6 +144,12 @@ set(FILAMAT_LIB_NAME ${CMAKE_STATIC_LIBRARY_PREFIX}filamat${CMAKE_STATIC_LIBRARY
 install(FILES "${FILAMAT_COMBINED_OUTPUT}" DESTINATION lib/${DIST_DIR} RENAME ${FILAMAT_LIB_NAME})
 install(DIRECTORY ${PUBLIC_HDR_DIR}/filamat DESTINATION include)
 
+# Need to install libtint for filamat on Android.
+# See libs/filamat/CMakeLists.txt and android/filamat-android/CMakeLists.txt.
+if (ANDROID)
+   target_link_libraries(${TARGET} libtint_combined)
+endif()
+
 # ==================================================================================================
 # Tests
 # ==================================================================================================

libs/filamat/include/filamat/MaterialBuilder.h

@@ -217,12 +217,13 @@ public:
     MaterialBuilder(MaterialBuilder&& rhs) noexcept = default;
     MaterialBuilder& operator=(MaterialBuilder&& rhs) noexcept = default;
 
-    static constexpr size_t MATERIAL_VARIABLES_COUNT = 4;
+    static constexpr size_t MATERIAL_VARIABLES_COUNT = 5;
     enum class Variable : uint8_t {
         CUSTOM0,
         CUSTOM1,
         CUSTOM2,
-        CUSTOM3
+        CUSTOM3,
+        CUSTOM4, // CUSTOM4 is only available if the vertex attribute `color` is not required.
         // when adding more variables, make sure to update MATERIAL_VARIABLES_COUNT
     };
 

libs/filamat/src/Enums.cpp

@@ -49,7 +49,8 @@ std::unordered_map<std::string, Property> Enums::mStringToProperty = {
         { "microThickness",      Property::MICRO_THICKNESS },
         { "bentNormal",          Property::BENT_NORMAL },
         { "specularFactor",      Property::SPECULAR_FACTOR },
-        { "specularColorFactor",  Property::SPECULAR_COLOR_FACTOR }
+        { "specularColorFactor", Property::SPECULAR_COLOR_FACTOR },
+        { "shadowStrength",       Property::SHADOW_STRENGTH }
 };
 
 template <>

libs/filamat/src/GLSLPostProcessor.cpp

@@ -517,24 +517,104 @@ void GLSLPostProcessor::spirvToMsl(const SpirvBlob* spirv, std::string* outMsl,
         MetalArgumentBuffer::destroy(&argBuffer);
     }
 }
+void GLSLPostProcessor::rebindImageSamplerForWGSL(std::vector<uint32_t>& spirv) {
+    constexpr size_t HEADER_SIZE = 5;
+    size_t const dataSize = spirv.size();
+    uint32_t* data = spirv.data();
 
-bool GLSLPostProcessor::spirvToWgsl(const SpirvBlob *spirv, std::string *outWsl) {
+    struct Descriptor {
+        uint32_t binding = 0xFFFFFFFF;
+        bool fixed = false;
+    };
+
+    std::unordered_map<uint32_t, Descriptor> descriptors;
+    std::set<uint32_t> unidentifiedLoadTargets;
+    std::vector<uint32_t> bindingTargets;
+
+    auto getDesc = [&](uint32_t var) -> Descriptor& {
+        using itertype = std::unordered_map<uint32_t, Descriptor>::iterator;
+        itertype itr;
+        if (itr = descriptors.find(var); itr == descriptors.end()) {
+            itr = descriptors.insert({var, {}}).first;
+        }
+        return itr->second;
+    };
+
+    auto pass = [&](uint32_t targetOp, std::function<void(uint32_t)> f) {
+        for (uint32_t cursor = HEADER_SIZE, cursorEnd = dataSize; cursor < cursorEnd;) {
+            uint32_t const firstWord = data[cursor];
+            uint32_t const wordCount = firstWord >> 16;
+            uint32_t const op = firstWord & 0x0000FFFF;
+            if (targetOp == op) {
+                f(cursor+1);
+            }
+            cursor += wordCount;
+        }
+    };
+
+    uint32_t samplerTypeId = 0;
+    pass(spv::Op::OpName, [&](uint32_t pos) {
+        auto target = data[pos];
+        char* name = (char*)&data[pos+1];
+        std::string_view view(name);
+        if (view.find("_sampler") != std::string_view::npos) {
+            unidentifiedLoadTargets.insert(target);
+        }
+});
+
+
+    // Write out the offsetted bindings
+    pass(spv::Op::OpDecorate, [&](uint32_t pos) {
+        uint32_t const type = data[pos + 1];
+        if (type == spv::Decoration::DecorationBinding) {
+            uint32_t const targetVar = data[pos];
+            if (unidentifiedLoadTargets.find(targetVar) != unidentifiedLoadTargets.end()) {
+                data[pos + 2] = data[pos + 2]*2 + 1;
+            }
+            else {
+                data[pos + 2] = data[pos + 2] *2;
+            }
+        }
+    });
+}
+
+bool GLSLPostProcessor::spirvToWgsl(SpirvBlob *spirv, std::string *outWsl) {
 #if FILAMENT_SUPPORTS_WEBGPU
-    //Currently no options we want to use
-    const tint::spirv::reader::Options readerOpts{};
+    //We need to run some opt-passes at all times to transpile to WGSL
+    auto optimizer = createEmptyOptimizer();
+    optimizer->RegisterPass(CreateSplitCombinedImageSamplerPass());
+    //optimizer->RegisterPass(CreateResolveBindingConflictsPass());
+
+    optimizeSpirv(optimizer, *spirv);
+
+    //After splitting the image samplers, we need to remap the bindings to separate them.
+    //TODO: This has issues, so use CreateResolveBindingConflictsPass instead. Mapping is less predictable but short term
+    rebindImageSamplerForWGSL(*spirv);
+
+    //Allow non-uniform derivitives due to our nested shaders. See https://github.com/gpuweb/gpuweb/issues/3479
+    const tint::spirv::reader::Options readerOpts{true};
     tint::wgsl::writer::Options writerOpts{};
 
     tint::Program tintRead = tint::spirv::reader::Read(*spirv, readerOpts);
 
     if (tintRead.Diagnostics().ContainsErrors()) {
-        //TODO remove this if block once combined image sampler conversion works.
-        if (tintRead.Diagnostics().Str().rfind("error: WGSL does not support combined image-samplers") != std::string::npos) {
-            slog.w << "This tint reader error is currently ignored during WebGPU bringup: " << tintRead.Diagnostics().Str() << io::endl;
-        }
-        else {
-            slog.e << "Tint Reader Error: " << tintRead.Diagnostics().Str() << io::endl;
-            return false;
-        }
+        //We know errors can potentially crop up, and want the ability to ignore them if needed for sample bringup
+#ifndef FILAMENT_WEBGPU_IGNORE_TNT_READ_ERRORS
+        slog.e << "Tint Reader Error: " << tintRead.Diagnostics().Str() << io::endl;
+        spv_context context = spvContextCreate(SPV_ENV_VULKAN_1_1_SPIRV_1_4);
+        spv_text text = nullptr;
+        spv_diagnostic diagnostic = nullptr;
+        spv_result_t result = spvBinaryToText(
+            context,
+            spirv->data(),
+            spirv->size(),
+            SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | SPV_BINARY_TO_TEXT_OPTION_COLOR,
+            &text,
+            &diagnostic);
+        slog.e << "Beginning SpirV-output dump\n\n" << text->str << "\n\nEndSPIRV\n" << io::endl;
+        spvTextDestroy(text);
+        return false;
+#endif
     }
 
     tint::Result<tint::wgsl::writer::Output> wgslOut = tint::wgsl::writer::Generate(tintRead,writerOpts);
@@ -882,10 +962,8 @@ bool GLSLPostProcessor::fullOptimization(const TShader& tShader,
     return true;
 }
 
-std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
-        MaterialBuilder::Optimization optimization, Config const& config) {
+std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createEmptyOptimizer() {
     auto optimizer = std::make_shared<spvtools::Optimizer>(SPV_ENV_UNIVERSAL_1_3);
-
     optimizer->SetMessageConsumer([](spv_message_level_t level,
             const char* source, const spv_position_t& position, const char* message) {
         if (!filterSpvOptimizerMessage(level)) {
@@ -894,6 +972,12 @@ std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
         slog.e << stringifySpvOptimizerMessage(level, source, position, message)
                 << io::endl;
     });
+    return optimizer;
+}
+
+std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
+        MaterialBuilder::Optimization optimization, Config const& config) {
+    auto optimizer = createEmptyOptimizer();
 
     if (optimization == MaterialBuilder::Optimization::SIZE) {
         // When optimizing for size, we don't run the SPIR-V through any size optimization passes
@@ -918,7 +1002,7 @@ std::shared_ptr<spvtools::Optimizer> GLSLPostProcessor::createOptimizer(
     return optimizer;
 }
 
-void GLSLPostProcessor::optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv) const {
+void GLSLPostProcessor::optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv) {
     if (!optimizer->Run(spirv.data(), spirv.size(), &spirv)) {
         slog.e << "SPIR-V optimizer pass failed" << io::endl;
         return;
@@ -972,7 +1056,7 @@ void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config c
 
     RegisterPass(CreateWrapOpKillPass());
     RegisterPass(CreateDeadBranchElimPass());
-    RegisterPass(CreateMergeReturnPass(), MaterialBuilder::TargetApi::METAL);
+    RegisterPass(CreateMergeReturnPass(), MaterialBuilder::TargetApi::METAL | MaterialBuilder::TargetApi::WEBGPU);
     RegisterPass(CreateInlineExhaustivePass());
     RegisterPass(CreateAggressiveDCEPass());
     RegisterPass(CreatePrivateToLocalPass());