Testing stencilling 2

2024-10-09 16:24:45 -07:00
53 changed files with 365 additions and 465 deletions
@@ -1,17 +0,0 @@
-name: 'Android Continuous'
-inputs:
-  build-abi:
-    description: 'The target platform ABI'
-    required: true
-    default: 'armeabi-v7a'
-runs:
-  using: "composite"
-  steps:
-    - uses: actions/setup-java@v3
-      with:
-        distribution: 'temurin'
-        java-version: '17'
-    - name: Run build script
-      run: |
-        cd build/android && printf "y" | ./build.sh continuous ${{ inputs.build-abi }}
-      shell: bash
@@ -8,35 +8,32 @@ on:
      - rc/**

 jobs:
-  build-android-armv7:
-    name: build-android-armv7
+  build-android:
+    name: build-android
    runs-on: macos-14

    steps:
      - uses: actions/checkout@v4.1.6
-      - name: Run Android Continuous
-        uses: ./.github/actions/android-continuous
+      - uses: actions/setup-java@v3
        with:
-          build-abi: armeabi-v7a
-
-  build-android-armv8a:
-    name: build-android-armv8a
-    runs-on: macos-14
-
-    steps:
-      - uses: actions/checkout@v4.1.6
-      - name: Run Android Continuous
-        uses: ./.github/actions/android-continuous
+          distribution: 'temurin'
+          java-version: '17'
+      - name: Run build script
+        run: |
+          cd build/android && printf "y" | ./build.sh continuous
+      - uses: actions/upload-artifact@v1.0.0
        with:
-          build-abi: arm64-v8a
-
-  build-android-x86_64:
-    name: build-android-x86_64
-    runs-on: macos-14
-
-    steps:
-      - uses: actions/checkout@v4.1.6
-      - name: Run Android Continuous
-        uses: ./.github/actions/android-continuous
+          name: filament-android
+          path: out/filament-android-release.aar
+      - uses: actions/upload-artifact@v1.0.0
        with:
-          build-abi: x86_64
+          name: filamat-android-full
+          path: out/filamat-android-release.aar
+      - uses: actions/upload-artifact@v1.0.0
+        with:
+          name: gltfio-android-release
+          path: out/gltfio-android-release.aar
+      - uses: actions/upload-artifact@v1.0.0
+        with:
+          name: filament-utils-android-release
+          path: out/filament-utils-android-release.aar
@@ -49,10 +49,8 @@ jobs:
          distribution: 'temurin'
          java-version: '17'
      - name: Run build script
-        # Only build 1 64 bit target during presubmit to cut down build times during presubmit
-        # Continuous builds will build everything
        run: |
-          cd build/android && printf "y" | ./build.sh presubmit arm64-v8a
+          cd build/android && printf "y" | ./build.sh presubmit

  build-ios:
    name: build-iOS
@@ -120,7 +120,7 @@ jobs:
        env:
          TAG: ${{ steps.git_ref.outputs.tag }}
        run: |
-          cd build/android && printf "y" | ./build.sh release armeabi-v7a,arm64-v8a,x86,x86_64
+          cd build/android && printf "y" | ./build.sh release
          cd ../..
          mv out/filament-android-release.aar out/filament-${TAG}-android.aar
          mv out/filamat-android-release.aar out/filamat-${TAG}-android.aar
@@ -7,3 +7,5 @@ for next branch cut* header.
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).

 ## Release notes for next branch cut
+
+- Add a `name` API to Filament objects for debugging handle use-after-free assertions
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.54.3'
+    implementation 'com.google.android.filament:filament-android:1.54.0'
 }
 ```

@@ -51,9 +51,19 @@ 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.54.3'
+pod 'Filament', '~> 1.54.0'
 ```

+### Snapshots
+
+If you prefer to live on the edge, you can download a continuous build by following the following
+steps:
+
+1. Find the [commit](https://github.com/google/filament/commits/main) you're interested in.
+2. Click the green check mark under the commit message.
+3. Click on the _Details_ link for the platform you're interested in.
+4. On the top left click _Summary_, then in the _Artifacts_ section choose the desired artifact.
+
 ## Documentation

 - [Filament](https://google.github.io/filament/Filament.html), an in-depth explanation of
@@ -7,13 +7,6 @@ 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.54.3
-
-
-## v1.54.2
-
- Add a `name` API to Filament objects for debugging handle use-after-free assertions
-
 ## v1.54.1


@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.54.3
+VERSION_NAME=1.54.0

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

@@ -60,7 +60,13 @@ if [[ ! -d "${ANDROID_HOME}/ndk/$FILAMENT_NDK_VERSION" ]]; then
    yes | ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager --licenses
    ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager "ndk;$FILAMENT_NDK_VERSION"
 fi
+
+# Only build 1 64 bit target during presubmit to cut down build times during presubmit
+# Continuous builds will build everything
 ANDROID_ABIS=
+if [[ "$TARGET" == "presubmit" ]]; then
+  ANDROID_ABIS="-q arm64-v8a"
+fi

 # Build the Android sample-gltf-viewer APK during release.
 BUILD_SAMPLES=
@@ -68,19 +74,5 @@ if [[ "$TARGET" == "release" ]]; then
    BUILD_SAMPLES="-k sample-gltf-viewer"
 fi

-function build_android() {
-    local ABI=$1
-
-    # Do the following in two steps so that we do not run out of space
-    if [[ -n "${BUILD_DEBUG}" ]]; then
-        FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION} ./build.sh -p android -q ${ABI} -c ${BUILD_SAMPLES} ${GENERATE_ARCHIVES} ${BUILD_DEBUG}
-        rm -rf out/cmake-android-debug-*
-    fi
-    if [[ -n "${BUILD_RELEASE}" ]]; then
-        FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION} ./build.sh -p android -q ${ABI} -c ${BUILD_SAMPLES} ${GENERATE_ARCHIVES} ${BUILD_RELEASE}
-        rm -rf out/cmake-android-release-*
-    fi
-}
-
 pushd `dirname $0`/../.. > /dev/null
-build_android $2
+FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION} ./build.sh -p android $ANDROID_ABIS -c $BUILD_SAMPLES $GENERATE_ARCHIVES $BUILD_DEBUG $BUILD_RELEASE
@@ -1058,7 +1058,7 @@ struct RasterState {
            bool inverseFrontFaces                      : 1;        // 31

            //! padding, must be 0
-            bool depthClamp                             : 1;        // 32
+            uint8_t padding                             : 1;        // 32
        };
        uint32_t u = 0;
    };
@@ -309,7 +309,6 @@ DECL_DRIVER_API_SYNCHRONOUS_0(bool, isParallelShaderCompileSupported)
 DECL_DRIVER_API_SYNCHRONOUS_0(bool, isDepthStencilResolveSupported)
 DECL_DRIVER_API_SYNCHRONOUS_N(bool, isDepthStencilBlitSupported, backend::TextureFormat, format)
 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_0(math::float2, getClipSpaceParams)
@@ -444,10 +443,12 @@ DECL_DRIVER_API_N(setPushConstant,
        backend::PushConstantVariant, value)

 DECL_DRIVER_API_N(insertEventMarker,
-        const char*, string)
+        const char*, string,
+        uint32_t, len = 0)

 DECL_DRIVER_API_N(pushGroupMarker,
-        const char*, string)
+        const char*, string,
+        uint32_t, len = 0)

 DECL_DRIVER_API_0(popGroupMarker)

@@ -208,8 +208,14 @@ public:
        // TODO: for now, only pool handles check for use-after-free, so we only keep tags for
        // those
        if (isPoolHandle(id)) {
-            // Truncate the age to get the debug tag
-            uint32_t const key = id & ~(HANDLE_DEBUG_TAG_MASK ^ HANDLE_AGE_MASK);
+            // Truncate the tag's age to N bits.
+            constexpr uint8_t N = 2; // support a history of 4 tags
+            constexpr uint8_t mask = (1 << N) - 1;
+
+            uint8_t const age = (id & HANDLE_AGE_MASK) >> HANDLE_AGE_SHIFT;
+            uint8_t const newAge = age & mask;
+            uint32_t const key = (id & ~HANDLE_AGE_MASK) | (newAge << HANDLE_AGE_SHIFT);
+
            // This line is the costly part. In the future, we could potentially use a custom
            // allocator.
            mDebugTags[key] = std::move(tag);
@@ -220,8 +226,7 @@ public:
        if (!isPoolHandle(id)) {
            return "(no tag)";
        }
-        uint32_t const key = id & ~(HANDLE_DEBUG_TAG_MASK ^ HANDLE_AGE_MASK);
-        if (auto pos = mDebugTags.find(key); pos != mDebugTags.end()) {
+        if (auto pos = mDebugTags.find(id); pos != mDebugTags.end()) {
            return pos->second;
        }
        return "(no tag)";
@@ -344,24 +349,12 @@ private:
        }
    }

-    // number if bits allotted to the handle's age (currently 4 max)
-    static constexpr uint32_t HANDLE_AGE_BIT_COUNT = 4;
-    // number if bits allotted to the handle's debug tag (HANDLE_AGE_BIT_COUNT max)
-    static constexpr uint32_t HANDLE_DEBUG_TAG_BIT_COUNT = 2;
-    // bit shift for both the age and debug tag
-    static constexpr uint32_t HANDLE_AGE_SHIFT = 27;
-    // mask for the heap (vs pool) flag
-    static constexpr uint32_t HANDLE_HEAP_FLAG = 0x80000000u;
-    // mask for the age
-    static constexpr uint32_t HANDLE_AGE_MASK =
-            ((1 << HANDLE_AGE_BIT_COUNT) - 1) << HANDLE_AGE_SHIFT;
-    // mask for the debug tag
-    static constexpr uint32_t HANDLE_DEBUG_TAG_MASK =
-            ((1 << HANDLE_DEBUG_TAG_BIT_COUNT) - 1) << HANDLE_AGE_SHIFT;
-    // mask for the index
-    static constexpr uint32_t HANDLE_INDEX_MASK = 0x07FFFFFFu;
-
-    static_assert(HANDLE_DEBUG_TAG_BIT_COUNT <= HANDLE_AGE_BIT_COUNT);
+    // we handle a 4 bits age per address
+    static constexpr uint32_t HANDLE_HEAP_FLAG      = 0x80000000u;      // pool vs heap handle
+    static constexpr uint32_t HANDLE_AGE_MASK       = 0x78000000u;      // handle's age
+    static constexpr uint32_t HANDLE_INDEX_MASK     = 0x07FFFFFFu;      // handle index
+    static constexpr uint32_t HANDLE_TAG_MASK       = HANDLE_AGE_MASK;
+    static constexpr uint32_t HANDLE_AGE_SHIFT      = 27;

    static bool isPoolHandle(HandleBase::HandleId id) noexcept {
        return (id & HANDLE_HEAP_FLAG) == 0u;
@@ -376,7 +369,7 @@ private:
        // a non-pool handle.
        if (UTILS_LIKELY(isPoolHandle(id))) {
            char* const base = (char*)mHandleArena.getArea().begin();
-            uint32_t const tag = id & HANDLE_AGE_MASK;
+            uint32_t const tag = id & HANDLE_TAG_MASK;
            size_t const offset = (id & HANDLE_INDEX_MASK) * Allocator::getAlignment();
            return { static_cast<void*>(base + offset), tag };
        }
@@ -391,7 +384,7 @@ private:
        size_t const offset = (char*)p - base;
        assert_invariant((offset % Allocator::getAlignment()) == 0);
        auto id = HandleBase::HandleId(offset / Allocator::getAlignment());
-        id |= tag & HANDLE_AGE_MASK;
+        id |= tag & HANDLE_TAG_MASK;
        assert_invariant((id & HANDLE_HEAP_FLAG) == 0);
        return id;
    }
@@ -24,7 +24,7 @@
 #include <utils/debug.h>
 #include <utils/ostream.h>

-#if !defined(WIN32) && !defined(__EMSCRIPTEN__)
+#if !defined(WIN32) && !defined(__EMSCRIPTEN__) && !defined(IOS)
 #    include <sys/mman.h>
 #    include <unistd.h>
 #    define HAS_MMAP 1
@@ -160,8 +160,6 @@ public:
         size_t size, bool forceGpuBuffer = false);
    ~MetalBuffer();

-    [[nodiscard]] bool wasAllocationSuccessful() const noexcept { return mBuffer || mCpuBuffer; }
-
    MetalBuffer(const MetalBuffer& rhs) = delete;
    MetalBuffer& operator=(const MetalBuffer& rhs) = delete;

@@ -53,8 +53,8 @@ MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType,
        mBuffer = { [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate],
            TrackedMetalBuffer::Type::GENERIC };
    }
-    // mBuffer might fail to be allocated. Clients can check for this by calling
-    // wasAllocationSuccessful().
+    FILAMENT_CHECK_POSTCONDITION(mBuffer)
+            << "Could not allocate Metal buffer of size " << size << ".";
 }

 MetalBuffer::~MetalBuffer() {
@@ -112,7 +112,6 @@ struct MetalContext {
    std::array<BufferState, MAX_SSBO_COUNT> ssboState;
    CullModeStateTracker cullModeState;
    WindingStateTracker windingState;
-    DepthClampStateTracker depthClampState;
    Handle<HwRenderPrimitive> currentRenderPrimitive;

    // State caches.
@@ -57,6 +57,7 @@ class MetalDriver final : public DriverBase {

 public:
    static Driver* create(MetalPlatform* platform, const Platform::DriverConfig& driverConfig);
+    void runAtNextTick(const std::function<void()>& fn) noexcept;

 private:

@@ -72,12 +73,10 @@ private:

    /*
     * Tasks run regularly on the driver thread.
-     * Not thread-safe; tasks are run from the driver thead and must be enqueued from the driver
-     * thread.
     */
-    void runAtNextTick(const std::function<void()>& fn) noexcept;
    void executeTickOps() noexcept;
    std::vector<std::function<void()>> mTickOps;
+    std::mutex mTickOpsLock;

    /*
     * Driver interface
@@ -320,40 +320,17 @@ void MetalDriver::createVertexBufferR(Handle<HwVertexBuffer> vbh,
        uint32_t vertexCount, Handle<HwVertexBufferInfo> vbih) {
    MetalVertexBufferInfo const* const vbi = handle_cast<const MetalVertexBufferInfo>(vbih);
    construct_handle<MetalVertexBuffer>(vbh, *mContext, vertexCount, vbi->bufferCount, vbih);
-    // No actual GPU memory is allocated here, so no need to check for allocation success.
 }

 void MetalDriver::createIndexBufferR(Handle<HwIndexBuffer> ibh, ElementType elementType,
        uint32_t indexCount, BufferUsage usage) {
-    auto elementSize = (uint8_t)getElementTypeSize(elementType);
-    auto* indexBuffer =
-            construct_handle<MetalIndexBuffer>(ibh, *mContext, usage, elementSize, indexCount);
-    auto& buffer = indexBuffer->buffer;
-    // If the allocation was not successful, postpone the error message until the next tick, to give
-    // Filament a chance to call setDebugTag on the handle; this way we get a nicer error message.
-    if (UTILS_UNLIKELY(!buffer.wasAllocationSuccessful())) {
-        const size_t byteCount = buffer.getSize();
-        runAtNextTick([byteCount, this, ibh]() {
-            FILAMENT_CHECK_POSTCONDITION(false)
-                    << "Could not allocate Metal index buffer of size " << byteCount
-                    << ", tag=" << mHandleAllocator.getHandleTag(ibh.getId()).c_str_safe();
-        });
-    }
+    auto elementSize = (uint8_t) getElementTypeSize(elementType);
+    construct_handle<MetalIndexBuffer>(ibh, *mContext, usage, elementSize, indexCount);
 }

 void MetalDriver::createBufferObjectR(Handle<HwBufferObject> boh, uint32_t byteCount,
        BufferObjectBinding bindingType, BufferUsage usage) {
-    auto* bufferObject =
-            construct_handle<MetalBufferObject>(boh, *mContext, bindingType, usage, byteCount);
-    // If the allocation was not successful, postpone the error message until the next tick, to give
-    // Filament a chance to call setDebugTag on the handle; this way we get a nicer error message.
-    if (UTILS_UNLIKELY(!bufferObject->getBuffer()->wasAllocationSuccessful())) {
-        runAtNextTick([byteCount, this, boh]() {
-            FILAMENT_CHECK_POSTCONDITION(false)
-                    << "Could not allocate Metal buffer of size " << byteCount
-                    << ", tag=" << mHandleAllocator.getHandleTag(boh.getId()).c_str_safe();
-        });
-    }
+    construct_handle<MetalBufferObject>(boh, *mContext, bindingType, usage, byteCount);
 }

 void MetalDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint8_t levels,
@@ -857,10 +834,6 @@ bool MetalDriver::isProtectedTexturesSupported() {
    return false;
 }

-bool MetalDriver::isDepthClampSupported() {
-    return true;
-}
-
 bool MetalDriver::isWorkaroundNeeded(Workaround workaround) {
    switch (workaround) {
        case Workaround::SPLIT_EASU:
@@ -1302,11 +1275,11 @@ void MetalDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
    pushConstants.setPushConstant(value, index);
 }

-void MetalDriver::insertEventMarker(const char* string) {
+void MetalDriver::insertEventMarker(const char* string, uint32_t len) {

 }

-void MetalDriver::pushGroupMarker(const char* string) {
+void MetalDriver::pushGroupMarker(const char* string, uint32_t len) {
    mContext->groupMarkers.push(string);
 }

@@ -1778,13 +1751,6 @@ void MetalDriver::bindPipeline(PipelineState const& ps) {
        [mContext->currentRenderPassEncoder setFrontFacingWinding:winding];
    }

-    // depth clip mode
-    MTLDepthClipMode depthClipMode = rs.depthClamp ? MTLDepthClipModeClamp : MTLDepthClipModeClip;
-    mContext->depthClampState.updateState(depthClipMode);
-    if (mContext->depthClampState.stateChanged()) {
-        [mContext->currentRenderPassEncoder setDepthClipMode:depthClipMode];
-    }
-
    // Set the depth-stencil state, if a state change is needed.
    DepthStencilState depthState;
    if (depthAttachment) {
@@ -1794,8 +1760,6 @@ void MetalDriver::bindPipeline(PipelineState const& ps) {
    if (stencilAttachment) {
        const auto& ss = ps.stencilState;

-        // Ben test
-
        auto& front = depthState.front;
        front.stencilCompare = getMetalCompareFunction(ss.front.stencilFunc);
        front.stencilOperationStencilFail = getMetalStencilOperation(ss.front.stencilOpStencilFail);
@@ -2102,12 +2066,15 @@ void MetalDriver::setDebugTag(HandleBase::HandleId handleId, utils::CString tag)
 }

 void MetalDriver::runAtNextTick(const std::function<void()>& fn) noexcept {
+    std::lock_guard<std::mutex> const lock(mTickOpsLock);
    mTickOps.push_back(fn);
 }

 void MetalDriver::executeTickOps() noexcept {
    std::vector<std::function<void()>> ops;
+    mTickOpsLock.lock();
    std::swap(ops, mTickOps);
+    mTickOpsLock.unlock();
    for (const auto& f : ops) {
        f();
    }
@@ -257,6 +257,10 @@ void MetalSwapChain::present() {
    }
 }

+#ifndef FILAMENT_RELEASE_PRESENT_DRAWABLE_MAIN_THREAD
+#define FILAMENT_RELEASE_PRESENT_DRAWABLE_MAIN_THREAD 1
+#endif
+
 class PresentDrawableData {
 public:
    PresentDrawableData() = delete;
@@ -275,10 +279,14 @@ public:
           [that->mDrawable present];
        }

+#if FILAMENT_RELEASE_PRESENT_DRAWABLE_MAIN_THREAD == 1
        // mDrawable is acquired on the driver thread. Typically, we would release this object on
        // the same thread, but after receiving consistent crash reports from within
        // [CAMetalDrawable dealloc], we suspect this object requires releasing on the main thread.
        dispatch_async(dispatch_get_main_queue(), ^{ cleanupAndDestroy(that); });
+#else
+        that->mDriver->runAtNextTick([that]() { cleanupAndDestroy(that); });
+#endif
    }

 private:
@@ -382,7 +382,6 @@ using SamplerStateCache = StateCache<SamplerState, id<MTLSamplerState>, SamplerS

 using CullModeStateTracker = StateTracker<MTLCullMode>;
 using WindingStateTracker = StateTracker<MTLWinding>;
-using DepthClampStateTracker = StateTracker<MTLDepthClipMode>;

 // Argument encoder

@@ -202,10 +202,6 @@ bool NoopDriver::isProtectedTexturesSupported() {
    return true;
 }

-bool NoopDriver::isDepthClampSupported() {
-    return false;
-}
-
 bool NoopDriver::isWorkaroundNeeded(Workaround) {
    return false;
 }
@@ -320,10 +316,10 @@ void NoopDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
        backend::PushConstantVariant value) {
 }

-void NoopDriver::insertEventMarker(char const* string) {
+void NoopDriver::insertEventMarker(char const* string, uint32_t len) {
 }

-void NoopDriver::pushGroupMarker(char const* string) {
+void NoopDriver::pushGroupMarker(char const* string,  uint32_t len) {
 }

 void NoopDriver::popGroupMarker(int) {
@@ -676,7 +676,6 @@ void OpenGLContext::initExtensionsGLES(Extensions* ext, GLint major, GLint minor
 #ifndef __EMSCRIPTEN__
    ext->EXT_debug_marker = exts.has("GL_EXT_debug_marker"sv);
 #endif
-    ext->EXT_depth_clamp = exts.has("GL_EXT_depth_clamp"sv);
    ext->EXT_discard_framebuffer = exts.has("GL_EXT_discard_framebuffer"sv);
 #ifndef __EMSCRIPTEN__
    ext->EXT_disjoint_timer_query = exts.has("GL_EXT_disjoint_timer_query"sv);
@@ -747,7 +746,6 @@ void OpenGLContext::initExtensionsGL(Extensions* ext, GLint major, GLint minor)
    ext->EXT_color_buffer_half_float = true;  // Assumes core profile.
    ext->EXT_clip_cull_distance = true;
    ext->EXT_debug_marker = exts.has("GL_EXT_debug_marker"sv);
-    ext->EXT_depth_clamp = true;
    ext->EXT_discard_framebuffer = false;
    ext->EXT_disjoint_timer_query = true;
    ext->EXT_multisampled_render_to_texture = false;
@@ -1046,6 +1044,11 @@ void OpenGLContext::resetState() noexcept {
    );
    glDepthMask(state.raster.depthMask);
    glDepthFunc(state.raster.depthFunc);
+
+    utils::slog.e << "stencil front=" << 
+        state.stencil.front.func.func << " "  <<
+        state.stencil.front.func.ref << " "  <<
+        state.stencil.front.func.mask << " " << utils::io::endl;
    
    // state.stencil
    glStencilFuncSeparate(
@@ -220,9 +220,8 @@ public:
        bool EXT_color_buffer_float;
        bool EXT_color_buffer_half_float;
        bool EXT_debug_marker;
-        bool EXT_depth_clamp;
-        bool EXT_discard_framebuffer;
        bool EXT_disjoint_timer_query;
+        bool EXT_discard_framebuffer;
        bool EXT_multisampled_render_to_texture2;
        bool EXT_multisampled_render_to_texture;
        bool EXT_protected_textures;
@@ -240,10 +239,10 @@ public:
        bool KHR_parallel_shader_compile;
        bool KHR_texture_compression_astc_hdr;
        bool KHR_texture_compression_astc_ldr;
-        bool OES_EGL_image_external_essl3;
-        bool OES_depth24;
        bool OES_depth_texture;
+        bool OES_depth24;
        bool OES_packed_depth_stencil;
+        bool OES_EGL_image_external_essl3;
        bool OES_rgb8_rgba8;
        bool OES_standard_derivatives;
        bool OES_texture_npot;
@@ -628,7 +627,6 @@ constexpr size_t OpenGLContext::getIndexForCap(GLenum cap) noexcept { //NOLINT
 #ifdef BACKEND_OPENGL_VERSION_GL
        case GL_PROGRAM_POINT_SIZE:             index = 10; break;
 #endif
-        case GL_DEPTH_CLAMP:                    index = 11; break;
        default: break;
    }
    assert_invariant(index < state.enables.caps.size());
@@ -451,14 +451,6 @@ void OpenGLDriver::setRasterState(RasterState rs) noexcept {
    } else {
        gl.disable(GL_SAMPLE_ALPHA_TO_COVERAGE);
    }
-
-    if (gl.ext.EXT_depth_clamp) {
-        if (rs.depthClamp) {
-            gl.enable(GL_DEPTH_CLAMP);
-        } else {
-            gl.disable(GL_DEPTH_CLAMP);
-        }
-    }
 }

 void OpenGLDriver::setStencilState(StencilState ss) noexcept {
@@ -468,20 +460,20 @@ void OpenGLDriver::setStencilState(StencilState ss) noexcept {

    // stencil test / operation
    // GL_STENCIL_TEST must be enabled if we're testing OR writing to the stencil buffer.
-    if (UTILS_LIKELY(
-            ss.front.stencilFunc == StencilState::StencilFunction::A &&
-            ss.back.stencilFunc == StencilState::StencilFunction::A &&
-            ss.front.stencilOpDepthFail == StencilOperation::KEEP &&
-            ss.back.stencilOpDepthFail == StencilOperation::KEEP &&
-            ss.front.stencilOpStencilFail == StencilOperation::KEEP &&
-            ss.back.stencilOpStencilFail == StencilOperation::KEEP &&
-            ss.front.stencilOpDepthStencilPass == StencilOperation::KEEP &&
-            ss.back.stencilOpDepthStencilPass == StencilOperation::KEEP)) {
-        // that's equivalent to having the stencil test disabled
-        gl.disable(GL_STENCIL_TEST);
-    } else {
+    // if (UTILS_LIKELY(
+    //         ss.front.stencilFunc == StencilState::StencilFunction::A &&
+    //         ss.back.stencilFunc == StencilState::StencilFunction::A &&
+    //         ss.front.stencilOpDepthFail == StencilOperation::KEEP &&
+    //         ss.back.stencilOpDepthFail == StencilOperation::KEEP &&
+    //         ss.front.stencilOpStencilFail == StencilOperation::KEEP &&
+    //         ss.back.stencilOpStencilFail == StencilOperation::KEEP &&
+    //         ss.front.stencilOpDepthStencilPass == StencilOperation::KEEP &&
+    //         ss.back.stencilOpDepthStencilPass == StencilOperation::KEEP) && false) {
+    //     // that's equivalent to having the stencil test disabled
+    //     gl.disable(GL_STENCIL_TEST);
+    // } else {
        gl.enable(GL_STENCIL_TEST);
-    }
+//    }

    // glStencilFuncSeparate() also sets the reference value, which may be used depending
    // on the stencilOp, so we always need to call glStencilFuncSeparate().
@@ -489,9 +481,9 @@ void OpenGLDriver::setStencilState(StencilState ss) noexcept {
            getStencilFunc(ss.front.stencilFunc), ss.front.ref, ss.front.readMask,
            getStencilFunc(ss.back.stencilFunc), ss.back.ref, ss.back.readMask);

-    if (UTILS_LIKELY(!ss.stencilWrite)) {
-        gl.stencilMaskSeparate(0x00, 0x00);
-    } else {
+//    if (UTILS_LIKELY(!ss.stencilWrite)) {
+//        gl.stencilMaskSeparate(0x00, 0x00);
+//    } else {
        // Stencil ops are only relevant when stencil write is enabled
        gl.stencilOpSeparate(
                getStencilOp(ss.front.stencilOpStencilFail),
@@ -501,7 +493,7 @@ void OpenGLDriver::setStencilState(StencilState ss) noexcept {
                getStencilOp(ss.back.stencilOpDepthFail),
                getStencilOp(ss.back.stencilOpDepthStencilPass));
        gl.stencilMaskSeparate(ss.front.writeMask, ss.back.writeMask);
-    }
+//    }
 }

 // ------------------------------------------------------------------------------------------------
@@ -2127,10 +2119,6 @@ bool OpenGLDriver::isProtectedTexturesSupported() {
    return getContext().ext.EXT_protected_textures;
 }

-bool OpenGLDriver::isDepthClampSupported() {
-    return getContext().ext.EXT_depth_clamp;
-}
-
 bool OpenGLDriver::isWorkaroundNeeded(Workaround workaround) {
    switch (workaround) {
        case Workaround::SPLIT_EASU:
@@ -3196,23 +3184,23 @@ void OpenGLDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
    CHECK_GL_ERROR(utils::slog.e)
 }

-void OpenGLDriver::insertEventMarker(char const* string) {
+void OpenGLDriver::insertEventMarker(char const* string, uint32_t len) {
 #ifndef __EMSCRIPTEN__
 #ifdef GL_EXT_debug_marker
    auto& gl = mContext;
    if (gl.ext.EXT_debug_marker) {
-        glInsertEventMarkerEXT(GLsizei(strlen(string)), string);
+        glInsertEventMarkerEXT(GLsizei(len ? len : strlen(string)), string);
    }
 #endif
 #endif
 }

-void OpenGLDriver::pushGroupMarker(char const* string) {
+void OpenGLDriver::pushGroupMarker(char const* string, uint32_t len) {
 #ifndef __EMSCRIPTEN__
 #ifdef GL_EXT_debug_marker
 #if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_OPENGL
    if (UTILS_LIKELY(mContext.ext.EXT_debug_marker)) {
-        glPushGroupMarkerEXT(GLsizei(strlen(string)), string);
+        glPushGroupMarkerEXT(GLsizei(len ? len : strlen(string)), string);
    }
 #endif
 #endif
@@ -201,12 +201,6 @@ using namespace glext;
 #   define GL_CLIP_DISTANCE1                        0x3001
 #endif

-#if defined(GL_EXT_depth_clamp)
-#   define GL_DEPTH_CLAMP                           GL_DEPTH_CLAMP_EXT
-#else
-#   define GL_DEPTH_CLAMP                           0x864F
-#endif
-
 #if defined(GL_KHR_debug)
 #   define GL_DEBUG_OUTPUT                          GL_DEBUG_OUTPUT_KHR
 #   define GL_DEBUG_OUTPUT_SYNCHRONOUS              GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR
@@ -125,10 +125,6 @@ public:
        return mPhysicalDeviceFeatures.imageCubeArray == VK_TRUE;
    }

-    inline bool isDepthClampSupported() const noexcept {
-        return mPhysicalDeviceFeatures.depthClamp == VK_TRUE;
-    }
-
    inline bool isDebugMarkersSupported() const noexcept {
        return mDebugMarkersSupported;
    }
@@ -944,10 +944,6 @@ bool VulkanDriver::isProtectedTexturesSupported() {
    return false;
 }

-bool VulkanDriver::isDepthClampSupported() {
-    return mContext.isDepthClampSupported();
-}
-
 bool VulkanDriver::isWorkaroundNeeded(Workaround workaround) {
    switch (workaround) {
        case Workaround::SPLIT_EASU: {
@@ -1606,13 +1602,13 @@ void VulkanDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
            value);
 }

-void VulkanDriver::insertEventMarker(char const* string) {
+void VulkanDriver::insertEventMarker(char const* string, uint32_t len) {
 #if FVK_ENABLED(FVK_DEBUG_GROUP_MARKERS)
-    mCommands.insertEventMarker(string, strlen(string));
+    mCommands.insertEventMarker(string, len);
 #endif
 }

-void VulkanDriver::pushGroupMarker(char const* string) {
+void VulkanDriver::pushGroupMarker(char const* string, uint32_t) {
    // Turns out all the markers are 0-terminated, so we can just pass it without len.
 #if FVK_ENABLED(FVK_DEBUG_GROUP_MARKERS)
    mCommands.pushGroupMarker(string);
@@ -1820,7 +1816,6 @@ void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
        .dstAlphaBlendFactor = getBlendFactor(rasterState.blendFunctionDstAlpha),
        .colorWriteMask = (VkColorComponentFlags) (rasterState.colorWrite ? 0xf : 0x0),
        .rasterizationSamples = rt->getSamples(),
-        .depthClamp = rasterState.depthClamp,
        .colorTargetCount = rt->getColorTargetCount(mCurrentRenderPass),
        .colorBlendOp = rasterState.blendEquationRGB,
        .alphaBlendOp =  rasterState.blendEquationAlpha,
@@ -16,6 +16,7 @@

 #include "VulkanHandles.h"

+#include "VulkanDriver.h"
 #include "VulkanConstants.h"
 #include "VulkanDriver.h"
 #include "VulkanMemory.h"
@@ -184,7 +184,6 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
    vkRaster.polygonMode = VK_POLYGON_MODE_FILL;
    vkRaster.cullMode = raster.cullMode;
    vkRaster.frontFace = raster.frontFace;
-    vkRaster.depthClampEnable = raster.depthClamp;
    vkRaster.depthBiasEnable = raster.depthBiasEnable;
    vkRaster.depthBiasConstantFactor = raster.depthBiasConstantFactor;
    vkRaster.depthBiasClamp = 0.0f;
@@ -90,8 +90,7 @@ public:
        VkBlendFactor         srcAlphaBlendFactor : 5;
        VkBlendFactor         dstAlphaBlendFactor : 5;
        VkColorComponentFlags colorWriteMask : 4;
-        uint8_t               rasterizationSamples : 4;// offset = 4 bytes
-        uint8_t               depthClamp : 4;
+        uint8_t               rasterizationSamples;    // offset = 4 bytes
        uint8_t               colorTargetCount;        // offset = 5 bytes
        BlendEquation         colorBlendOp : 4;        // offset = 6 bytes
        BlendEquation         alphaBlendOp : 4;
@@ -97,11 +97,13 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        imageInfo.extent.depth = 1;
    }

-    if (any(usage & TextureUsage::BLIT_SRC)) {
-        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-    }
-    if (any(usage & TextureUsage::BLIT_DST)) {
-        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    // Filament expects blit() to work with any texture, so we almost always set these usage flags.
+    // TODO: investigate performance implications of setting these flags.
+    constexpr VkImageUsageFlags blittable = VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+            VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+
+    if (any(usage & (TextureUsage::BLIT_DST | TextureUsage::BLIT_SRC))) {
+        imageInfo.usage |= blittable;
    }

    if (any(usage & TextureUsage::SAMPLEABLE)) {
@@ -119,7 +121,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        imageInfo.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
    }
    if (any(usage & TextureUsage::COLOR_ATTACHMENT)) {
-        imageInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        imageInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | blittable;
        if (any(usage & TextureUsage::SUBPASS_INPUT)) {
            imageInfo.usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
        }
@@ -128,9 +130,10 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        imageInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
    }
    if (any(usage & TextureUsage::UPLOADABLE)) {
-        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+        imageInfo.usage |= blittable;
    }
    if (any(usage & TextureUsage::DEPTH_ATTACHMENT)) {
+        imageInfo.usage |= blittable;
        imageInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;

        // Depth resolves uses a custom shader and therefore needs to be sampleable.
@@ -325,7 +325,6 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
    // We could simply enable all supported features, but since that may have performance
    // consequences let's just enable the features we need.
    VkPhysicalDeviceFeatures enabledFeatures{
-            .depthClamp = features.depthClamp,
            .samplerAnisotropy = features.samplerAnisotropy,
            .textureCompressionETC2 = features.textureCompressionETC2,
            .textureCompressionBC = features.textureCompressionBC,
@@ -55,8 +55,7 @@ public:
 template<typename T>
 using BuilderBase = utils::PrivateImplementation<T>;

-// This needs to be public because it is used in the following template.
-UTILS_PUBLIC void builderMakeName(utils::CString& outName, const char* name, size_t len) noexcept;
+void builderMakeName(utils::CString& outName, const char* name, size_t len) noexcept;

 template <typename Builder>
 class UTILS_PUBLIC BuilderNameMixin {
@@ -459,12 +459,10 @@ void PerViewUniforms::bind(backend::DriverApi& driver) noexcept {

 void PerViewUniforms::unbindSamplers() noexcept {
    auto& samplerGroup = mSamplers;
-    samplerGroup.clearSampler(PerViewSib::SHADOW_MAP);
-    samplerGroup.clearSampler(PerViewSib::IBL_SPECULAR);
    samplerGroup.clearSampler(PerViewSib::SSAO);
    samplerGroup.clearSampler(PerViewSib::SSR);
    samplerGroup.clearSampler(PerViewSib::STRUCTURE);
-    samplerGroup.clearSampler(PerViewSib::FOG);
+    samplerGroup.clearSampler(PerViewSib::SHADOW_MAP);
 }

 } // namespace filament
@@ -3193,7 +3193,6 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::resolve(FrameGraph& fg,
                assert_invariant(dst);
                assert_invariant(srcDesc.format == dstDesc.format);
                assert_invariant(srcDesc.width == dstDesc.width && srcDesc.height == dstDesc.height);
-                assert_invariant(srcDesc.samples > 1 && dstDesc.samples <= 1);
                driver.resolve(
                        dst, dstSubDesc.level, dstSubDesc.layer,
                        src, srcSubDesc.level, srcSubDesc.layer);
@@ -419,8 +419,7 @@ RenderPass::Command* RenderPass::instanceify(FEngine& engine,
 UTILS_ALWAYS_INLINE // This function exists only to make the code more readable. we want it inlined.
 inline              // and we don't need it in the compilation unit
 void RenderPass::setupColorCommand(Command& cmdDraw, Variant variant,
-        FMaterialInstance const* const UTILS_RESTRICT mi,
-        bool inverseFrontFaces, bool hasDepthClamp) noexcept {
+        FMaterialInstance const* const UTILS_RESTRICT mi, bool inverseFrontFaces) noexcept {

    FMaterial const * const UTILS_RESTRICT ma = mi->getMaterial();
    variant = Variant::filterVariant(variant, ma->isVariantLit());
@@ -461,7 +460,6 @@ void RenderPass::setupColorCommand(Command& cmdDraw, Variant variant,
    cmdDraw.info.rasterState.colorWrite = mi->isColorWriteEnabled();
    cmdDraw.info.rasterState.depthWrite = mi->isDepthWriteEnabled();
    cmdDraw.info.rasterState.depthFunc = mi->getDepthFunc();
-    cmdDraw.info.rasterState.depthClamp = hasDepthClamp;
    cmdDraw.info.materialVariant = variant;
    // we keep "RasterState::colorWrite" to the value set by material (could be disabled)
 }
@@ -560,9 +558,6 @@ RenderPass::Command* RenderPass::generateCommandsImpl(RenderPass::CommandTypeFla
    bool const hasInstancedStereo =
            renderFlags & IS_INSTANCED_STEREOSCOPIC;

-    bool const hasDepthClamp =
-            renderFlags & HAS_DEPTH_CLAMP;
-
    float const cameraPositionDotCameraForward = dot(cameraPosition, cameraForward);

    auto const* const UTILS_RESTRICT soaWorldAABBCenter = soa.data<FScene::WORLD_AABB_CENTER>();
@@ -582,7 +577,6 @@ RenderPass::Command* RenderPass::generateCommandsImpl(RenderPass::CommandTypeFla
        cmd.info.rasterState.depthWrite = true;
        cmd.info.rasterState.depthFunc = RasterState::DepthFunc::GE;
        cmd.info.rasterState.alphaToCoverage = false;
-        cmd.info.rasterState.depthClamp = hasDepthClamp;
    }

    for (uint32_t i = range.first; i < range.last; ++i) {
@@ -697,8 +691,7 @@ RenderPass::Command* RenderPass::generateCommandsImpl(RenderPass::CommandTypeFla
            cmd.info.morphingOffset = primitive.getMorphingBufferOffset();

            if constexpr (isColorPass) {
-                RenderPass::setupColorCommand(cmd, renderableVariant, mi,
-                        inverseFrontFaces, hasDepthClamp);
+                RenderPass::setupColorCommand(cmd, renderableVariant, mi, inverseFrontFaces);
                const bool blendPass = Pass(cmd.key & PASS_MASK) == Pass::BLENDED;
                if (blendPass) {
                    // TODO: at least for transparent objects, AABB should be per primitive
@@ -284,7 +284,6 @@ public:
    static constexpr RenderFlags HAS_SHADOWING             = 0x01;
    static constexpr RenderFlags HAS_INVERSE_FRONT_FACES   = 0x02;
    static constexpr RenderFlags IS_INSTANCED_STEREOSCOPIC = 0x04;
-    static constexpr RenderFlags HAS_DEPTH_CLAMP           = 0x08;

    // Arena used for commands
    using Arena = utils::Arena<
@@ -445,7 +444,7 @@ private:
            uint8_t instancedStereoEyeCount) noexcept;

    static void setupColorCommand(Command& cmdDraw, Variant variant,
-            FMaterialInstance const* mi, bool inverseFrontFaces, bool hasDepthClamp) noexcept;
+            FMaterialInstance const* mi, bool inverseFrontFaces) noexcept;

    static void updateSummedPrimitiveCounts(
            FScene::RenderableSoa& renderableData, utils::Range<uint32_t> vr) noexcept;
@@ -529,9 +528,7 @@ public:
    // like above but allows to set specific flags
    RenderPassBuilder& renderFlags(
            RenderPass::RenderFlags mask, RenderPass::RenderFlags value) noexcept {
-        value &= mask;
-        mFlags &= ~mask;
-        mFlags |= value;
+        mFlags = (mFlags & mask) | (value & mask);
        return *this;
    }

@@ -40,7 +40,6 @@
 #include <utils/Panic.h>

 #include <algorithm>
-#include <optional>
 #include <utility>

 #include <stddef.h>
@@ -51,9 +50,8 @@ namespace filament {
 using namespace backend;
 using namespace math;

-RendererUtils::ColorPassOutput RendererUtils::colorPass(
+FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
        FrameGraph& fg, const char* name, FEngine& engine, FView const& view,
-        ColorPassInput const& colorPassInput,
        FrameGraphTexture::Descriptor const& colorBufferDesc,
        ColorPassConfig const& config, PostProcessManager::ColorGradingConfig colorGradingConfig,
        RenderPass::Executor passExecutor) noexcept {
@@ -69,6 +67,8 @@ RendererUtils::ColorPassOutput RendererUtils::colorPass(
        FrameGraphId<FrameGraphTexture> structure;
    };

+    Blackboard& blackboard = fg.getBlackboard();
+
    auto& colorPass = fg.addPass<ColorPassData>(name,
            [&](FrameGraph::Builder& builder, ColorPassData& data) {

@@ -76,21 +76,21 @@ RendererUtils::ColorPassOutput RendererUtils::colorPass(
                TargetBufferFlags clearDepthFlags = config.clearFlags & TargetBufferFlags::DEPTH;
                TargetBufferFlags clearStencilFlags = config.clearFlags & TargetBufferFlags::STENCIL;

-                data.color = colorPassInput.linearColor;
-                data.depth = colorPassInput.depth;
-                data.shadows = colorPassInput.shadows;
-                data.ssao = colorPassInput.ssao;
+                data.shadows = blackboard.get<FrameGraphTexture>("shadows");
+                data.ssao = blackboard.get<FrameGraphTexture>("ssao");
+                data.color = blackboard.get<FrameGraphTexture>("color");
+                data.depth = blackboard.get<FrameGraphTexture>("depth");

                // Screen-space reflection or refractions
                if (config.hasScreenSpaceReflectionsOrRefractions) {
-                    data.ssr = colorPassInput.ssr;
+                    data.ssr = blackboard.get<FrameGraphTexture>("ssr");
                    if (data.ssr) {
                        data.ssr = builder.sample(data.ssr);
                    }
                }

                if (config.hasContactShadows) {
-                    data.structure = colorPassInput.structure;
+                    data.structure = blackboard.get<FrameGraphTexture>("structure");
                    assert_invariant(data.structure);
                    data.structure = builder.sample(data.structure);
                }
@@ -153,8 +153,6 @@ RendererUtils::ColorPassOutput RendererUtils::colorPass(
                }

                if (colorGradingConfig.asSubpass) {
-                    assert_invariant(config.msaa <= 1);
-                    assert_invariant(colorBufferDesc.samples <= 1);
                    data.output = builder.createTexture("Tonemapped Buffer", {
                            .width = colorBufferDesc.width,
                            .height = colorBufferDesc.height,
@@ -196,6 +194,7 @@ RendererUtils::ColorPassOutput RendererUtils::colorPass(
                        .samples = config.msaa,
                        .layerCount = static_cast<uint8_t>(colorBufferDesc.depth),
                        .clearFlags = clearColorFlags | clearDepthFlags | clearStencilFlags});
+                blackboard["depth"] = data.depth;
            },
            [=, passExecutor = std::move(passExecutor), &view, &engine](FrameGraphResources const& resources,
                    ColorPassData const& data, DriverApi& driver) {
@@ -261,21 +260,24 @@ RendererUtils::ColorPassOutput RendererUtils::colorPass(
            }
    );

-    return {
-            .linearColor = colorPass->color,
-            .tonemappedColor = colorPass->output,   // can be null
-            .depth = colorPass->depth
-    };
+    // when color grading is done as a subpass, the output of the color-pass is the ldr buffer
+    auto output = colorGradingConfig.asSubpass ? colorPass->output : colorPass->color;
+
+    blackboard["color"] = output;
+    return output;
 }

-std::optional<RendererUtils::ColorPassOutput> RendererUtils::refractionPass(
+std::pair<FrameGraphId<FrameGraphTexture>, bool> RendererUtils::refractionPass(
        FrameGraph& fg, FEngine& engine, FView const& view,
-        ColorPassInput colorPassInput,
        ColorPassConfig config,
        PostProcessManager::ScreenSpaceRefConfig const& ssrConfig,
        PostProcessManager::ColorGradingConfig colorGradingConfig,
        RenderPass const& pass) noexcept {

+    auto& blackboard = fg.getBlackboard();
+    auto input = blackboard.get<FrameGraphTexture>("color");
+    FrameGraphId<FrameGraphTexture> output;
+
    // find the first refractive object in channel 2
    RenderPass::Command const* const refraction = std::partition_point(pass.begin(), pass.end(),
            [](auto const& command) {
@@ -290,35 +292,34 @@ std::optional<RendererUtils::ColorPassOutput> RendererUtils::refractionPass(

    // if there wasn't any refractive object, just skip everything below.
    if (UTILS_UNLIKELY(hasScreenSpaceRefraction)) {
-        assert_invariant(!colorPassInput.linearColor);
-        assert_invariant(!colorPassInput.depth);
+        PostProcessManager& ppm = engine.getPostProcessManager();
+
+        // clear the color/depth buffers, which will orphan (and cull) the color pass
+        input.clear();
+        blackboard.remove("color");
+        blackboard.remove("depth");
+
        config.hasScreenSpaceReflectionsOrRefractions = true;

-        PostProcessManager& ppm = engine.getPostProcessManager();
-        auto const opaquePassOutput = RendererUtils::colorPass(fg,
-                "Color Pass (opaque)", engine, view, colorPassInput, {
+        input = RendererUtils::colorPass(fg, "Color Pass (opaque)", engine, view, {
                        // When rendering the opaques, we need to conserve the sample buffer,
                        // so create a config that specifies the sample count.
                        .width = config.physicalViewport.width,
                        .height = config.physicalViewport.height,
                        .samples = config.msaa,
                        .format = config.hdrFormat
-                },
-                config, { .asSubpass = false, .customResolve = false },
+                }, config, { .asSubpass = false },
                pass.getExecutor(pass.begin(), refraction));

        // generate the mipmap chain
        PostProcessManager::generateMipmapSSR(ppm, fg,
-                opaquePassOutput.linearColor,
-                ssrConfig.refraction,
-                true, ssrConfig);
+                input, ssrConfig.refraction, true, ssrConfig);

        // Now we're doing the refraction pass proper.
-        // This uses the same framebuffer (color and depth) used by the opaque pass.
-        // For this reason, the `colorBufferDesc` parameter of colorPass() below is only used  for
-        // the width and height.
-        colorPassInput.linearColor = opaquePassOutput.linearColor;
-        colorPassInput.depth = opaquePassOutput.depth;
+        // This uses the same framebuffer (color and depth) used by the opaque pass. This happens
+        // automatically because these are set in the Blackboard (they were set by the opaque
+        // pass). For this reason, `desc` below is only used in colorPass() for the width and
+        // height.

        // Since we're reusing the existing target we don't want to clear any of its buffer.
        // Important: if this target ended up being an imported target, then the clearFlags
@@ -326,25 +327,22 @@ std::optional<RendererUtils::ColorPassOutput> RendererUtils::refractionPass(
        // and we'd end up clearing the opaque pass. This scenario never happens because it is
        // prevented in Renderer.cpp's final blit.
        config.clearFlags = TargetBufferFlags::NONE;
-        auto transparentPassOutput = RendererUtils::colorPass(fg, "Color Pass (transparent)",
-                engine, view, colorPassInput, {
+        output = RendererUtils::colorPass(fg, "Color Pass (transparent)", engine, view, {
                        .width = config.physicalViewport.width,
                        .height = config.physicalViewport.height },
-                config, colorGradingConfig,
-                pass.getExecutor(refraction, pass.end()));
+                config, colorGradingConfig, pass.getExecutor(refraction, pass.end()));

        if (config.msaa > 1 && !colorGradingConfig.asSubpass) {
            // We need to do a resolve here because later passes (such as color grading or DoF) will
            // need to sample from 'output'. However, because we have MSAA, we know we're not
            // sampleable. And this is because in the SSR case, we had to use a renderbuffer to
            // conserve the multi-sample buffer.
-            transparentPassOutput.linearColor = ppm.resolve(fg, "Resolved Color Buffer",
-                    transparentPassOutput.linearColor, { .levels = 1 });
+            output = ppm.resolve(fg, "Resolved Color Buffer", output, { .levels = 1 });
        }
-        return transparentPassOutput;
+    } else {
+        output = input;
    }
-
-    return std::nullopt;
+    return { output, hasScreenSpaceRefraction };
 }

 UTILS_NOINLINE
@@ -21,19 +21,14 @@
 #include "RenderPass.h"

 #include "fg/FrameGraphId.h"
-#include "fg/FrameGraphTexture.h"
-
-#include <filament/Viewport.h>

 #include <backend/DriverEnums.h>
 #include <backend/PixelBufferDescriptor.h>

-#include <math/vec2.h>
 #include <math/vec4.h>

 #include <stdint.h>

-#include <optional>
 #include <utility>

 namespace filament {
@@ -76,32 +71,15 @@ public:
        bool screenSpaceReflectionHistoryNotReady;
    };

-    struct ColorPassInput {
-        FrameGraphId<FrameGraphTexture> linearColor;
-        FrameGraphId<FrameGraphTexture> tonemappedColor;
-        FrameGraphId<FrameGraphTexture> depth;
-        FrameGraphId<FrameGraphTexture> shadows;
-        FrameGraphId<FrameGraphTexture> ssao;
-        FrameGraphId<FrameGraphTexture> ssr;
-        FrameGraphId<FrameGraphTexture> structure;
-    };
-    struct ColorPassOutput {
-        FrameGraphId<FrameGraphTexture> linearColor;
-        FrameGraphId<FrameGraphTexture> tonemappedColor;
-        FrameGraphId<FrameGraphTexture> depth;
-    };
-
-    static ColorPassOutput colorPass(
+    static FrameGraphId<FrameGraphTexture> colorPass(
            FrameGraph& fg, const char* name, FEngine& engine, FView const& view,
-            ColorPassInput const& colorPassInput,
            FrameGraphTexture::Descriptor const& colorBufferDesc,
            ColorPassConfig const& config,
            PostProcessManager::ColorGradingConfig colorGradingConfig,
            RenderPass::Executor passExecutor) noexcept;

-    static std::optional<RendererUtils::ColorPassOutput> refractionPass(
+    static std::pair<FrameGraphId<FrameGraphTexture>, bool> refractionPass(
            FrameGraph& fg, FEngine& engine, FView const& view,
-            ColorPassInput colorPassInput,
            ColorPassConfig config,
            PostProcessManager::ScreenSpaceRefConfig const& ssrConfig,
            PostProcessManager::ColorGradingConfig colorGradingConfig,
@@ -143,14 +143,12 @@ void ResourceAllocator::terminate() noexcept {
    }
 }

-RenderTargetHandle ResourceAllocator::createRenderTarget(const char* name,
+RenderTargetHandle ResourceAllocator::createRenderTarget(const char*,
        TargetBufferFlags targetBufferFlags, uint32_t width, uint32_t height,
        uint8_t samples, uint8_t layerCount, MRT color, TargetBufferInfo depth,
        TargetBufferInfo stencil) noexcept {
-    auto handle = mBackend.createRenderTarget(targetBufferFlags,
+    return mBackend.createRenderTarget(targetBufferFlags,
            width, height, samples ? samples : 1u, layerCount, color, depth, stencil);
-    mBackend.setDebugTag(handle.getId(), CString{ name });
-    return handle;
 }

 void ResourceAllocator::destroyRenderTarget(RenderTargetHandle h) noexcept {
@@ -172,9 +170,9 @@ backend::TextureHandle ResourceAllocator::createTexture(const char* name,

    // do we have a suitable texture in the cache?
    TextureHandle handle;
-    TextureKey const key{ name, target, levels, format, samples, width, height, depth, usage, swizzle };
    if constexpr (mEnabled) {
        auto& textureCache = mTextureCache;
+        const TextureKey key{ name, target, levels, format, samples, width, height, depth, usage, swizzle };
        auto it = textureCache.find(key);
        if (UTILS_LIKELY(it != textureCache.end())) {
            // we do, move the entry to the in-use list, and remove from the cache
@@ -192,6 +190,7 @@ backend::TextureHandle ResourceAllocator::createTexture(const char* name,
                        swizzle[0], swizzle[1], swizzle[2], swizzle[3]);
            }
        }
+        mDisposer->checkout(handle, key);
    } else {
        if (swizzle == defaultSwizzle) {
            handle = mBackend.createTexture(
@@ -202,14 +201,12 @@ backend::TextureHandle ResourceAllocator::createTexture(const char* name,
                    swizzle[0], swizzle[1], swizzle[2], swizzle[3]);
        }
    }
-    mDisposer->checkout(handle, key);
-    mBackend.setDebugTag(handle.getId(), CString{ name });
    return handle;
 }

 void ResourceAllocator::destroyTexture(TextureHandle h) noexcept {
-    auto const key = mDisposer->checkin(h);
    if constexpr (mEnabled) {
+        auto const key = mDisposer->checkin(h);
        if (UTILS_LIKELY(key.has_value())) {
            uint32_t const size = key.value().getSize();
            mTextureCache.emplace(key.value(), TextureCachePayload{ h, mAge, size });
@@ -829,13 +829,13 @@ ShadowMap::Corners ShadowMap::computeFrustumCorners(
    Corners const csViewFrustumCorners = {
            .vertices = {
                    { -1, -1, far  },
-                    {  1, -1, far  },
-                    { -1,  1, far  },
-                    {  1,  1, far  },
+                    { 1,  -1, far  },
+                    { -1, 1,  far  },
+                    { 1,  1,  far  },
                    { -1, -1, near },
-                    {  1, -1, near },
-                    { -1,  1, near },
-                    {  1,  1, near },
+                    { 1,  -1, near },
+                    { -1, 1,  near },
+                    { 1,  1,  near },
            }
    };

@@ -66,15 +66,15 @@ namespace filament {
 using namespace backend;
 using namespace math;

-ShadowMapManager::ShadowMapManager(FEngine& engine)
-    : mIsDepthClampSupported(engine.getDriverApi().isDepthClampSupported()) {
+// do this only if depth-clamp is available
+static constexpr bool USE_DEPTH_CLAMP = false;
+
+ShadowMapManager::ShadowMapManager(FEngine& engine) {
    FDebugRegistry& debugRegistry = engine.getDebugRegistry();
    debugRegistry.registerProperty("d.shadowmap.visualize_cascades",
            &engine.debug.shadowmap.visualize_cascades);
    debugRegistry.registerProperty("d.shadowmap.disable_light_frustum_align",
            &engine.debug.shadowmap.disable_light_frustum_align);
-    debugRegistry.registerProperty("d.shadowmap.depth_clamp",
-            &engine.debug.shadowmap.depth_clamp);
 }

 ShadowMapManager::~ShadowMapManager() {
@@ -367,20 +367,7 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG

                    // generate and sort the commands for rendering the shadow map

-                    RenderPass::RenderFlags renderPassFlags{};
-
-                    bool const canUseDepthClamp =
-                            shadowMap.getShadowType() == ShadowType::DIRECTIONAL &&
-                            !view.hasVSM() &&
-                            mIsDepthClampSupported &&
-                            engine.debug.shadowmap.depth_clamp;
-
-                    if (canUseDepthClamp) {
-                        renderPassFlags |= RenderPass::HAS_DEPTH_CLAMP;
-                    }
-
                    RenderPass const pass = passBuilder
-                            .renderFlags(RenderPass::HAS_DEPTH_CLAMP, renderPassFlags)
                            .camera(cameraInfo)
                            .visibilityMask(entry.visibilityMask)
                            .geometry(scene->getRenderableData(),
@@ -654,14 +641,8 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng
            cameraInfo.zf = -nearFarPlanes[i + 1];
            updateNearFarPlanes(&cameraInfo.cullingProjection, cameraInfo.zn, cameraInfo.zf);

-            bool const canUseDepthClamp =
-                    !view.hasVSM() &&
-                    mIsDepthClampSupported &&
-                    engine.debug.shadowmap.depth_clamp;
-
            auto shaderParameters = shadowMap.updateDirectional(engine,
-                    lightData, 0, cameraInfo, shadowMapInfo, sceneInfo,
-                    canUseDepthClamp);
+                    lightData, 0, cameraInfo, shadowMapInfo, sceneInfo, USE_DEPTH_CLAMP);

            if (shadowMap.hasVisibleShadows()) {
                const size_t shadowIndex = shadowMap.getShadowIndex();
@@ -232,7 +232,6 @@ private:
    ShadowMapCacheContainer mShadowMapCache;
    uint32_t mDirectionalShadowMapCount = 0;
    uint32_t mSpotShadowMapCount = 0;
-    bool const mIsDepthClampSupported;
    bool mInitialized = false;

    ShadowMap& getShadowMap(size_t index) noexcept {
@@ -28,6 +28,12 @@
 #include <string_view>
 #include <utility>

+#ifndef NDEBUG
+#   define DEBUG_PROPERTIES_WRITABLE true
+#else
+#   define DEBUG_PROPERTIES_WRITABLE false
+#endif
+
 using namespace filament::math;
 using namespace utils;

@@ -73,15 +79,17 @@ bool FDebugRegistry::hasProperty(const char* name) const noexcept {

 template<typename T>
 bool FDebugRegistry::setProperty(const char* name, T v) noexcept {
-    auto info = getPropertyInfo(name);
-    T* const addr = static_cast<T*>(info.first);
-    if (addr) {
-        auto old = *addr;
-        *addr = v;
-        if (info.second && old != v) {
-            info.second();
+    if constexpr (DEBUG_PROPERTIES_WRITABLE) {
+        auto info = getPropertyInfo(name);
+        T* const addr = static_cast<T*>(info.first);
+        if (addr) {
+            auto old = *addr;
+            *addr = v;
+            if (info.second && old != v) {
+                info.second();
+            }
+            return true;
        }
-        return true;
    }
    return false;
 }
@@ -600,7 +600,6 @@ public:
            bool focus_shadowcasters = true;
            bool visualize_cascades = false;
            bool disable_light_frustum_align = false;
-            bool depth_clamp = true;
            float dzn = -1.0f;
            float dzf =  1.0f;
            float display_shadow_texture_scale = 0.25f;
@@ -651,25 +651,20 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {

    const bool isProtectedContent =  mSwapChain && mSwapChain->isProtected();

-    // Conditions to meet to be able to use the sub-pass rendering path. This is regardless of
-    // whether the backend supports subpasses (or if they are disabled in the debugRegistry).
-    const bool isSubpassPossible =
-             msaaSampleCount <= 1 &&
-             hasColorGrading &&
-             !bloomOptions.enabled && !dofOptions.enabled && !taaOptions.enabled;
-
    // asSubpass is disabled with TAA (although it's supported) because performance was degraded
    // on qualcomm hardware -- we might need a backend dependent toggle at some point
    const PostProcessManager::ColorGradingConfig colorGradingConfig{
            .asSubpass =
-                    isSubpassPossible &&
+                    hasColorGrading &&
+                    msaaSampleCount <= 1 &&
+                    !bloomOptions.enabled && !dofOptions.enabled && !taaOptions.enabled &&
                    driver.isFrameBufferFetchSupported() &&
                    !engine.debug.renderer.disable_subpasses,
            .customResolve =
-                    msaaSampleCount > 1 &&
-                    driver.isFrameBufferFetchMultiSampleSupported() &&
                    msaaOptions.customResolve &&
+                    msaaSampleCount > 1 &&
                    hasColorGrading &&
+                    driver.isFrameBufferFetchMultiSampleSupported() &&
                    !engine.debug.renderer.disable_subpasses,
            .translucent = needsAlphaChannel,
            .fxaa = hasFXAA,
@@ -678,9 +673,6 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
                    TextureFormat::RGBA8 : getLdrFormat(needsAlphaChannel)
    };

-    // by construction (msaaSampleCount) both asSubpass and customResolve can't be true
-    assert_invariant(colorGradingConfig.asSubpass + colorGradingConfig.customResolve < 2);
-
    // whether we're scaled at all
     bool scaled = any(notEqual(scale, float2(1.0f)));

@@ -703,12 +695,13 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {

    CameraInfo cameraInfo = view.computeCameraInfo(engine);

-    // If fxaa and scaling are not enabled, we're essentially in a very fast rendering path -- in
-    // this case, we would need an extra blit to "resolve" the buffer padding (because there are no
-    // other pass that can do it as a side effect). In this case, it is better to skip the padding,
-    // which won't be helping much.
-    const bool noBufferPadding = (isSubpassPossible &&
-            !hasFXAA && !scaled) || engine.debug.renderer.disable_buffer_padding;
+    // when colorgrading-as-subpass is active, we know that many other effects are disabled
+    // such as dof, bloom. Moreover, if fxaa and scaling are not enabled, we're essentially in
+    // a very fast rendering path -- in this case, we would need an extra blit to "resolve" the
+    // buffer padding (because there are no other pass that can do it as a side effect).
+    // In this case, it is better to skip the padding, which won't be helping much.
+    const bool noBufferPadding = (colorGradingConfig.asSubpass && !hasFXAA && !scaled)
+            || engine.debug.renderer.disable_buffer_padding;

    // guardBand must be a multiple of 16 to guarantee the same exact rendering up to 4 mip levels.
    float const guardBand = guardBandOptions.enabled ? 16.0f : 0.0f;
@@ -823,14 +816,14 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
        blackboard["shadows"] = shadows;
    }

-    // When we don't have a custom RenderTarget, customRenderTarget below is nullptr and is
+    // When we don't have a custom RenderTarget, currentRenderTarget below is nullptr and is
    // recorded in the list of targets already rendered into -- this ensures that
    // initializeClearFlags() is called only once for the default RenderTarget.
    auto& previousRenderTargets = mPreviousRenderTargets;
-    FRenderTarget* const customRenderTarget = downcast(view.getRenderTarget());
+    FRenderTarget* const currentRenderTarget = downcast(view.getRenderTarget());
    if (UTILS_LIKELY(
-            previousRenderTargets.find(customRenderTarget) == previousRenderTargets.end())) {
-        previousRenderTargets.insert(customRenderTarget);
+            previousRenderTargets.find(currentRenderTarget) == previousRenderTargets.end())) {
+        previousRenderTargets.insert(currentRenderTarget);
        initializeClearFlags();
    }

@@ -847,10 +840,10 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
    const TargetBufferFlags keepOverrideStartFlags = TargetBufferFlags::ALL & ~discardStartFlags;
    TargetBufferFlags keepOverrideEndFlags = TargetBufferFlags::NONE;

-    if (customRenderTarget) {
+    if (currentRenderTarget) {
        // For custom RenderTarget, we look at each attachment flag and if they have their
        // SAMPLEABLE usage bit set, we assume they must not be discarded after the render pass.
-        keepOverrideEndFlags |= customRenderTarget->getSampleableAttachmentsMask();
+        keepOverrideEndFlags |= currentRenderTarget->getSampleableAttachmentsMask();
    }

    // Renderer's ClearOptions apply once at the beginning of the frame (not for each View),
@@ -959,6 +952,7 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
            .scale = aoOptions.resolution,
            .picking = view.hasPicking()
    });
+    blackboard["structure"] = structure;
    const auto picking = picking_;


@@ -1006,6 +1000,7 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
            ssReflectionsOptions.enabled ? TextureFormat::RGBA16F : TextureFormat::R11F_G11F_B10F,
            view.getCameraUser().getFieldOfView(Camera::Fov::VERTICAL), config.scale);
    config.ssrLodOffset = ssrConfig.lodOffset;
+    blackboard["ssr"] = ssrConfig.ssr;

    // --------------------------------------------------------------------------------------------
    // screen-space reflections pass
@@ -1019,10 +1014,6 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
                { .width = svp.width, .height = svp.height });

        if (UTILS_LIKELY(reflections)) {
-            fg.addTrivialSideEffectPass("SSR Cleanup", [&view](DriverApi& driver) {
-                view.getPerViewUniforms().prepareStructure({});
-                view.commitUniforms(driver);
-            });
            // generate the mipchain
            PostProcessManager::generateMipmapSSR(ppm, fg,
                    reflections, ssrConfig.reflection, false, ssrConfig);
@@ -1113,45 +1104,24 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
    );

    // the color pass itself + color-grading as subpass if needed
-    auto colorPassOutput = RendererUtils::colorPass(fg, "Color Pass", mEngine, view, {
-                .shadows = blackboard.get<FrameGraphTexture>("shadows"),
-                .ssao = blackboard.get<FrameGraphTexture>("ssao"),
-                .ssr = ssrConfig.ssr,
-                .structure = structure
-            },
+    auto colorPassOutput = RendererUtils::colorPass(fg, "Color Pass", mEngine, view,
            colorBufferDesc, config, colorGradingConfigForColor, pass.getExecutor());

    if (view.isScreenSpaceRefractionEnabled() && !pass.empty()) {
-        // This cancels the colorPass() call above if refraction is active.
-        // The color pass + refraction + color-grading as subpass if needed
-        auto const output = RendererUtils::refractionPass(fg, mEngine, view, {
-                        .shadows = blackboard.get<FrameGraphTexture>("shadows"),
-                        .ssao = blackboard.get<FrameGraphTexture>("ssao"),
-                        .ssr = ssrConfig.ssr,
-                        .structure = structure
-                },
+        // this cancels the colorPass() call above if refraction is active.
+        // the color pass + refraction + color-grading as subpass if needed
+        const auto [output, enabled] = RendererUtils::refractionPass(fg, mEngine, view,
                config, ssrConfig, colorGradingConfigForColor, pass);
-
-        hasScreenSpaceRefraction = output.has_value();
-        if (hasScreenSpaceRefraction) {
-            colorPassOutput = output.value();
-        }
+        colorPassOutput = output;
+        hasScreenSpaceRefraction = enabled;
    }

-    fg.addTrivialSideEffectPass("Finish Color Passes", [&view](DriverApi& driver) {
-        // Unbind SSAO sampler, b/c the FrameGraph will delete the texture at the end of the pass.
-        view.cleanupRenderPasses();
-        view.commitUniforms(driver);
-    });
-
    if (colorGradingConfig.customResolve) {
-        assert_invariant(fg.getDescriptor(colorPassOutput.linearColor).samples <= 1);
        // TODO: we have to "uncompress" (i.e. detonemap) the color buffer here because it's used
        //       by many other passes (Bloom, TAA, DoF, etc...). We could make this more
        //       efficient by using ARM_shader_framebuffer_fetch. We use a load/store (i.e.
        //       subpass) here because it's more convenient.
-        colorPassOutput.linearColor =
-                ppm.customResolveUncompressPass(fg, colorPassOutput.linearColor);
+        colorPassOutput = ppm.customResolveUncompressPass(fg, colorPassOutput);
    }

    // export the color buffer if screen-space reflections are enabled
@@ -1167,9 +1137,7 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
                    // The "output" of this pass is going to be used during the next frame as
                    // an "import".
                    builder.sideEffect();
-
-                    // we can't use colorPassOutput here because it could be tonemapped
-                    data.history = builder.sample(colorPassOutput.linearColor); // FIXME: an access must be declared for detach(), why?
+                    data.history = builder.sample(colorPassOutput); // FIXME: an access must be declared for detach(), why?
                }, [&view, projection](FrameGraphResources const& resources, auto const& data,
                        backend::DriverApi&) {
                    auto& history = view.getFrameHistory();
@@ -1179,20 +1147,19 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
                });
    }

-    // this is the output of the color pass / input to post processing,
-    // this is only used later for comparing it with the output after post-processing
-    FrameGraphId<FrameGraphTexture> const postProcessInput = colorGradingConfig.asSubpass ?
-                                                             colorPassOutput.tonemappedColor :
-                                                             colorPassOutput.linearColor;
-
-    // input can change below
-    FrameGraphId<FrameGraphTexture> input = postProcessInput;
+    FrameGraphId<FrameGraphTexture> input = colorPassOutput;
+    fg.addTrivialSideEffectPass("Finish Color Passes", [&view](DriverApi& driver) {
+        // Unbind SSAO sampler, b/c the FrameGraph will delete the texture at the end of the pass.
+        view.cleanupRenderPasses();
+        view.commitUniforms(driver);
+    });

    // Resolve depth -- which might be needed because of TAA or DoF. This pass will be culled
    // if the depth is not used below or if the depth is not MS (e.g. it could have been
    // auto-resolved).
    // In practice, this is used on Vulkan and older Metal devices.
-    auto depth = ppm.resolve(fg, "Resolved Depth Buffer", colorPassOutput.depth, { .levels = 1 });
+    auto depth = blackboard.get<FrameGraphTexture>("depth");
+    depth = ppm.resolve(fg, "Resolved Depth Buffer", depth, { .levels = 1 });

    // Debug: CSM visualisation
    if (UTILS_UNLIKELY(engine.debug.shadowmap.visualize_cascades &&
@@ -1308,7 +1275,7 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
    // The intermediate buffer is accomplished with a "fake" opaqueBlit (i.e. blit) operation.

    const bool outputIsSwapChain =
-            (input == postProcessInput) && (viewRenderTarget == mRenderTargetHandle);
+            (input == colorPassOutput) && (viewRenderTarget == mRenderTargetHandle);
    if (mightNeedFinalBlit) {
        if (blendModeTranslucent ||
            xvp != svp ||
@@ -245,8 +245,6 @@ FTexture::FTexture(FEngine& engine, const Builder& builder) {
    }
    if (auto name = builder.getName(); !name.empty()) {
        driver.setDebugTag(mHandle.getId(), std::move(name));
-    } else {
-        driver.setDebugTag(mHandle.getId(), CString{"FTexture"});
    }
 }

@@ -1040,8 +1040,10 @@ void FView::commitFrameHistory(FEngine& engine) noexcept {
    auto& frameHistory = mFrameHistory;

    FrameHistoryEntry& last = frameHistory.back();
-    disposer.destroy(std::move(last.taa.color.handle));
-    disposer.destroy(std::move(last.ssr.color.handle));
+    disposer.destroy(last.taa.color.handle);
+    disposer.destroy(last.ssr.color.handle);
+    last.taa.color.handle.clear();
+    last.ssr.color.handle.clear();

    // and then push the new history entry to the history stack
    frameHistory.commit();
@@ -1053,8 +1055,10 @@ void FView::clearFrameHistory(FEngine& engine) noexcept {
    auto& frameHistory = mFrameHistory;
    for (size_t i = 0; i < frameHistory.size(); ++i) {
        FrameHistoryEntry& last = frameHistory[i];
-        disposer.destroy(std::move(last.taa.color.handle));
-        disposer.destroy(std::move(last.ssr.color.handle));
+        disposer.destroy(last.taa.color.handle);
+        disposer.destroy(last.ssr.color.handle);
+        last.taa.color.handle.clear();
+        last.ssr.color.handle.clear();
    }
 }

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
  spec.name = "Filament"
-  spec.version = "1.54.3"
+  spec.version = "1.54.0"
  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.54.3/filament-v1.54.3-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.54.0/filament-v1.54.0-ios.tgz" }

  # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
  spec.pod_target_xcconfig = {
@@ -671,13 +671,15 @@ void GLSLPostProcessor::fixupClipDistance(
 // - triggers a crash on some Adreno drivers (b/291140208, b/289401984, b/289393290)
 // However Metal requires this pass in order to correctly generate half-precision MSL
 //
-// CreateSimplificationPass() creates a lot of problems:
+// Note: CreateSimplificationPass() used to creates a lot of problems:
 // - Adreno GPU show artifacts after running simplification passes (Vulkan)
 // - spirv-cross fails generating working glsl
 //      (https://github.com/KhronosGroup/SPIRV-Cross/issues/2162)
-// - generally it makes the code more complicated, e.g.: replacing for loops with
-//   while-if-break, unclear if it helps for anything.
-// However, the simplification passes below are necessary when targeting Metal, otherwise the
+//
+// However this problem was addressed in spirv-cross here:
+//      https://github.com/KhronosGroup/SPIRV-Cross/pull/2163
+//
+// The simplification passes below are necessary when targeting Metal, otherwise the
 // result is mismatched half / float assignments in MSL.


@@ -710,11 +712,11 @@ void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config c
    RegisterPass(CreateAggressiveDCEPass());
    RegisterPass(CreateRedundancyEliminationPass());
    RegisterPass(CreateCombineAccessChainsPass());
-    RegisterPass(CreateSimplificationPass(), MaterialBuilder::TargetApi::METAL);
+    RegisterPass(CreateSimplificationPass());
    RegisterPass(CreateVectorDCEPass());
    RegisterPass(CreateDeadInsertElimPass());
    RegisterPass(CreateDeadBranchElimPass());
-    RegisterPass(CreateSimplificationPass(), MaterialBuilder::TargetApi::METAL);
+    RegisterPass(CreateSimplificationPass());
    RegisterPass(CreateIfConversionPass());
    RegisterPass(CreateCopyPropagateArraysPass());
    RegisterPass(CreateReduceLoadSizePass());
@@ -723,7 +725,7 @@ void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config c
    RegisterPass(CreateRedundancyEliminationPass());
    RegisterPass(CreateDeadBranchElimPass());
    RegisterPass(CreateBlockMergePass());
-    RegisterPass(CreateSimplificationPass(), MaterialBuilder::TargetApi::METAL);
+    RegisterPass(CreateSimplificationPass());
 }

 void GLSLPostProcessor::registerSizePasses(Optimizer& optimizer, Config const& config) {
@@ -905,8 +905,6 @@ int main(int argc, char** argv) {
                        debug.getPropertyAddress<bool>("d.shadowmap.focus_shadowcasters"));
                ImGui::Checkbox("Disable light frustum alignment",
                        debug.getPropertyAddress<bool>("d.shadowmap.disable_light_frustum_align"));
-                ImGui::Checkbox("Depth clamp",
-                        debug.getPropertyAddress<bool>("d.shadowmap.depth_clamp"));

                bool debugDirectionalShadowmap;
                if (debug.getProperty("d.shadowmap.debug_directional_shadowmap",
@@ -20,6 +20,7 @@
 #include <filament/Material.h>
 #include <filament/MaterialInstance.h>
 #include <filament/RenderableManager.h>
+#include <filament/Renderer.h>
 #include <filament/Scene.h>
 #include <filament/Skybox.h>
 #include <filament/TransformManager.h>
@@ -46,23 +47,33 @@ using utils::EntityManager;
 struct App {
    Config config;
    VertexBuffer* vb;
+    VertexBuffer* vb2;
    IndexBuffer* ib;
    Material* mat;
    Camera* cam;
    Entity camera;
    Skybox* skybox;
    Entity renderable;
+    Entity r2;
 };

 struct Vertex {
-    filament::math::float2 position;
+    filament::math::float3 position;
    uint32_t color;
 };

+float const z = 5;
+
 static const Vertex TRIANGLE_VERTICES[3] = {
-    {{1, 0}, 0xffff0000u},
-    {{cos(M_PI * 2 / 3), sin(M_PI * 2 / 3)}, 0xff00ff00u},
-    {{cos(M_PI * 4 / 3), sin(M_PI * 4 / 3)}, 0xff0000ffu},
+    {{1, 0, z}, 0xffff0000u},
+    {{cos(M_PI * 2 / 3), sin(M_PI * 2 / 3), z}, 0xff00ff00u},
+    {{cos(M_PI * 4 / 3), sin(M_PI * 4 / 3), z}, 0xff0000ffu},
+};
+
+static Vertex T2[3] = {
+        TRIANGLE_VERTICES[0],
+        TRIANGLE_VERTICES[1],
+        TRIANGLE_VERTICES[2],
 };

 static constexpr uint16_t TRIANGLE_INDICES[3] = { 0, 1, 2 };
@@ -120,25 +131,39 @@ static int handleCommandLineArguments(int argc, char* argv[], App* app) {
 }

 int main(int argc, char** argv) {
+    T2[0].position.z = z - 10;
+    T2[1].position.z = z - 10;
+    T2[2].position.z = z - 10;
+
+    T2[0].color = 0xFF0000FF;
+    T2[1].color = 0xFF0000FF;
+    T2[2].color = 0xFF0000FF;
+
    App app{};
    app.config.title = "hellotriangle";
    app.config.featureLevel = backend::FeatureLevel::FEATURE_LEVEL_0;
    handleCommandLineArguments(argc, argv, &app);

    auto setup = [&app](Engine* engine, View* view, Scene* scene) {
-        app.skybox = Skybox::Builder().color({0.1, 0.125, 0.25, 1.0}).build(*engine);
-        scene->setSkybox(app.skybox);
        view->setPostProcessingEnabled(false);
-        static_assert(sizeof(Vertex) == 12, "Strange vertex size.");
-        app.vb = VertexBuffer::Builder()
+        view->setStencilBufferEnabled(true);
+
+        
+//        app.skybox = Skybox::Builder().color({0.1, 0.125, 0.25, 1.0}).build(*engine);
+//        scene->setSkybox(app.skybox);
+        static_assert(sizeof(Vertex) == 16, "Strange vertex size.");
+        auto builder = VertexBuffer::Builder()
                .vertexCount(3)
                .bufferCount(1)
-                .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT2, 0, 12)
-                .attribute(VertexAttribute::COLOR, 0, VertexBuffer::AttributeType::UBYTE4, 8, 12)
-                .normalized(VertexAttribute::COLOR)
-                .build(*engine);
+                .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT3, 0, 16)
+                .attribute(VertexAttribute::COLOR, 0, VertexBuffer::AttributeType::UBYTE4, 12, 16)
+                .normalized(VertexAttribute::COLOR);
+        app.vb = builder.build(*engine);
+        app.vb2 = builder.build(*engine);
        app.vb->setBufferAt(*engine, 0,
-                VertexBuffer::BufferDescriptor(TRIANGLE_VERTICES, 36, nullptr));
+                VertexBuffer::BufferDescriptor(TRIANGLE_VERTICES, 48, nullptr));
+        app.vb2->setBufferAt(*engine, 0,
+                VertexBuffer::BufferDescriptor(T2, 48, nullptr));
        app.ib = IndexBuffer::Builder()
                .indexCount(3)
                .bufferType(IndexBuffer::IndexType::USHORT)
@@ -149,22 +174,67 @@ int main(int argc, char** argv) {
                .package(RESOURCES_BAKEDCOLOR_DATA, RESOURCES_BAKEDCOLOR_SIZE)
                .build(*engine);
        app.renderable = EntityManager::get().create();
+        app.r2 = EntityManager::get().create();
+
+        auto inst1 = app.mat->createInstance();
+        inst1->setDepthWrite(false);        
+        inst1->setDepthFunc(MaterialInstance::DepthFunc::A);        
+        inst1->setDepthCulling(false);
+        
+        inst1->setStencilWrite(true);
+        inst1->setStencilCompareFunction(MaterialInstance::StencilCompareFunc::E);
+        inst1->setStencilOpDepthStencilPass(MaterialInstance::StencilOperation::REPLACE);
+        inst1->setStencilReferenceValue(6);
+
+        auto inst2 = app.mat->createInstance();
+        inst2->setDepthWrite(false);
+        inst2->setDepthFunc(MaterialInstance::DepthFunc::A);
+        inst2->setDepthCulling(false);
+        
+        inst2->setStencilWrite(true);
+        inst2->setStencilCompareFunction(MaterialInstance::StencilCompareFunc::L);
+        inst2->setStencilOpDepthStencilPass(MaterialInstance::StencilOperation::REPLACE);
+        inst2->setStencilReferenceValue(6);
+
+
+        auto& renderableMan = engine->getRenderableManager();
+
        RenderableManager::Builder(1)
                .boundingBox({{ -1, -1, -1 }, { 1, 1, 1 }})
-                .material(0, app.mat->getDefaultInstance())
+                .material(0, inst1)
                .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, app.vb, app.ib, 0, 3)
                .culling(false)
                .receiveShadows(false)
                .castShadows(false)
                .build(*engine, app.renderable);
+
+
+        RenderableManager::Builder(1)
+                .boundingBox({{ -1, -1, -1 }, { 1, 1, 1 }})
+                .material(0, inst2)
+                .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, app.vb2, app.ib, 0, 3)
+                .culling(false)
+                .receiveShadows(false)
+                .castShadows(false)
+                .build(*engine, app.r2);
+
        scene->addEntity(app.renderable);
+
+
+        auto r1inst = renderableMan.getInstance(app.renderable);
+        renderableMan.setPriority(r1inst, 7);
+
+        scene->addEntity(app.r2);        
+        auto r2inst = renderableMan.getInstance(app.r2);
+        renderableMan.setPriority(r2inst, 6);
+
        app.camera = utils::EntityManager::get().create();
        app.cam = engine->createCamera(app.camera);
        view->setCamera(app.cam);
    };

    auto cleanup = [&app](Engine* engine, View*, Scene*) {
-        engine->destroy(app.skybox);
+//        engine->destroy(app.skybox);
        engine->destroy(app.renderable);
        engine->destroy(app.mat);
        engine->destroy(app.vb);
@@ -174,19 +244,24 @@ int main(int argc, char** argv) {
    };

    FilamentApp::get().animate([&app](Engine* engine, View* view, double now) {
-        constexpr float ZOOM = 1.5f;
+        constexpr float ZOOM = 1.5;
        const uint32_t w = view->getViewport().width;
        const uint32_t h = view->getViewport().height;
        const float aspect = (float) w / h;
        app.cam->setProjection(Camera::Projection::ORTHO,
            -aspect * ZOOM, aspect * ZOOM,
-            -ZOOM, ZOOM, 0, 1);
+            -ZOOM, ZOOM, -100, 100);
        auto& tcm = engine->getTransformManager();
        tcm.setTransform(tcm.getInstance(app.renderable),
                filament::math::mat4f::rotation(now, filament::math::float3{ 0, 0, 1 }));
    });

-    FilamentApp::get().run(app.config, setup, cleanup);
+
+    auto preRender = [](Engine*, View* view, Scene*, Renderer* renderer) {
+        renderer->setClearOptions({ .clearStencil = 0u, .clear = true,  });
+    };
+
+    FilamentApp::get().run(app.config, setup, cleanup, {}, preRender);

    return 0;
 }
@@ -1,6 +1,6 @@
 {
  "name": "filament",
-  "version": "1.54.3",
+  "version": "1.54.0",
  "description": "Real-time physically based rendering engine",
  "main": "filament.js",
  "module": "filament.js",