Gemini tinkering 3

.github/workflows/presubmit.yml

@@ -41,7 +41,8 @@ jobs:
 
   build-windows:
     name: build-windows
-    runs-on: windows-2022-32core
+    runs-on: win-2019-16core
+
     steps:
       - uses: actions/checkout@v4.1.6
         with:

.github/workflows/release.yml

@@ -226,7 +226,7 @@ jobs:
 
   build-windows:
     name: build-windows
-    runs-on: windows-2022-32core
+    runs-on: windows-2019-32core
     if: github.event_name == 'release' || github.event.inputs.platform == 'windows'
 
     steps:

.github/workflows/windows-continuous.yml

@@ -10,7 +10,7 @@ on:
 jobs:
   build-windows:
     name: build-windows
-    runs-on: windows-2022-32core
+    runs-on: windows-2019-32core
 
     steps:
       - uses: actions/checkout@v4.1.6

CMakeLists.txt

@@ -49,10 +49,6 @@ option(FILAMENT_SUPPORTS_OSMESA "Enable OSMesa (headless GL context) for Filamen
 
 option(FILAMENT_ENABLE_FGVIEWER "Enable the frame graph viewer" OFF)
 
-# This is to disable GTAO for the short-term while we investigate a way to better manage size increases.
-# On the regular filament build (where size is of less concern), we enable GTAO by default.
-option(FILAMENT_DISABLE_GTAO "Disable GTAO" OFF)
-
 set(FILAMENT_NDK_VERSION "" CACHE STRING
     "Android NDK version or version prefix to be used when building for Android."
 )

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.61.0'
+    implementation 'com.google.android.filament:filament-android:1.60.1'
 }
 ```
 
@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:
 
 ```shell
-pod 'Filament', '~> 1.61.0'
+pod 'Filament', '~> 1.60.1'
 ```
 
 ## Documentation

android/gradle.properties

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

build/windows/build-github.bat

@@ -47,11 +47,7 @@ if "%RUNNING_LOCALLY%" == "1" (
     set "PATH=%PATH%;C:\Program Files\7-Zip"
 )
 
-:: Outdated windows-2019 pattern
-:: call "C:\Program Files (x86)\Microsoft Visual Studio\2019\%VISUAL_STUDIO_VERSION%\VC\Auxiliary\Build\vcvars64.bat"
-
-call "C:\Program Files\Microsoft Visual Studio\2022\%VISUAL_STUDIO_VERSION%\VC\Auxiliary\Build\vcvars64.bat"
-echo Passed vcvars64.bat
+call "C:\Program Files (x86)\Microsoft Visual Studio\2019\%VISUAL_STUDIO_VERSION%\VC\Auxiliary\Build\vcvars64.bat"
 if errorlevel 1 exit /b %errorlevel%
 
 msbuild /version
@@ -111,7 +107,7 @@ cd out\cmake-%variant%
 if errorlevel 1 exit /b %errorlevel%
 
 cmake ..\.. ^
-    -G "Visual Studio 17 2022" ^
+    -G "Visual Studio 16 2019" ^
     -A x64 ^
     %flag% ^
     -DCMAKE_INSTALL_PREFIX=..\%variant% ^

filament/CMakeLists.txt

@@ -262,15 +262,10 @@ set(MATERIAL_SRCS
         src/materials/ssao/mipmapDepth.mat
         src/materials/ssao/sao.mat
         src/materials/ssao/saoBentNormals.mat
-        src/materials/vsmMipmap.mat
-)
-
-if (NOT FILAMENT_DISABLE_GTAO)
-    list(APPEND MATERIAL_SRCS
         src/materials/ssao/gtao.mat
         src/materials/ssao/gtaoBentNormals.mat
-    )
-endif()
+        src/materials/vsmMipmap.mat
+)
 
 set(MATERIAL_FL0_SRCS
         src/materials/defaultMaterial.mat
@@ -321,10 +316,6 @@ if (FILAMENT_FORCE_PROFILING_MODE)
     add_definitions(-DFILAMENT_FORCE_PROFILING_MODE)
 endif()
 
-if (FILAMENT_DISABLE_GTAO)
-    add_definitions(-DFILAMENT_DISABLE_GTAO)
-endif()
-
 # ==================================================================================================
 # Definitions
 # ==================================================================================================
@@ -472,29 +463,27 @@ add_custom_command(
         APPEND
 )
 
-if (NOT FILAMENT_DISABLE_GTAO)
-    add_custom_command(
-            OUTPUT "${MATERIAL_DIR}/gtao.filamat"
-            DEPENDS src/materials/ssao/ssaoUtils.fs
-            DEPENDS src/materials/ssao/ssct.fs
-            DEPENDS src/materials/utils/depthUtils.fs
-            DEPENDS src/materials/utils/geometry.fs
-            DEPENDS src/materials/ssao/gtaoImpl.fs
-            DEPENDS src/materials/ssao/ssctImpl.fs
-            APPEND
-    )
+add_custom_command(
+        OUTPUT "${MATERIAL_DIR}/gtao.filamat"
+        DEPENDS src/materials/ssao/ssaoUtils.fs
+        DEPENDS src/materials/ssao/ssct.fs
+        DEPENDS src/materials/utils/depthUtils.fs
+        DEPENDS src/materials/utils/geometry.fs
+        DEPENDS src/materials/ssao/gtaoImpl.fs
+        DEPENDS src/materials/ssao/ssctImpl.fs
+        APPEND
+)
 
-    add_custom_command(
-            OUTPUT "${MATERIAL_DIR}/gtaoBentNormals.filamat"
-            DEPENDS src/materials/ssao/ssaoUtils.fs
-            DEPENDS src/materials/ssao/ssct.fs
-            DEPENDS src/materials/utils/depthUtils.fs
-            DEPENDS src/materials/utils/geometry.fs
-            DEPENDS src/materials/ssao/gtaoImpl.fs
-            DEPENDS src/materials/ssao/ssctImpl.fs
-            APPEND
-    )
-endif()
+add_custom_command(
+        OUTPUT "${MATERIAL_DIR}/gtaoBentNormals.filamat"
+        DEPENDS src/materials/ssao/ssaoUtils.fs
+        DEPENDS src/materials/ssao/ssct.fs
+        DEPENDS src/materials/utils/depthUtils.fs
+        DEPENDS src/materials/utils/geometry.fs
+        DEPENDS src/materials/ssao/gtaoImpl.fs
+        DEPENDS src/materials/ssao/ssctImpl.fs
+        APPEND
+)
 
 add_custom_command(
         OUTPUT "${MATERIAL_DIR}/bilateralBlur.filamat"

filament/backend/include/backend/PixelBufferDescriptor.h

@@ -204,23 +204,15 @@ public:
                 }, new T(std::forward<T>(functor))
         };
     }
-
-    // --------------------------------------------------------------------------------------------
-
     /**
-     * Computes the size in bytes needed to fit an image of given dimensions and format
+     * Computes the size in bytes for a pixel of given dimensions and format
      *
      * @param format    Format of the image pixels
      * @param type      Type of the image pixels
-     * @param stride    Stride of a row in pixels
-     * @param height    Height of the image in rows
-     * @param alignment Alignment in bytes of pixel rows
-     * @return The buffer size needed to fit this image in bytes
+     * @return The size of the specified pixel in bytes
      */
-    static constexpr size_t computeDataSize(PixelDataFormat format, PixelDataType type,
-            size_t stride, size_t height, size_t alignment) noexcept {
-        assert_invariant(alignment);
 
+    static constexpr size_t computePixelSize(PixelDataFormat format, PixelDataType type) noexcept {
         if (type == PixelDataType::COMPRESSED) {
             return 0;
         }
@@ -242,7 +234,7 @@ public:
             case PixelDataFormat::RGB_INTEGER:
                 n = 3;
                 break;
-            case PixelDataFormat::UNUSED: // shouldn't happen (used to be rgbm)
+            case PixelDataFormat::UNUSED:// shouldn't happen (used to be rgbm)
             case PixelDataFormat::RGBA:
             case PixelDataFormat::RGBA_INTEGER:
                 n = 4;
@@ -251,7 +243,7 @@ public:
 
         size_t bpp = n;
         switch (type) {
-            case PixelDataType::COMPRESSED: // Impossible -- to squash the IDE warnings
+            case PixelDataType::COMPRESSED:// Impossible -- to squash the IDE warnings
             case PixelDataType::UBYTE:
             case PixelDataType::BYTE:
                 // nothing to do
@@ -282,16 +274,35 @@ public:
                 bpp = 2;
                 break;
         }
+        return bpp;
+    }
 
+    // --------------------------------------------------------------------------------------------
+
+    /**
+     * Computes the size in bytes needed to fit an image of given dimensions and format
+     *
+     * @param format    Format of the image pixels
+     * @param type      Type of the image pixels
+     * @param stride    Stride of a row in pixels
+     * @param height    Height of the image in rows
+     * @param alignment Alignment in bytes of pixel rows
+     * @return The buffer size needed to fit this image in bytes
+     */
+    static constexpr size_t computeDataSize(PixelDataFormat format, PixelDataType type,
+            size_t stride, size_t height, size_t alignment) noexcept {
+        assert_invariant(alignment);
+
+        size_t bpp = computePixelSize(format, type);
         size_t const bpr = bpp * stride;
         size_t const bprAligned = (bpr + (alignment - 1)) & (~alignment + 1);
         return bprAligned * height;
     }
 
     //! left coordinate in pixels
-    uint32_t left   = 0;
+    uint32_t left = 0;
     //! top coordinate in pixels
-    uint32_t top    = 0;
+    uint32_t top = 0;
     union {
         struct {
             //! stride in pixels

filament/backend/include/backend/Platform.h

@@ -149,13 +149,6 @@ public:
          *      - PlatformEGLAndroid
          */
         bool assertNativeWindowIsValid = false;
-
-        /**
-         * The action to take if a Drawable cannot be acquired. If true, the
-         * frame is aborted instead of panic. This is only supported for:
-         *      - PlatformMetal
-         */
-        bool metalDisablePanicOnDrawableFailure = false;
     };
 
     Platform() noexcept;

filament/backend/src/metal/PlatformMetal.mm

@@ -53,9 +53,6 @@ PlatformMetal::~PlatformMetal() noexcept {
 }
 
 Driver* PlatformMetal::createDriver(void* /*sharedContext*/, const Platform::DriverConfig& driverConfig) noexcept {
-    pImpl->mDrawableFailureBehavior = driverConfig.metalDisablePanicOnDrawableFailure
-            ? DrawableFailureBehavior::ABORT_FRAME
-            : DrawableFailureBehavior::PANIC;
     return MetalDriverFactory::create(this, driverConfig);
 }
 

filament/backend/src/opengl/GLDescriptorSet.cpp

@@ -162,11 +162,8 @@ void GLDescriptorSet::update(OpenGLContext&,
     }, descriptors[binding].desc);
 }
 
-void GLDescriptorSet::update(OpenGLContext& gl, HandleAllocatorGL& handleAllocator,
-        descriptor_binding_t binding, TextureHandle th, SamplerParams params) noexcept {
-
-    GLTexture* t = th ? handleAllocator.handle_cast<GLTexture*>(th) : nullptr;
-
+void GLDescriptorSet::update(OpenGLContext& gl,
+        descriptor_binding_t binding, GLTexture* t, SamplerParams params) noexcept {
     assert_invariant(binding < descriptors.size());
     std::visit([=, &gl](auto&& arg) mutable {
         using T = std::decay_t<decltype(arg)>;
@@ -199,12 +196,20 @@ void GLDescriptorSet::update(OpenGLContext& gl, HandleAllocatorGL& handleAllocat
                 }
             }
 
-            arg.handle = th;
+            arg.target = t ? t->gl.target : 0;
+            arg.id = t ? t->gl.id : 0;
+            arg.external = t ? t->gl.external :  false;
             if constexpr (std::is_same_v<T, Sampler> ||
                           std::is_same_v<T, SamplerWithAnisotropyWorkaround>) {
                 if constexpr (std::is_same_v<T, SamplerWithAnisotropyWorkaround>) {
                     arg.anisotropy = float(1u << params.anisotropyLog2);
                 }
+                if (t) {
+                    arg.ref = t->ref;
+                    arg.baseLevel = t->gl.baseLevel;
+                    arg.maxLevel = t->gl.maxLevel;
+                    arg.swizzle = t->gl.swizzle;
+                }
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
                 arg.sampler = gl.getSampler(params);
 #else
@@ -220,39 +225,39 @@ void GLDescriptorSet::update(OpenGLContext& gl, HandleAllocatorGL& handleAllocat
     }, descriptors[binding].desc);
 }
 
+template<typename T>
 void GLDescriptorSet::updateTextureView(OpenGLContext& gl,
-        HandleAllocatorGL& handleAllocator, GLuint unit, GLTexture const* t) noexcept {
+        HandleAllocatorGL& handleAllocator, GLuint unit, T const& desc) noexcept {
     // The common case is that we don't have a ref handle (we only have one if
     // the texture ever had a View on it).
-    assert_invariant(t);
-    assert_invariant(t->ref);
-    GLTextureRef* const ref = handleAllocator.handle_cast<GLTextureRef*>(t->ref);
-    if (UTILS_UNLIKELY((t->gl.baseLevel != ref->baseLevel || t->gl.maxLevel != ref->maxLevel))) {
+    assert_invariant(desc.ref);
+    GLTextureRef* const ref = handleAllocator.handle_cast<GLTextureRef*>(desc.ref);
+    if (UTILS_UNLIKELY((desc.baseLevel != ref->baseLevel || desc.maxLevel != ref->maxLevel))) {
         // If we have views, then it's still uncommon that we'll switch often
         // handle the case where we reset to the original texture
-        GLint baseLevel = GLint(t->gl.baseLevel); // NOLINT(*-signed-char-misuse)
-        GLint maxLevel = GLint(t->gl.maxLevel); // NOLINT(*-signed-char-misuse)
+        GLint baseLevel = GLint(desc.baseLevel); // NOLINT(*-signed-char-misuse)
+        GLint maxLevel = GLint(desc.maxLevel); // NOLINT(*-signed-char-misuse)
         if (baseLevel > maxLevel) {
             baseLevel = 0;
             maxLevel = 1000; // per OpenGL spec
         }
         // that is very unfortunate that we have to call activeTexture here
         gl.activeTexture(unit);
-        glTexParameteri(t->gl.target, GL_TEXTURE_BASE_LEVEL, baseLevel);
-        glTexParameteri(t->gl.target, GL_TEXTURE_MAX_LEVEL,  maxLevel);
-        ref->baseLevel = t->gl.baseLevel;
-        ref->maxLevel = t->gl.maxLevel;
+        glTexParameteri(desc.target, GL_TEXTURE_BASE_LEVEL, baseLevel);
+        glTexParameteri(desc.target, GL_TEXTURE_MAX_LEVEL,  maxLevel);
+        ref->baseLevel = desc.baseLevel;
+        ref->maxLevel = desc.maxLevel;
     }
-    if (UTILS_UNLIKELY(t->gl.swizzle != ref->swizzle)) {
+    if (UTILS_UNLIKELY(desc.swizzle != ref->swizzle)) {
         using namespace GLUtils;
         gl.activeTexture(unit);
 #if !defined(__EMSCRIPTEN__)  && !defined(FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2)
-        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_R, (GLint)getSwizzleChannel(t->gl.swizzle[0]));
-        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_G, (GLint)getSwizzleChannel(t->gl.swizzle[1]));
-        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_B, (GLint)getSwizzleChannel(t->gl.swizzle[2]));
-        glTexParameteri(t->gl.target, GL_TEXTURE_SWIZZLE_A, (GLint)getSwizzleChannel(t->gl.swizzle[3]));
+        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_R, (GLint)getSwizzleChannel(desc.swizzle[0]));
+        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_G, (GLint)getSwizzleChannel(desc.swizzle[1]));
+        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_B, (GLint)getSwizzleChannel(desc.swizzle[2]));
+        glTexParameteri(desc.target, GL_TEXTURE_SWIZZLE_A, (GLint)getSwizzleChannel(desc.swizzle[3]));
 #endif
-        ref->swizzle = t->gl.swizzle;
+        ref->swizzle = desc.swizzle;
     }
 }
 
@@ -305,31 +310,27 @@ void GLDescriptorSet::bind(
                 }
             } else if constexpr (std::is_same_v<T, Sampler>) {
                 GLuint const unit = p.getTextureUnit(set, binding);
-
-
-                if (arg.handle) {
-                    GLTexture const* const t = handleAllocator.handle_cast<GLTexture*>(arg.handle);
-                    gl.bindTexture(unit, t->gl.target, t->gl.id, t->gl.external);
+                if (arg.target) {
+                    gl.bindTexture(unit, arg.target, arg.id, arg.external);
                     gl.bindSampler(unit, arg.sampler);
-                    if (UTILS_UNLIKELY(t->ref)) {
-                        updateTextureView(gl, handleAllocator, unit, t);
+                    if (UTILS_UNLIKELY(arg.ref)) {
+                        updateTextureView(gl, handleAllocator, unit, arg);
                     }
                 } else {
                     gl.unbindTextureUnit(unit);
                 }
             } else if constexpr (std::is_same_v<T, SamplerWithAnisotropyWorkaround>) {
                 GLuint const unit = p.getTextureUnit(set, binding);
-                if (arg.handle) {
-                    GLTexture const* const t = handleAllocator.handle_cast<GLTexture*>(arg.handle);
-                    gl.bindTexture(unit, t->gl.target, t->gl.id, t->gl.external);
+                if (arg.target) {
+                    gl.bindTexture(unit, arg.target, arg.id, arg.external);
                     gl.bindSampler(unit, arg.sampler);
-                    if (UTILS_UNLIKELY(t->ref)) {
-                        updateTextureView(gl, handleAllocator, unit, t);
+                    if (UTILS_UNLIKELY(arg.ref)) {
+                        updateTextureView(gl, handleAllocator, unit, arg);
                     }
 #if defined(GL_EXT_texture_filter_anisotropic)
                     // Driver claims to support anisotropic filtering, but it fails when set on
                     // the sampler, we have to set it on the texture instead.
-                    glTexParameterf(t->gl.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
+                    glTexParameterf(arg.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                             std::min(gl.gets.max_anisotropy, float(arg.anisotropy)));
 #endif
                 } else {
@@ -338,20 +339,19 @@ void GLDescriptorSet::bind(
             } else if constexpr (std::is_same_v<T, SamplerGLES2>) {
                 // in ES2 the sampler parameters need to be set on the texture itself
                 GLuint const unit = p.getTextureUnit(set, binding);
-                if (arg.handle) {
-                    GLTexture const* const t = handleAllocator.handle_cast<GLTexture*>(arg.handle);
-                    gl.bindTexture(unit, t->gl.target, t->gl.id, t->gl.external);
+                if (arg.target) {
+                    gl.bindTexture(unit, arg.target, arg.id, arg.external);
                     SamplerParams const params = arg.params;
-                    glTexParameteri(t->gl.target, GL_TEXTURE_MIN_FILTER,
+                    glTexParameteri(arg.target, GL_TEXTURE_MIN_FILTER,
                             (GLint)GLUtils::getTextureFilter(params.filterMin));
-                    glTexParameteri(t->gl.target, GL_TEXTURE_MAG_FILTER,
+                    glTexParameteri(arg.target, GL_TEXTURE_MAG_FILTER,
                             (GLint)GLUtils::getTextureFilter(params.filterMag));
-                    glTexParameteri(t->gl.target, GL_TEXTURE_WRAP_S,
+                    glTexParameteri(arg.target, GL_TEXTURE_WRAP_S,
                             (GLint)GLUtils::getWrapMode(params.wrapS));
-                    glTexParameteri(t->gl.target, GL_TEXTURE_WRAP_T,
+                    glTexParameteri(arg.target, GL_TEXTURE_WRAP_T,
                             (GLint)GLUtils::getWrapMode(params.wrapT));
 #if defined(GL_EXT_texture_filter_anisotropic)
-                    glTexParameterf(t->gl.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
+                    glTexParameterf(arg.target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                             std::min(gl.gets.max_anisotropy, arg.anisotropy));
 #endif
                 } else {

filament/backend/src/opengl/GLDescriptorSet.h

@@ -59,8 +59,8 @@ struct GLDescriptorSet : public HwDescriptorSet {
             descriptor_binding_t binding, GLBufferObject* bo, size_t offset, size_t size) noexcept;
 
     // update a sampler descriptor in the set
-    void update(OpenGLContext& gl, HandleAllocatorGL& handleAllocator,
-            descriptor_binding_t binding, TextureHandle th, SamplerParams params) noexcept;
+    void update(OpenGLContext& gl,
+            descriptor_binding_t binding, GLTexture* t, SamplerParams params) noexcept;
 
     // conceptually bind the set to the command buffer
     void bind(
@@ -111,19 +111,46 @@ private:
 
     // A sampler descriptor
     struct Sampler {
-        TextureHandle handle;                   // 4
+        uint16_t target;                        // 2 (GLenum)
+        bool external = false;                  // 1
+        bool reserved = false;                  // 1
+        GLuint id = 0;                          // 4
         GLuint sampler = 0;                     // 4
+        Handle<GLTextureRef> ref;               // 4
+        int8_t baseLevel = 0x7f;                // 1
+        int8_t maxLevel = -1;                   // 1
+        std::array<TextureSwizzle, 4> swizzle{  // 4
+                TextureSwizzle::CHANNEL_0,
+                TextureSwizzle::CHANNEL_1,
+                TextureSwizzle::CHANNEL_2,
+                TextureSwizzle::CHANNEL_3
+        };
     };
 
     struct SamplerWithAnisotropyWorkaround {
-        TextureHandle handle;                   // 4
+        uint16_t target;                        // 2 (GLenum)
+        bool external = false;                  // 1
+        bool reserved = false;                  // 1
+        GLuint id = 0;                          // 4
         GLuint sampler = 0;                     // 4
+        Handle<GLTextureRef> ref;               // 4
         math::half anisotropy = 1.0f;           // 2
+        int8_t baseLevel = 0x7f;                // 1
+        int8_t maxLevel = -1;                   // 1
+        std::array<TextureSwizzle, 4> swizzle{  // 4
+                TextureSwizzle::CHANNEL_0,
+                TextureSwizzle::CHANNEL_1,
+                TextureSwizzle::CHANNEL_2,
+                TextureSwizzle::CHANNEL_3
+        };
     };
 
     // A sampler descriptor for ES2
     struct SamplerGLES2 {
-        TextureHandle handle;                   // 4
+        uint16_t target;                        // 2 (GLenum)
+        bool external = false;                  // 1
+        bool reserved = false;                  // 1
+        GLuint id = 0;                          // 4
         SamplerParams params{};                 // 4
         float anisotropy = 1.0f;                // 4
     };
@@ -138,8 +165,9 @@ private:
     };
     static_assert(sizeof(Descriptor) <= 32);
 
+    template<typename T>
     static void updateTextureView(OpenGLContext& gl,
-            HandleAllocatorGL& handleAllocator, GLuint unit, GLTexture const* t) noexcept;
+            HandleAllocatorGL& handleAllocator, GLuint unit, T const& desc) noexcept;
 
     utils::FixedCapacityVector<Descriptor> descriptors;     // 16
     utils::bitset64 dynamicBuffers;                         // 8

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -2514,33 +2514,10 @@ void OpenGLDriver::makeCurrent(Handle<HwSwapChain> schDraw, Handle<HwSwapChain>
 
     mPlatform.makeCurrent(scDraw->swapChain, scRead->swapChain,
             [this]() {
-                for (auto t: mTexturesWithStreamsAttached) {
-                    if (t->hwStream->streamType == StreamType::NATIVE) {
-                        mPlatform.detach(t->hwStream->stream);
-                    }
-                }
                 // OpenGL context is about to change, unbind everything
                 mContext.unbindEverything();
             },
             [this](size_t index) {
-                for (auto t: mTexturesWithStreamsAttached) {
-                    if (t->hwStream->streamType == StreamType::NATIVE) {
-                        if (t->externalTexture) {
-                            glGenTextures(1, &t->externalTexture->id);
-                            t->gl.id = t->externalTexture->id;
-                        } else {
-                            glGenTextures(1, &t->gl.id);
-                        }
-                        mPlatform.attach(t->hwStream->stream, t->gl.id);
-                        mContext.updateTexImage(GL_TEXTURE_EXTERNAL_OES, t->gl.id);
-                    }
-                }
-
-                // force invalidation of all bound descriptor sets
-                decltype(mInvalidDescriptorSetBindings) changed;
-                changed.setValue((1 << MAX_DESCRIPTOR_SET_COUNT) - 1);
-                mInvalidDescriptorSetBindings |= changed;
-
                 // OpenGL context has changed, resynchronize the state with the cache
                 mContext.synchronizeStateAndCache(index);
                 slog.d << "*** OpenGL context change : " << (index ? "protected" : "default") << io::endl;
@@ -3015,7 +2992,6 @@ void OpenGLDriver::attachStream(GLTexture* t, GLStream* hwStream) noexcept {
     switch (hwStream->streamType) {
         case StreamType::NATIVE:
             mPlatform.attach(hwStream->stream, t->gl.id);
-            mContext.updateTexImage(GL_TEXTURE_EXTERNAL_OES, t->gl.id);
             break;
         case StreamType::ACQUIRED:
             break;
@@ -3044,12 +3020,7 @@ void OpenGLDriver::detachStream(GLTexture* t) noexcept {
             break;
     }
 
-    if (t->externalTexture) {
-        glGenTextures(1, &t->externalTexture->id);
-        t->gl.id = t->externalTexture->id;
-    } else {
-        glGenTextures(1, &t->gl.id);
-    }
+    glGenTextures(1, &t->gl.id);
 
     t->hwStream = nullptr;
 }
@@ -3073,14 +3044,8 @@ void OpenGLDriver::replaceStream(GLTexture* texture, GLStream* newStream) noexce
 
     switch (newStream->streamType) {
         case StreamType::NATIVE:
-            if (texture->externalTexture) {
-                glGenTextures(1, &texture->externalTexture->id);
-                texture->gl.id = texture->externalTexture->id;
-            } else {
-                glGenTextures(1, &texture->gl.id);
-            }
+            glGenTextures(1, &texture->gl.id);
             mPlatform.attach(newStream->stream, texture->gl.id);
-            mContext.updateTexImage(GL_TEXTURE_EXTERNAL_OES, texture->gl.id);
             break;
         case StreamType::ACQUIRED:
             // Just re-use the old texture id.
@@ -3743,7 +3708,8 @@ void OpenGLDriver::updateDescriptorSetTexture(
         TextureHandle th,
         SamplerParams params) {
     GLDescriptorSet* ds = handle_cast<GLDescriptorSet*>(dsh);
-    ds->update(mContext, mHandleAllocator, binding, th, params);
+    GLTexture* t = th ? handle_cast<GLTexture*>(th) : nullptr;
+    ds->update(mContext, binding, t, params);
 }
 
 void OpenGLDriver::flush(int) {

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

@@ -21,7 +21,6 @@
 
 #include <utils/bitset.h>
 #include <utils/FixedCapacityVector.h>
-#include <utils/Panic.h>
 
 #include <bluevk/BlueVK.h>
 

filament/backend/src/webgpu/WebGPUDriver.cpp

@@ -26,7 +26,7 @@
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>
 #include <backend/TargetBufferInfo.h>
-
+#include <private/backend/BackendUtils.h>
 #include <math/mat3.h>
 #include <utils/CString.h>
 #include <utils/Panic.h>
@@ -39,6 +39,7 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <sstream>
 #include <string_view>
 #include <utility>
@@ -353,6 +354,17 @@ void WebGPUDriver::destroyProgram(Handle<HwProgram> ph) {
 }
 
 void WebGPUDriver::destroyRenderTarget(Handle<HwRenderTarget> rth) {
+    if (rth) {
+        WGPURenderTarget* rt = handleCast<WGPURenderTarget>(rth);
+        if (rt == mDefaultRenderTarget) {
+            mDefaultRenderTarget = nullptr;
+        }
+        // WGPURenderTarget destructor is trivial.
+        // The HwTexture handles stored within WGPURenderTarget (via MRT, TargetBufferInfo)
+        // are not owned by WGPURenderTarget, so they are not destroyed here.
+        // They are destroyed via WebGPUDriver::destroyTexture.
+        destructHandle<WGPURenderTarget>(rth);
+    }
 }
 
 void WebGPUDriver::destroySwapChain(Handle<HwSwapChain> sch) {
@@ -579,7 +591,21 @@ void WebGPUDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {
 
 void WebGPUDriver::createRenderTargetR(Handle<HwRenderTarget> rth, TargetBufferFlags targets,
         uint32_t width, uint32_t height, uint8_t samples, uint8_t layerCount, MRT color,
-        TargetBufferInfo depth, TargetBufferInfo stencil) {}
+        TargetBufferInfo depth, TargetBufferInfo stencil) {
+    // The `targets` flags indicate which of the `color`, `depth`, `stencil` TargetBufferInfo
+    // are actually active for this render target.
+    // We'll pass all TargetBufferInfo to WGPURenderTarget; it will use them if their handles are valid.
+
+    // Ensure that textures intended for use as attachments were created with
+    // wgpu::TextureUsage::RenderAttachment. This check should ideally be in createTextureR
+    // or validated here if possible.
+
+    // The `layerCount` parameter might be for creating array textures that this RT targets.
+    // Individual attachments (color[i].layer, depth.layer, stencil.layer) specify which layer
+    // of an array texture to bind. For now, we assume textures are pre-configured.
+
+    constructHandle<WGPURenderTarget>(rth, width, height, samples, color, depth, stencil);
+}
 
 void WebGPUDriver::createFenceR(Handle<HwFence> fh, int) {}
 
@@ -752,11 +778,72 @@ void WebGPUDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh, uint32_t in
     vertexBuffer->buffers[index] = bufferObject->getBuffer();
 }
 
-void WebGPUDriver::update3DImage(Handle<HwTexture> th,
-        uint32_t level, uint32_t xoffset, uint32_t yoffset, uint32_t zoffset,
-        uint32_t width, uint32_t height, uint32_t depth,
-        PixelBufferDescriptor&& data) {
-    scheduleDestroy(std::move(data));
+void WebGPUDriver::update3DImage(Handle<HwTexture> th, uint32_t level, uint32_t xoffset,
+        uint32_t yoffset, uint32_t zoffset, uint32_t width, uint32_t height, uint32_t depth,
+        PixelBufferDescriptor&& p) {
+    PixelBufferDescriptor* data = &p;
+    PixelBufferDescriptor reshapedData;
+    if (reshape(p, reshapedData)) {
+        data = &reshapedData;
+    }
+    auto texture = handleCast<WGPUTexture>(th);
+
+    // TODO: Writing to a depth texture is illegal and errors. I'm not sure why Filament is trying
+    // to do so, but early returning is working?
+    if(texture->getAspect() == wgpu::TextureAspect::DepthOnly){
+        scheduleDestroy(std::move(p));
+        return;
+    }
+    size_t blockWidth = texture->getBlockWidth();
+    size_t blockHeight = texture->getBlockHeight();
+    // WebGPU specification requires that for compressed textures, the x and y offsets
+    // must be a multiple of the compressed texture format's block width and height.
+    // See: https://www.w3.org/TR/webgpu/#abstract-opdef-validating-gputexelcopytextureinfo
+    if (blockWidth > 1 || blockHeight > 1) {
+        FILAMENT_CHECK_PRECONDITION(xoffset % blockWidth == 0)
+                << "xoffset must be aligned to blockwidth, but offset is " << blockWidth
+                << "and offset is " << xoffset;
+        FILAMENT_CHECK_PRECONDITION(yoffset % blockHeight == 0)
+                << "yoffset must be aligned to blockHeight, but offset is " << blockHeight
+                << "and offset is " << yoffset;
+    }
+
+    auto copyInfo = wgpu::TexelCopyTextureInfo{ .texture = texture->getTexture(),
+        .mipLevel = level,
+        .origin = { .x = xoffset, .y = yoffset, .z = zoffset },
+        .aspect = texture->getAspect() };
+    uint32_t bytesPerRow = static_cast<uint32_t>(
+            PixelBufferDescriptor::computePixelSize(data->format, data->type) * width);
+    auto extent = wgpu::Extent3D{ .width = width, .height = height, .depthOrArrayLayers = depth };
+
+    const uint8_t* dataBuff = static_cast<const uint8_t*>(data->buffer);
+    size_t dataSize = data->size;
+    std::unique_ptr<uint8_t[]> paddedBuffer;
+
+    if (bytesPerRow % 256 != 0) {
+        uint32_t padding = 256 - (bytesPerRow % 256);
+        uint32_t paddedBytesPerRow = bytesPerRow + padding;
+
+        size_t paddedBufferSize = static_cast<size_t>(paddedBytesPerRow) * height * depth;
+        paddedBuffer = std::make_unique<uint8_t[]>(paddedBufferSize);
+        uint8_t* dest = paddedBuffer.get();
+
+        for (uint32_t z = 0; z < depth; ++z) {
+            for (uint32_t y = 0; y < height; ++y) {
+                std::memcpy(dest, dataBuff, bytesPerRow);
+                dest += paddedBytesPerRow;
+                dataBuff += bytesPerRow;
+            }
+        }
+        dataBuff = paddedBuffer.get();
+        dataSize = paddedBufferSize;
+        bytesPerRow = paddedBytesPerRow;
+    }
+
+    auto layout = wgpu::TexelCopyBufferLayout{ .bytesPerRow = bytesPerRow, .rowsPerImage = height };
+
+    mQueue.WriteTexture(&copyInfo, dataBuff, dataSize, &layout, &extent);
+    scheduleDestroy(std::move(p));
 }
 
 void WebGPUDriver::setupExternalImage(void* image) {
@@ -783,35 +870,74 @@ void WebGPUDriver::compilePrograms(CompilerPriorityQueue priority,
 
 void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> rth, RenderPassParams const& params) {
     assert_invariant(mCommandEncoder);
-
     auto* renderTarget = handleCast<WGPURenderTarget>(rth);
-    // if (renderTarget == mDefaultRenderTarget) {
-    //     FWGPU_LOGW << "Default render target"
-    //                << utils::io::endl;
-    // } else {
-    //     FWGPU_LOGW << "Non Default render target"
-    //                << utils::io::endl;
-    // }
-    wgpu::RenderPassDescriptor renderPassDescriptor;
-    wgpu::RenderPassDepthStencilAttachment depthStencilAttachment{
-        .view = mSwapChain->getDepthTextureView(),
-        .depthLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH),
-        .depthStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH),
-        .depthClearValue = static_cast<float>(params.clearDepth),
-        .depthReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0,
-        .stencilLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL),
-        .stencilStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL),
-        .stencilClearValue = params.clearStencil,
-        .stencilReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0
-    };
-    renderTarget->setUpRenderPassAttachments(renderPassDescriptor, mTextureView, params);
-    renderPassDescriptor.depthStencilAttachment = &depthStencilAttachment;
 
-    assert_invariant(mTextureView);
+    wgpu::RenderPassDescriptor renderPassDescriptor{};
+    wgpu::TextureView defaultColorView = nullptr;
+    wgpu::TextureView defaultDepthStencilView = nullptr;
+
+    std::array<wgpu::TextureView, MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT> customColorViews{};
+    uint32_t customColorViewCount = 0;
+    wgpu::TextureView customDepthView = nullptr;
+    wgpu::TextureView customStencilView = nullptr;
+
+    if (renderTarget->isDefaultRenderTarget()) {
+        assert_invariant(mSwapChain && mTextureView);
+        defaultColorView = mTextureView;
+        defaultDepthStencilView = mSwapChain->getDepthTextureView();
+    } else {
+        // Resolve views for custom render target
+        const auto& colorInfos = renderTarget->getColorAttachmentInfos();
+        for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; ++i) {
+            if (colorInfos[i].handle) {
+                auto* hwTexture = handleCast<WGPUTexture>(colorInfos[i].handle);
+                if (hwTexture) {
+                    // TODO: Consider colorInfos[i].level and colorInfos[i].layer for view creation
+                    // if WGPUTexture::getTexView() isn't sufficient or needs parameters.
+                    customColorViews[customColorViewCount++] = hwTexture->getTexView();
+                }
+            }
+        }
+
+        const auto& depthInfo = renderTarget->getDepthAttachmentInfo();
+        if (depthInfo.handle) {
+            auto* hwTexture = handleCast<WGPUTexture>(depthInfo.handle);
+            if (hwTexture) {
+                customDepthView = hwTexture->getTexView();
+            }
+        }
+
+        const auto& stencilInfo = renderTarget->getStencilAttachmentInfo();
+        if (stencilInfo.handle) {
+            // If depth and stencil use the same texture handle, this will re-cast but that's fine.
+            auto* hwTexture = handleCast<WGPUTexture>(stencilInfo.handle);
+            if (hwTexture) {
+                customStencilView = hwTexture->getTexView();
+            }
+        }
+    }
+
+    renderTarget->setUpRenderPassAttachments(renderPassDescriptor,
+            params,
+            defaultColorView,
+            defaultDepthStencilView,
+            customColorViews.data(),
+            customColorViewCount,
+            customDepthView,
+            customStencilView);
 
     mRenderPassEncoder = mCommandEncoder.BeginRenderPass(&renderPassDescriptor);
-    mRenderPassEncoder.SetViewport(params.viewport.left, params.viewport.bottom,
-            params.viewport.width, params.viewport.height, params.depthRange.near, params.depthRange.far);
+    // Ensure viewport dimensions are positive
+    uint32_t viewportWidth = params.viewport.width > 0 ? params.viewport.width : 1;
+    uint32_t viewportHeight = params.viewport.height > 0 ? params.viewport.height : 1;
+
+    mRenderPassEncoder.SetViewport(
+            static_cast<float>(params.viewport.left),
+            static_cast<float>(params.viewport.bottom),
+            static_cast<float>(viewportWidth),
+            static_cast<float>(viewportHeight),
+            params.depthRange.near,
+            params.depthRange.far);
 }
 
 void WebGPUDriver::endRenderPass(int /* dummy */) {

filament/backend/src/webgpu/WebGPUHandles.cpp

@@ -20,7 +20,7 @@
 
 #include <utils/BitmaskEnum.h>
 #include <utils/Panic.h>
-
+#include <private/backend/BackendUtils.h>
 #include <webgpu/webgpu_cpp.h>
 
 #include <algorithm>
@@ -68,7 +68,7 @@ wgpu::VertexFormat getVertexFormat(filament::backend::ElementType type, bool nor
             case ElementType::BYTE4: return VertexFormat::Snorm8x4;
             case ElementType::UBYTE4: return VertexFormat::Unorm8x4;
             case ElementType::SHORT4: return VertexFormat::Snorm16x4;
-            case ElementType::USHORT4: return VertexFormat::Unorm8x4;
+            case ElementType::USHORT4: return VertexFormat::Unorm16x4;
             default:
                 FILAMENT_CHECK_POSTCONDITION(false) << "Normalized format does not exist.";
                 return VertexFormat::Float32x3;
@@ -502,6 +502,8 @@ WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat forma
     mUsage = fToWGPUTextureUsage(usage);
     mFormat = fToWGPUTextureFormat(format);
     mAspect = fToWGPUTextureViewAspect(usage, format);
+    mBlockWidth = filament::backend::getBlockWidth(format);
+    mBlockHeight = filament::backend::getBlockHeight(format);
     wgpu::TextureDescriptor textureDescriptor{
         .label = getUserTextureLabel(target),
         .usage = mUsage,
@@ -548,6 +550,10 @@ WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat forma
 
 WGPUTexture::WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept {
     mTexture = src->mTexture;
+    mAspect = src->mAspect;
+    mBlockWidth = src->mBlockWidth;
+    mBlockHeight = src->mBlockHeight;
+
     mTexView = makeTextureView(baseLevel, levelCount, target);
 }
 
@@ -917,58 +923,147 @@ wgpu::TextureView WGPUTexture::makeTextureView(const uint8_t& baseLevel, const u
     return textureView;
 }
 
-WGPURenderTarget::Attachment WGPURenderTarget::getDrawColorAttachment(size_t index) {
-    assert_invariant( index < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
-    auto result = color[index];
-    if (index == 0 && defaultRenderTarget) {
-
-    }
-
-    return result;
+WGPURenderTarget::WGPURenderTarget(uint32_t width, uint32_t height, uint8_t samples,
+        const MRT& colorAttachmentsMRT,
+        const Attachment& depthAttachmentInfo,
+        const Attachment& stencilAttachmentInfo)
+    : HwRenderTarget(width, height),
+      defaultRenderTarget(false),
+      samples(samples),
+      mColorAttachments(colorAttachmentsMRT),
+      mDepthAttachment(depthAttachmentInfo),
+      mStencilAttachment(stencilAttachmentInfo) {
+    mColorAttachmentDescriptors.reserve(MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
 }
 
+// Static helper to map MRT index to TargetBufferFlags
+TargetBufferFlags WGPURenderTarget::getTargetBufferFlagsAt(int mrtIndex) {
+    if (mrtIndex < 0 || mrtIndex >= MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT) {
+        return TargetBufferFlags::NONE;
+    }
+    // This mapping assumes TargetBufferFlags::COLOR_0, COLOR_1 etc. are contiguous
+    return static_cast<TargetBufferFlags>(
+            static_cast<uint32_t>(TargetBufferFlags::COLOR0) << mrtIndex);
+}
+
+// Corrected getLoadOperation
 wgpu::LoadOp WGPURenderTarget::getLoadOperation(RenderPassParams const& params,
-                                             TargetBufferFlags buffer) {
-    auto clearFlags = params.flags.clear;
-    auto discardStartFlags = params.flags.discardStart;
-    if (any(clearFlags & buffer)) {
-        return wgpu::LoadOp::Clear;
-    } else if (any(discardStartFlags & buffer)) {
+                                                TargetBufferFlags bufferToOperateOn) {
+    if (any(params.flags.clear & bufferToOperateOn)) {
         return wgpu::LoadOp::Clear;
     }
+    if (any(params.flags.discardStart & bufferToOperateOn)) {
+        return wgpu::LoadOp::Clear; // Or wgpu::LoadOp::Undefined if clear is not desired on discard
+    }
     return wgpu::LoadOp::Load;
 }
 
+// Corrected getStoreOperation
 wgpu::StoreOp WGPURenderTarget::getStoreOperation(RenderPassParams const& params,
-                                               TargetBufferFlags buffer) {
-    const auto discardEndFlags = params.flags.discardEnd;
-    if (any(discardEndFlags & buffer)) {
+                                                  TargetBufferFlags bufferToOperateOn) {
+    if (any(params.flags.discardEnd & bufferToOperateOn)) {
         return wgpu::StoreOp::Discard;
     }
     return wgpu::StoreOp::Store;
 }
-void WGPURenderTarget::setUpRenderPassAttachments(wgpu::RenderPassDescriptor& descriptor,
-        wgpu::TextureView const& textureView, RenderPassParams const& params) {
-    // auto discardFlags = params.flags.discardEnd;
-    // (void) discardFlags;
-    // std::vector<wgpu::RenderPassColorAttachment> colorAttachments;
-    colorAttachments.clear();
-    for (size_t i = 0; i < 1/*MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT*/; i++) {
-        // auto attachment = getDrawColorAttachment(i);
-        // if (attachment) {
-            wgpu::RenderPassColorAttachment colorAttachment;
-            colorAttachment.view = textureView;
-            colorAttachment.loadOp  = getLoadOperation(params, getTargetBufferFlagsAt(i));
-            colorAttachment.storeOp = getStoreOperation(params, getTargetBufferFlagsAt(i));
-            colorAttachment.clearValue = { params.clearColor.r, params.clearColor.g, params.clearColor.b, params.clearColor.a };
-            colorAttachments.emplace_back(colorAttachment);
-        // }
+
+void WGPURenderTarget::setUpRenderPassAttachments(
+        wgpu::RenderPassDescriptor& descriptor,
+        RenderPassParams const& params,
+        wgpu::TextureView const& defaultColorTextureView,
+        wgpu::TextureView const& defaultDepthStencilTextureView,
+        wgpu::TextureView const* customColorTextureViews,
+        uint32_t customColorTextureViewCount,
+        wgpu::TextureView const& customDepthTextureView,
+        wgpu::TextureView const& customStencilTextureView) {
+    mColorAttachmentDescriptors.clear();
+    mHasDepthStencilAttachment = false;
+
+    if (defaultRenderTarget) {
+        assert_invariant(defaultColorTextureView);
+        wgpu::RenderPassColorAttachment colorAttDesc{};
+        colorAttDesc.view = defaultColorTextureView;
+        colorAttDesc.resolveTarget = nullptr;
+        colorAttDesc.loadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::COLOR0);
+        colorAttDesc.storeOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::COLOR0);
+        colorAttDesc.clearValue = {params.clearColor.r, params.clearColor.g,
+                                   params.clearColor.b, params.clearColor.a};
+        mColorAttachmentDescriptors.push_back(colorAttDesc);
+
+        if (defaultDepthStencilTextureView) {
+            mDepthStencilAttachmentDescriptor = {
+                .view = defaultDepthStencilTextureView,
+                .depthLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH),
+                .depthStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH),
+                .depthClearValue = static_cast<float>(params.clearDepth),
+                .depthReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0,
+                .stencilLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL),
+                .stencilStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL),
+                .stencilClearValue = params.clearStencil,
+                .stencilReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0,
+            };
+            mHasDepthStencilAttachment = true;
+        }
+    } else { // Custom Render Target
+        for (uint32_t i = 0; i < customColorTextureViewCount; ++i) {
+            if (customColorTextureViews[i]) {
+                wgpu::RenderPassColorAttachment colorAttDesc{};
+                colorAttDesc.view = customColorTextureViews[i];
+                colorAttDesc.resolveTarget = nullptr; // TODO: MSAA resolve for custom RT
+                colorAttDesc.loadOp = WGPURenderTarget::getLoadOperation(params, getTargetBufferFlagsAt(i));
+                colorAttDesc.storeOp = WGPURenderTarget::getStoreOperation(params, getTargetBufferFlagsAt(i));
+                colorAttDesc.clearValue = {params.clearColor.r, params.clearColor.g,
+                                           params.clearColor.b, params.clearColor.a};
+                mColorAttachmentDescriptors.push_back(colorAttDesc);
+            }
+        }
+
+        wgpu::TextureView combinedDsView = customDepthTextureView ? customDepthTextureView : customStencilTextureView;
+
+        if (combinedDsView) {
+            mDepthStencilAttachmentDescriptor = {};
+            mDepthStencilAttachmentDescriptor.view = combinedDsView;
+
+            if (customDepthTextureView) {
+                mDepthStencilAttachmentDescriptor.depthLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH);
+                mDepthStencilAttachmentDescriptor.depthStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH);
+                mDepthStencilAttachmentDescriptor.depthClearValue = static_cast<float>(params.clearDepth);
+                mDepthStencilAttachmentDescriptor.depthReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0;
+            } else {
+                mDepthStencilAttachmentDescriptor.depthLoadOp = wgpu::LoadOp::Undefined;
+                mDepthStencilAttachmentDescriptor.depthStoreOp = wgpu::StoreOp::Undefined;
+                mDepthStencilAttachmentDescriptor.depthReadOnly = true;
+            }
+
+            if (customStencilTextureView) {
+                mDepthStencilAttachmentDescriptor.stencilLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL);
+                mDepthStencilAttachmentDescriptor.stencilStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL);
+                mDepthStencilAttachmentDescriptor.stencilClearValue = params.clearStencil;
+                mDepthStencilAttachmentDescriptor.stencilReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0;
+            } else {
+                mDepthStencilAttachmentDescriptor.stencilLoadOp = wgpu::LoadOp::Undefined;
+                mDepthStencilAttachmentDescriptor.stencilStoreOp = wgpu::StoreOp::Undefined;
+                mDepthStencilAttachmentDescriptor.stencilReadOnly = true;
+            }
+            mHasDepthStencilAttachment = true;
+        }
     }
-    descriptor.colorAttachments = colorAttachments.data();
-    descriptor.colorAttachmentCount = colorAttachments.size();
-    descriptor.depthStencilAttachment = nullptr;
-    descriptor.timestampWrites = nullptr;
+
+    descriptor.colorAttachmentCount = mColorAttachmentDescriptors.size();
+    descriptor.colorAttachments = mColorAttachmentDescriptors.data();
+    descriptor.depthStencilAttachment = mHasDepthStencilAttachment ? &mDepthStencilAttachmentDescriptor : nullptr;
+    // descriptor.sampleCount was removed from the core spec. If your webgpu.h still has it,
+    // and your Dawn version expects it, you might need to set it here based on this->samples.
+    // e.g., descriptor.sampleCount = this->samples;
 }
 
+math::uint2 WGPURenderTarget::getAttachmentSize() const noexcept {
+    if (!defaultRenderTarget) {
+        return {width, height};
+    }
+    // For default RT, size is dynamic and usually obtained from the swapchain.
+    // The caller (WebGPUDriver::beginRenderPass) should know the current swapchain size.
+    return {0,0};
+}
 
 }// namespace filament::backend

filament/backend/src/webgpu/WebGPUHandles.h

@@ -161,6 +161,9 @@ public:
             wgpu::Device const& device) noexcept;
 
     WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept;
+    wgpu::TextureAspect getAspect() const { return mAspect; }
+    size_t getBlockWidth() const { return mBlockWidth; }
+    size_t getBlockHeight() const { return mBlockHeight; }
 
     [[nodiscard]] const wgpu::Texture& getTexture() const { return mTexture; }
     [[nodiscard]] const wgpu::TextureView& getTexView() const { return mTexView; }
@@ -184,6 +187,8 @@ private:
     uint32_t mArrayLayerCount = 1;
     wgpu::TextureView mTexView = nullptr;
     wgpu::TextureUsage fToWGPUTextureUsage(filament::backend::TextureUsage const& fUsage);
+    size_t mBlockWidth;
+    size_t mBlockHeight;
 };
 
 struct WGPURenderPrimitive : public HwRenderPrimitive {
@@ -192,57 +197,66 @@ struct WGPURenderPrimitive : public HwRenderPrimitive {
     WGPUIndexBuffer* indexBuffer = nullptr;
 };
 
+
+
 class WGPURenderTarget : public HwRenderTarget {
 public:
-    class Attachment {
-    public:
-        friend class WGPURenderTarget;
-
-        Attachment() = default;
-        Attachment(WGPUTexture* gpuTexture, uint8_t level = 0, uint16_t layer = 0)
-            : level(level),
-              layer(layer),
-              texture(gpuTexture->getTexture()),
-              mWGPUTexture(gpuTexture) {}
-        operator bool() const {
-            return mWGPUTexture != nullptr;
-        }
-
-        uint8_t level = 0;
-        uint16_t layer = 0;
-
-    private:
-        wgpu::Texture texture = nullptr;
-        WGPUTexture* mWGPUTexture = nullptr;
-    };
+    using Attachment = TargetBufferInfo; // Using TargetBufferInfo directly for attachments
 
     WGPURenderTarget(uint32_t width, uint32_t height, uint8_t samples,
-            Attachment colorAttachments[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT]);
+            const MRT& colorAttachments,
+            const Attachment& depthAttachment,
+            const Attachment& stencilAttachment);
+
+    // Default constructor for the default render target
     WGPURenderTarget()
         : HwRenderTarget(0, 0),
-          defaultRenderTarget(true) {}
+          defaultRenderTarget(true),
+          samples(1) {}
 
-    void setUpRenderPassAttachments(wgpu::RenderPassDescriptor& descriptor,
-            wgpu::TextureView const& textureView, RenderPassParams const& params);
+    // Updated signature: takes resolved views for custom RTs, and default views for default RT
+    void setUpRenderPassAttachments(
+            wgpu::RenderPassDescriptor& descriptor,
+            RenderPassParams const& params,
+            // For default render target:
+            wgpu::TextureView const& defaultColorTextureView,
+            wgpu::TextureView const& defaultDepthStencilTextureView,
+            // For custom render targets:
+            wgpu::TextureView const* customColorTextureViews, // Array of views
+            uint32_t customColorTextureViewCount,
+            wgpu::TextureView const& customDepthTextureView,
+            wgpu::TextureView const& customStencilTextureView);
 
-    math::uint2 getAttachmentSize() noexcept;
+
+    math::uint2 getAttachmentSize() const noexcept;
 
     bool isDefaultRenderTarget() const { return defaultRenderTarget; }
     uint8_t getSamples() const { return samples; }
 
-    Attachment getDrawColorAttachment(size_t index);
-    Attachment getReadColorAttachment(size_t index);
+    // Accessors for the driver to get stored attachment info
+    const MRT& getColorAttachmentInfos() const { return mColorAttachments; }
+    const Attachment& getDepthAttachmentInfo() const { return mDepthAttachment; }
+    const Attachment& getStencilAttachmentInfo() const { return mStencilAttachment; }
 
+    // Static helpers for load/store operations
     static wgpu::LoadOp getLoadOperation(const RenderPassParams& params, TargetBufferFlags buffer);
     static wgpu::StoreOp getStoreOperation(const RenderPassParams& params, TargetBufferFlags buffer);
+
 private:
+    // Helper to map MRT index to TargetBufferFlags
+    static TargetBufferFlags getTargetBufferFlagsAt(int mrtIndex);
+
     bool defaultRenderTarget = false;
     uint8_t samples = 1;
 
-    Attachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT] = {};
-    math::uint2 attachmentSize = {};
-    std::vector<wgpu::RenderPassColorAttachment> colorAttachments{};
-};
+    MRT mColorAttachments{};
+    Attachment mDepthAttachment{};
+    Attachment mStencilAttachment{};
 
+    // Cached descriptors for the render pass
+    std::vector<wgpu::RenderPassColorAttachment> mColorAttachmentDescriptors;
+    wgpu::RenderPassDepthStencilAttachment mDepthStencilAttachmentDescriptor{};
+    bool mHasDepthStencilAttachment = false;
+};
 }// namespace filament::backend
 #endif// TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H

filament/include/filament/Engine.h

@@ -317,15 +317,6 @@ public:
          */
         size_t metalUploadBufferSizeBytes = 512 * 1024;
 
-        /**
-         * The action to take if a Drawable cannot be acquired.
-         *
-         * Each frame rendered requires a CAMetalDrawable texture, which is
-         * presented on-screen at the completion of each frame. These are
-         * limited and provided round-robin style by the system.
-         */
-        bool metalDisablePanicOnDrawableFailure = false;
-
         /**
          * Set to `true` to forcibly disable parallel shader compilation in the backend.
          * Currently only honored by the GL and Metal backends.

filament/src/PostProcessManager.cpp

@@ -304,10 +304,8 @@ static const PostProcessManager::StaticMaterialInfo sMaterialList[] = {
         { "mipmapDepth",                MATERIAL(MIPMAPDEPTH) },
         { "sao",                        MATERIAL(SAO) },
         { "saoBentNormals",             MATERIAL(SAOBENTNORMALS) },
-#ifndef FILAMENT_DISABLE_GTAO
         { "gtao",                       MATERIAL(GTAO) },
         { "gtaoBentNormals",            MATERIAL(GTAOBENTNORMALS) },
-#endif
         { "separableGaussianBlur1",     MATERIAL(SEPARABLEGAUSSIANBLUR),
                 { {"arraySampler", false}, {"componentCount", 1} } },
         { "separableGaussianBlur1L",    MATERIAL(SEPARABLEGAUSSIANBLUR),
@@ -876,25 +874,20 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::screenSpaceAmbientOcclusion(
                 }};
 
                 std::string_view materialName;
-                auto aoType = options.aoType;
-#ifdef FILAMENT_DISABLE_GTAO
-                materialName = computeBentNormals ? "saoBentNormals" : "sao";
-                aoType = AmbientOcclusionOptions::AmbientOcclusionType::SAO;
-#else
-                if (aoType ==
+                if (options.aoType ==
                         AmbientOcclusionOptions::AmbientOcclusionType::GTAO) {
                     materialName = computeBentNormals ? "gtaoBentNormals" : "gtao";
                 } else {
                     materialName = computeBentNormals ? "saoBentNormals" : "sao";
                 }
-#endif
+
                 auto& material = getPostProcessMaterial(materialName);
 
                 FMaterial const * const ma = material.getMaterial(mEngine);
                 FMaterialInstance* const mi = PostProcessMaterial::getMaterialInstance(ma);
 
                 // Set AO type specific material parameters
-                switch (aoType) {
+                switch (options.aoType) {
                     case AmbientOcclusionOptions::AmbientOcclusionType::SAO: {
                         // Where the falloff function peaks
                         const float peak = 0.1f * options.radius;

filament/src/details/Engine.cpp

@@ -67,7 +67,6 @@
 #include <math/vec4.h>
 
 #include <algorithm>
-#include <array>
 #include <chrono>
 #include <initializer_list>
 #include <memory>
@@ -140,7 +139,6 @@ Engine* FEngine::create(Builder const& builder) {
                 .forceGLES2Context = instance->getConfig().forceGLES2Context,
                 .stereoscopicType = instance->getConfig().stereoscopicType,
                 .assertNativeWindowIsValid = instance->features.backend.opengl.assert_native_window_is_valid,
-                .metalDisablePanicOnDrawableFailure = instance->getConfig().metalDisablePanicOnDrawableFailure,
         };
         instance->mDriver = platform->createDriver(sharedContext, driverConfig);
 
@@ -371,16 +369,9 @@ void FEngine::init() {
             .sampler(Texture::Sampler::SAMPLER_CUBEMAP)
             .build(*this));
 
-    static constexpr std::array<uint32_t, 6> zeroCubemap{};
-    static constexpr std::array<uint32_t, 1> zeroRGBA{};
-    static constexpr std::array<uint32_t, 1> oneRGBA{ 0xffffffff };
-    static constexpr std::array<float   , 1> oneFloat{ 1.0f };
-    auto const size = [](auto&& array) {
-        return array.size() * sizeof(decltype(array[0]));
-    };
-
     driverApi.update3DImage(mDefaultIblTexture->getHwHandle(), 0, 0, 0, 0, 1, 1, 6,
-            { zeroCubemap.data(), size(zeroCubemap), Texture::Format::RGBA, Texture::Type::UBYTE });
+            { std::array<uint8_t, 6>{}.data(), 6,
+                Texture::Format::RGBA, Texture::Type::UBYTE });
 
     // 3 bands = 9 float3
     constexpr float sh[9 * 3] = { 0.0f };
@@ -402,10 +393,12 @@ void FEngine::init() {
             TextureFormat::RGBA8, 1, 1, 1, 1, TextureUsage::DEFAULT);
 
     driverApi.update3DImage(mDummyOneTexture, 0, 0, 0, 0, 1, 1, 1,
-            { oneRGBA.data(), size(oneRGBA), Texture::Format::RGBA, Texture::Type::UBYTE });
+            { std::array<uint8_t, 4>{0xff, 0xff, 0xff, 0xff}.data(), 4,
+                Texture::Format::RGBA, Texture::Type::UBYTE });
 
     driverApi.update3DImage(mDummyZeroTexture, 0, 0, 0, 0, 1, 1, 1,
-            { zeroRGBA.data(), size(zeroRGBA), Texture::Format::RGBA, Texture::Type::UBYTE });
+            { std::array<uint8_t, 4>{}.data(), 4,
+                Texture::Format::RGBA, Texture::Type::UBYTE });
 
 
     mPerViewDescriptorSetLayoutSsrVariant = {
@@ -470,13 +463,16 @@ void FEngine::init() {
                 TextureFormat::RGBA8, 1, 1, 1, 1, TextureUsage::DEFAULT);
 
         driverApi.update3DImage(mDummyOneTextureArray, 0, 0, 0, 0, 1, 1, 1,
-                { oneRGBA.data(), size(oneRGBA), Texture::Format::RGBA, Texture::Type::UBYTE });
+                { std::array<uint8_t, 4>{0xff, 0xff, 0xff, 0xff}.data(), 4,
+                    Texture::Format::RGBA, Texture::Type::UBYTE });
 
         driverApi.update3DImage(mDummyOneTextureArrayDepth, 0, 0, 0, 0, 1, 1, 1,
-                { oneFloat.data(), size(oneFloat), Texture::Format::DEPTH_COMPONENT, Texture::Type::FLOAT });
+                { std::array<float, 1>{1.0f}.data(), 4,
+                    Texture::Format::DEPTH_COMPONENT, Texture::Type::FLOAT });
 
         driverApi.update3DImage(mDummyZeroTextureArray, 0, 0, 0, 0, 1, 1, 1,
-                { zeroRGBA.data(), size(zeroRGBA), Texture::Format::RGBA, Texture::Type::UBYTE });
+                { std::array<uint8_t, 4>{}.data(), 4,
+                    Texture::Format::RGBA, Texture::Type::UBYTE });
 
         mDummyUniformBuffer = driverApi.createBufferObject(CONFIG_MINSPEC_UBO_SIZE,
                 BufferObjectBinding::UNIFORM, BufferUsage::STATIC);
@@ -628,7 +624,6 @@ void FEngine::shutdown() {
     driver.destroyTexture(std::move(mDummyOneTextureArray));
     driver.destroyTexture(std::move(mDummyZeroTexture));
     driver.destroyTexture(std::move(mDummyZeroTextureArray));
-    driver.destroyTexture(std::move(mDummyOneTextureArrayDepth));
 
     driver.destroyBufferObject(std::move(mDummyUniformBuffer));
 
@@ -760,7 +755,6 @@ int FEngine::loop() {
             .forceGLES2Context = mConfig.forceGLES2Context,
             .stereoscopicType =  mConfig.stereoscopicType,
             .assertNativeWindowIsValid = features.backend.opengl.assert_native_window_is_valid,
-            .metalDisablePanicOnDrawableFailure = mConfig.metalDisablePanicOnDrawableFailure,
     };
     mDriver = mPlatform->createDriver(mSharedGLContext, driverConfig);
 

filament/src/details/MaterialInstance.cpp

@@ -147,7 +147,8 @@ FMaterialInstance::FMaterialInstance(FEngine& engine,
     FEngine::DriverApi& driver = engine.getDriverApi();
     FMaterial const* const material = other->getMaterial();
 
-    mUniforms.setUniforms(other->getUniformBuffer());
+    size_t const uboSize = std::max(size_t(16), material->getUniformInterfaceBlock().getSize());
+    mUniforms = UniformBuffer(uboSize);
     mUbHandle = driver.createBufferObject(mUniforms.getSize(),
             BufferObjectBinding::UNIFORM, BufferUsage::DYNAMIC);
     driver.setDebugTag(mUbHandle.getId(), material->getName());
@@ -429,7 +430,7 @@ void FMaterialInstance::fixMissingSamplers() const {
                 FEngine const& engine = mMaterial->getEngine();
                 filament::DescriptorSetLayout const& layout = mMaterial->getDescriptorSetLayout();
 
-                if (pos->format == SamplerFormat::FLOAT) {
+                if (pos->format != SamplerFormat::FLOAT) {
                     // TODO: we only handle missing samplers that are FLOAT
                     switch (pos->type) {
                         case SamplerType::SAMPLER_2D:

filament/src/ds/DescriptorSet.cpp

@@ -241,8 +241,6 @@ bool DescriptorSet::isTextureCompatibleWithDescriptor(
             return t == TextureType::DEPTH || t == TextureType::DEPTH_STENCIL;
 
         case DescriptorType::SAMPLER_EXTERNAL:
-            return true;
-
         case DescriptorType::UNIFORM_BUFFER:
         case DescriptorType::SHADER_STORAGE_BUFFER:
         case DescriptorType::INPUT_ATTACHMENT:

ios/CocoaPods/Filament.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
   spec.name = "Filament"
-  spec.version = "1.61.0"
+  spec.version = "1.60.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.61.0/filament-v1.61.0-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.60.1/filament-v1.60.1-ios.tgz" }
 
   # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
   spec.pod_target_xcconfig = {

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 = 61;
+static constexpr size_t MATERIAL_VERSION = 60;
 
 /**
  * Supported shading models

libs/utils/include/private/utils/Tracing.h

@@ -30,9 +30,9 @@
 #   define FILAMENT_APPLE_SYSTRACE 0
 #endif
 
-#if defined(__ANDROID__) && FILAMENT_TRACING_ENABLED
+#if defined(__ANDROID__)
 #    include <private/utils/android/Tracing.h>
-#elif defined(__APPLE__) && FILAMENT_APPLE_SYSTRACE && FILAMENT_TRACING_ENABLED
+#elif defined(__APPLE__) && FILAMENT_APPLE_SYSTRACE
 #    include <private/utils/darwin/Tracing.h>
 #else
 

libs/utils/include/utils/FixedCapacityVector.h

@@ -40,7 +40,7 @@
 
 namespace utils {
 
-class UTILS_PUBLIC FixedCapacityVectorBase {
+class FixedCapacityVectorBase {
 protected:
     UTILS_NORETURN static void capacityCheckFailed(size_t capacity, size_t size);
 };

libs/utils/src/JobSystem.cpp

@@ -14,13 +14,8 @@
  * limitations under the License.
  */
 
-// TODO: Clean-up. We shouldn't need this #ifndef here, but a client has requested that perfetto be
-// disabled due to size increase.  In their case, this flag would be defined across targets. Hence
-// we guard below with an #ifndef.
-#ifndef FILAMENT_TRACING_ENABLED
 // Note: The overhead of TRACING is not negligible especially with parallel_for().
 #define FILAMENT_TRACING_ENABLED false
-#endif
 
 // when FILAMENT_TRACING_ENABLED is true, enables even heavier tracing
 #define HEAVY_TRACING  0
@@ -64,7 +59,6 @@
     // see https://developer.android.com/topic/performance/threads#priority
 #    include <sys/time.h>
 #    include <sys/resource.h>
-#    include <unistd.h>
 #    ifndef ANDROID_PRIORITY_URGENT_DISPLAY
 #        define ANDROID_PRIORITY_URGENT_DISPLAY (-8)
 #    endif

web/filament-js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filament",
-  "version": "1.61.0",
+  "version": "1.60.1",
   "description": "Real-time physically based rendering engine",
   "main": "filament.js",
   "module": "filament.js",