add logging

Full commit hash is 29e91f0d3a

DOCS_ALLOW_DIRECT_EDITS

.github/actions/get-commit-msg/action.yml

@@ -27,17 +27,24 @@ runs:
         echo "$HASH" > /tmp/commit_hash.txt
     - name: Find commit message (PR)
       shell: bash
-      id: checkout_code
       if: github.event_name == 'pull_request'
       run: |
-        BEFORE_HASH=$(git rev-parse HEAD)
-        echo "hash=$BEFORE_HASH" >> "$GITHUB_OUTPUT"
-        # Next we will checkout the actual head (not the merge commits) of the PR
-        AFTER_HASH="${{ github.event.pull_request.head.sha }}"
-        git checkout $AFTER_HASH
-        COMMIT_MESSAGE=$(git log -1 --no-merges)
-        echo "$COMMIT_MESSAGE" > /tmp/commit_msg.txt
-        echo "$AFTER_HASH" > /tmp/commit_hash.txt
+        PR_NUMBER="${{ github.event.pull_request.number }}"
+        # Fetch the head of the PR explicitly to handle forks. Depth 50 ensures we can traverse past recent merge commits.
+        git fetch --depth=50 origin "pull/$PR_NUMBER/head:pr-head"
+
+        COMMIT_HASH=$(git log -1 --no-merges pr-head --format=%H)
+        AUTHOR_NAME=$(git log -1 --no-merges pr-head --format=%an)
+        AUTHOR_EMAIL=$(git log -1 --no-merges pr-head --format=%ae)
+        TSTAMP=$(git log -1 --no-merges pr-head --format=%aI)
+        COMMIT_MESSAGE=$(git log -1 --no-merges pr-head --format=%B)
+
+        echo "commit $COMMIT_HASH" > /tmp/commit_msg.txt
+        echo "Author: ${AUTHOR_NAME}<${AUTHOR_EMAIL}>" >> /tmp/commit_msg.txt
+        echo "Date: ${TSTAMP}" >> /tmp/commit_msg.txt
+        echo "" >> /tmp/commit_msg.txt
+        echo "$COMMIT_MESSAGE" >> /tmp/commit_msg.txt
+        echo "$COMMIT_HASH" > /tmp/commit_hash.txt
     - shell: bash
       id: action_output
       run: |
@@ -47,9 +54,4 @@ runs:
         cat /tmp/commit_msg.txt >> "$GITHUB_OUTPUT"
         echo "$DELIMITER" >> "$GITHUB_OUTPUT"
         # Get the commit hash
-        echo "hash=$(cat /tmp/commit_hash.txt)" >> "$GITHUB_OUTPUT"
-    - name: Cleanup Find commit message (PR)
-      shell: bash
-      if: github.event_name == 'pull_request'
-      run: |
-        git checkout ${{ steps.checkout_code.outputs.hash }}
+        echo "hash=$(cat /tmp/commit_hash.txt)" >> "$GITHUB_OUTPUT"

.github/workflows/release.yml

@@ -188,6 +188,54 @@ jobs:
             const globber = await glob.create(['out/*.aar', 'out/*.apk', 'out/*.tgz'].join('\n'));
             await upload({ github, context }, await globber.glob(), TAG);
 
+  sonatype-publish:
+    name: sonatype-publish
+    runs-on: 'ubuntu-24.04-16core'
+    # Depends on the the Android build for the Android binaries.
+    # Depends on the Mac, Linux, and Windows builds for host tools.
+    needs: [build-mac, build-linux, build-windows, build-android]
+    if: github.event_name == 'release' || github.event.inputs.platform == 'android'
+
+    steps:
+      - name: Decide Git ref
+        id: git_ref
+        run: |
+          REF=${RELEASE_TAG:-${GITHUB_REF}}
+          TAG=${REF##*/}
+          echo "ref=${REF}" >> $GITHUB_OUTPUT
+          echo "tag=${TAG}" >> $GITHUB_OUTPUT
+      - uses: actions/checkout@v4.1.6
+        with:
+          ref: ${{ steps.git_ref.outputs.ref }}
+      - uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+      - uses: ./.github/actions/linux-prereq
+      - name: Download Android Release
+        run: |
+          gh release download ${TAG} \
+            --repo ${{ github.repository }} \
+            --pattern 'filament-*-android-native.tgz'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ steps.git_ref.outputs.tag }}
+      - name: Unzip Android Release
+        run: |
+          mkdir -p out/android-release
+          tar -xzvf filament-${TAG}-android-native.tgz -C out/android-release/
+        env:
+          TAG: ${{ steps.git_ref.outputs.tag }}
+      - name: Publish To Sonatype
+        run: |
+          cd android
+          ./gradlew publishToSonatype closeSonatypeStagingRepository
+        env:
+          ORG_GRADLE_PROJECT_sonatypeUsername: ${{ secrets.SONATYPE_USERNAME }}
+          ORG_GRADLE_PROJECT_sonatypePassword: ${{ secrets.SONATYPE_PASSWORD }}
+          ORG_GRADLE_PROJECT_signingKey: ${{ secrets.MAVEN_SIGNING_KEY }}
+          ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.MAVEN_SIGNING_PASSWORD }}
+
   build-ios:
     name: build-ios
     runs-on: macos-14-xlarge

NEW_RELEASE_NOTES.md

@@ -6,6 +6,3 @@
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).
 
 ## Release notes for next branch cut
-
-- engine: fix crash when using variance shadow maps
-- materials: better shadow normal-bias calculations [⚠️ **New Material Version**]

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.69.4'
+    implementation 'com.google.android.filament:filament-android:1.69.5'
 }
 ```
 
@@ -50,7 +50,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.69.4'
+pod 'Filament', '~> 1.69.5'
 ```
 
 ## Documentation

RELEASE_NOTES.md

@@ -7,6 +7,11 @@ 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.70.0
+
+- engine: fix crash when using variance shadow maps
+- materials: better shadow normal-bias calculations [⚠️ **New Material Version**]
+
 ## v1.69.5
 
 - engine: fix crash when using variance shadow maps

android/build.gradle

@@ -40,15 +40,21 @@
 //   - Build and upload artifacts with ./gradlew publish
 //   - Close and release staging repo on Nexus with ./gradlew closeAndReleaseStagingRepository
 //
-// The following is needed in ~/gradle/gradle.properties:
+// The following properties need to be set (either in ~/gradle/gradle.properties, on the command
+// line, or as environment variables, e.g.: ORG_GRADLE_PROJECT_property=value):
 //
 //     sonatypeUsername=nexus_user
 //     sonatypePassword=nexus_password
 //
+//     To sign with a key ring file:
 //     signing.keyId=pgp_key_id
 //     signing.password=pgp_key_password
 //     signing.secretKeyRingFile=/Users/user/.gnupg/maven_signing.key
 //
+//     To sign with in-memory keys (useful for CI):,
+//     signingKey=ASCII armored key (begins with -----BEGIN PGP PRIVATE KEY BLOCK-----)
+//     signingPassword=key password
+//
 
 buildscript {
     def path = providers

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

@@ -2121,7 +2121,7 @@ public class View {
          */
         public boolean highPrecision = false;
         /**
-         * VSM minimum variance scale, must be positive.
+         * @deprecated has no effect.
          */
         public float minVarianceScale = 0.5f;
         /**

android/gradle.properties

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

android/gradle/gradle-mvn-push.gradle

@@ -94,6 +94,13 @@ afterEvaluate { project ->
     }
 
     signing {
+        def signingKey = findProperty("signingKey")
+        def signingPassword = findProperty("signingPassword")
+        if (signingKey && signingPassword) {
+            println("Signing with in-memory keys")
+            useInMemoryPgpKeys(signingKey, signingPassword)
+        }
+
         publishing.publications.all { publication ->
             sign publication
         }

android/samples/sample-render-validation/build.gradle

@@ -26,7 +26,8 @@ tasks.register('copyDamagedHelmetGltf', Copy) {
 preBuild.dependsOn copyDamagedHelmetGltf
 
 clean.doFirst {
-    delete "src/main/assets"
+    delete "src/main/assets/envs"
+    delete "src/main/assets/models"
 }
 
 android {
@@ -48,6 +49,7 @@ android {
 dependencies {
     implementation deps.kotlin
     implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
+    implementation 'com.google.android.material:material:1.10.0'
     implementation deps.coroutines.core
     implementation project(':filament-android')
     implementation project(':gltfio-android')

android/samples/sample-render-validation/src/main/AndroidManifest.xml

@@ -12,10 +12,11 @@
         android:supportsRtl="true"
         android:largeHeap="true"
         android:requestLegacyExternalStorage="true"
-        android:theme="@android:style/Theme.NoTitleBar">
+        android:theme="@style/Theme.Material3.DayNight.NoActionBar">
         <activity
             android:name=".MainActivity"
             android:exported="true"
+            android:launchMode="singleTop"
             android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
             android:screenOrientation="fullSensor">
             <intent-filter>

android/samples/sample-render-validation/src/main/assets/default_test.json

@@ -0,0 +1,899 @@
+{
+  "name": "Default Test",
+  "backends": [
+    "opengl"
+  ],
+  "models": {
+    "DamagedHelmet": "helmet.glb"
+  },
+  "presets": [
+    {
+      "name": "base",
+      "models": [
+        "DamagedHelmet"
+      ],
+      "rendering": {
+        "camera": {
+          "enabled": true,
+          "horizontalFov": 45.0,
+          "center": [
+            0,
+            0,
+            0
+          ],
+          "lookAt": [
+            0,
+            0,
+            -1
+          ]
+        },
+        "view": {
+          "postProcessingEnabled": true,
+          "dithering": "NONE"
+        },
+        "tolerance": {
+          "maxAbsDiff": 0.1,
+          "maxFailingPixelsFraction": 0.0
+        }
+      }
+    },
+    {
+      "name": "tilted",
+      "rendering": {
+        "camera": {
+          "enabled": true,
+          "horizontalFov": 45.0,
+          "center": [
+            -4,
+            -2,
+            -3
+          ],
+          "lookAt": [
+            0,
+            0,
+            -4
+          ]
+        }
+      }
+    }
+  ],
+  "tests": [
+    {
+      "name": "basic",
+      "apply_presets": [
+        "base"
+      ]
+    },
+    {
+      "name": "rotated",
+      "apply_presets": [
+        "base",
+        "tilted"
+      ]
+    },
+    {
+      "name": "ssao",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true
+      }
+    },
+    {
+      "name": "msaa",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.msaa.enabled": true
+      }
+    },
+    {
+      "name": "bloom",
+      "apply_presets": [
+        "base",
+        "tilted"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true
+      }
+    },
+    {
+      "name": "aa_none",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.antiAliasing": "NONE"
+      }
+    },
+    {
+      "name": "aa_fxaa",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.antiAliasing": "FXAA"
+      }
+    },
+    {
+      "name": "dithering_none",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dithering": "NONE"
+      }
+    },
+    {
+      "name": "msaa_8",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.msaa.enabled": true,
+        "view.msaa.sampleCount": 8
+      }
+    },
+    {
+      "name": "taa_custom",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.taa.enabled": true,
+        "view.taa.feedback": 0.2,
+        "view.taa.jitterPattern": "HALTON_23_X16"
+      }
+    },
+    {
+      "name": "ssao_gtao",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.aoType": "GTAO"
+      }
+    },
+    {
+      "name": "ssao_sao",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.aoType": "SAO"
+      }
+    },
+    {
+      "name": "ssao_radius_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.radius": 1.0
+      }
+    },
+    {
+      "name": "ssao_radius_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.radius": 0.1
+      }
+    },
+    {
+      "name": "ssao_power_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.power": 2.0
+      }
+    },
+    {
+      "name": "ssao_power_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.power": 0.5
+      }
+    },
+    {
+      "name": "ssao_bias_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.bias": 0.05
+      }
+    },
+    {
+      "name": "ssao_resolution_half",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.resolution": 0.5
+      }
+    },
+    {
+      "name": "ssao_resolution_full",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.resolution": 1.0
+      }
+    },
+    {
+      "name": "ssao_intensity_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.intensity": 2.0
+      }
+    },
+    {
+      "name": "ssao_bent_normals",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.bentNormals": true
+      }
+    },
+    {
+      "name": "ssao_quality_ultra",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.quality": "ULTRA"
+      }
+    },
+    {
+      "name": "ssao_quality_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.quality": "LOW"
+      }
+    },
+    {
+      "name": "ssao_lowPassFilter_ultra",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.lowPassFilter": "ULTRA"
+      }
+    },
+    {
+      "name": "ssao_upsampling_ultra",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.ssao.enabled": true,
+        "view.ssao.upsampling": "ULTRA"
+      }
+    },
+    {
+      "name": "ssr_basic",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true
+      }
+    },
+    {
+      "name": "ssr_thickness_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true,
+        "view.screenSpaceReflections.thickness": 0.5
+      }
+    },
+    {
+      "name": "ssr_bias_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true,
+        "view.screenSpaceReflections.bias": 0.1
+      }
+    },
+    {
+      "name": "ssr_maxDistance_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true,
+        "view.screenSpaceReflections.maxDistance": 5.0
+      }
+    },
+    {
+      "name": "ssr_stride_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true,
+        "view.screenSpaceReflections.stride": 4.0
+      }
+    },
+    {
+      "name": "ssr_stride_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true,
+        "view.screenSpaceReflections.stride": 1.0
+      }
+    },
+    {
+      "name": "ssr_thickness_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true,
+        "view.screenSpaceReflections.thickness": 0.01
+      }
+    },
+    {
+      "name": "ssr_maxDistance_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true,
+        "view.screenSpaceReflections.maxDistance": 1.0
+      }
+    },
+    {
+      "name": "ssr_bias_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true,
+        "view.screenSpaceReflections.bias": 0.001
+      }
+    },
+    {
+      "name": "ssr_quality_combo",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.screenSpaceReflections.enabled": true,
+        "view.screenSpaceReflections.thickness": 0.2,
+        "view.screenSpaceReflections.stride": 2.0
+      }
+    },
+    {
+      "name": "bloom_levels_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.levels": 8
+      }
+    },
+    {
+      "name": "bloom_levels_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.levels": 4
+      }
+    },
+    {
+      "name": "bloom_resolution_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.resolution": 1024
+      }
+    },
+    {
+      "name": "bloom_strength_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.strength": 0.5
+      }
+    },
+    {
+      "name": "bloom_strength_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.strength": 0.01
+      }
+    },
+    {
+      "name": "bloom_blendMode_interpolate",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.blendMode": "INTERPOLATE"
+      }
+    },
+    {
+      "name": "bloom_no_threshold",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.threshold": false
+      }
+    },
+    {
+      "name": "bloom_quality_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.quality": "HIGH"
+      }
+    },
+    {
+      "name": "bloom_lensflare",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.lensFlare": true
+      }
+    },
+    {
+      "name": "bloom_lensflare_no_starburst",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.lensFlare": true,
+        "view.bloom.starburst": false
+      }
+    },
+    {
+      "name": "bloom_lensflare_chromatic",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.lensFlare": true,
+        "view.bloom.chromaticAberration": 0.05
+      }
+    },
+    {
+      "name": "bloom_lensflare_ghosts",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.lensFlare": true,
+        "view.bloom.ghostCount": 8
+      }
+    },
+    {
+      "name": "bloom_lensflare_ghostSpacing",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.lensFlare": true,
+        "view.bloom.ghostSpacing": 0.8
+      }
+    },
+    {
+      "name": "bloom_halo_thick",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.lensFlare": true,
+        "view.bloom.haloThickness": 0.2
+      }
+    },
+    {
+      "name": "bloom_halo_radius",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.bloom.enabled": true,
+        "view.bloom.lensFlare": true,
+        "view.bloom.haloRadius": 0.5
+      }
+    },
+    {
+      "name": "dof_basic",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true
+      }
+    },
+    {
+      "name": "dof_cocScale_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true,
+        "view.dof.cocScale": 2.0
+      }
+    },
+    {
+      "name": "dof_cocScale_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true,
+        "view.dof.cocScale": 0.5
+      }
+    },
+    {
+      "name": "dof_cocAspectRatio",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true,
+        "view.dof.cocAspectRatio": 2.0
+      }
+    },
+    {
+      "name": "dof_maxApertureDiameter",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true,
+        "view.dof.maxApertureDiameter": 0.05
+      }
+    },
+    {
+      "name": "dof_filter_none",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true,
+        "view.dof.filter": "NONE"
+      }
+    },
+    {
+      "name": "dof_nativeResolution",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true,
+        "view.dof.nativeResolution": true
+      }
+    },
+    {
+      "name": "dof_rings_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true,
+        "view.dof.foregroundRingCount": 5,
+        "view.dof.backgroundRingCount": 5
+      }
+    },
+    {
+      "name": "dof_rings_low",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true,
+        "view.dof.foregroundRingCount": 3,
+        "view.dof.backgroundRingCount": 3
+      }
+    },
+    {
+      "name": "dof_max_coc",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.dof.enabled": true,
+        "view.dof.maxForegroundCOC": 16,
+        "view.dof.maxBackgroundCOC": 16
+      }
+    },
+    {
+      "name": "fog_basic",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true
+      }
+    },
+    {
+      "name": "fog_distance",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true,
+        "view.fog.distance": 10.0
+      }
+    },
+    {
+      "name": "fog_cutOffDistance",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true,
+        "view.fog.cutOffDistance": 100.0
+      }
+    },
+    {
+      "name": "fog_maximumOpacity",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true,
+        "view.fog.maximumOpacity": 0.5
+      }
+    },
+    {
+      "name": "fog_height",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true,
+        "view.fog.height": 5.0
+      }
+    },
+    {
+      "name": "fog_heightFalloff",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true,
+        "view.fog.heightFalloff": 0.5
+      }
+    },
+    {
+      "name": "fog_density_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true,
+        "view.fog.density": 0.5
+      }
+    },
+    {
+      "name": "fog_inScatteringStart",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true,
+        "view.fog.inScatteringStart": 5.0
+      }
+    },
+    {
+      "name": "fog_inScatteringSize",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true,
+        "view.fog.inScatteringSize": 10.0
+      }
+    },
+    {
+      "name": "fog_fogColorFromIbl",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.fog.enabled": true,
+        "view.fog.fogColorFromIbl": true
+      }
+    },
+    {
+      "name": "vignette_basic",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.vignette.enabled": true
+      }
+    },
+    {
+      "name": "vignette_midPoint",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.vignette.enabled": true,
+        "view.vignette.midPoint": 0.8
+      }
+    },
+    {
+      "name": "vignette_roundness_circle",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.vignette.enabled": true,
+        "view.vignette.roundness": 1.0
+      }
+    },
+    {
+      "name": "vignette_roundness_rect",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.vignette.enabled": true,
+        "view.vignette.roundness": 0.0
+      }
+    },
+    {
+      "name": "vignette_feather_sharp",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.vignette.enabled": true,
+        "view.vignette.feather": 0.1
+      }
+    },
+    {
+      "name": "cg_filmic",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.colorGrading.toneMapping": "FILMIC"
+      }
+    },
+    {
+      "name": "cg_aces",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.colorGrading.toneMapping": "ACES"
+      }
+    },
+    {
+      "name": "cg_agx",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.colorGrading.toneMapping": "AGX"
+      }
+    },
+    {
+      "name": "cg_pbr_neutral",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.colorGrading.toneMapping": "PBR_NEUTRAL"
+      }
+    },
+    {
+      "name": "cg_contrast_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.colorGrading.contrast": 1.5
+      }
+    },
+    {
+      "name": "cg_saturation_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.colorGrading.saturation": 1.5
+      }
+    },
+    {
+      "name": "cg_exposure_high",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.colorGrading.exposure": 1.0
+      }
+    },
+    {
+      "name": "shadow_vsm",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.shadowType": "VSM"
+      }
+    },
+    {
+      "name": "shadow_vsm_anisotropy",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.shadowType": "VSM",
+        "view.vsmShadowOptions.anisotropy": 2
+      }
+    },
+    {
+      "name": "shadow_vsm_highPrecision",
+      "apply_presets": [
+        "base"
+      ],
+      "rendering": {
+        "view.shadowType": "VSM",
+        "view.vsmShadowOptions.highPrecision": true
+      }
+    }
+  ]
+}

android/samples/sample-render-validation/src/main/java/com/google/android/filament/validation/MainActivity.kt

@@ -17,36 +17,35 @@
 package com.google.android.filament.validation
 
 import android.app.Activity
+import android.app.AlertDialog
+import android.content.Intent
 import android.graphics.Bitmap
+import android.graphics.Color
 import android.os.Bundle
+import android.text.Html
 import android.util.Log
 import android.view.Choreographer
 import android.view.SurfaceView
 import android.view.View
 import android.view.WindowManager
+import android.widget.ArrayAdapter
+import android.widget.Button
 import android.widget.ImageView
 import android.widget.LinearLayout
-import android.widget.ScrollView
+import android.widget.Spinner
 import android.widget.TextView
+import com.google.android.filament.utils.KTX1Loader
 import com.google.android.filament.utils.ModelViewer
 import com.google.android.filament.utils.Utils
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import com.google.android.filament.utils.KTX1Loader
-import com.google.android.filament.IndirectLight
-import com.google.android.filament.Skybox
-import android.graphics.Color
 import java.io.File
-import java.io.FileOutputStream
-import java.net.HttpURLConnection
-import java.net.URL
 import java.nio.ByteBuffer
-import android.widget.ArrayAdapter
-import android.widget.Button
-import android.widget.Spinner
-import android.widget.AdapterView
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
 
 class MainActivity : Activity(), ValidationRunner.Callback {
 
@@ -62,13 +61,17 @@ class MainActivity : Activity(), ValidationRunner.Callback {
     private lateinit var choreographer: Choreographer
     private lateinit var modelViewer: ModelViewer
     private lateinit var statusTextView: TextView
+    private lateinit var testResultsHeader: TextView
     private lateinit var resultsContainer: LinearLayout
     private lateinit var inputManager: ValidationInputManager
     private var currentInput: ValidationInputManager.ValidationInput? = null
-    private lateinit var modeSpinner: Spinner
-    private lateinit var runButton: Button
-    private var resultManager: ValidationResultManager? = null
 
+    // UI Elements
+    private lateinit var runButton: Button
+    private lateinit var loadButton: Button
+    private lateinit var optionsButton: Button
+
+    private var resultManager: ValidationResultManager? = null
     private var validationRunner: ValidationRunner? = null
 
     // Frame callback
@@ -89,25 +92,53 @@ class MainActivity : Activity(), ValidationRunner.Callback {
         surfaceView.holder.setFixedSize(512, 512)
 
         statusTextView = findViewById(R.id.status_text)
-        modeSpinner = findViewById(R.id.mode_spinner)
-        runButton = findViewById(R.id.run_button)
+        testResultsHeader = findViewById(R.id.test_results_header)
         resultsContainer = findViewById(R.id.results_container)
 
-        // Setup Spinner
-        val modes = arrayOf("Run Validation", "Generate Goldens")
-        val adapter = ArrayAdapter(this, android.R.layout.simple_spinner_item, modes)
-        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
-        modeSpinner.adapter = adapter
+        runButton = findViewById(R.id.run_button)
+        loadButton = findViewById(R.id.load_button)
+        optionsButton = findViewById(R.id.options_button)
 
         // Setup Run Button
         runButton.setOnClickListener {
             currentInput?.let { input ->
-                val generateGoldens = modeSpinner.selectedItemPosition == 1
-                val newInput = input.copy(generateGoldens = generateGoldens)
-                startValidation(newInput)
+                // Always use the generateGoldens flag from the intent/input
+                startValidation(input)
             }
         }
 
+        // Setup Load Button
+        loadButton.setOnClickListener {
+            showLoadDialog()
+        }
+
+        // Setup Options Menu Button
+        optionsButton.setOnClickListener { view ->
+            val popup = android.widget.PopupMenu(this, view)
+            popup.menu.add(0, 1, 0, "Generate Golden")
+            popup.menu.add(0, 2, 0, "Export Test")
+            popup.menu.add(0, 3, 0, "Export Result")
+            popup.menu.add(0, 4, 0, "Test ADB Info")
+            popup.menu.add(0, 5, 0, "Result ADB Info")
+
+            popup.setOnMenuItemClickListener { item ->
+                when (item.itemId) {
+                    1 -> {
+                        currentInput?.let { input ->
+                            val goldenInput = input.copy(generateGoldens = true)
+                            startValidation(goldenInput)
+                        }
+                    }
+                    2 -> exportTestBundleAction()
+                    3 -> exportTestResultsAction()
+                    4 -> showTestAdbInfo()
+                    5 -> showResultAdbInfo()
+                }
+                true
+            }
+            popup.show()
+        }
+
         window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
 
         choreographer = Choreographer.getInstance()
@@ -120,6 +151,134 @@ class MainActivity : Activity(), ValidationRunner.Callback {
         handleIntent()
     }
 
+    private fun showLoadDialog() {
+        val exportDir = getExternalFilesDir(null) ?: filesDir
+        // Filter out result zips (starting with "results_") to only show test bundles
+        val zips = exportDir.listFiles { _, name ->
+            name.endsWith(".zip") && !name.startsWith("results_")
+        }?.sortedByDescending { it.lastModified() } ?: emptyList()
+
+        if (zips.isEmpty()) {
+            AlertDialog.Builder(this)
+                .setTitle("Load Test")
+                .setMessage("No test bundles found.")
+                .setPositiveButton("OK", null)
+                .show()
+            return
+        }
+
+        val builder = AlertDialog.Builder(this)
+        builder.setTitle("Select Test Bundle")
+
+        val items = zips.map { it.name }.toTypedArray()
+
+        builder.setItems(items) { dialog, which ->
+            val selectedFile = zips[which]
+            loadZipBundle(selectedFile)
+            dialog.dismiss()
+        }
+
+        builder.setNegativeButton("Cancel", null)
+        builder.show()
+    }
+
+    private fun showTestAdbInfo() {
+        val exportDir = getExternalFilesDir(null) ?: filesDir
+        val path = exportDir.absolutePath
+        val isInternal = path.startsWith(filesDir.absolutePath)
+        val message = StringBuilder()
+
+        message.append("Storage Path: $path<br><br>")
+
+        message.append("<b>--- PULL FROM DEVICE ---</b><br>")
+        if (isInternal) {
+            message.append("<tt>adb shell \"run-as $packageName cat files/&lt;filename&gt;\" &gt; &lt;filename&gt;</tt><br><br>")
+        } else {
+            message.append("<tt>adb pull $path/&lt;filename&gt; .</tt><br><br>")
+        }
+
+        message.append("<b>--- PUSH TO DEVICE ---</b><br>")
+        if (isInternal) {
+            message.append("1. <tt>adb push &lt;filename&gt; /sdcard/Download/</tt><br>")
+            message.append("2. <tt>adb shell \"run-as $packageName cp /sdcard/Download/&lt;filename&gt; files/\"</tt><br>")
+        } else {
+            message.append("<tt>adb push &lt;filename&gt; $path/</tt><br>")
+        }
+        message.append("<br>Note: Use underscores instead of spaces in &lt;filename&gt;.")
+
+        AlertDialog.Builder(this)
+            .setTitle("Test Bundle ADB Info")
+            .setMessage(Html.fromHtml(message.toString(), Html.FROM_HTML_MODE_LEGACY))
+            .setPositiveButton("OK", null)
+            .show()
+    }
+
+    private fun showResultAdbInfo() {
+        val exportDir = getExternalFilesDir(null) ?: filesDir
+        val path = exportDir.absolutePath
+        val isInternal = path.startsWith(filesDir.absolutePath)
+        val message = StringBuilder()
+
+        message.append("<b>--- PULL RESULTS ---</b><br>")
+        if (isInternal) {
+            message.append("<tt>adb shell \"run-as $packageName cat files/&lt;filename&gt;\" &gt; &lt;filename&gt;</tt><br><br>")
+        } else {
+            message.append("<tt>adb pull $path/&lt;filename&gt; .</tt><br><br>")
+        }
+
+        message.append("<b>--- AVAILABLE RESULTS ---</b><br>")
+        val zips = exportDir.listFiles { _, name ->
+            name.endsWith(".zip") && name.startsWith("results_")
+        }?.sortedByDescending { it.lastModified() } ?: emptyList()
+
+        if (zips.isEmpty()) {
+            message.append("No result zips found.<br>")
+        } else {
+            zips.forEach { file ->
+                message.append("${file.name}<br>")
+            }
+        }
+
+        AlertDialog.Builder(this)
+            .setTitle("Result ADB Info")
+            .setMessage(Html.fromHtml(message.toString(), Html.FROM_HTML_MODE_LEGACY))
+            .setPositiveButton("OK", null)
+            .show()
+    }
+
+    private fun loadZipBundle(file: File) {
+         statusTextView.text = "Loading ${file.name}..."
+         CoroutineScope(Dispatchers.Main).launch {
+             try {
+                 val config = inputManager.loadFromZip(file)
+                 val baseDir = getExternalFilesDir(null) ?: filesDir
+                 val outputDir = File(baseDir, "validation_results").apply { mkdirs() }
+
+                 // Clear existing results UI and state
+                 resultsContainer.removeAllViews()
+                 resultManager = null
+
+                 val newInput = ValidationInputManager.ValidationInput(
+                     config = config,
+                     outputDir = outputDir,
+                     generateGoldens = false,
+                     autoRun = false,
+                     autoExport = false,
+                     autoExportResults = false,
+                     sourceZip = file
+                 )
+
+                 currentInput = newInput
+                 statusTextView.text = "Loaded ${config.name}"
+                 Log.i(TAG, "Setting header to: Test Results: ${config.name}")
+                 testResultsHeader.text = "${config.name}"
+             } catch (e: Exception) {
+                 Log.e(TAG, "Failed to load zip", e)
+                 statusTextView.text = "Error: ${e.message}"
+             }
+         }
+    }
+
     private fun createIndirectLight() {
         try {
             val engine = modelViewer.engine
@@ -156,12 +315,18 @@ class MainActivity : Activity(), ValidationRunner.Callback {
         CoroutineScope(Dispatchers.Main).launch {
             try {
                 val input = inputManager.resolveConfig(intent)
+
+                // Update header
+                Log.i(TAG, "handleIntent: Setting header to: Test Results: ${input.config.name}")
+                testResultsHeader.text = "${input.config.name}"
                 currentInput = input
 
-                // Sync spinner with intent
-                modeSpinner.setSelection(if (input.generateGoldens) 1 else 0)
-
-                startValidation(input)
+                if (input.autoRun) {
+                    startValidation(input)
+                } else {
+                    // Just show status
+                    statusTextView.text = "Ready: ${input.config.name}"
+                }
             } catch (e: Exception) {
                 Log.e(TAG, "Failed to resolve config", e)
                 statusTextView.text = "Error: ${e.message}"
@@ -175,6 +340,8 @@ class MainActivity : Activity(), ValidationRunner.Callback {
             Log.i(TAG, "Starting validation with config: ${input.config.name}")
             Log.i(TAG, "Output dir: ${input.outputDir.absolutePath}")
 
+            testResultsHeader.text = "${input.config.name}"
+
             resultManager = ValidationResultManager(input.outputDir)
 
             validationRunner = ValidationRunner(this, modelViewer, input.config, resultManager!!)
@@ -182,9 +349,6 @@ class MainActivity : Activity(), ValidationRunner.Callback {
             validationRunner?.generateGoldens = input.generateGoldens
             validationRunner?.start()
 
-            // Sync spinner in case it was called programmatically or changed implicitly
-            modeSpinner.setSelection(if (input.generateGoldens) 1 else 0)
-
         } catch (e: Exception) {
             Log.e(TAG, "Failed to start validation", e)
             statusTextView.text = "Error: ${e.message}"
@@ -196,6 +360,12 @@ class MainActivity : Activity(), ValidationRunner.Callback {
         choreographer.postFrameCallback(frameScheduler)
     }
 
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        handleIntent()
+    }
+
     override fun onPause() {
         super.onPause()
         choreographer.removeFrameCallback(frameScheduler)
@@ -221,13 +391,30 @@ class MainActivity : Activity(), ValidationRunner.Callback {
             resultContainer.orientation = LinearLayout.VERTICAL
             resultContainer.setPadding(0, 10, 0, 20)
 
-            // Header
-            val resultView = TextView(this)
-            resultView.text = "${result.testName}: ${if(result.passed) "PASS" else "FAIL"} (Diff: ${result.diffMetric})"
-            resultView.setTextColor(if(result.passed) Color.GREEN else Color.RED)
-            resultView.textSize = 16f
-            resultView.setTypeface(null, android.graphics.Typeface.BOLD)
-            resultContainer.addView(resultView)
+            // Header Layout
+            val headerRow = LinearLayout(this)
+            headerRow.orientation = LinearLayout.HORIZONTAL
+            headerRow.gravity = android.view.Gravity.CENTER_VERTICAL
+
+            // Status Icon + Name
+            val statusView = TextView(this)
+            val icon = if (result.passed) "✔" else "✖"
+
+            statusView.text = "$icon ${result.testName}"
+            statusView.setTextColor(
+                if (result.passed) Color.parseColor("#4CAF50") else Color.parseColor("#F44336")
+            )
+            statusView.textSize = 12f
+            statusView.setTypeface(null, android.graphics.Typeface.BOLD)
+            headerRow.addView(statusView)
+
+            // Diff Metric (only show if it's relevant/there's a diff or we just always show it like before)
+            val diffView = TextView(this)
+            diffView.text = "  (Diff: ${result.diffMetric})"
+            diffView.textSize = 12f
+            diffView.setTextColor(Color.GRAY)
+            headerRow.addView(diffView)
+            resultContainer.addView(headerRow)
 
             // Images Row
             val imagesRow = LinearLayout(this)
@@ -241,7 +428,7 @@ class MainActivity : Activity(), ValidationRunner.Callback {
 
                     val labelView = TextView(this)
                     labelView.text = label
-                    labelView.textSize = 12f
+                    labelView.textSize = 9f
                     container.addView(labelView)
 
                     val iv = ImageView(this)
@@ -274,7 +461,46 @@ class MainActivity : Activity(), ValidationRunner.Callback {
     override fun onAllTestsFinished() {
         runOnUiThread {
             statusTextView.text = "All tests finished!"
-            Log.i(TAG, "All tests finished")
+            Log.i(TAG, "All tests finished " + if (currentInput?.autoExport == true) "Exporting bundle" else "x")
+
+            if (currentInput?.autoExport == true) {
+                exportTestBundleAction()
+            }
+            if (currentInput?.autoExportResults == true) {
+                exportTestResultsAction()
+            }
+        }
+    }
+
+    private fun exportTestBundleAction() {
+        currentInput?.let { input ->
+            val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+            val rm = resultManager ?: ValidationResultManager(input.outputDir)
+            val zip = rm.exportTestBundle(input.config, timestamp)
+            if (zip != null) {
+                val msg = "Exported Bundle: ${zip.name}"
+                statusTextView.text = msg
+                Log.i(TAG, "Exported test bundle to ${zip.absolutePath}")
+            } else {
+                statusTextView.text = "Export Bundle failed"
+                Log.e(TAG, "Export Bundle failed")
+            }
+        }
+    }
+
+    private fun exportTestResultsAction() {
+        currentInput?.let { input ->
+            val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+            val rm = resultManager ?: ValidationResultManager(input.outputDir)
+            val zip = rm.exportTestResults(input.sourceZip, timestamp)
+            if (zip != null) {
+                val msg = "Exported Results: ${zip.name}"
+                statusTextView.text = msg
+                Log.i(TAG, "Exported results to ${zip.absolutePath}")
+            } else {
+                statusTextView.text = "Export Results failed"
+                Log.e(TAG, "Export Results failed")
+            }
         }
     }
 
@@ -301,50 +527,3 @@ class MainActivity : Activity(), ValidationRunner.Callback {
         }
     }
 }
-
-/*
- * Scripts for reference:
- *
- * generate_goldens.sh:
- * --------------------
- * #!/bin/bash
- * set -e
- *
- * # Config path (on device)
- * CONFIG_PATH=$1
- * if [ -z "$CONFIG_PATH" ]; then
- *     echo "Usage: $0 <device_config_path>"
- *     echo "Example: $0 /sdcard/Android/data/com.google.android.filament.validation/files/default_test.json"
- *     exit 1
- * fi
- *
- * echo "Starting Golden Generation for $CONFIG_PATH..."
- * adb shell am force-stop com.google.android.filament.validation
- * adb shell am start -n com.google.android.filament.validation/.MainActivity \
- *     -e test_config "$CONFIG_PATH" \
- *     --ez generate_goldens true
- *
- * echo "Check device or logcat for progress."
- * echo "adb logcat -s FilamentValidation:I ValidationRunner:I"
- * echo "To pull results: ./samples/sample-render-validation/pull_goldens.sh"
- *
- * pull_goldens.sh:
- * ----------------
- * #!/bin/bash
- * set -e
- *
- * # Default destination is local golden directory relative to script
- * SCRIPT_DIR=$(cd $(dirname $0); pwd)
- * DEST_DIR=${1:-"$SCRIPT_DIR/golden"}
- *
- * echo "Pulling goldens to $DEST_DIR..."
- * mkdir -p "$DEST_DIR"
- *
- * # Path on device
- * DEVICE_GOLDEN_DIR="/storage/emulated/0/Android/data/com.google.android.filament.validation/files/golden/."
- *
- * adb pull "$DEVICE_GOLDEN_DIR" "$DEST_DIR"
- *
- * echo "Done."
- * ls -l "$DEST_DIR"
- */

android/samples/sample-render-validation/src/main/java/com/google/android/filament/validation/ValidationInputManager.kt

@@ -26,6 +26,7 @@ import java.io.File
 import java.io.FileOutputStream
 import java.net.HttpURLConnection
 import java.net.URL
+import java.util.zip.ZipFile
 
 /**
  * Handles the retrieval and preparation of test configuration and assets.
@@ -42,7 +43,11 @@ class ValidationInputManager(private val context: Context) {
     data class ValidationInput(
         val config: RenderTestConfig,
         val outputDir: File,
-        val generateGoldens: Boolean
+        val generateGoldens: Boolean,
+        val autoRun: Boolean = false,
+        val autoExport: Boolean = false,
+        val autoExportResults: Boolean = false,
+        val sourceZip: File? = null
     )
 
     /**
@@ -53,22 +58,111 @@ class ValidationInputManager(private val context: Context) {
         val testConfigPath = intent.getStringExtra("test_config")
         val urlConfig = intent.getStringExtra("url_config")
         val urlModelsBase = intent.getStringExtra("url_models_base")
+        val zipPath = intent.getStringExtra("zip_path")
         val generateGoldens = intent.getBooleanExtra("generate_goldens", false)
+        val autoRun = intent.getBooleanExtra("auto_run", false)
+        val autoExport = intent.getBooleanExtra("auto_export", false)
+        val autoExportResults = intent.getBooleanExtra("auto_export_results", false)
         val outputPath = intent.getStringExtra("output_path")
 
-        val outputDir = if (outputPath != null) {
-            File(outputPath).apply { mkdirs() }
+        Log.i(TAG, "Resolving config with outputPath: $outputPath")
+
+        val baseDir = context.getExternalFilesDir(null) ?: context.filesDir
+        Log.i(TAG, "Base directory for resolution: ${baseDir.absolutePath}")
+        
+        val outputDir = if (!outputPath.isNullOrBlank()) {
+            val file = File(outputPath)
+            val resolved = if (file.isAbsolute) {
+                file
+            } else {
+                File(baseDir, outputPath)
+            }
+            
+            // Critical check: if resolved is root or very short, it's likely wrong
+            if (resolved.absolutePath == "/" || resolved.parent == null) {
+                Log.w(TAG, "Resolved outputDir is root ($resolved), defaulting to app-specific dir")
+                File(baseDir, "validation_results")
+            } else {
+                resolved
+            }
         } else {
-            File(context.getExternalFilesDir(null), "validation_results").apply { mkdirs() }
+            File(baseDir, "validation_results")
+        }
+        
+        if (!outputDir.exists() && !outputDir.mkdirs()) {
+            Log.e(TAG, "Failed to create outputDir: ${outputDir.absolutePath}")
+        }
+        Log.i(TAG, "Final outputDir: ${outputDir.absolutePath}")
+
+        val sourceZipFile = if (zipPath != null) {
+            val file = File(zipPath)
+            if (file.isAbsolute) {
+                file
+            } else {
+                File(baseDir, zipPath)
+            }
+        } else {
+            null
         }
 
         val config = when {
+            sourceZipFile != null && sourceZipFile.exists() -> loadFromZip(sourceZipFile)
             urlConfig != null -> downloadConfig(urlConfig, urlModelsBase)
             testConfigPath != null -> ConfigParser.parseFromPath(testConfigPath)
             else -> extractDefaultAssets()
         }
 
-        return@withContext ValidationInput(config, outputDir, generateGoldens)
+        return@withContext ValidationInput(config, outputDir, generateGoldens, autoRun, autoExport, autoExportResults, sourceZipFile)
+    }
+
+    suspend fun loadFromZip(zipFile: File): RenderTestConfig {
+        Log.i(TAG, "Unzipping validation bundle: ${zipFile.absolutePath}")
+        // Use a unique cache dir based on timestamp or just overwrite a common one
+        // Overwriting is safer to avoid filling up disk, but we must ensure we don't conflict with current run
+        val baseCacheDir = context.externalCacheDir ?: context.cacheDir
+        val cacheDir = File(baseCacheDir, "unzipped_validation")
+        if (cacheDir.exists()) cacheDir.deleteRecursively()
+        cacheDir.mkdirs()
+
+        Log.i(TAG, "Using cacheDir: ${cacheDir.absolutePath}")
+
+        ZipFile(zipFile).use { zip ->
+            val entries = zip.entries()
+            while (entries.hasMoreElements()) {
+                val entry = entries.nextElement()
+                val entryFile = File(cacheDir, entry.name)
+                // specific check to avoid zip slip vulnerability (though low risk here)
+                if (!entryFile.canonicalPath.startsWith(cacheDir.canonicalPath)) {
+                    throw SecurityException("Zip entry is outside of the target dir: ${entry.name}")
+                }
+                
+                if (entry.isDirectory) {
+                    entryFile.mkdirs()
+                } else {
+                    entryFile.parentFile?.mkdirs()
+                    zip.getInputStream(entry).use { input ->
+                         FileOutputStream(entryFile).use { output ->
+                             input.copyTo(output)
+                         }
+                    }
+                }
+            }
+        }
+        
+        // Find config.json
+        // We look for a file ending in .json within the unzipped structure
+        // Exclude results.json if it happened to be there
+        val jsonFiles = cacheDir.walkTopDown()
+            .filter { it.isFile && it.extension == "json" && it.name != "results.json" }
+            .toList()
+            
+        if (jsonFiles.isEmpty()) throw IllegalStateException("No config.json found in zip")
+        
+        // Prefer one named config.json or take the first one
+        val configFile = jsonFiles.find { it.name == "config.json" } ?: jsonFiles.first()
+
+        Log.i(TAG, "Parsed config from ${configFile.absolutePath}")
+        return ConfigParser.parseFromPath(configFile.absolutePath)
     }
 
     private suspend fun extractDefaultAssets(): RenderTestConfig {
@@ -90,9 +184,9 @@ class ValidationInputManager(private val context: Context) {
         // Copy DamagedHelmet.glb
         val modelsDir = File(filesDir, "models")
         modelsDir.mkdirs()
-        val modelOut = File(modelsDir, "DamagedHelmet.glb")
+        val modelOut = File(modelsDir, "helmet.glb")
 
-        assetManager.open("DamagedHelmet.glb").use { input ->
+        assetManager.open("models/helmet.glb").use { input ->
             FileOutputStream(modelOut).use { output ->
                 input.copyTo(output)
             }

android/samples/sample-render-validation/src/main/java/com/google/android/filament/validation/ValidationResultManager.kt

@@ -67,22 +67,201 @@ class ValidationResultManager(private val outputDir: File) {
     fun finalizeResults(): File? {
         // Write results JSON
         writeResultsJson()
+        return null
+    }
+
+    /**
+     * Exports a zip containing:
+     * - results.json
+     * - input test bundle (as nested zip), if provided
+     * - diff images (if any failure)
+     */
+    fun exportTestResults(sourceZip: File?, timestamp: String): File? {
+        // Safe parent dir resolution
+        val parentDir = outputDir.canonicalFile.parentFile ?: outputDir.parentFile
+        if (parentDir == null) return null
+
+        val resultZipName = "results_$timestamp"
+        val zipFile = File(parentDir, "$resultZipName.zip")
+
+        Log.i(TAG, "Exporting results to ${zipFile.absolutePath}")
 
-        // Zip results
-        val zipFile = File(outputDir, "results.zip")
         try {
             ZipOutputStream(FileOutputStream(zipFile)).use { zos ->
-                outputDir.walkTopDown().filter { it.isFile && it.name != "results.zip" }.forEach { file ->
-                    val entryName = file.relativeTo(outputDir).path
-                    zos.putNextEntry(ZipEntry(entryName))
-                    file.inputStream().use { it.copyTo(zos) }
+                // 1. Add results.json
+                val resultsJson = File(outputDir, "results.json")
+                if (resultsJson.exists()) {
+                    zos.putNextEntry(ZipEntry("results.json"))
+                    resultsJson.inputStream().use { it.copyTo(zos) }
+                    zos.closeEntry()
+                }
+
+                // 2. Add source zip if exists
+                if (sourceZip != null && sourceZip.exists()) {
+                    zos.putNextEntry(ZipEntry(sourceZip.name))
+                    sourceZip.inputStream().use { it.copyTo(zos) }
+                    zos.closeEntry()
+                }
+
+                // 3. Add diff images (any file ending in _diff.png in outputDir)
+                outputDir.listFiles { _, name -> name.endsWith("_diff.png") }?.forEach { diffFile ->
+                    zos.putNextEntry(ZipEntry(diffFile.name))
+                    diffFile.inputStream().use { it.copyTo(zos) }
                     zos.closeEntry()
                 }
             }
-            Log.i(TAG, "Zipped results to ${zipFile.absolutePath}")
+            Log.i(TAG, "Exported results to ${zipFile.absolutePath}")
             return zipFile
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to zip results", e)
+            Log.e(TAG, "Failed to export results", e)
+            return null
+        }
+    }
+
+    /**
+     * Exports a zip bundle containing:
+     * - Modified config.json (with updated name and relative paths)
+     * - Models (in models/ subdirectory)
+     * - Golden images (in goldens/ subdirectory)
+     *
+     * Structure:
+     *   test_name_TIMESTAMP/
+     *     config.json
+     *     models/
+     *       model.glb
+     *     goldens/
+     *       test_result.png
+     */
+    fun exportTestBundle(config: RenderTestConfig, timestamp: String): File? {
+        Log.i(TAG, "Starting exportTestBundle for ${config.name} at $timestamp")
+        Log.i(TAG, "OutputDir: ${outputDir.absolutePath}")
+
+        val parentDir = outputDir.canonicalFile.parentFile ?: outputDir.parentFile
+        if (parentDir == null) {
+            Log.e(TAG, "OutputDir parent is null: ${outputDir.absolutePath}")
+            return null
+        }
+        Log.i(TAG, "Using parentDir for export: ${parentDir.absolutePath}")
+
+        val testNameWithTimestamp = "${config.name}_$timestamp"
+        val exportNameNoSpaces = testNameWithTimestamp.replace(" ", "_")
+
+        val exportDir = File(parentDir, "export_temp_$timestamp")
+
+        Log.i(TAG, "Creating export temp dir: ${exportDir.absolutePath}")
+        if (exportDir.exists()) exportDir.deleteRecursively()
+        if (!exportDir.mkdirs()) {
+             Log.e(TAG, "Failed to create export dir: ${exportDir.absolutePath}")
+             return null
+        }
+
+        val rootDir = File(exportDir, exportNameNoSpaces)
+        rootDir.mkdirs()
+
+        val modelsDir = File(rootDir, "models")
+        modelsDir.mkdirs()
+
+        val goldensDir = File(rootDir, "goldens")
+        goldensDir.mkdirs()
+
+        try {
+            // 1. Copy Models and update config map
+            val newModelsMap = mutableMapOf<String, String>()
+            Log.i(TAG, "Copying models...")
+            for ((modelName, modelPath) in config.models) {
+                val sourceFile = File(modelPath)
+                if (sourceFile.exists()) {
+                    val destFile = File(modelsDir, sourceFile.name)
+                    Log.d(TAG, "Copying model $modelName: $modelPath -> ${destFile.name}")
+                    sourceFile.copyTo(destFile, overwrite = true)
+                    // Use relative path for the new config
+                    newModelsMap[modelName] = "models/${sourceFile.name}"
+                } else {
+                    Log.w(TAG, "Model file not found: $modelPath")
+                }
+            }
+
+            // 2. Copy Golden Images
+            // We assume goldens are in outputDir with .png extension
+            Log.i(TAG, "Copying goldens from ${outputDir.absolutePath}...")
+            outputDir.listFiles { _, name -> name.endsWith(".png") }?.forEach { file ->
+                Log.d(TAG, "Copying golden: ${file.name}")
+                file.copyTo(File(goldensDir, file.name), overwrite = true)
+            }
+
+            // 3. Create modified config JSON
+            Log.i(TAG, "Creating config.json...")
+            val newConfigJson = JSONObject()
+            newConfigJson.put("name", testNameWithTimestamp) // Keep spaces in JSON name
+
+            // Reconstruct backends
+            val backendsArray = JSONArray()
+            config.backends.forEach { backendsArray.put(it) }
+            newConfigJson.put("backends", backendsArray)
+
+            // Reconstruct models
+            val modelsJson = JSONObject()
+            for ((k, v) in newModelsMap) {
+                modelsJson.put(k, v)
+            }
+            newConfigJson.put("models", modelsJson)
+
+            // Reconstruct tests
+            val testsArray = JSONArray()
+            for (test in config.tests) {
+                val testJson = JSONObject()
+                testJson.put("name", test.name)
+                if (test.description != null) testJson.put("description", test.description)
+
+                // Models for this test (set of strings)
+                val testModelsArray = JSONArray()
+                test.models.forEach { testModelsArray.put(it) }
+                testJson.put("models", testModelsArray)
+
+                // Rendering settings
+                testJson.put("rendering", test.rendering)
+
+                // Tolerance
+                if (test.tolerance != null) {
+                    testJson.put("tolerance", test.tolerance)
+                }
+
+                // Backends (optional override)
+                 val testBackends = JSONArray()
+                 test.backends.forEach { testBackends.put(it) }
+                 testJson.put("backends", testBackends)
+
+                testsArray.put(testJson)
+            }
+            newConfigJson.put("tests", testsArray)
+
+            // Write config.json
+            File(rootDir, "config.json").writeText(newConfigJson.toString(4))
+
+            // 4. Zip it
+            val zipFile = File(parentDir, "$exportNameNoSpaces.zip")
+            Log.i(TAG, "Zipping to ${zipFile.absolutePath}...")
+
+            ZipOutputStream(FileOutputStream(zipFile)).use { zos ->
+                rootDir.walkTopDown().forEach { file ->
+                    if (file.isFile) {
+                        val entryName = file.relativeTo(exportDir).path
+                        zos.putNextEntry(ZipEntry(entryName))
+                        file.inputStream().use { it.copyTo(zos) }
+                        zos.closeEntry()
+                    }
+                }
+            }
+
+            // Cleanup temp dir
+            exportDir.deleteRecursively()
+
+            Log.i(TAG, "Exported test bundle to ${zipFile.absolutePath}")
+            return zipFile
+
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to export test bundle", e)
+            exportDir.deleteRecursively()
             return null
         }
     }

android/samples/sample-render-validation/src/main/java/com/google/android/filament/validation/ValidationRunner.kt

@@ -41,18 +41,13 @@ class ValidationRunner(
     private var currentTestConfig: TestConfig? = null
     private var currentModelName: String? = null
 
-    private var loadStartFence: com.google.android.filament.Fence? = null
-    private var loadStartTime = 0L
     private var frameCounter = 0
 
     enum class State {
         IDLE,
-        LOADING_MODEL,
-        WAITING_FOR_FENCE,
         WAITING_FOR_RESOURCES,
         WARMUP,
-        RUNNING_TEST,
-        COMPARING
+        RUNNING_TEST
     }
 
     interface Callback {
@@ -93,8 +88,6 @@ class ValidationRunner(
             nextModel()
             return
         }
-
-        currentState = State.LOADING_MODEL
         callback?.onStatusChanged("Loading $modelName for ${currentTestConfig?.name}")
 
         // Load model on main thread (required by ModelViewer)
@@ -110,51 +103,24 @@ class ValidationRunner(
             Log.i("ValidationRunner", "Loading GLB buffer... (${bytes.size} bytes)")
             val buffer = ByteBuffer.wrap(bytes)
             modelViewer.loadModelGlb(buffer)
-            Log.i("ValidationRunner", "Model loaded. initializing fence.")
+            Log.i("ValidationRunner", "Model loaded.")
             modelViewer.transformToUnitCube()
-            loadStartFence = modelViewer.engine.createFence()
-            loadStartTime = System.nanoTime()
-            currentState = State.WAITING_FOR_FENCE
-            frameCounter = 0 // Reset for fence timeout tracking
-            Log.i("ValidationRunner", "State set to WAITING_FOR_FENCE")
+            currentState = State.WAITING_FOR_RESOURCES
+            frameCounter = 0
+            Log.i("ValidationRunner", "State set to WAITING_FOR_RESOURCES")
         } catch (e: Exception) {
-             Log.e("ValidationRunner", "Failed to load $path", e)
-             nextModel()
+            Log.e("ValidationRunner", "Failed to load $path", e)
+            nextModel()
         }
     }
 
     fun onFrame(frameTimeNanos: Long) {
         if (frameCounter % 60 == 0) {
-             Log.i("ValidationRunner", "onFrame: $currentState (frame: $frameCounter)")
+            Log.i("ValidationRunner", "onFrame: $currentState (frame: $frameCounter)")
         }
 
         when (currentState) {
             State.IDLE -> {}
-            State.WAITING_FOR_FENCE -> {
-                frameCounter++
-                if (frameCounter > 600) {
-                     Log.w("ValidationRunner", "Fence timed out after 600 frames! Forcing proceed.")
-                     modelViewer.engine.destroyFence(loadStartFence!!)
-                     loadStartFence = null
-                     currentState = State.WAITING_FOR_RESOURCES
-                     return
-                }
-
-                loadStartFence?.let { fence ->
-                     if (fence.wait(com.google.android.filament.Fence.Mode.FLUSH, 0) ==
-                            com.google.android.filament.Fence.FenceStatus.CONDITION_SATISFIED) {
-                         modelViewer.engine.destroyFence(fence)
-                         loadStartFence = null
-
-                         // Compile materials (simplified)
-                         modelViewer.scene.forEach { entity ->
-                             // ... existing material compilation logic ...
-                         }
-
-                         currentState = State.WAITING_FOR_RESOURCES
-                     }
-                }
-            }
             State.WAITING_FOR_RESOURCES -> {
                  val progress = modelViewer.progress
                  if (progress >= 1.0f) {
@@ -166,12 +132,12 @@ class ValidationRunner(
             State.WARMUP -> {
                 frameCounter++
                 if (frameCounter > 5) { // 5 frames warmup
-                     startAutomation()
+                    startAutomation()
                 }
             }
             State.RUNNING_TEST -> {
-                 // Log.i("ValidationRunner", "Running test...")
-                 currentEngine?.let { engine ->
+                // Log.i("ValidationRunner", "Running test...")
+                currentEngine?.let { engine ->
                     val content = AutomationEngine.ViewerContent()
                     content.view = modelViewer.view
                     content.renderer = modelViewer.renderer
@@ -186,13 +152,11 @@ class ValidationRunner(
                     if (engine.shouldClose()) {
                         Log.i("ValidationRunner", "Finishing test (frames: $frameCounter)")
                         // Test finished (for this spec)
-                        currentState = State.COMPARING
+                        currentState = State.IDLE
                         captureAndCompare()
                     }
                 }
             }
-            State.COMPARING -> {} // Busy
-            State.LOADING_MODEL -> {}
         }
     }
 
@@ -233,7 +197,36 @@ class ValidationRunner(
 
          // Golden path
          val modelFile = File(config.models.get(modelName)!!)
-         val goldenFile = modelFile.parentFile!!.parentFile!!.resolve("golden/${testFullName}.png")
+         val modelParent = modelFile.parentFile!!
+
+         // Search for golden in:
+         // 1. ../golden/ (standard structure)
+         // 2. ../goldens/ (exported structure, sibling of models)
+         // 3. ./goldens/ (backup)
+
+         val searchPaths = mutableListOf<File>()
+         modelParent.parentFile?.let {
+             searchPaths.add(it.resolve("golden"))
+             searchPaths.add(it.resolve("goldens"))
+         }
+         searchPaths.add(modelParent.resolve("goldens"))
+
+         var goldenFile: File? = null
+         for (path in searchPaths) {
+             val f = path.resolve("${testFullName}.png")
+             if (f.exists()) {
+                 goldenFile = f
+                 break
+             }
+         }
+
+         if (goldenFile != null) {
+             Log.i("ValidationRunner", "Found golden at ${goldenFile.absolutePath}")
+         } else {
+             Log.w("ValidationRunner", "Golden not found for $testFullName. Searched in: ${searchPaths.joinToString { it.absolutePath }}")
+             // Fallback to old behavior for reference if everything else fails
+             goldenFile = modelParent.parentFile?.resolve("golden/${testFullName}.png") ?: File("nonexistent")
+         }
 
          Thread {
              try {
@@ -245,14 +238,15 @@ class ValidationRunner(
                 var diffMetric = 0f
 
                 if (generateGoldens) {
-                    goldenFile.parentFile?.mkdirs()
-                    FileOutputStream(goldenFile).use { out ->
+                    val targetGolden = goldenFile ?: modelParent.parentFile?.resolve("golden/${testFullName}.png") ?: File(modelParent, "golden/${testFullName}.png")
+                    targetGolden.parentFile?.mkdirs()
+                    FileOutputStream(targetGolden).use { out ->
                         flipped.compress(Bitmap.CompressFormat.PNG, 100, out)
                     }
                     passed = true // Generating goldens always passes if successful
                     callback?.onStatusChanged("Golden generated")
                 } else {
-                    if (goldenFile.exists()) {
+                    if (goldenFile != null && goldenFile.exists()) {
                         val golden = android.graphics.BitmapFactory.decodeFile(goldenFile.absolutePath)
                         if (golden != null) {
                             callback?.onImageResult("Golden", golden)
@@ -273,7 +267,7 @@ class ValidationRunner(
                             callback?.onStatusChanged("Failed to load golden")
                         }
                     } else {
-                        Log.w("ValidationRunner", "Golden not found: ${goldenFile.absolutePath}")
+                        Log.w("ValidationRunner", "Golden not found: ${goldenFile?.absolutePath}")
                         callback?.onStatusChanged("Golden not found")
                     }
                 }

android/samples/sample-render-validation/src/main/res/layout/activity_main.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout 
+<androidx.constraintlayout.widget.ConstraintLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
@@ -10,6 +10,8 @@
         android:layout_width="0dp"
         android:layout_height="0dp"
         app:layout_constraintDimensionRatio="1:1"
+        app:layout_constraintWidth_percent="0.6"
+        android:layout_marginTop="32dp"
         app:layout_constraintTop_toTopOf="parent"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintEnd_toEndOf="parent">
@@ -20,10 +22,83 @@
             android:layout_height="match_parent" />
     </FrameLayout>
 
+    <LinearLayout
+        android:id="@+id/controls_container"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:paddingStart="20dp"
+        android:paddingEnd="20dp"
+        android:paddingTop="20dp"
+        android:paddingBottom="0dp"
+        app:layout_constraintTop_toBottomOf="@id/surface_container"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent">
+
+        <TextView
+            android:id="@+id/status_text"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Initializing..."
+            android:textSize="12sp" />
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:paddingTop="10dp"
+            android:paddingBottom="10dp">
+
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:gravity="center_vertical"
+                android:paddingBottom="8dp">
+
+                <com.google.android.material.button.MaterialButton
+                    android:id="@+id/run_button"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    style="@style/Widget.Material3.Button"
+                    android:text="Run Test" />
+
+                <com.google.android.material.button.MaterialButton
+                    android:id="@+id/load_button"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    style="@style/Widget.Material3.Button.TonalButton"
+                    android:text="Load Test"
+                    android:layout_marginStart="8dp"/>
+
+                <com.google.android.material.button.MaterialButton
+                    android:id="@+id/options_button"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    style="@style/Widget.Material3.Button.IconButton.Outlined"
+                    app:icon="@android:drawable/ic_menu_more"
+                    android:contentDescription="More Options"
+                    android:layout_marginStart="8dp"/>
+            </LinearLayout>
+        </LinearLayout>
+
+        <TextView
+            android:id="@+id/test_results_header"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="Test Results"
+            android:gravity="center"
+            android:textSize="14sp"
+            android:paddingTop="0dp"
+            android:paddingBottom="8dp" />
+
+    </LinearLayout>
+
     <ScrollView
         android:layout_width="0dp"
         android:layout_height="0dp"
-        app:layout_constraintTop_toBottomOf="@id/surface_container"
+        app:layout_constraintTop_toBottomOf="@id/controls_container"
         app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintEnd_toEndOf="parent">
@@ -32,41 +107,9 @@
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:orientation="vertical"
-            android:padding="20dp">
-
-            <TextView
-                android:id="@+id/status_text"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:text="Initializing..."
-                android:textSize="14sp" />
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="horizontal"
-                android:paddingTop="10dp"
-                android:paddingBottom="10dp">
-
-                <Spinner
-                    android:id="@+id/mode_spinner"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content" />
-
-                <Button
-                    android:id="@+id/run_button"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="Run" />
-            </LinearLayout>
-
-            <TextView
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:text="Test Results"
-                android:textSize="18sp"
-                android:paddingTop="20dp"
-                android:paddingBottom="10dp" />
+            android:paddingStart="20dp"
+            android:paddingEnd="20dp"
+            android:paddingBottom="20dp">
 
             <LinearLayout
                 android:id="@+id/results_container"
@@ -74,7 +117,6 @@
                 android:layout_height="wrap_content"
                 android:orientation="vertical" />
 
-
         </LinearLayout>
     </ScrollView>
 

docs/dup/intro.html

@@ -181,7 +181,7 @@ important for <code>matc</code> (material compiler).</p>
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.69.4'
+    implementation 'com.google.android.filament:filament-android:1.69.5'
 }
 </code></pre>
 <p>Here are all the libraries available in the group <code>com.google.android.filament</code>:</p>
@@ -195,7 +195,7 @@ dependencies {
 </div>
 <h3 id="ios"><a class="header" href="#ios">iOS</a></h3>
 <p>iOS projects can use CocoaPods to install the latest release:</p>
-<pre><code class="language-shell">pod 'Filament', '~&gt; 1.69.4'
+<pre><code class="language-shell">pod 'Filament', '~&gt; 1.69.5'
 </code></pre>
 <h2 id="documentation"><a class="header" href="#documentation">Documentation</a></h2>
 <ul>

docs/dup/test_ci_renderdiff.html

@@ -225,7 +225,7 @@ into <strong>branch</strong> of <code>filament-assets</code>. This branch is pai
 <code>filament</code> repo.</p>
 <p>As an example, imagine I am working on a PR, and I've uploaded my change, which is in a
 branch called <code>my-pr-branch</code>, to <code>filament</code>. This PR requires updating the golden. We would do
-it in the following fashion</p>
+it in the following fashion on a macOS machine:</p>
 <h3 id="using-a-script-to-update-the-golden-repo"><a class="header" href="#using-a-script-to-update-the-golden-repo">Using a script to update the golden repo</a></h3>
 <ul>
 <li>Make sure you've completed the steps in 'Setting up python'</li>

filament/backend/CMakeLists.txt

@@ -564,170 +564,170 @@ endif()
 # ==================================================================================================
 # Test
 # ==================================================================================================
-option(INSTALL_BACKEND_TEST "Install the backend test library so it can be consumed on iOS" OFF)
+if (FILAMENT_BUILD_TESTING)
+    option(INSTALL_BACKEND_TEST "Install the backend test library so it can be consumed on iOS" OFF)
 
-if (APPLE OR LINUX)
-    set(BACKEND_TEST_SRC
-        test/BackendTest.cpp
-        test/ShaderGenerator.cpp
-        test/TrianglePrimitive.cpp
-        test/Arguments.cpp
-        test/ImageExpectations.cpp
-        test/Lifetimes.cpp
-        test/PlatformRunner.cpp
-        test/Shader.cpp
-        test/SharedShaders.cpp
-        test/Skip.cpp
-        test/test_Autoresolve.cpp
-        test/test_FeedbackLoops.cpp
-        test/test_Blit.cpp
-        test/test_MissingRequiredAttributes.cpp
-        test/test_ReadPixels.cpp
-        test/test_ReadTexture.cpp
-        test/test_BufferUpdates.cpp
-        test/test_Callbacks.cpp
-        test/test_JobQueue.cpp
-        test/test_MemoryMappedBuffer.cpp
-        test/test_MsaaSwapChain.cpp
-        test/test_MRT.cpp
-        test/test_PushConstants.cpp
-        test/test_LoadImage.cpp
-        test/test_StencilBuffer.cpp
-        test/test_Scissor.cpp
-        test/test_MipLevels.cpp
-        test/test_Handles.cpp
-        test/test_CircularBuffer.cpp
-        test/test_CommandBufferQueue.cpp
-        test/test_Template.cpp
-    )
-    if (FILAMENT_SUPPORTS_WEBGPU)
-        list(APPEND BACKEND_TEST_SRC
-                test/test_WebGPUAsyncTaskCounter.cpp
-                test/test_WebGPUComposeSwizzle.cpp)
-    endif()
-    if (APPLE)
-        # Metal-specific tests
-        list(APPEND BACKEND_TEST_SRC
-            test/test_MetalBlitter.mm
+    if (APPLE OR LINUX)
+        set(BACKEND_TEST_SRC
+            test/BackendTest.cpp
+            test/ShaderGenerator.cpp
+            test/TrianglePrimitive.cpp
+            test/Arguments.cpp
+            test/ImageExpectations.cpp
+            test/Lifetimes.cpp
+            test/PlatformRunner.cpp
+            test/Shader.cpp
+            test/SharedShaders.cpp
+            test/Skip.cpp
+            test/test_Autoresolve.cpp
+            test/test_FeedbackLoops.cpp
+            test/test_Blit.cpp
+            test/test_MissingRequiredAttributes.cpp
+            test/test_ReadPixels.cpp
+            test/test_ReadTexture.cpp
+            test/test_BufferUpdates.cpp
+            test/test_Callbacks.cpp
+            test/test_JobQueue.cpp
+            test/test_MemoryMappedBuffer.cpp
+            test/test_MsaaSwapChain.cpp
+            test/test_MRT.cpp
+            test/test_PushConstants.cpp
+            test/test_LoadImage.cpp
+            test/test_StencilBuffer.cpp
+            test/test_Scissor.cpp
+            test/test_MipLevels.cpp
+            test/test_Handles.cpp
+            test/test_CircularBuffer.cpp
+            test/test_CommandBufferQueue.cpp
+            test/test_Template.cpp
         )
-    endif()
-    set(BACKEND_TEST_LIBS
-        absl::str_format
-        backend
-        getopt
-        gtest
-        imageio
-        filamat
-        SPIRV
-        spirv-cross-glsl)
-    # Create input/output directories for test result images.
-    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/images/actual_images)
-    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/images/diff_images)
-    file(COPY test/expected_images DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/images)
-endif()
-
-# TODO: Disabling IOS test due to breakage wrt glslang update
-if (APPLE AND NOT IOS)
-    # TODO: we should expand this test to Linux and other platforms.
-    list(APPEND BACKEND_TEST_SRC
-         test/test_RenderExternalImage.cpp)
-    add_library(backend_test STATIC ${BACKEND_TEST_SRC})
-    target_link_libraries(backend_test PUBLIC ${BACKEND_TEST_LIBS})
-    target_compile_options(backend_test PRIVATE "-fobjc-arc")
-
-    set(BACKEND_TEST_DEPS
-            OSDependent
-            SPIRV
-            SPIRV-Tools
-            SPIRV-Tools-opt
-            backend_test
+        if (FILAMENT_SUPPORTS_WEBGPU)
+            list(APPEND BACKEND_TEST_SRC
+                    test/test_WebGPUAsyncTaskCounter.cpp
+                    test/test_WebGPUComposeSwizzle.cpp)
+        endif()
+        if (APPLE)
+            # Metal-specific tests
+            list(APPEND BACKEND_TEST_SRC
+                test/test_MetalBlitter.mm
+            )
+        endif()
+        set(BACKEND_TEST_LIBS
+            absl::str_format
+            backend
             getopt
             gtest
-            glslang
-            spirv-cross-core
-            spirv-cross-glsl
-            spirv-cross-msl)
-
-    if (NOT IOS)
-        target_link_libraries(backend_test PRIVATE image imageio)
-        list(APPEND BACKEND_TEST_DEPS image)
-    endif()
-    if (FILAMENT_SUPPORTS_WEBGPU)
-        target_link_libraries(backend_test PRIVATE webgpu_dawn dawncpp_headers)
-        list(APPEND BACKEND_TEST_DEPS webgpu_dawn dawncpp_headers)
+            imageio
+            filamat
+            SPIRV
+            spirv-cross-glsl)
+        # Create input/output directories for test result images.
+        file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/images/actual_images)
+        file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/images/diff_images)
+        file(COPY test/expected_images DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/images)
     endif()
 
-    set(BACKEND_TEST_COMBINED_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libbackendtest_combined.a")
-    combine_static_libs(backend_test "${BACKEND_TEST_COMBINED_OUTPUT}" "${BACKEND_TEST_DEPS}")
+    # TODO: Disabling IOS test due to breakage wrt glslang update
+    if (APPLE AND NOT IOS)
+        # TODO: we should expand this test to Linux and other platforms.
+        list(APPEND BACKEND_TEST_SRC
+            test/test_RenderExternalImage.cpp)
+        add_library(backend_test STATIC ${BACKEND_TEST_SRC})
+        target_link_libraries(backend_test PUBLIC ${BACKEND_TEST_LIBS})
+        target_compile_options(backend_test PRIVATE "-fobjc-arc")
 
-    set(BACKEND_TEST_LIB_NAME ${CMAKE_STATIC_LIBRARY_PREFIX}backend_test${CMAKE_STATIC_LIBRARY_SUFFIX})
+        set(BACKEND_TEST_DEPS
+                OSDependent
+                SPIRV
+                SPIRV-Tools
+                SPIRV-Tools-opt
+                backend_test
+                getopt
+                gtest
+                glslang
+                spirv-cross-core
+                spirv-cross-glsl
+                spirv-cross-msl)
 
-    if (INSTALL_BACKEND_TEST)
-        install(FILES "${BACKEND_TEST_COMBINED_OUTPUT}" DESTINATION lib/${DIST_DIR} RENAME ${BACKEND_TEST_LIB_NAME})
-        install(FILES test/PlatformRunner.h DESTINATION include/backend_test)
+        if (NOT IOS)
+            target_link_libraries(backend_test PRIVATE image imageio)
+            list(APPEND BACKEND_TEST_DEPS image)
+        endif()
+        if (FILAMENT_SUPPORTS_WEBGPU)
+            target_link_libraries(backend_test PRIVATE webgpu_dawn dawncpp_headers)
+            list(APPEND BACKEND_TEST_DEPS webgpu_dawn dawncpp_headers)
+        endif()
+
+        set(BACKEND_TEST_COMBINED_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libbackendtest_combined.a")
+        combine_static_libs(backend_test "${BACKEND_TEST_COMBINED_OUTPUT}" "${BACKEND_TEST_DEPS}")
+
+        set(BACKEND_TEST_LIB_NAME ${CMAKE_STATIC_LIBRARY_PREFIX}backend_test${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+        if (INSTALL_BACKEND_TEST)
+            install(FILES "${BACKEND_TEST_COMBINED_OUTPUT}" DESTINATION lib/${DIST_DIR} RENAME ${BACKEND_TEST_LIB_NAME})
+            install(FILES test/PlatformRunner.h DESTINATION include/backend_test)
+        endif()
+
+        set_target_properties(backend_test PROPERTIES FOLDER Tests)
+
+        if (APPLE AND NOT IOS)
+            add_executable(backend_test_mac test/mac_runner.mm)
+            target_link_libraries(backend_test_mac PRIVATE "-framework Metal -framework AppKit -framework QuartzCore")
+            # Because each test case is a separate file, the -force_load flag is necessary to prevent the
+            # linker from removing "unused" symbols.
+            target_link_libraries(backend_test_mac PRIVATE -force_load backend_test)
+            set_target_properties(backend_test_mac PROPERTIES FOLDER Tests)
+
+            # This is needed after XCode 15.3
+            set_target_properties(backend_test_mac PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
+            set_target_properties(backend_test_mac PROPERTIES INSTALL_RPATH /usr/local/lib)
+        endif()
     endif()
 
-    set_target_properties(backend_test PROPERTIES FOLDER Tests)
+    if (LINUX)
+        add_executable(backend_test_linux test/linux_runner.cpp ${BACKEND_TEST_SRC})
+        target_link_libraries(backend_test_linux PRIVATE ${BACKEND_TEST_LIBS})
+        set_target_properties(backend_test_linux PROPERTIES FOLDER Tests)
+        if (FILAMENT_SUPPORTS_WEBGPU)
+            target_link_libraries(backend_test_linux PRIVATE webgpu_dawn dawncpp_headers)
+        endif()
+    endif()
+
+    # ==================================================================================================
+    # Compute tests
+    #
+    #if (NOT IOS AND NOT WEBGL)
+    #
+    #add_executable(compute_test
+    #        test/ComputeTest.cpp
+    #        test/Arguments.cpp
+    #        test/test_ComputeBasic.cpp
+    #        )
+    #
+    #target_link_libraries(compute_test PRIVATE
+    #        backend
+    #        getopt
+    #        gtest
+    #        )
+    #
+    #set_target_properties(compute_test PROPERTIES FOLDER Tests)
+    #
+    #endif()
+
+    # ==================================================================================================
+    # Metal utils tests
 
     if (APPLE AND NOT IOS)
-       add_executable(backend_test_mac test/mac_runner.mm)
-       target_link_libraries(backend_test_mac PRIVATE "-framework Metal -framework AppKit -framework QuartzCore")
-       # Because each test case is a separate file, the -force_load flag is necessary to prevent the
-       # linker from removing "unused" symbols.
-       target_link_libraries(backend_test_mac PRIVATE -force_load backend_test)
-       set_target_properties(backend_test_mac PROPERTIES FOLDER Tests)
+        add_executable(metal_utils_test test/MetalTest.mm)
 
-       # This is needed after XCode 15.3
-       set_target_properties(backend_test_mac PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
-       set_target_properties(backend_test_mac PROPERTIES INSTALL_RPATH /usr/local/lib)
+        target_compile_options(metal_utils_test PRIVATE "-fobjc-arc")
+
+        target_link_libraries(metal_utils_test PRIVATE
+                backend
+                getopt
+                gtest
+                )
+
+        set_target_properties(metal_utils_test PROPERTIES FOLDER Tests)
     endif()
-endif()
-
-if (LINUX)
-    add_executable(backend_test_linux test/linux_runner.cpp ${BACKEND_TEST_SRC})
-    target_link_libraries(backend_test_linux PRIVATE ${BACKEND_TEST_LIBS})
-    set_target_properties(backend_test_linux PROPERTIES FOLDER Tests)
-    if (FILAMENT_SUPPORTS_WEBGPU)
-        target_link_libraries(backend_test_linux PRIVATE webgpu_dawn dawncpp_headers)
-    endif()
-endif()
-
-# ==================================================================================================
-# Compute tests
-#
-#if (NOT IOS AND NOT WEBGL)
-#
-#add_executable(compute_test
-#        test/ComputeTest.cpp
-#        test/Arguments.cpp
-#        test/test_ComputeBasic.cpp
-#        )
-#
-#target_link_libraries(compute_test PRIVATE
-#        backend
-#        getopt
-#        gtest
-#        )
-#
-#set_target_properties(compute_test PROPERTIES FOLDER Tests)
-#
-#endif()
-
-# ==================================================================================================
-# Metal utils tests
-
-if (APPLE AND NOT IOS)
-
-add_executable(metal_utils_test test/MetalTest.mm)
-
-target_compile_options(metal_utils_test PRIVATE "-fobjc-arc")
-
-target_link_libraries(metal_utils_test PRIVATE
-        backend
-        getopt
-        gtest
-        )
-
-set_target_properties(metal_utils_test PROPERTIES FOLDER Tests)
-
-endif()
+endif()

filament/backend/src/VirtualMachineEnv.cpp

@@ -25,6 +25,11 @@
 
 #include <mutex>
 
+#ifdef __ANDROID__
+#include <pthread.h>
+#endif
+
+
 namespace filament {
 
 using namespace utils;
@@ -105,8 +110,21 @@ JNIEnv* VirtualMachineEnv::getEnvironmentSlow() {
     FILAMENT_CHECK_PRECONDITION(mVirtualMachine)
             << "JNI_OnLoad() has not been called";
 
-#if defined(__ANDROID__)
-    jint const result = mVirtualMachine->AttachCurrentThread(&mJniEnv, nullptr);
+#ifdef __ANDROID__
+    JavaVMAttachArgs args;
+    args.version = JNI_VERSION_1_6;
+    args.group = nullptr;
+    char threadName[16]; // pthread_getname_np returns at most 16 bytes
+    if (__builtin_available(android 26, *)) {
+        if (pthread_getname_np(pthread_self(), threadName, sizeof(threadName)) == 0) {
+            args.name = threadName;
+        } else {
+            args.name = nullptr;
+        }
+    } else {
+        args.name = nullptr;
+    }
+    jint const result = mVirtualMachine->AttachCurrentThread(&mJniEnv, &args);
 #else
     jint const result = mVirtualMachine->AttachCurrentThread(reinterpret_cast<void**>(&mJniEnv), nullptr);
 #endif

filament/backend/src/vulkan/VulkanAsyncHandles.cpp

@@ -29,6 +29,12 @@ using namespace bluevk;
 
 namespace filament::backend {
 
+std::shared_ptr<VulkanCmdFence> VulkanCmdFence::completed() noexcept {
+    auto cmdFence = std::make_shared<VulkanCmdFence>(VK_NULL_HANDLE);
+    cmdFence->mStatus = VK_SUCCESS;
+    return cmdFence;
+}
+
 FenceStatus VulkanCmdFence::wait(VkDevice device, uint64_t const timeout,
     std::chrono::steady_clock::time_point const until) {
 

filament/backend/src/vulkan/VulkanAsyncHandles.h

@@ -40,6 +40,13 @@ struct VulkanCmdFence {
     explicit VulkanCmdFence(VkFence fence) : mFence(fence) { }
     ~VulkanCmdFence() = default;
 
+    // Creates a VulkanCmdFence with its status set to VK_SUCCESS. It holds
+    // a null handle; it is assumed that any user of this object will avoid
+    // using the fence handle directly if getStatus() returns VK_SUCCESS, as
+    // in that case, it's likely the fence is being reused for other passes,
+    // and is not in the expected state anyway.
+    static std::shared_ptr<VulkanCmdFence> completed() noexcept;
+
     void setStatus(VkResult const value) {
         std::lock_guard const l(mLock);
         mStatus = value;

filament/backend/src/vulkan/VulkanBufferCache.cpp

@@ -118,6 +118,14 @@ void VulkanBufferCache::terminate() noexcept {
     }
 }
 
+size_t VulkanBufferCache::getSize() const noexcept {
+    size_t size = 0;
+    for (int i = 0; i < MAX_POOL_COUNT; i++) {
+        size += mGpuBufferPools[i].size();
+    }
+    return size;
+}
+
 void VulkanBufferCache::release(VulkanGpuBuffer const* gpuBuffer) noexcept {
     assert_invariant(gpuBuffer != nullptr);
 

filament/backend/src/vulkan/VulkanBufferCache.h

@@ -48,6 +48,8 @@ public:
     // This should be called while the context's VkDevice is still alive.
     void terminate() noexcept;
 
+    size_t getSize() const noexcept;
+
 private:
     struct UnusedGpuBuffer {
         uint64_t lastAccessed;

filament/backend/src/vulkan/VulkanCommands.h

@@ -158,6 +158,8 @@ struct CommandBufferPool {
 
     inline bool isRecording() const { return mRecording != INVALID; }
 
+    size_t getSize() const noexcept { return mBuffers.size(); }
+
 private:
     static constexpr int CAPACITY = FVK_MAX_COMMAND_BUFFERS;
     // int8 only goes up to 127, therefore capacity must be less than that.
@@ -255,6 +257,17 @@ public:
     // Updates the atomic "status" variable in every extant fence.
     void updateFences();
 
+    struct SizeInfo {
+        size_t regular;
+        size_t protectedPool;
+    };
+    SizeInfo getSize() const noexcept {
+        return {
+            mPool ? mPool->getSize() : 0,
+            mProtectedPool ? mProtectedPool->getSize() : 0
+        };
+    }
+
 #if FVK_ENABLED(FVK_DEBUG_GROUP_MARKERS)
     void pushGroupMarker(char const* str, VulkanGroupMarkers::Timestamp timestamp = {});
     void popGroupMarker();
@@ -277,7 +290,11 @@ private:
     fvkmemory::resource_ptr<VulkanSemaphore> mLastSubmit;
 
     VkFence mLastFence = VK_NULL_HANDLE;
-    std::shared_ptr<VulkanCmdFence> mLastFenceStatus;
+    // Start out with a completed fence, because if no commands have
+    // been queued or submited, then by definition, all pending work
+    // is complete.
+    std::shared_ptr<VulkanCmdFence> mLastFenceStatus =
+            VulkanCmdFence::completed();
 
     VkPipelineStageFlags mInjectedDependencyWaitStage = 0;
 };

filament/backend/src/vulkan/VulkanDescriptorSetCache.cpp

@@ -119,6 +119,9 @@ public:
         return mCapacity;
     }
 
+    uint16_t size() const { return mSize; }
+    uint16_t unusedCount() const { return mUnusedCount; }
+
     // A convenience method for checking if this pool can allocate sets for a given layout.
     inline bool canAllocate(DescriptorCount const& count) {
         return count == mCount;
@@ -255,6 +258,16 @@ public:
         }
     }
 
+    VulkanDescriptorSetCache::SizeInfo getSize() const {
+        VulkanDescriptorSetCache::SizeInfo info = {};
+        info.poolCount = mPools.size();
+        for (auto& pool : mPools) {
+            info.totalSize += pool->size();
+            info.totalUnusedCount += pool->unusedCount();
+        }
+        return info;
+    }
+
 private:
     VkDevice mDevice;
     std::vector<std::unique_ptr<DescriptorPool>> mPools;
@@ -448,6 +461,10 @@ void VulkanDescriptorSetCache::manualRecycle(VulkanDescriptorSetLayout::Count co
 
 void VulkanDescriptorSetCache::gc() { mStashedSets = {}; }
 
+VulkanDescriptorSetCache::SizeInfo VulkanDescriptorSetCache::getSize() const noexcept {
+    return mDescriptorPool->getSize();
+}
+
 void VulkanDescriptorSetCache::copySet(VkDescriptorSet srcSet, VkDescriptorSet dstSet,
         fvkutils::SamplerBitmask bindings) const {
     // TODO: fix the size for better memory management

filament/backend/src/vulkan/VulkanDescriptorSetCache.h

@@ -89,6 +89,13 @@ public:
 
     void resetCachedState() noexcept { mLastBoundInfo = {}; }
 
+    struct SizeInfo {
+        size_t poolCount;
+        size_t totalSize;
+        size_t totalUnusedCount;
+    };
+    SizeInfo getSize() const noexcept;
+
 private:
     void copySet(VkDescriptorSet srcSet, VkDescriptorSet destSet,
             fvkutils::SamplerBitmask copyBindings) const;

filament/backend/src/vulkan/VulkanDescriptorSetLayoutCache.h

@@ -49,6 +49,8 @@ public:
             fvkutils::SamplerBitmask externalSamplers,
             utils::FixedCapacityVector<std::pair<uint64_t, VkSampler>> immutableSamplers = {});
 
+    size_t getSize() const noexcept { return mVkLayouts.size(); }
+
 private:
     VkDevice mDevice;
     fvkmemory::ResourceManager* mResourceManager;

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -49,6 +49,7 @@
 
 #include <chrono>
 #include <mutex>
+#include <stdio.h>
 
 using namespace bluevk;
 
@@ -445,6 +446,29 @@ void VulkanDriver::collectGarbage() {
 
     mResourceManager.gc();
 
+    auto dsSize = mDescriptorSetCache.getSize();
+    auto stageSize = mStagePool.getSize();
+    auto externalSize = mExternalImageManager.getSize();
+    auto commandsSize = mCommands.getSize();
+
+    fprintf(stderr, "Vulkan Cache Sizes:\n");
+    fprintf(stderr, "  Pipelines: %zu\n", mPipelineCache.getSize());
+    fprintf(stderr, "  Pipeline Layouts: %zu\n", mPipelineLayoutCache.getSize());
+    fprintf(stderr, "  Descriptor Set Layouts: %zu\n", mDescriptorSetLayoutCache.getSize());
+    fprintf(stderr, "  Descriptor Sets: %zu (pools: %zu, unused: %zu)\n", dsSize.totalSize, dsSize.poolCount, dsSize.totalUnusedCount);
+    fprintf(stderr, "  FBOs: %zu\n", mFramebufferCache.getFboCacheSize());
+    fprintf(stderr, "  Render Passes: %zu (refcount: %zu)\n",
+            mFramebufferCache.getRenderPassCacheSize(), mFramebufferCache.getRenderPassRefCountSize());
+    fprintf(stderr, "  Samplers: %zu\n", mSamplerCache.getSize());
+    fprintf(stderr, "  Buffers: %zu\n", mBufferCache.getSize());
+    fprintf(stderr, "  Stages: %zu, Free Images: %zu\n", stageSize.stages, stageSize.freeImages);
+    fprintf(stderr, "  YCbCr Conversions: %zu\n", mYcbcrConversionCache.getSize());
+    fprintf(stderr, "  External Images: %zu, Set Bindings: %zu\n", externalSize.images, externalSize.setBindings);
+    fprintf(stderr, "  Streamed Bindings: %zu\n", mStreamedImageManager.getSize());
+    fprintf(stderr, "  Command Buffers: %zu (regular: %zu, protected: %zu)\n",
+            commandsSize.regular + commandsSize.protectedPool, commandsSize.regular, commandsSize.protectedPool);
+    fprintf(stderr, "  Semaphores: %zu\n", mSemaphoreManager.getSize());
+
 #if FVK_ENABLED(FVK_DEBUG_RESOURCE_LEAK)
     mResourceManager.print();
 #endif
@@ -1913,9 +1937,6 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
 
     auto rt = resource_ptr<VulkanRenderTarget>::cast(&mResourceManager, rth);
 
-    VulkanCommandBuffer* commandBuffer = rt->isProtected() ?
-           &mCommands.getProtected() : &mCommands.get();
-
     // Filament has the expectation that the contents of the swap chain are not preserved on the
     // first render pass. Note however that its contents are often preserved on subsequent render
     // passes, due to multiple views.
@@ -1930,6 +1951,11 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         }
     }
 
+    // Note that this needs to come after the acquireNextswapchainImage() above because that path
+    // might flush the current command buffer.
+    VulkanCommandBuffer* commandBuffer =
+            rt->isProtected() ? &mCommands.getProtected() : &mCommands.get();
+
     // Note that retrieving the extent must come after the acquireNextSwapchainImage() above;
     // otherwise it might be 0.
     VkExtent2D const extent = rt->getExtent();

filament/backend/src/vulkan/VulkanExternalImageManager.h

@@ -85,6 +85,12 @@ public:
     // - Update the bindings that use external samplers.
     void updateSetAndLayout(fvkmemory::resource_ptr<VulkanDescriptorSet> set);
 
+    struct SizeInfo {
+        size_t setBindings;
+        size_t images;
+    };
+    SizeInfo getSize() const noexcept { return { mSetBindings.size(), mImages.size() }; }
+
 private:
 
     VulkanSamplerCache* mSamplerCache;

filament/backend/src/vulkan/VulkanFboCache.h

@@ -120,6 +120,10 @@ public:
     // Frees all Vulkan objects. Call this during shutdown before the device is destroyed.
     void terminate() noexcept;
 
+    size_t getFboCacheSize() const noexcept { return mFramebufferCache.size(); }
+    size_t getRenderPassCacheSize() const noexcept { return mRenderPassCache.size(); }
+    size_t getRenderPassRefCountSize() const noexcept { return mRenderPassRefCount.size(); }
+
 private:
     VkDevice mDevice;
     using FboMap = tsl::robin_map<FboKey, FboVal, FboKeyHashFn, FboKeyEqualFn>;

filament/backend/src/vulkan/VulkanPipelineCache.h

@@ -136,6 +136,8 @@ public:
     void terminate() noexcept;
     void gc() noexcept;
 
+    size_t getSize() const noexcept { return mPipelines.size(); }
+
 private:
     // PIPELINE CACHE KEY
     // ------------------

filament/backend/src/vulkan/VulkanPipelineLayoutCache.h

@@ -59,6 +59,8 @@ public:
     VkPipelineLayout getLayout(DescriptorSetLayoutArray const& descriptorSetLayouts,
             fvkmemory::resource_ptr<VulkanProgram> program);
 
+    size_t getSize() const noexcept { return mPipelineLayouts.size(); }
+
 private:
     using Timestamp = uint64_t;
     struct PipelineLayoutCacheEntry {

filament/backend/src/vulkan/VulkanSamplerCache.h

@@ -40,6 +40,8 @@ public:
     explicit VulkanSamplerCache(VkDevice device);
     VkSampler getSampler(Params params);
     void terminate() noexcept;
+
+    size_t getSize() const noexcept { return mCache.size(); }
 private:
     VkDevice mDevice;
 

filament/backend/src/vulkan/VulkanSemaphoreManager.h

@@ -37,6 +37,8 @@ public:
     void terminate();
     Semaphore acquire();
 
+    size_t getSize() const noexcept { return mPool.size(); }
+
 private:
     friend struct VulkanSemaphore;
     void recycle(VkSemaphore semaphore);

filament/backend/src/vulkan/VulkanStagePool.h

@@ -223,6 +223,12 @@ public:
     // resource_ptrs, as this would lead to undefined behavior.
     void terminate() noexcept;
 
+    struct SizeInfo {
+        size_t stages;
+        size_t freeImages;
+    };
+    SizeInfo getSize() const noexcept { return { mStages.size(), mFreeImages.size() }; }
+
 private:
     VmaAllocator mAllocator;
     fvkmemory::ResourceManager* mResManager;

filament/backend/src/vulkan/VulkanStreamedImageManager.h

@@ -46,6 +46,8 @@ public:
     void onStreamAcquireImage(fvkmemory::resource_ptr<VulkanTexture> image,
             fvkmemory::resource_ptr<VulkanStream> stream);
 
+    size_t getSize() const noexcept { return mStreamedTexturesBindings.size(); }
+
 private:
     struct StreamedTextureBinding {
         uint8_t binding = 0;

filament/backend/src/vulkan/VulkanYcbcrConversionCache.h

@@ -42,6 +42,8 @@ public:
     VkSamplerYcbcrConversion getConversion(Params params);
     void terminate() noexcept;
 
+    size_t getSize() const noexcept { return mCache.size(); }
+
 private:
     VkDevice mDevice;
 

filament/include/filament/LightManager.h

@@ -372,7 +372,7 @@ public:
         } vsm;
 
         /**
-         * Light bulb radius used for soft shadows. Currently this is only used when DPCF or PCSS is
+         * Light bulb radius used for soft shadows. Currently, this is only used when DPCF or PCSS is
          * enabled. (2cm by default).
          */
         float shadowBulbRadius = 0.02f;

filament/include/filament/Options.h

@@ -735,7 +735,7 @@ struct VsmShadowOptions {
     bool highPrecision = false;
 
     /**
-     * VSM minimum variance scale, must be positive.
+     * @deprecated has no effect.
      */
     float minVarianceScale = 0.5f;
 

filament/src/MaterialInstanceManager.cpp

@@ -19,90 +19,61 @@
 
 #include "details/Engine.h"
 #include "details/Material.h"
-#include "details/MaterialInstance.h"
 
-#include <utils/debug.h>
-
-#include <iterator>
-#include <utility>
-
-#include <stdint.h>
+#include <cstdint>
 
 namespace filament {
 
-using Record = MaterialInstanceManager::Record;
+using namespace utils;
 
-std::pair<FMaterialInstance*, int32_t> Record::getInstance() {
-    if (mAvailable < mInstances.size()) {
-        auto index = mAvailable++;
-        return { mInstances[index], index };
-    }
-    assert_invariant(mAvailable == mInstances.size());
-    auto& name = mMaterial->getName();
-    FMaterialInstance* inst = mMaterial->createInstance(name.c_str_safe());
-    mInstances.push_back(inst);
-    return { inst, mAvailable++ };
-}
+MaterialInstanceManager::MaterialInstanceManager() noexcept = default;
 
-FMaterialInstance* Record::getInstance(int32_t const fixedInstanceindex) const {
-    assert_invariant(fixedInstanceindex >= 0 &&  fixedInstanceindex < int32_t(mInstances.size()));
-    return mInstances[fixedInstanceindex];
-}
-
-// Defined in cpp to avoid inlining
-Record::Record(Record const& rhs) noexcept = default;
-Record& Record::operator=(Record const& rhs) noexcept = default;
-Record::Record(Record&& rhs) noexcept = default;
-Record& Record::operator=(Record&& rhs) noexcept = default;
-
-void Record::terminate(FEngine& engine) {
-    std::for_each(mInstances.begin(), mInstances.end(),
-            [&engine](auto instance) { engine.destroy(instance); });
-}
-
-MaterialInstanceManager::MaterialInstanceManager() noexcept {}
-
-MaterialInstanceManager::MaterialInstanceManager(
-        MaterialInstanceManager const& rhs) noexcept = default;
 MaterialInstanceManager::MaterialInstanceManager(MaterialInstanceManager&& rhs) noexcept = default;
-MaterialInstanceManager& MaterialInstanceManager::operator=(
-        MaterialInstanceManager const& rhs) noexcept = default;
-MaterialInstanceManager& MaterialInstanceManager::operator=(
-        MaterialInstanceManager&& rhs) noexcept = default;
-
+MaterialInstanceManager& MaterialInstanceManager::operator=(MaterialInstanceManager&& rhs) noexcept = default;
 MaterialInstanceManager::~MaterialInstanceManager() = default;
 
 void MaterialInstanceManager::terminate(FEngine& engine) {
-    std::for_each(mMaterials.begin(), mMaterials.end(), [&engine](auto& record) {
-        record.terminate(engine);
-    });
+    for (auto const& [key, instance] : mMaterialInstances) {
+        engine.destroy(instance);
+    }
+    mMaterialInstances.clear();
+
+    for (auto const& [material, pool] : mAnonymousMaterialInstances) {
+        for (auto instance : pool.instances) {
+            engine.destroy(instance);
+        }
+    }
+    mAnonymousMaterialInstances.clear();
 }
 
-Record& MaterialInstanceManager::getRecord(FMaterial const* const ma) const {
-    auto itr = std::find_if(mMaterials.begin(), mMaterials.end(), [ma](auto& record) {
-        return ma == record.mMaterial;
-    });
-    if (itr == mMaterials.end()) {
-        mMaterials.emplace_back(ma);
-        itr = std::prev(mMaterials.end());
+void MaterialInstanceManager::reset() {
+    for (auto& [material, pool] : mAnonymousMaterialInstances) {
+        pool.highWaterMark = 0;
     }
-    return *itr;
+}
+
+FMaterialInstance* MaterialInstanceManager::getMaterialInstance(FMaterial const* ma, uint32_t tag) const {
+    Key const key{ma, tag};
+    auto it = mMaterialInstances.find(key);
+    if (it != mMaterialInstances.end()) {
+        return it->second;
+    }
+
+    FMaterialInstance* const instance = ma->createInstance(ma->getName().c_str_safe());
+    mMaterialInstances.emplace(key, instance);
+    return instance;
 }
 
 FMaterialInstance* MaterialInstanceManager::getMaterialInstance(FMaterial const* ma) const {
-    auto [inst, index] = getRecord(ma).getInstance();
-    return inst;
-}
+    AnonymousPool& pool = mAnonymousMaterialInstances[ma];
+    if (pool.highWaterMark < pool.instances.size()) {
+        return pool.instances[pool.highWaterMark++];
+    }
 
-FMaterialInstance* MaterialInstanceManager::getMaterialInstance(FMaterial const* ma,
-        int32_t const fixedIndex) const {
-    return getRecord(ma).getInstance(fixedIndex);
+    FMaterialInstance* const instance = ma->createInstance(ma->getName().c_str_safe());
+    pool.instances.push_back(instance);
+    pool.highWaterMark++;
+    return instance;
 }
 
-std::pair<FMaterialInstance*, int32_t> MaterialInstanceManager::getFixedMaterialInstance(
-        FMaterial const* ma) {
-    return getRecord(ma).getInstance();
-}
-
-
 } // namespace filament

filament/src/MaterialInstanceManager.h

@@ -16,10 +16,13 @@
 
 #pragma once
 
-#include <utils/bitset.h>
-
+#include <cstddef>
+#include <cstdint>
+#include <unordered_map>
 #include <vector>
 
+#include <utils/Hash.h>
+
 namespace filament {
 
 class FMaterial;
@@ -30,37 +33,10 @@ class FEngine;
 // re-use instances across frames.
 class MaterialInstanceManager {
 public:
-    class Record {
-    public:
-        Record(FMaterial const* material)
-            : mMaterial(material),
-              mAvailable(0) {}
-        ~Record() = default;
-
-        Record(Record const& rhs) noexcept;
-        Record& operator=(Record const& rhs) noexcept;
-        Record(Record&& rhs) noexcept;
-        Record& operator=(Record&& rhs) noexcept;
-
-        void terminate(FEngine& engine);
-        void reset() { mAvailable = 0; }
-        std::pair<FMaterialInstance*, int32_t> getInstance();
-        FMaterialInstance* getInstance(int32_t fixedInstanceindex) const;
-
-    private:
-        FMaterial const* mMaterial = nullptr;
-        std::vector<FMaterialInstance*> mInstances;
-        uint32_t mAvailable;
-
-        friend class MaterialInstanceManager;
-    };
-
-    constexpr static int32_t INVALID_FIXED_INDEX = -1;
-
     MaterialInstanceManager() noexcept;
-    MaterialInstanceManager(MaterialInstanceManager const& rhs) noexcept;
+    MaterialInstanceManager(MaterialInstanceManager const& rhs) = delete;
     MaterialInstanceManager(MaterialInstanceManager&& rhs) noexcept;
-    MaterialInstanceManager& operator=(MaterialInstanceManager const& rhs) noexcept;
+    MaterialInstanceManager& operator=(MaterialInstanceManager const& rhs) = delete;
     MaterialInstanceManager& operator=(MaterialInstanceManager&& rhs) noexcept;
 
     ~MaterialInstanceManager();
@@ -71,40 +47,60 @@ public:
      */
     void terminate(FEngine& engine);
 
-    /*
-     * This returns a material instance given a material. The implementation will try to find an
-     * available instance in the cache. If one is not found, then a new instance will be created and
-     * added to the cache.
+    /**
+     * Resets the anonymous material instances cache.
+     */
+    void reset();
+
+    /**
+     * This returns a material instance given a material and a tag.
+     *
+     * If the material instance doesn't exist in the cache, it is created and cached.
+     *
+     * @param ma    FMaterial to get a MaterialInstance for
+     * @param tag   A unique tag identifying the MaterialInstance
+     * @return      A FMaterialInstance pointer
+     */
+    FMaterialInstance* getMaterialInstance(FMaterial const* ma, uint32_t tag) const;
+
+    /**
+     * This returns a material instance given a material from a cache.
+     *
+     * If the material instance doesn't exist in the cache, it is created and cached.
+     *
+     * It is permissible to call the method several times, in which case a different MaterialInstance will be returned.
+     * It is guaranteed to be different from MaterialInstances returned with a tag.
+     *
+     * @param ma    FMaterial to get a MaterialInstance for
+     * @return      A FMaterialInstance pointer
      */
     FMaterialInstance* getMaterialInstance(FMaterial const* ma) const;
 
-    /*
-     * This returns a material instance given a material and an index. The `fixedIndex` should be
-     * a value returned by getiFixedMaterialInstance.
-     */
-    FMaterialInstance* getMaterialInstance(FMaterial const* ma, int32_t const fixedIndex) const;
-
-    /*
-     * This returns a material instance and an index given a material. This is needed for the
-     * case when two framegraph passes need to refer to the same material instance.
-     * The returned index can be used with `getFixedMaterialInstance` to get a specific instance
-     * of a material (and not a random entry in the record cache).
-     */
-    std::pair<FMaterialInstance*, int32_t> getFixedMaterialInstance(FMaterial const* ma);
-
-
-    /*
-     * Marks all of the material instances as unused. Typically, you'd call this at the beginning of
-     * a frame.
-     */
-    void reset() {
-        std::for_each(mMaterials.begin(), mMaterials.end(), [](auto& record) { record.reset(); });
-    }
-
 private:
-    Record& getRecord(FMaterial const* material) const;
+    struct Key {
+        FMaterial const* material;
+        uint32_t tag;
+        bool operator==(Key const& rhs) const noexcept {
+            return material == rhs.material && tag == rhs.tag;
+        }
+    };
 
-    mutable std::vector<Record> mMaterials;
+    struct Hasher {
+        std::size_t operator()(Key const& key) const noexcept {
+            std::size_t seed = 0;
+            utils::hash::combine(seed, key.material);
+            utils::hash::combine(seed, key.tag);
+            return seed;
+        }
+    };
+
+    struct AnonymousPool {
+        std::vector<FMaterialInstance*> instances;
+        uint32_t highWaterMark = 0;
+    };
+
+    mutable std::unordered_map<Key, FMaterialInstance*, Hasher> mMaterialInstances;
+    mutable std::unordered_map<FMaterial const*, AnonymousPool> mAnonymousMaterialInstances;
 };
 
 } // namespace filament

filament/src/PostProcessManager.cpp

@@ -225,7 +225,6 @@ const PostProcessManager::JitterSequence<32>
 
 PostProcessManager::PostProcessManager(FEngine& engine) noexcept
         : mEngine(engine),
-          mFixedMaterialInstanceIndex {},
           mWorkaroundSplitEasu(false),
           mWorkaroundAllowReadOnlyAncillaryFeedbackLoop(false) {
     // don't use Engine here, it's not fully initialized yet
@@ -455,7 +454,6 @@ Handle<HwTexture> PostProcessManager::getZeroTextureArray() const {
 
 void PostProcessManager::resetForRender() {
     mMaterialInstanceManager.reset();
-    mFixedMaterialInstanceIndex = {};
 }
 
 void PostProcessManager::unbindAllDescriptorSets(DriverApi& driver) noexcept {
@@ -2552,11 +2550,7 @@ void PostProcessManager::colorGradingSubpass(DriverApi& driver,
     auto const& material = getPostProcessMaterial("colorGradingAsSubpass");
     FMaterial const* const ma = material.getMaterial(mEngine, driver, variant);
     // the UBO has been set and committed in colorGradingPrepareSubpass()
-    int32_t const fixedIndex = colorGradingConfig.translucent
-                                       ? mFixedMaterialInstanceIndex.colorGradingTranslucent
-                                       : mFixedMaterialInstanceIndex.colorGradingOpaque;
-
-    FMaterialInstance const* mi = mMaterialInstanceManager.getMaterialInstance(ma, fixedIndex);
+    FMaterialInstance const* mi = mMaterialInstanceManager.getMaterialInstance(ma, colorGradingConfig.translucent);
     mi->use(driver);
     auto const pipeline = getPipelineState(ma, variant);
     driver.nextSubpass();
@@ -2567,8 +2561,7 @@ void PostProcessManager::colorGradingSubpass(DriverApi& driver,
 void PostProcessManager::customResolvePrepareSubpass(DriverApi& driver, CustomResolveOp const op) noexcept {
     auto const& material = getPostProcessMaterial("customResolveAsSubpass");
     auto const ma = material.getMaterial(mEngine, driver, PostProcessVariant::OPAQUE);
-    auto [mi, fixedIndex] = mMaterialInstanceManager.getFixedMaterialInstance(ma);
-    mFixedMaterialInstanceIndex.customResolve = fixedIndex;
+    auto* const mi = mMaterialInstanceManager.getMaterialInstance(ma, 0);
     mi->setParameter("direction", op == CustomResolveOp::COMPRESS ? 1.0f : -1.0f),
     mi->commit(driver, getUboManager());
 }
@@ -2580,8 +2573,7 @@ void PostProcessManager::customResolveSubpass(DriverApi& driver) noexcept {
     auto const& material = getPostProcessMaterial("customResolveAsSubpass");
     FMaterial const* const ma = material.getMaterial(mEngine, driver);
     // the UBO has been set and committed in customResolvePrepareSubpass()
-    FMaterialInstance const* mi = mMaterialInstanceManager.getMaterialInstance(ma,
-            mFixedMaterialInstanceIndex.customResolve);
+    FMaterialInstance const* mi = mMaterialInstanceManager.getMaterialInstance(ma, 0);
     mi->use(driver);
 
     auto const pipeline = getPipelineState(ma);
@@ -2620,9 +2612,8 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::customResolveUncompressPass(
 void PostProcessManager::clearAncillaryBuffersPrepare(DriverApi& driver,
         Variant::type_t variant) noexcept {
     auto const& material = getPostProcessMaterial("clearDepth");
-    auto ma = material.getMaterial(mEngine, driver, variant);
-    auto [mi, fixedIndex] = mMaterialInstanceManager.getFixedMaterialInstance(ma);
-    mFixedMaterialInstanceIndex.clearDepth = fixedIndex;
+    auto const ma = material.getMaterial(mEngine, driver, variant);
+    auto const mi = mMaterialInstanceManager.getMaterialInstance(ma, 0);
     mi->commit(driver, getUboManager());
 }
 
@@ -2640,8 +2631,7 @@ void PostProcessManager::clearAncillaryBuffers(DriverApi& driver,
     FMaterial const* const ma = material.getMaterial(mEngine, driver, variant);
 
     // the UBO has been set and committed in clearAncillaryBuffersPrepare()
-    FMaterialInstance const* const mi = mMaterialInstanceManager.getMaterialInstance(ma,
-            mFixedMaterialInstanceIndex.clearDepth);
+    FMaterialInstance const* const mi = mMaterialInstanceManager.getMaterialInstance(ma, 0);
     mi->use(driver);
 
     auto pipeline = getPipelineState(ma, variant);
@@ -2960,11 +2950,7 @@ FMaterialInstance* PostProcessManager::configureColorGradingMaterial(backend::Dr
                                                ? PostProcessVariant::TRANSLUCENT
                                                : PostProcessVariant::OPAQUE;
     ma = material.getMaterial(mEngine, driver, variant);
-    FMaterialInstance* mi = nullptr;
-    int32_t& fixedIndex = colorGradingConfig.translucent
-                                  ? mFixedMaterialInstanceIndex.colorGradingTranslucent
-                                  : mFixedMaterialInstanceIndex.colorGradingOpaque;
-    std::tie(mi, fixedIndex) = mMaterialInstanceManager.getFixedMaterialInstance(ma);
+    FMaterialInstance* mi = mMaterialInstanceManager.getMaterialInstance(ma, colorGradingConfig.translucent);
 
     const SamplerParams params = SamplerParams{
             .filterMag = SamplerMagFilter::LINEAR,
@@ -3823,15 +3809,13 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::vsmMipmapPass(FrameGraph& fg
                 auto const& inDesc = resources.getDescriptor(data.in);
                 auto width = inDesc.width;
                 assert_invariant(width == inDesc.height);
-                int const dim = width >> (level + 1);
+                uint32_t const dim = std::max(1u, width >> (level + 1));
 
                 auto& material = getPostProcessMaterial("vsmMipmap");
                 FMaterial const* const ma = material.getMaterial(mEngine, driver);
 
-                // When generating shadow map mip levels, we want to preserve the 1 texel border.
-                // (note clearing never respects the scissor in Filament)
                 auto const pipeline = getPipelineState(ma);
-                backend::Viewport const scissor = { 1u, 1u, dim - 2u, dim - 2u };
+                backend::Viewport const scissor = { 0, 0, dim, dim };
 
                 FMaterialInstance* const mi = getMaterialInstance(ma);
                 mi->setParameter("color", in, SamplerParams{

filament/src/PostProcessManager.h

@@ -486,13 +486,6 @@ private:
 
     MaterialInstanceManager mMaterialInstanceManager;
 
-    struct {
-        int32_t colorGradingTranslucent = MaterialInstanceManager::INVALID_FIXED_INDEX;
-        int32_t colorGradingOpaque = MaterialInstanceManager::INVALID_FIXED_INDEX;
-        int32_t customResolve = MaterialInstanceManager::INVALID_FIXED_INDEX;
-        int32_t clearDepth = MaterialInstanceManager::INVALID_FIXED_INDEX;
-    } mFixedMaterialInstanceIndex;
-
     backend::Handle<backend::HwTexture> mStarburstTexture;
 
     std::uniform_real_distribution<float> mUniformDistribution{0.0f, 1.0f};

filament/src/ShadowMap.cpp

@@ -62,6 +62,8 @@ ShadowMap::ShadowMap(FEngine& engine) noexcept
         : mPerShadowMapUniforms(engine),
           mShadowType(ShadowType::DIRECTIONAL),
           mHasVisibleShadows(false),
+          mVsm(false),
+          mReservedBit(false),
           mFace(0) {
     Entity entities[2];
     engine.getEntityManager().create(2, entities);
@@ -85,7 +87,7 @@ void ShadowMap::terminate(FEngine& engine) {
 
 ShadowMap::~ShadowMap() = default;
 
-void ShadowMap::initialize(size_t const lightIndex, ShadowType const shadowType,
+void ShadowMap::initialize(size_t const lightIndex, ShadowType const shadowType, bool const vsm,
         uint16_t const shadowIndex, uint8_t const face,
         LightManager::ShadowOptions const* options) {
     mLightIndex = lightIndex;
@@ -93,6 +95,7 @@ void ShadowMap::initialize(size_t const lightIndex, ShadowType const shadowType,
     mOptions = options;
     mShadowType = shadowType;
     mFace = face;
+    mVsm = vsm;
 }
 
 mat4f ShadowMap::getDirectionalLightViewMatrix(float3 direction, float3 up,
@@ -1181,9 +1184,8 @@ float2 ShadowMap::texelSizeWorldSpace(mat4f const& S, uint16_t const shadowDimen
     return s;
 }
 
-template<typename Casters, typename Receivers>
-void ShadowMap::visitScene(const FScene& scene, uint32_t const visibleLayers,
-        Casters casters, Receivers receivers) noexcept {
+template<typename Visitor>
+void ShadowMap::visitScene(const FScene& scene, uint32_t const visibleLayers, Visitor visitor) noexcept {
     FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
 
     using State = FRenderableManager::Visibility;
@@ -1196,14 +1198,11 @@ void ShadowMap::visitScene(const FScene& scene, uint32_t const visibleLayers,
     size_t const c = soa.size();
     for (size_t i = 0; i < c; i++) {
         if (layers[i] & visibleLayers) {
-            const Aabb aabb{ worldAABBCenter[i] - worldAABBExtent[i],
-                             worldAABBCenter[i] + worldAABBExtent[i] };
-            if (visibility[i].castShadows) {
-                casters(aabb, visibleMasks[i]);
-            }
-            if (visibility[i].receiveShadows) {
-                receivers(aabb, visibleMasks[i]);
-            }
+            Aabb const aabb{
+                worldAABBCenter[i] - worldAABBExtent[i],
+                worldAABBCenter[i] + worldAABBExtent[i]
+            };
+            visitor(aabb, visibleMasks[i], visibility[i]);
         }
     }
 }
@@ -1222,13 +1221,15 @@ ShadowMap::SceneInfo::SceneInfo(
     wsShadowCastersVolume = {};
     wsShadowReceiversVolume = {};
     visitScene(scene, visibleLayers,
-            [&](Aabb caster, Culler::result_type) {
-                wsShadowCastersVolume.min = min(wsShadowCastersVolume.min, caster.min);
-                wsShadowCastersVolume.max = max(wsShadowCastersVolume.max, caster.max);
-            },
-            [&](Aabb receiver, Culler::result_type) {
-                wsShadowReceiversVolume.min = min(wsShadowReceiversVolume.min, receiver.min);
-                wsShadowReceiversVolume.max = max(wsShadowReceiversVolume.max, receiver.max);
+            [this](Aabb const& aabb, Culler::result_type, FRenderableManager::Visibility const visibility) {
+                if (visibility.castShadows) {
+                    wsShadowCastersVolume.min = min(wsShadowCastersVolume.min, aabb.min);
+                    wsShadowCastersVolume.max = max(wsShadowCastersVolume.max, aabb.max);
+                }
+                if (visibility.receiveShadows) {
+                    wsShadowReceiversVolume.min = min(wsShadowReceiversVolume.min, aabb.min);
+                    wsShadowReceiversVolume.max = max(wsShadowReceiversVolume.max, aabb.max);
+                }
             }
     );
 }
@@ -1242,18 +1243,20 @@ void ShadowMap::updateSceneInfoDirectional(mat4f const& Mv, FScene const& scene,
     sceneInfo.lsCastersNearFar = { std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max() };
     sceneInfo.lsReceiversNearFar = { std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max() };
     visitScene(scene, sceneInfo.visibleLayers,
-            [&](Aabb caster, Culler::result_type) {
-                auto r = Aabb::transform(Mv.upperLeft(), Mv[3].xyz, caster);
-                sceneInfo.lsCastersNearFar.x = max(sceneInfo.lsCastersNearFar.x, r.max.z);
-                sceneInfo.lsCastersNearFar.y = min(sceneInfo.lsCastersNearFar.y, r.min.z);
-            },
-            [&](Aabb receiver, Culler::result_type const vis) {
-                // account only for objects that are visible by the camera
-                auto mask = 1u << VISIBLE_RENDERABLE_BIT;
-                if ((vis & mask) == mask) {
-                    auto r = Aabb::transform(Mv.upperLeft(), Mv[3].xyz, receiver);
-                    sceneInfo.lsReceiversNearFar.x = max(sceneInfo.lsReceiversNearFar.x, r.max.z);
-                    sceneInfo.lsReceiversNearFar.y = min(sceneInfo.lsReceiversNearFar.y, r.min.z);
+            [&](Aabb const& aabb, Culler::result_type const vis, FRenderableManager::Visibility const visibility) {
+                if (visibility.castShadows) {
+                    auto const r = Aabb::transform(Mv.upperLeft(), Mv[3].xyz, aabb);
+                    sceneInfo.lsCastersNearFar.x = max(sceneInfo.lsCastersNearFar.x, r.max.z);
+                    sceneInfo.lsCastersNearFar.y = min(sceneInfo.lsCastersNearFar.y, r.min.z);
+                }
+                if (visibility.castShadows) {
+                    // account only for objects that are visible by the camera
+                    constexpr auto mask = 1u << VISIBLE_RENDERABLE_BIT;
+                    if ((vis & mask) == mask) {
+                        auto r = Aabb::transform(Mv.upperLeft(), Mv[3].xyz, aabb);
+                        sceneInfo.lsReceiversNearFar.x = max(sceneInfo.lsReceiversNearFar.x, r.max.z);
+                        sceneInfo.lsReceiversNearFar.y = min(sceneInfo.lsReceiversNearFar.y, r.min.z);
+                    }
                 }
             }
     );
@@ -1268,15 +1271,15 @@ void ShadowMap::updateSceneInfoSpot(mat4f const& Mv, FScene const& scene,
     sceneInfo.lsCastersNearFar = { std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max() };
     // account only for objects that are visible by both the camera and the light
     visitScene(scene, sceneInfo.visibleLayers,
-            [&](Aabb caster, Culler::result_type const vis) {
-                auto mask = VISIBLE_DYN_SHADOW_RENDERABLE;
-                if ((vis & mask) == mask) {
-                    auto r = Aabb::transform(Mv.upperLeft(), Mv[3].xyz, caster);
-                    sceneInfo.lsCastersNearFar.x = std::max(sceneInfo.lsCastersNearFar.x, r.max.z);  // near
-                    sceneInfo.lsCastersNearFar.y = std::min(sceneInfo.lsCastersNearFar.y, r.min.z);  // far
+            [&](Aabb const& aabb, Culler::result_type const vis, FRenderableManager::Visibility const visibility) {
+                if (visibility.castShadows) {
+                    constexpr auto mask = VISIBLE_DYN_SHADOW_RENDERABLE;
+                    if ((vis & mask) == mask) {
+                        auto const r = Aabb::transform(Mv.upperLeft(), Mv[3].xyz, aabb);
+                        sceneInfo.lsCastersNearFar.x = std::max(sceneInfo.lsCastersNearFar.x, r.max.z);  // near
+                        sceneInfo.lsCastersNearFar.y = std::min(sceneInfo.lsCastersNearFar.y, r.min.z);  // far
+                    }
                 }
-            },
-            [&](Aabb receiver, Culler::result_type) {
             }
     );
 }
@@ -1286,47 +1289,56 @@ void ShadowMap::setAllocation(uint8_t const layer, backend::Viewport viewport) n
 }
 
 backend::Viewport ShadowMap::getViewport() const noexcept {
-    // We set a viewport with a 1-texel border for when we index outside the texture.
-    // This happens only for directional lights when "focus shadow casters" is used,
-    // or when shadowFar is smaller than the camera far.
-    // For spot- and point-lights we also use a 1-texel border, so that bilinear filtering
-    // can work properly if the shadowmap is in an atlas (and we can't rely on h/w clamp).
+    // This is used for calculating the light space; in particular, if the shadowmap is in a 2D atlas, this
+    // returns the valid area of the shadowmap. By definition all values must be integer.
+
+    // We set a viewport with a 1-texel border for when we index outside the texture, which should only happen for
+    // directional lights when "focus shadow casters" is used, or when shadowFar is smaller than the camera far.
+    // For directional lights, the border is filed with "fully lit".
+    //
+    // For point-lights, we also use a 1-texel border, but for a different reason; the border is filled with data
+    // so that bilinear (PCF) filtering works properly.
+    //
+    // Spot-light a treated like point lights (the border will be filled with "fully-lit" anyways)
+
     const uint32_t dim = mOptions->mapSize;
     const uint16_t border = 1u;
     return { mOffset.x + border, mOffset.y + border, dim - 2u * border, dim - 2u * border };
 }
 
 backend::Viewport ShadowMap::getScissor() const noexcept {
-    // We set a viewport with a 1-texel border for when we index outside the texture.
-    // This happens only for directional lights when "focus shadow casters" is used,
-    // or when shadowFar is smaller than the camera far.
-    // For spot- and point-lights we also use a 1-texel border, so that bilinear filtering
-    // can work properly if the shadowmap is in an atlas (and we can't rely on h/w clamp), so we
-    // don't scissor the border, so it gets filled with correct neighboring texels.
+    // This is used while rendering the shadowmap.
+
     const uint32_t dim = mOptions->mapSize;
     const uint16_t border = 1u;
-    switch (mShadowType) {
-        case ShadowType::DIRECTIONAL:
-            return { mOffset.x + border, mOffset.y + border, dim - 2u * border, dim - 2u * border };
+    switch (mShadowType) { // NOLINT(*-multiway-paths-covered)
+        case ShadowType::DIRECTIONAL: {
+            // Don't render anything into the border; it's already filled with "fully lit".
+            return {mOffset.x + border, mOffset.y + border, dim - 2u * border, dim - 2u * border};
+        }
         case ShadowType::SPOT:
-        case ShadowType::POINT:
-            return { mOffset.x, mOffset.y, dim, dim };
+        case ShadowType::POINT: {
+            // Render into the border (which will get the adjacent faces texels)
+            return {mOffset.x, mOffset.y, dim, dim};
+        }
     }
+    return {};
 }
 
 float4 ShadowMap::getClampToEdgeCoords(ShadowMapInfo const& shadowMapInfo) const noexcept {
-    float border; // shadowmap border in texels
-    switch (mShadowType) {
+    // This is used to clamp the texture coordinates when sampling the shadowmap
+
+    float border = 0; // shadowmap border in texels
+    switch (mShadowType) { // NOLINT(*-multiway-paths-covered)
         case ShadowType::DIRECTIONAL:
-            // For directional lights, we need to allow the sampling to reach the border, it
-            // happens when "focus shadow casters" is used for instance.
+            // For directional lights, we need to allow the sampling to reach the center of border texels,
+            // but no further, so we don't read into the adjacent texture in the 2D atlas (taking bilinear filtering
+            // into account).
             border = 0.5f;
             break;
         case ShadowType::SPOT:
         case ShadowType::POINT:
-            // For spot and point light, this is equal to the viewport. i.e. the valid
-            // texels are inside the viewport (w/ 1-texel border), the border will be used
-            // for bilinear filtering.
+            // For point-light, the border is only needed for bilinear filtering (of the other faces)
             border = 1.0f;
             break;
     }
@@ -1355,8 +1367,8 @@ void ShadowMap::prepareCamera(Transaction const& transaction,
 }
 
 void ShadowMap::prepareViewport(Transaction const& transaction,
-        backend::Viewport const& viewport) noexcept {
-    ShadowMapDescriptorSet::prepareViewport(transaction, viewport);
+        backend::Viewport const& physicalViewport, backend::Viewport const& logicalViewport) noexcept {
+    ShadowMapDescriptorSet::prepareViewport(transaction, physicalViewport, logicalViewport);
 }
 
 void ShadowMap::prepareTime(Transaction const& transaction,
@@ -1370,8 +1382,8 @@ void ShadowMap::prepareMaterialGlobals(Transaction const& transaction,
 }
 
 void ShadowMap::prepareShadowMapping(Transaction const& transaction,
-        bool const highPrecision) noexcept {
-    ShadowMapDescriptorSet::prepareShadowMapping(transaction, highPrecision);
+        float const vsmExponent, float const vsmMaxMoment) noexcept {
+    ShadowMapDescriptorSet::prepareShadowMapping(transaction, vsmExponent, vsmMaxMoment);
 }
 
 ShadowMapDescriptorSet::Transaction ShadowMap::open(DriverApi& driver) noexcept {

filament/src/ShadowMap.h

@@ -128,7 +128,7 @@ public:
     static math::mat4f getPointLightViewMatrix(backend::TextureCubemapFace face,
             math::float3 position) noexcept;
 
-    void initialize(size_t lightIndex, ShadowType shadowType, uint16_t shadowIndex, uint8_t face,
+    void initialize(size_t lightIndex, ShadowType shadowType, bool vsm, uint16_t shadowIndex, uint8_t face,
             LightManager::ShadowOptions const* options);
 
     struct ShaderParameters {
@@ -173,7 +173,10 @@ public:
     static void updateSceneInfoSpot(const math::mat4f& Mv, FScene const& scene,
             SceneInfo& sceneInfo);
 
-    LightManager::ShadowOptions const* getShadowOptions() const noexcept { return mOptions; }
+    LightManager::ShadowOptions const& getShadowOptions() const noexcept {
+            assert_invariant(mOptions);
+            return *mOptions;
+    }
     size_t getLightIndex() const { return mLightIndex; }
     uint16_t getShadowIndex() const { return mShadowIndex; }
     void setAllocation(uint8_t layer, backend::Viewport viewport) noexcept;
@@ -193,13 +196,13 @@ public:
     static void prepareCamera(Transaction const& transaction,
             FEngine const& engine, const CameraInfo& cameraInfo) noexcept;
     static void prepareViewport(Transaction const& transaction,
-            backend::Viewport const& viewport) noexcept;
+            backend::Viewport const& physicalViewport, backend::Viewport const& logicalViewport) noexcept;
     static void prepareTime(Transaction const& transaction,
             FEngine const& engine, math::float4 const& userTime) noexcept;
     static void prepareMaterialGlobals(Transaction const& transaction,
             std::array<math::float4, 4> const& materialGlobals) noexcept;
     static void prepareShadowMapping(Transaction const& transaction,
-            bool highPrecision) noexcept;
+            float vsmExponent, float vsmMaxMoment) noexcept;
     static ShadowMapDescriptorSet::Transaction open(backend::DriverApi& driver) noexcept;
     void commit(Transaction& transaction, FEngine& engine, backend::DriverApi& driver) const noexcept;
     void bind(backend::DriverApi& driver) const noexcept;
@@ -273,9 +276,8 @@ private:
     static inline math::float4 computeBoundingSphere(
             math::float3 const* vertices, size_t count) noexcept;
 
-    template<typename Casters, typename Receivers>
-    static void visitScene(FScene const& scene, uint32_t visibleLayers,
-            Casters casters, Receivers receivers) noexcept;
+    template<typename Visitor>
+    static void visitScene(FScene const& scene, uint32_t visibleLayers, Visitor visitor) noexcept;
 
     static inline Aabb compute2DBounds(const math::mat4f& lightView,
             math::float3 const* wsVertices, size_t count) noexcept;
@@ -349,9 +351,11 @@ private:
     uint8_t mLayer = 0;         // our layer in the shadowMap texture       // 1
     ShadowType mShadowType  : 2;                                            // :2
     bool mHasVisibleShadows : 1;                                            // :1
+    bool mVsm               : 1;                                            // :1
+    UTILS_UNUSED bool mReservedBit : 1;                                     // :1
     uint8_t mFace           : 3;                                            // :3
     math::ushort2 mOffset{};                                                // 4
-    UTILS_UNUSED uint8_t reserved[4];                                       // 4
+    UTILS_UNUSED uint8_t reserved[4] = {};                                  // 4
 };
 
 } // namespace filament

filament/src/ShadowMapManager.cpp

@@ -151,12 +151,14 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::update(
 
     mDirectionalShadowMapCount = builder.mDirectionalShadowMapCount;
     mSpotShadowMapCount = builder.mSpotShadowMapCount;
+    const bool vsm = view.hasVSM();
 
     for (auto const& entry : builder.mShadowMaps) {
         auto& shadowMap = getShadowMap(entry.shadowIndex);
         shadowMap.initialize(
                 entry.lightIndex,
                 entry.shadowType,
+                vsm,
                 entry.shadowIndex,
                 entry.face,
                 entry.options);
@@ -230,15 +232,12 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
         FView& view, CameraInfo const& mainCameraInfo,
         float4 const& userTime) noexcept {
 
-    const float moment2 = std::numeric_limits<half>::max();
-    const float moment1 = std::sqrt(moment2);
-    const float4 vsmClearColor{ moment1, moment2, -moment1, moment2 };
-
     FScene* scene = view.getScene();
     assert_invariant(scene);
 
     // make a copy here, because it's a very small structure
-    const TextureAtlasRequirements textureRequirements = mTextureAtlasRequirements;
+    VsmShadowOptions const& vsmShadowOptions = view.getVsmShadowOptions();
+    TextureAtlasRequirements const textureRequirements = mTextureAtlasRequirements;
     assert_invariant(textureRequirements.layers <= CONFIG_MAX_SHADOW_LAYERS);
 
     // -------------------------------------------------------------------------------------------
@@ -258,8 +257,6 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
         utils::FixedCapacityVector<ShadowPass> passList;
     };
 
-    VsmShadowOptions const& vsmShadowOptions = view.getVsmShadowOptions();
-
     auto& prepareShadowPass = fg.addPass<PrepareShadowPassData>("Prepare Shadow Pass",
             [&](FrameGraph::Builder& builder, auto& data) {
                 data.passList.reserve(getMaxShadowMapCount());
@@ -392,16 +389,18 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
 
                     auto transaction = ShadowMap::open(driver);
                     ShadowMap::prepareCamera(transaction, engine, cameraInfo);
-                    ShadowMap::prepareViewport(transaction, shadowMap.getViewport());
+                    ShadowMap::prepareViewport(transaction,
+                            { 0, 0, textureRequirements.size, textureRequirements.size },
+                            shadowMap.getViewport());
                     ShadowMap::prepareTime(transaction, engine, userTime);
                     ShadowMap::prepareMaterialGlobals(transaction, view.getMaterialGlobals());
                     ShadowMap::prepareShadowMapping(transaction,
-                            vsmShadowOptions.highPrecision);
+                            getWrapExponentEVSM(vsmShadowOptions, shadowMap.getShadowOptions()),
+                            getMaxMomentEVSM(vsmShadowOptions));
                     shadowMap.commit(transaction, engine, driver);
 
                     // updatePrimitivesLod must be run before RenderPass::appendCommands.
-                    FView::updatePrimitivesLod(scene->getRenderableData(),
-                            engine, cameraInfo, entry.range);
+                    FView::updatePrimitivesLod(scene->getRenderableData(), engine, cameraInfo, entry.range);
 
                     // generate and sort the commands for rendering the shadow map
 
@@ -430,10 +429,10 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
                     entry.executor = pass.getExecutor();
 
                     if (!view.hasVSM()) {
-                        auto const* options = shadowMap.getShadowOptions();
+                        auto const& options = shadowMap.getShadowOptions();
                         PolygonOffset const polygonOffset = { // handle reversed Z
-                                .slope    = -options->polygonOffsetSlope,
-                                .constant = -options->polygonOffsetConstant
+                                .slope    = -options.polygonOffsetSlope,
+                                .constant = -options.polygonOffsetConstant
                         };
                         entry.executor.overridePolygonOffset(&polygonOffset);
                     }
@@ -465,10 +464,10 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
         auto const& entry = *first;
 
         const uint8_t layer = entry.shadowMap->getLayer();
-        const auto* options = entry.shadowMap->getShadowOptions();
+        const auto& options = entry.shadowMap->getShadowOptions();
         const auto msaaSamples = textureRequirements.msaaSamples;
         const bool blur = entry.shadowMap->hasVisibleShadows() &&
-                view.hasVSM() && options->vsm.blurWidth > 0.0f;
+                view.hasVSM() && options.vsm.blurWidth > 0.0f;
 
         auto last = first;
         // loop over each shadow pass to find its layer range
@@ -508,10 +507,9 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
 
                         renderTargetDesc.attachments.color[0] = data.output;
                         renderTargetDesc.attachments.depth = depth;
-                        renderTargetDesc.clearFlags =
-                                TargetBufferFlags::COLOR | TargetBufferFlags::DEPTH;
+                        renderTargetDesc.clearFlags = TargetBufferFlags::COLOR | TargetBufferFlags::DEPTH;
                         // we need to clear the shadow map with the max EVSM moments
-                        renderTargetDesc.clearColor = vsmClearColor;
+                        renderTargetDesc.clearColor = textureRequirements.clearColor;
                         renderTargetDesc.samples = msaaSamples;
 
                         if (UTILS_UNLIKELY(blur)) {
@@ -530,16 +528,14 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
                                     .attachments = {
                                             .color = { data.tempBlurSrc },
                                             .depth = depth },
-                                    .clearColor = vsmClearColor,
+                                    .clearColor = textureRequirements.clearColor,
                                     .samples = msaaSamples,
-                                    .clearFlags = TargetBufferFlags::COLOR
-                                            | TargetBufferFlags::DEPTH
+                                    .clearFlags = TargetBufferFlags::COLOR | TargetBufferFlags::DEPTH
                             });
                         }
                     } else {
                         // the shadowmap layer
-                        data.output = builder.write(data.output,
-                                FrameGraphTexture::Usage::DEPTH_ATTACHMENT);
+                        data.output = builder.write(data.output, FrameGraphTexture::Usage::DEPTH_ATTACHMENT);
                         renderTargetDesc.attachments.depth = data.output;
                         renderTargetDesc.clearFlags = TargetBufferFlags::DEPTH;
                     }
@@ -594,27 +590,27 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
             //        the whole layer. Blurring should happen per shadowmap, not for the whole
             //        layer.
 
-            const float blurWidth = options->vsm.blurWidth;
+            // FIXME: this Gaussian blur is not precise enough for EVSM
+
+            const float blurWidth = options.vsm.blurWidth;
             if (blurWidth > 0.0f) {
                 const float sigma = (blurWidth + 1.0f) / 6.0f;
-                size_t kernelWidth = std::ceil((blurWidth - 5.0f) / 4.0f);
+                size_t kernelWidth = size_t(std::ceil((blurWidth - 5.0f) / 4.0f));
                 kernelWidth = kernelWidth * 4 + 5;
                 ppm.gaussianBlurPass(fg,
                         shadowPass->tempBlurSrc,
                         shadowPass->output,
                         false, kernelWidth, sigma);
             }
+        }
 
-            // FIXME: mipmapping here is broken because it'll access texels from adjacent
-            //        shadow maps.
-
-            // If the shadow texture has more than one level, mipmapping was requested, either directly
-            // or indirectly via anisotropic filtering.
-            // So generate the mipmaps for each layer
-            if (textureRequirements.levels > 1) {
-                for (size_t level = 0; level < textureRequirements.levels - 1; level++) {
-                    ppm.vsmMipmapPass(fg, prepareShadowPass->shadows, layer, level, vsmClearColor);
-                }
+        // If the shadow texture has more than one level, mipmapping was requested, either directly
+        // or indirectly via anisotropic filtering.
+        // So generate the mipmaps for each layer
+        if (UTILS_UNLIKELY(textureRequirements.levels > 1)) {
+            auto& ppm = engine.getPostProcessManager();
+            for (size_t level = 0; level < textureRequirements.levels - 1; level++) {
+                ppm.vsmMipmapPass(fg, prepareShadowPass->shadows, layer, level, textureRequirements.clearColor);
             }
         }
     }
@@ -626,7 +622,8 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng
         FView& view, CameraInfo cameraInfo, FScene::RenderableSoa& renderableData,
         FScene::LightSoa const& lightData, ShadowMap::SceneInfo sceneInfo) noexcept {
 
-    FScene* scene = view.getScene();
+    FScene const* const scene = view.getScene();
+    auto const& vsmShadowOptions = view.getVsmShadowOptions();
     auto& lcm = engine.getLightManager();
 
     FLightManager::Instance const directionalLight = lightData.elementAt<FScene::LIGHT_INSTANCE>(0);
@@ -650,7 +647,7 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng
     };
 
     bool hasVisibleShadows = false;
-    utils::Slice<ShadowMap> cascadedShadowMaps = getCascadedShadowMap();
+    utils::Slice<ShadowMap> const cascadedShadowMaps = getCascadedShadowMap();
     if (!cascadedShadowMaps.empty()) {
         // Even if we have more than one cascade, we cull directional shadow casters against the
         // entire camera frustum, as if we only had a single cascade.
@@ -750,6 +747,7 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng
                 s.shadows[shadowIndex].scissorNormalized = shaderParameters.scissorNormalized;
                 s.shadows[shadowIndex].normalBias = wsTexelSize * normalBias;
                 s.shadows[shadowIndex].elvsm = options.vsm.elvsm;
+                s.shadows[shadowIndex].vsmExponent = getWrapExponentEVSM(vsmShadowOptions, options);
                 s.shadows[shadowIndex].bulbRadiusLs =
                         mSoftShadowOptions.penumbraScale * options.shadowBulbRadius / length(wsTexelSize);
 
@@ -801,10 +799,8 @@ void ShadowMapManager::updateSpotVisibilityMasks(
         const bool visSpotShadowRenderable = v.castShadows && inVisibleLayer &&
                 (!v.culling || (mask & VISIBLE_DYN_SHADOW_RENDERABLE));
 
-        using Type = Culler::result_type;
-
-        visibleMask[i] &= ~Type(VISIBLE_DYN_SHADOW_RENDERABLE);
-        visibleMask[i] |= Type(visSpotShadowRenderable << VISIBLE_DYN_SHADOW_RENDERABLE_BIT);
+        visibleMask[i] &= ~Culler::result_type(VISIBLE_DYN_SHADOW_RENDERABLE);
+        visibleMask[i] |= Culler::result_type(visSpotShadowRenderable << VISIBLE_DYN_SHADOW_RENDERABLE_BIT);
     }
 }
 
@@ -813,13 +809,14 @@ void ShadowMapManager::prepareSpotShadowMap(ShadowMap& shadowMap, FEngine& engin
         FScene::LightSoa const& lightData, ShadowMap::SceneInfo const& sceneInfo) noexcept {
 
     const size_t lightIndex = shadowMap.getLightIndex();
-    FLightManager::ShadowOptions const* const options = shadowMap.getShadowOptions();
+    FLightManager::ShadowOptions const& options = shadowMap.getShadowOptions();
+    auto const& vsmShadowOptions = view.getVsmShadowOptions();
 
     // update the shadow map frustum/camera
     const ShadowMap::ShadowMapInfo shadowMapInfo{
             .atlasDimension      = mTextureAtlasRequirements.size,
-            .textureDimension    = uint16_t(options->mapSize),
-            .shadowDimension     = uint16_t(options->mapSize - 2u),
+            .textureDimension    = uint16_t(options.mapSize),
+            .shadowDimension     = uint16_t(options.mapSize - 2u),
             .textureSpaceFlipped = engine.getBackend() == Backend::METAL ||
                                    engine.getBackend() == Backend::VULKAN ||
                                    engine.getBackend() == Backend::WEBGPU,
@@ -834,7 +831,7 @@ void ShadowMapManager::prepareSpotShadowMap(ShadowMap& shadowMap, FEngine& engin
         const size_t shadowIndex = shadowMap.getShadowIndex();
         const float2 wsTexelSizeAtOneMeter = shaderParameters.texelSizeAtOneMeterWs;
         // note: normalBias is set to zero for VSM
-        const float normalBias = shadowMapInfo.vsm ? 0.0f : options->normalBias;
+        const float normalBias = shadowMapInfo.vsm ? 0.0f : options.normalBias;
 
         auto& s = mShadowUb.edit();
         const double n = shadowMap.getCamera().getNear();
@@ -845,9 +842,10 @@ void ShadowMapManager::prepareSpotShadowMap(ShadowMap& shadowMap, FEngine& engin
         s.shadows[shadowIndex].normalBias = normalBias * wsTexelSizeAtOneMeter;
         s.shadows[shadowIndex].lightFromWorldZ = shaderParameters.lightFromWorldZ;
         s.shadows[shadowIndex].nearOverFarMinusNear = float(n / (f - n));
-        s.shadows[shadowIndex].elvsm = options->vsm.elvsm;
+        s.shadows[shadowIndex].elvsm = options.vsm.elvsm;
+        s.shadows[shadowIndex].vsmExponent = getWrapExponentEVSM(vsmShadowOptions, options);
         s.shadows[shadowIndex].bulbRadiusLs =
-                mSoftShadowOptions.penumbraScale * options->shadowBulbRadius
+                mSoftShadowOptions.penumbraScale * options.shadowBulbRadius
                         / length(wsTexelSizeAtOneMeter);
 
     }
@@ -905,13 +903,14 @@ void ShadowMapManager::preparePointShadowMap(ShadowMap& shadowMap,
 
     const uint8_t face = shadowMap.getFace();
     const size_t lightIndex = shadowMap.getLightIndex();
-    FLightManager::ShadowOptions const* const options = shadowMap.getShadowOptions();
+    FLightManager::ShadowOptions const& options = shadowMap.getShadowOptions();
+    auto const& vsmShadowOptions = view.getVsmShadowOptions();
 
     // update the shadow map frustum/camera
     const ShadowMap::ShadowMapInfo shadowMapInfo{
             .atlasDimension      = mTextureAtlasRequirements.size,
-            .textureDimension    = uint16_t(options->mapSize),
-            .shadowDimension     = uint16_t(options->mapSize), // point-lights don't have a border
+            .textureDimension    = uint16_t(options.mapSize),
+            .shadowDimension     = uint16_t(options.mapSize), // point-lights don't have a border
             .textureSpaceFlipped = engine.getBackend() == Backend::METAL ||
                                    engine.getBackend() == Backend::VULKAN ||
                                    engine.getBackend() == Backend::WEBGPU,
@@ -926,7 +925,7 @@ void ShadowMapManager::preparePointShadowMap(ShadowMap& shadowMap,
         const size_t shadowIndex = shadowMap.getShadowIndex();
         const float2 wsTexelSizeAtOneMeter = shaderParameters.texelSizeAtOneMeterWs;
         // note: normalBias is set to zero for VSM
-        const float normalBias = shadowMapInfo.vsm ? 0.0f : options->normalBias;
+        const float normalBias = shadowMapInfo.vsm ? 0.0f : options.normalBias;
 
         auto& s = mShadowUb.edit();
         const double n = shadowMap.getCamera().getNear();
@@ -937,9 +936,10 @@ void ShadowMapManager::preparePointShadowMap(ShadowMap& shadowMap,
         s.shadows[shadowIndex].normalBias = normalBias * wsTexelSizeAtOneMeter;
         s.shadows[shadowIndex].lightFromWorldZ = shaderParameters.lightFromWorldZ;
         s.shadows[shadowIndex].nearOverFarMinusNear = float(n / (f - n));
-        s.shadows[shadowIndex].elvsm = options->vsm.elvsm;
+        s.shadows[shadowIndex].elvsm = options.vsm.elvsm;
+        s.shadows[shadowIndex].vsmExponent = getWrapExponentEVSM(vsmShadowOptions, options);
         s.shadows[shadowIndex].bulbRadiusLs =
-                mSoftShadowOptions.penumbraScale * options->shadowBulbRadius
+                mSoftShadowOptions.penumbraScale * options.shadowBulbRadius
                         / length(wsTexelSizeAtOneMeter);
     }
 }
@@ -995,7 +995,7 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateSpotShadowMaps(FEngine
             lightData.data<FScene::SHADOW_INFO>());
 
     ShadowTechnique shadowTechnique{};
-    utils::Slice<const ShadowMap> spotShadowMaps = getSpotShadowMaps();
+    utils::Slice<const ShadowMap> const spotShadowMaps = getSpotShadowMaps();
     if (!spotShadowMaps.empty()) {
         shadowTechnique |= ShadowTechnique::SHADOW_MAP;
         for (ShadowMap const& shadowMap : spotShadowMaps) {
@@ -1035,14 +1035,14 @@ void ShadowMapManager::calculateTextureRequirements(FEngine& engine, FView& view
     for (ShadowMap const& shadowMap : getCascadedShadowMap()) {
         // Shadow map size should be the same for all cascades.
         auto const& options = shadowMap.getShadowOptions();
-        maxDimension = std::max(maxDimension, options->mapSize);
-        elvsm = elvsm || options->vsm.elvsm;
+        maxDimension = std::max(maxDimension, options.mapSize);
+        elvsm = elvsm || options.vsm.elvsm;
     }
 
     for (ShadowMap const& shadowMap : getSpotShadowMaps()) {
         auto const& options = shadowMap.getShadowOptions();
-        maxDimension = std::max(maxDimension, options->mapSize);
-        elvsm = elvsm || options->vsm.elvsm;
+        maxDimension = std::max(maxDimension, options.mapSize);
+        elvsm = elvsm || options.vsm.elvsm;
     }
 
     uint8_t layersNeeded = 0;
@@ -1052,7 +1052,7 @@ void ShadowMapManager::calculateTextureRequirements(FEngine& engine, FView& view
         ShadowMap* pShadowMap) mutable {
         // Allocate shadowmap from our Atlas Allocator
         auto const& options = pShadowMap->getShadowOptions();
-        auto allocation = allocator.allocate(options->mapSize);
+        auto allocation = allocator.allocate(options.mapSize);
         assert_invariant(allocation.isValid());
         assert_invariant(!allocation.viewport.empty());
         pShadowMap->setAllocation(allocation.layer, allocation.viewport);
@@ -1088,6 +1088,7 @@ void ShadowMapManager::calculateTextureRequirements(FEngine& engine, FView& view
         msaaSamples = 1;
     }
 
+    float4 clearColor{};
     TextureFormat format = TextureFormat::DEPTH16;
     if (view.hasVSM()) {
         if (vsmShadowOptions.highPrecision) {
@@ -1095,6 +1096,9 @@ void ShadowMapManager::calculateTextureRequirements(FEngine& engine, FView& view
         } else {
             format = elvsm ? TextureFormat::RGBA16F : TextureFormat::RG16F;
         }
+        const float maxMoment2 = getMaxMomentEVSM(vsmShadowOptions);
+        const float maxMoment1 = std::sqrt(maxMoment2);
+        clearColor = { maxMoment1, maxMoment2, 0, 0 };
     }
 
     mSoftShadowOptions = view.getSoftShadowOptions();
@@ -1116,7 +1120,8 @@ void ShadowMapManager::calculateTextureRequirements(FEngine& engine, FView& view
             layersNeeded,
             mipLevels,
             msaaSamples,
-            format
+            format,
+            clearColor
     };
 }
 

filament/src/ShadowMapManager.h

@@ -47,9 +47,12 @@
 #include <utils/Slice.h>
 
 #include <math/mat4.h>
+#include <math/half.h>
 #include <math/vec4.h>
 
+#include <algorithm>
 #include <array>
+#include <limits>
 #include <memory>
 #include <new>
 #include <type_traits>
@@ -145,6 +148,28 @@ public:
     // for debugging only
     utils::FixedCapacityVector<Camera const*> getDirectionalShadowCameras() const noexcept;
 
+    static float getMaxMomentEVSM(VsmShadowOptions const& vsmShadowOptions) noexcept {
+        return vsmShadowOptions.highPrecision ?
+                std::numeric_limits<float>::max() :
+                float(std::numeric_limits<math::half>::max());
+    }
+
+    static float getMaxWrapExponentEVSM(VsmShadowOptions const& vsmShadowOptions) noexcept {
+        constexpr float low  = 5.2f;  // ~ std::log(std::numeric_limits<math::half>::max()) * 0.5f;
+        constexpr float high = 40.0f; // ~ std::log(std::numeric_limits<float>::max()) * 0.5f;
+        return vsmShadowOptions.highPrecision ? high : low;
+    }
+
+    static float getWrapExponentEVSM(
+            VsmShadowOptions const& vsmShadowOptions,
+            LightManager::ShadowOptions const& options) noexcept {
+        constexpr float ABSOLUTE_FILTER_LIMIT = 42.0f;
+        float const targetExponent = getMaxWrapExponentEVSM(vsmShadowOptions);
+        float const effectiveFilterRadius = std::max(1.0f, options.vsm.blurWidth);
+        float const filterCeiling = ABSOLUTE_FILTER_LIMIT / effectiveFilterRadius;
+        return std::min(targetExponent, filterCeiling);
+    }
+
 private:
     explicit ShadowMapManager(FEngine& engine);
 
@@ -216,6 +241,7 @@ private:
         uint8_t levels = 0;
         uint8_t msaaSamples = 1;
         backend::TextureFormat format = backend::TextureFormat::DEPTH16;
+        math::float4 clearColor{};
     } mTextureAtlasRequirements;
 
     SoftShadowOptions mSoftShadowOptions;

filament/src/details/MaterialInstance.h

@@ -93,6 +93,10 @@ public:
         mHasScissor = true;
     }
 
+    void setScissor(backend::Viewport const& viewport) noexcept {
+        setScissor(viewport.left, viewport.bottom, viewport.width, viewport.height);
+    }
+
     void unsetScissor() noexcept {
         constexpr uint32_t maxvalu = std::numeric_limits<int32_t>::max();
         mScissorRect = { 0, 0, maxvalu, maxvalu };

filament/src/details/View.cpp

@@ -76,6 +76,7 @@
 #include <cmath>
 #include <chrono>
 #include <functional>
+#include <limits>
 #include <memory>
 #include <new>
 #include <ratio>
@@ -1131,8 +1132,6 @@ void FView::prepareShadowMapping() const noexcept {
         uniforms = mShadowMapManager->getShadowMappingUniforms();
     }
 
-    constexpr float low  = 5.54f; // ~ std::log(std::numeric_limits<math::half>::max()) * 0.5f;
-    constexpr float high = 42.0f; // ~ std::log(std::numeric_limits<float>::max()) * 0.5f;
     constexpr uint32_t SHADOW_SAMPLING_RUNTIME_PCF = 0u;
     constexpr uint32_t SHADOW_SAMPLING_RUNTIME_EVSM = 1u;
     constexpr uint32_t SHADOW_SAMPLING_RUNTIME_DPCF = 2u;
@@ -1148,8 +1147,8 @@ void FView::prepareShadowMapping() const noexcept {
             break;
         case ShadowType::VSM:
             s.shadowSamplingType = SHADOW_SAMPLING_RUNTIME_EVSM;
-            s.vsmExponent = mVsmShadowOptions.highPrecision ? high : low;
-            s.vsmDepthScale = mVsmShadowOptions.minVarianceScale * 0.01f * s.vsmExponent;
+            s.vsmExponent = 0; // this is only used when rendering the shadowmap, not when using it
+            s.vsmMaxMoment = ShadowMapManager::getMaxMomentEVSM(mVsmShadowOptions);
             s.vsmLightBleedReduction = mVsmShadowOptions.lightBleedReduction;
             break;
         case ShadowType::DPCF:

filament/src/ds/ShadowMapDescriptorSet.cpp

@@ -28,9 +28,11 @@
 
 #include <utils/debug.h>
 
+#include <math/half.h>
 #include <math/vec4.h>
 
 #include <array>
+#include <limits>
 
 namespace filament {
 
@@ -74,8 +76,8 @@ void ShadowMapDescriptorSet::prepareLodBias(Transaction const& transaction, floa
 }
 
 void ShadowMapDescriptorSet::prepareViewport(Transaction const& transaction,
-        backend::Viewport const& viewport) noexcept {
-    PerViewDescriptorSetUtils::prepareViewport(edit(transaction), viewport, viewport);
+        backend::Viewport const& physicalViewport, backend::Viewport const& logicalViewport) noexcept {
+    PerViewDescriptorSetUtils::prepareViewport(edit(transaction), physicalViewport, logicalViewport);
     // TODO: offset calculation is now different
 }
 
@@ -90,11 +92,10 @@ void ShadowMapDescriptorSet::prepareMaterialGlobals(Transaction const& transacti
 }
 
 void ShadowMapDescriptorSet::prepareShadowMapping(Transaction const& transaction,
-        bool const highPrecision) noexcept {
+        float const vsmExponent, float const vsmMaxMoment) noexcept {
     auto& s = edit(transaction);
-    constexpr float low  = 5.54f; // ~ std::log(std::numeric_limits<math::half>::max()) * 0.5f;
-    constexpr float high = 42.0f; // ~ std::log(std::numeric_limits<float>::max()) * 0.5f;
-    s.vsmExponent = highPrecision ? high : low;
+    s.vsmExponent = vsmExponent;
+    s.vsmMaxMoment = vsmMaxMoment;
 }
 
 ShadowMapDescriptorSet::Transaction ShadowMapDescriptorSet::open(DriverApi& driver) noexcept {

filament/src/ds/ShadowMapDescriptorSet.h

@@ -66,7 +66,7 @@ public:
             float bias) noexcept;
 
     static void prepareViewport(Transaction const& transaction,
-            backend::Viewport const& viewport) noexcept;
+            backend::Viewport const& physicalViewport, backend::Viewport const& logicalViewport) noexcept;
 
     static void prepareTime(Transaction const& transaction,
             FEngine const& engine, math::float4 const& userTime) noexcept;
@@ -75,7 +75,7 @@ public:
             std::array<math::float4, 4> const& materialGlobals) noexcept;
 
     static void prepareShadowMapping(Transaction const& transaction,
-            bool highPrecision) noexcept;
+            float vsmExponent, float vsmMaxMoment) noexcept;
 
     static Transaction open(backend::DriverApi& driver) noexcept;
 

filament/src/materials/vsmMipmap.mat

@@ -19,7 +19,8 @@ material {
         {
             name : color,
             target : color,
-            type : float4
+            type : float4,
+            precision : high
         }
     ],
     domain : postprocess,
@@ -30,8 +31,29 @@ material {
 
 fragment {
     void postProcess(inout PostProcessInputs postProcess) {
-        highp vec2 uv = gl_FragCoord.xy * materialParams.uvscale;
-        postProcess.color = textureLod(materialParams_color,
-                vec3(uv, materialParams.layer), 0.0);
+        // For EVSM mipmapping, we use a custom box filter (instead of the GPU's bilinear filter), because GPUs often
+        // use a lower precision for texture interpolation and EVSM moments are very sensitive to that.
+
+        highp ivec2 destCoord = ivec2(gl_FragCoord.xy);
+        highp ivec3 srcCoord = ivec3(destCoord * 2, materialParams.layer);
+
+#if defined(TARGET_WEBGPU_ENVIRONMENT)
+        // it looks like WebGPU doesn't support texelFetchOffset
+        highp vec4 m0 = texelFetch(materialParams_color, ivec3(srcCoord.xy + ivec2(0, 0), srcCoord.z), 0);
+        highp vec4 m1 = texelFetch(materialParams_color, ivec3(srcCoord.xy + ivec2(1, 0), srcCoord.z), 0);
+        highp vec4 m2 = texelFetch(materialParams_color, ivec3(srcCoord.xy + ivec2(0, 1), srcCoord.z), 0);
+        highp vec4 m3 = texelFetch(materialParams_color, ivec3(srcCoord.xy + ivec2(1, 1), srcCoord.z), 0);
+#else
+        highp vec4 m0 = texelFetchOffset(materialParams_color, srcCoord, 0, ivec2(0, 0));
+        highp vec4 m1 = texelFetchOffset(materialParams_color, srcCoord, 0, ivec2(1, 0));
+        highp vec4 m2 = texelFetchOffset(materialParams_color, srcCoord, 0, ivec2(0, 1));
+        highp vec4 m3 = texelFetchOffset(materialParams_color, srcCoord, 0, ivec2(1, 1));
+#endif
+
+        // Make sure to not overflow the moments when averaging them
+        postProcess.color = (m0 * 0.25) +
+                            (m1 * 0.25) +
+                            (m2 * 0.25) +
+                            (m3 * 0.25);
     }
 }

ios/CocoaPods/Filament.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
   spec.name = "Filament"
-  spec.version = "1.69.4"
+  spec.version = "1.69.5"
   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.69.4/filament-v1.69.4-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.69.5/filament-v1.69.5-ios.tgz" }
 
   spec.libraries = 'c++'
 

libs/filabridge/include/private/filament/UibStructs.h

@@ -166,7 +166,7 @@ struct PerViewUib { // NOLINT(cppcoreguidelines-pro-type-member-init)
     // VSM shadows [variant: VSM]
     // --------------------------------------------------------------------------------------------
     float vsmExponent;
-    float vsmDepthScale;
+    float vsmMaxMoment;
     float vsmLightBleedReduction;
     uint32_t shadowSamplingType;                // 0: vsm, 1: dpcf
 
@@ -302,9 +302,9 @@ struct ShadowUib { // NOLINT(cppcoreguidelines-pro-type-member-init)
         float bulbRadiusLs;                     //  4
         float nearOverFarMinusNear;             //  4
         math::float2 normalBias;                //  4
-        bool elvsm;                             //  4
-        uint32_t layer;                         //  4
-        uint32_t reserved1;                     //  4
+        bool elvsm;                             //  4   // could be 1 bit
+        uint32_t layer;                         //  4   // could be 8 bits
+        float vsmExponent;                      //  4   // could be fp16
         uint32_t reserved2;                     //  4
     };
     ShadowData shadows[CONFIG_MAX_SHADOWMAPS];

libs/filamat/src/shaders/UibGenerator.cpp

@@ -175,7 +175,7 @@ BufferInterfaceBlock const& UibGenerator::getPerViewUib() noexcept  {
             // VSM shadows [variant: VSM]
             // ------------------------------------------------------------------------------------
             { "vsmExponent",             0, Type::FLOAT                  },
-            { "vsmDepthScale",           0, Type::FLOAT                  },
+            { "vsmMaxMoment",            0, Type::FLOAT, Precision::HIGH },
             { "vsmLightBleedReduction",  0, Type::FLOAT                  },
             { "shadowSamplingType",      0, Type::UINT                   },
 

libs/utils/src/JobSystem.cpp

@@ -17,6 +17,7 @@
 // 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.
+#include <cstring>
 #ifndef FILAMENT_TRACING_ENABLED
 // Note: The overhead of TRACING is not negligible especially with parallel_for().
 #define FILAMENT_TRACING_ENABLED false
@@ -98,7 +99,11 @@ namespace utils {
 
 void JobSystem::setThreadName(const char* name) noexcept {
 #if defined(__linux__)
-    pthread_setname_np(pthread_self(), name);
+    constexpr size_t MAX_PTHREAD_NAME_LEN = 16;
+    char buf[MAX_PTHREAD_NAME_LEN];
+    strncpy(buf, name, MAX_PTHREAD_NAME_LEN - 1);
+    buf[MAX_PTHREAD_NAME_LEN - 1] = '\0';
+    pthread_setname_np(pthread_self(), buf);
 #elif defined(__APPLE__)
     pthread_setname_np(name);
 #elif defined(WIN32)

shaders/src/surface_depth_main.fs

@@ -20,7 +20,7 @@ layout(location = 0) out highp uvec2 outPicking;
 // note: VARIANT_HAS_VSM and VARIANT_HAS_PICKING are mutually exclusive
 //------------------------------------------------------------------------------
 
-highp vec2 computeDepthMomentsVSM(const highp float depth);
+highp vec4 computeDepthMomentsVSM(const highp float depth);
 
 void main() {
     filament_lodBias = frameUniforms.lodBias;
@@ -53,9 +53,7 @@ void main() {
     // we always compute the "negative" side of ELVSM because the cost is small, and this allows
     // EVSM/ELVSM choice to be done on the CPU side more easily.
     highp float depth = vertex_worldPosition.w;
-    depth = exp(frameUniforms.vsmExponent * depth);
-    fragColor.xy = computeDepthMomentsVSM(depth);
-    fragColor.zw = computeDepthMomentsVSM(-1.0 / depth); // requires at least RGBA16F
+    fragColor = computeDepthMomentsVSM(depth);
 #elif defined(VARIANT_HAS_PICKING)
 #if FILAMENT_EFFECTIVE_VERSION == 100
     outPicking.a = mod(float(object_uniforms_objectId / 65536), 256.0) / 255.0;
@@ -74,22 +72,30 @@ void main() {
 #endif
 }
 
-highp vec2 computeDepthMomentsVSM(const highp float depth) {
-    // computes the moments
+#if MATERIAL_FEATURE_LEVEL > 0
+
+highp vec4 computeDepthMomentsVSM(const highp float depth) {
     // See GPU Gems 3
     // https://developer.nvidia.com/gpugems/gpugems3/part-ii-light-and-shadows/chapter-8-summed-area-variance-shadow-maps
-    highp vec2 moments;
+    // computes the first two moments
+    float c = frameUniforms.vsmExponent;
+    highp float MAX_MOMENT = frameUniforms.vsmMaxMoment;
 
-    // the first moment is just the depth (average)
-    moments.x = depth;
+    // wrap depth for EVSM
+    highp float z = exp(c * depth);
 
-    // compute the 2nd moment over the pixel extents.
-    moments.y = depth * depth;
+    // compute EVSM moments
+    highp vec2 m1 = vec2(z, -1.0 / z);
+    highp vec2 m2 = m1 * m1;
 
-    // the local linear approximation is not correct with a warped depth
-    //highp float dx = dFdx(depth);
-    //highp float dy = dFdy(depth);
-    //moments.y += 0.25 * (dx * dx + dy * dy);
+    // compute analytic variance (2nd moment), taking into account the change in depth accross the texel
+    highp float dzdx = dFdx(depth);
+    highp float dzdy = dFdy(depth);
+    highp float linearVariance = 0.25 * (dzdx * dzdx + dzdy * dzdy);
+    highp vec2 analyticVariance = c * c * m2 * linearVariance;
+    m2 = min(m2 + analyticVariance, MAX_MOMENT);
 
-    return moments;
+    return vec4(m1.x, m2.x, m1.y, m2.y);
 }
+
+#endif

shaders/src/surface_shadowing.fs

@@ -335,6 +335,91 @@ float ShadowSample_PCSS(const bool DIRECTIONAL,
     return 1.0 - percentageOccluded;
 }
 
+//------------------------------------------------------------------------------
+// VSM
+//------------------------------------------------------------------------------
+
+float chebyshevUpperBound(const highp vec2 moments, const highp float depth,
+        const highp float minVariance, const highp float lbrAmount) {
+    // Fast path: if the receiver is fully in front of the caster
+    if (depth <= moments.x) {
+        return 1.0;
+    }
+
+    // Calculate variance with our dynamically injected floor
+    highp float variance = max(moments.y - (moments.x * moments.x), minVariance);
+
+    // Standard Chebyshev inequality
+    highp float d = depth - moments.x;
+    highp float p_max = variance / (variance + d * d);
+
+    // Apply Light Bleeding Reduction (LBR)
+    return saturate((p_max - lbrAmount) / (1.0 - lbrAmount));
+}
+
+float evaluateEVSM(const bool ELVSM, float c,
+        const highp vec4 moments, const highp float zReceiver,
+        const highp vec2 dzduv, const highp vec2 texelSize) {
+    const highp float EPSILON_MULTIPLIER = 0.002; // could be 0.00001 in fp32
+    float lbrAmount = frameUniforms.vsmLightBleedReduction;
+
+    // Scale the UV-space gradient down to a single shadow map texel footprint.
+    highp vec2 texel_dzduv = dzduv * texelSize;
+
+    // squared magnitude of the linear depth gradient across a single shadow map texel footprint
+    highp float dz2 = dot(texel_dzduv, texel_dzduv);
+
+    // remap depth to [-1, 1]
+    highp float depth = zReceiver * 2.0 - 1.0;
+
+    // positive wrap
+    highp float pw = exp(c * depth);
+    highp float epsilon = EPSILON_MULTIPLIER * (pw * pw);
+    // Dynamic variance for the positive side (derivative of wraped depth w.r.t. light-space depth via Chain Rule)
+    highp float dpwdz = 2.0 * c * pw;
+    highp float pMinVariance = epsilon + 0.25 * (dpwdz * dpwdz) * dz2;
+    float p = chebyshevUpperBound(moments.xy, pw, pMinVariance, lbrAmount);
+
+    // negative wrap
+    if (ELVSM) {
+        highp float nw = -1.0 / pw;
+        highp float epsilon = EPSILON_MULTIPLIER * (nw * nw);
+        // Dynamic variance for the negative side (derivative of wraped depth w.r.t. light-space depth via Chain Rule)
+        highp float dnwdz = 2.0 * c * nw;
+        highp float nMinVariance = epsilon + 0.25 * (dnwdz * dnwdz) * dz2;
+        float n = chebyshevUpperBound(moments.zw, nw, nMinVariance, lbrAmount);
+       p = min(p, n);
+    }
+
+    return p;
+}
+
+float ShadowSample_VSM(const bool DIRECTIONAL, const highp sampler2DArray shadowMap,
+        const highp vec4 scissorNormalized,
+        const uint layer, const int index,
+        const highp vec4 shadowPosition, const highp float zLight) {
+
+    bool ELVSM = shadowUniforms.shadows[index].elvsm;
+    float c = shadowUniforms.shadows[index].vsmExponent;
+    highp vec2 texelSize = vec2(1.0) / vec2(textureSize(shadowMap, 0)); // TODO: put this in a uniform
+
+    // note: shadowPosition.z is in linear light-space normalized to [0, 1]
+    //  see: ShadowMap::computeVsmLightSpaceMatrix() in ShadowMap.cpp
+    //  see: computeLightSpacePosition() in common_shadowing.fs
+    highp vec3 position = vec3(shadowPosition.xy * (1.0 / shadowPosition.w), shadowPosition.z);
+
+    // plane receiver bias to reduce shadow acnee on the received plane (before clamp)
+    highp vec2 dzduv = computeReceiverPlaneDepthBias(position);
+
+    // clamp uv to border
+    position.xy = clamp(position.xy, scissorNormalized.xy, scissorNormalized.zw);
+
+    // Read the shadow map with all available filtering
+    highp vec4 moments = texture(shadowMap, vec3(position.xy, layer));
+
+    return evaluateEVSM(ELVSM, c, moments, position.z, dzduv, texelSize);
+}
+
 //------------------------------------------------------------------------------
 // Screen-space Contact Shadows
 //------------------------------------------------------------------------------
@@ -409,70 +494,6 @@ float screenSpaceContactShadow(vec3 lightDirection) {
     return occlusion;
 }
 
-//------------------------------------------------------------------------------
-// VSM
-//------------------------------------------------------------------------------
-
-float linstep(const float min, const float max, const float v) {
-    // we could use smoothstep() too
-    return clamp((v - min) / (max - min), 0.0, 1.0);
-}
-
-float reduceLightBleed(const float pMax, const float amount) {
-    // Remove the [0, amount] tail and linearly rescale (amount, 1].
-    return linstep(amount, 1.0, pMax);
-}
-
-float chebyshevUpperBound(const highp vec2 moments, const highp float mean,
-        const highp float minVariance, const float lightBleedReduction) {
-    // Donnelly and Lauritzen 2006, "Variance Shadow Maps"
-
-    highp float variance = moments.y - (moments.x * moments.x);
-    variance = max(variance, minVariance);
-
-    highp float d = mean - moments.x;
-    float pMax = variance / (variance + d * d);
-
-    pMax = reduceLightBleed(pMax, lightBleedReduction);
-
-    return mean <= moments.x ? 1.0 : pMax;
-}
-
-float evaluateShadowVSM(const highp vec2 moments, const highp float depth) {
-    highp float depthScale = frameUniforms.vsmDepthScale * depth;
-    highp float minVariance = depthScale * depthScale;
-    return chebyshevUpperBound(moments, depth, minVariance, frameUniforms.vsmLightBleedReduction);
-}
-
-float ShadowSample_VSM(const bool ELVSM, const highp sampler2DArray shadowMap,
-        const highp vec4 scissorNormalized,
-        const uint layer, const highp vec4 shadowPosition) {
-
-    // note: shadowPosition.z is in linear light-space normalized to [0, 1]
-    //  see: ShadowMap::computeVsmLightSpaceMatrix() in ShadowMap.cpp
-    //  see: computeLightSpacePosition() in common_shadowing.fs
-    highp vec3 position = vec3(shadowPosition.xy * (1.0 / shadowPosition.w), shadowPosition.z);
-
-    // Note: we don't need to clamp to `scissorNormalized` in the VSM case because this is only
-    // needed when the shadow casters and receivers are different, which is never the case with VSM
-    // (see ShadowMap.cpp).
-
-    // Read the shadow map with all available filtering
-    highp vec4 moments = texture(shadowMap, vec3(position.xy, layer));
-    highp float depth = position.z;
-
-    // EVSM depth warping
-    depth = depth * 2.0 - 1.0;
-    depth = frameUniforms.vsmExponent * depth;
-
-    depth = exp(depth);
-    float p = evaluateShadowVSM(moments.xy, depth);
-    if (ELVSM) {
-        p = min(p, evaluateShadowVSM(moments.zw, -1.0 / depth));
-    }
-    return p;
-}
-
 //------------------------------------------------------------------------------
 // Shadow sampling dispatch
 //------------------------------------------------------------------------------
@@ -529,6 +550,9 @@ float shadow(const bool DIRECTIONAL,
     } else if (CONFIG_SHADOW_SAMPLING_METHOD == SHADOW_SAMPLING_PCF_LOW) {
         return ShadowSample_PCF_Low(shadowMap, scissorNormalized, layer, shadowPosition);
     }
+
+    // should not happen
+    return 0.0;
 }
 
 // Shadow requiring a sampler2D sampler (VSM, DPCF and PCSS)
@@ -539,9 +563,8 @@ float shadow(const bool DIRECTIONAL,
     uint layer = shadowUniforms.shadows[index].layer;
     // This conditional is resolved at compile time
     if (frameUniforms.shadowSamplingType == SHADOW_SAMPLING_RUNTIME_EVSM) {
-        bool elvsm = shadowUniforms.shadows[index].elvsm;
-        return ShadowSample_VSM(elvsm, shadowMap, scissorNormalized, layer,
-                shadowPosition);
+        return ShadowSample_VSM(DIRECTIONAL, shadowMap, scissorNormalized, layer, index,
+                shadowPosition, zLight);
     }
 
     if (frameUniforms.shadowSamplingType == SHADOW_SAMPLING_RUNTIME_DPCF) {
@@ -558,8 +581,8 @@ float shadow(const bool DIRECTIONAL,
         // This is here mostly for debugging at this point.
         // Note: In this codepath, the normal bias is not applied because we're in the VSM variant.
         // (see: get{Cascade|Spot}LightSpacePosition)
-        return ShadowSample_PCF(shadowMap, scissorNormalized,
-                layer, shadowPosition);
+        return ShadowSample_PCF(shadowMap, scissorNormalized, layer,
+                shadowPosition);
     }
 
     // should not happen

shaders/src/surface_types.glsl

@@ -10,7 +10,7 @@ struct ShadowData {
     highp vec2 normalBias;
     bool elvsm;
     mediump uint layer;
-    mediump uint reserved1;
+    mediump float vsmExponent;
     mediump uint reserved2;
 };
 #endif

test/render-validation/README.md

@@ -0,0 +1,85 @@
+# Render Validation Sample & TUI
+
+This project is an Android application for validating Filament render behavior on-device, primarily using bundled tests and goldens. It operates via `adb` intents to automate the generation, exporting, and running of test bundles.
+
+## Automated Execution via ADB Intents
+
+You can fully control the validation app directly from your host machine without touching the device screen. The app listens for specific intent extras when launched.
+
+**General Command Structure:**
+```bash
+adb shell am start -n com.google.android.filament.validation/.MainActivity <extras>
+```
+
+### Supported Intent Extras (Booleans)
+- `--ez auto_run true`: Immediately runs the loaded or default test upon startup.
+- `--ez generate_goldens true`: Forces the app to generate new golden reference images for the current test instead of comparing against existing ones.
+- `--ez auto_export true`: Automatically packages the generated tests/goldens into a `.zip` archive (`Default_Test_<timestamp>.zip`) to the app's files directory when finished.
+- `--ez auto_export_results true`: Automatically packages the comparison results and diff images into a `.zip` archive (`results_<timestamp>.zip`) to the app's files directory when finished.
+
+### Supported Intent Extras (Strings)
+- `--es zip_path <filename.zip>`: Loads a specific test `.zip` bundle.
+  - If you pass an absolute path, it loads from there.
+  - If you pass just a filename (e.g. `Default_Test_123.zip`), it intelligently searches the app's external files directory (`/sdcard/Android/data/.../files`) to find it.
+
+### Example ADB Workflows
+**Generate new goldens and export them as a test bundle:**
+```bash
+adb shell am start -n com.google.android.filament.validation/.MainActivity \
+  --ez auto_run true \
+  --ez generate_goldens true \
+  --ez auto_export true
+```
+
+**Run an existing specific test bundle and export the results:**
+```bash
+adb shell am start -n com.google.android.filament.validation/.MainActivity \
+  --es zip_path "Default_Test_123.zip" \
+  --ez auto_run true \
+  --ez auto_export_results true
+```
+
+### Manual File Management via ADB
+Depending on the Android version and device storage policy, the app's file location resides either on standard External Storage or strictly within inside its Internal Sandbox.
+
+**App's External Storage (Default for most devices):**
+- **Push a test bundle to device:** `adb push <filename.zip> /sdcard/Android/data/com.google.android.filament.validation/files/`
+- **Pull a test bundle from device:** `adb pull /sdcard/Android/data/com.google.android.filament.validation/files/<filename.zip> .`
+- **Pull a result bundle from device:** `adb pull /sdcard/Android/data/com.google.android.filament.validation/files/results_<timestamp>.zip .`
+
+**App's Internal Storage (If external is unavailable):**
+*Note: Due to security restrictions, you must use `run-as` to pipe data into/out of the application's secure sandbox.*
+- **Push a test bundle to device:**
+  1. `adb push <filename.zip> /sdcard/Download/`
+  2. `adb shell "run-as com.google.android.filament.validation cp /sdcard/Download/<filename.zip> files/"`
+- **Pull a test or result bundle from device:**
+  `adb shell "run-as com.google.android.filament.validation cat files/<filename.zip>" > <filename.zip>`
+
+---
+
+## Python Terminal UI (TUI) Dashboard
+
+To make managing tests and results easier, a Python-based Textual TUI (`validation_app.py`) is provided in the `validation_tui` directory. It automatically polls the connected device using ADB, acts as a GUI for the intent commands above, and handles downloading/uploading `.zip` bundles to circumvent Android's scoped storage limits.
+
+### Setup
+1. Ensure you have Python 3 and `adb` installed and in your PATH.
+2. Navigate to the TUI directory: `cd test/render-validation`
+3. Create a virtual environment: `python3 -m venv venv`
+4. Activate it: `source venv/bin/activate` (Mac/Linux) or `venv\Scripts\activate` (Windows)
+5. Install requirements: `pip install -r requirements.txt` (Installs the `textual` framework)
+
+### Usage
+Start the dashboard by running:
+```bash
+python validation_app.py
+```
+
+### TUI Features
+- **Auto-Polling Mechanism**: Syncs the file lists with your device every 2 seconds.
+- **Generate Test/Result Buttons**: One-click execution of the `am start` intents.
+- **Upload Local Test Bundle**: Automatically pushes a local `.zip` file from your PC to the correct directory on the Android device.
+- **Per-File Actions**:
+  - `▶` (Load): Restarts the app with `--es zip_path <filename>` to set it as the active test on device.
+  - `↓` (Download): Pulls the `.zip` to your PC's current working directory.
+  - `✎` (Rename): Quickly renames the file directly on the Android file system.
+  - `✗` (Delete): Quickly removes the file from the Android device to free up storage.

test/render-validation/requirements.txt

@@ -0,0 +1 @@
+textual>=0.52.0

test/render-validation/validation_app.py

@@ -0,0 +1,559 @@
+import os
+import sys
+import shutil
+import asyncio
+
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical, ScrollableContainer
+from textual.widgets import Header, Footer, Button, Label, Static, ListItem, ListView, Input, DirectoryTree
+from textual.screen import Screen, ModalScreen
+from textual.reactive import reactive
+from textual.message import Message
+
+PACKAGE = "com.google.android.filament.validation"
+EXTERNAL_DIR = f"/sdcard/Android/data/{PACKAGE}/files"
+INTERNAL_DIR = "files"
+
+if not shutil.which("adb"):
+    print("Error: 'adb' not found in PATH. Please install Android Platform Tools and ensure it's in your PATH.", file=sys.stderr)
+    sys.exit(1)
+
+async def run_adb_cmd(*args):
+    """Run an adb command asynchronously and return code, stdout, stderr."""
+    proc = await asyncio.create_subprocess_exec(
+        "adb", *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE
+    )
+    stdout, stderr = await proc.communicate()
+    return proc.returncode, stdout.decode().strip(), stderr.decode().strip()
+
+class DeviceSelectScreen(Screen):
+    def compose(self) -> ComposeResult:
+        yield Label("Multiple Android devices detected. Please select one:", id="title")
+        yield ListView(id="device_list")
+
+    async def on_mount(self) -> None:
+        code, out, err = await run_adb_cmd("devices")
+        lv = self.query_one("#device_list", ListView)
+        for line in out.splitlines()[1:]:
+            if line.strip() and "device" in line:
+                serial = line.split()[0]
+                await lv.append(ListItem(Label(serial), id=f"dev_{serial}"))
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        serial = event.item.id.replace("dev_", "")
+        self.dismiss(serial)
+
+class FileSelectScreen(ModalScreen[str]):
+    CSS = """
+    FileSelectScreen {
+        align: center middle;
+    }
+    #dialog {
+        width: 80%;
+        height: 80%;
+        padding: 1;
+        border: thick $background 80%;
+        background: $surface;
+    }
+    """
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Label("Select a local .zip test bundle to upload:")
+            yield DirectoryTree(os.getcwd())
+            with Horizontal():
+                yield Button("Cancel", id="btn_cancel_upload", variant="error")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn_cancel_upload":
+            self.dismiss(None)
+
+    def on_directory_tree_file_selected(self, event: DirectoryTree.FileSelected) -> None:
+        if str(event.path).endswith(".zip"):
+            self.dismiss(str(event.path))
+        else:
+            self.app.notify("Please select a .zip file!", severity="warning")
+
+class FileItem(Static):
+    class FileChanged(Message):
+        """Emitted when a file is renamed or deleted."""
+        pass
+    class TestLoaded(Message):
+        """Emitted when a test is loaded on device."""
+        def __init__(self, filename: str) -> None:
+            self.filename = filename
+            super().__init__()
+
+    def __init__(self, filename: str, filepath: str, is_internal: bool, serial: str, **kwargs):
+        super().__init__(**kwargs)
+        self.filename = filename
+        self.filepath = filepath
+        self.is_internal = is_internal
+        self.serial = serial
+        self.renaming = False
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="file-item-container"):
+            with Horizontal(id="file_row", classes="file-item-row"):
+                yield Label(self.filename, id="lbl_filename", classes="file-name")
+
+                # Only show Load button for test configurations, not results
+                if not self.filename.startswith("results_"):
+                    yield Button("▶", id="btn_load", variant="success", classes="compact-btn", tooltip="Load this test on device")
+
+                yield Button("↓", id="btn_download", variant="primary", classes="compact-btn", tooltip="Download to PC")
+                yield Button("✎", id="btn_start_rename", variant="warning", classes="compact-btn", tooltip="Rename on device")
+                yield Button("✗", id="btn_delete", variant="error", classes="compact-btn", tooltip="Delete on device")
+            with Horizontal(id="rename_row", classes="rename-row"):
+                yield Input(value=self.filename, id="inp_rename", classes="rename-input")
+                yield Button("Save", id="btn_save_rename", variant="success", classes="compact-btn")
+                yield Button("Cancel", id="btn_cancel_rename", classes="compact-btn")
+
+    def on_mount(self):
+        self.query_one("#rename_row").display = False
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id
+
+        if btn_id == "btn_start_rename":
+            self.query_one("#file_row").display = False
+            self.query_one("#rename_row").display = True
+            inp = self.query_one("#inp_rename", Input)
+            inp.value = self.filename
+            inp.focus()
+
+        elif btn_id == "btn_cancel_rename":
+            self.query_one("#rename_row").display = False
+            self.query_one("#file_row").display = True
+
+        elif btn_id == "btn_save_rename":
+            new_name = self.query_one("#inp_rename", Input).value.strip()
+            if new_name and new_name != self.filename:
+                # Need to run ADB mv
+                base_dir = self.filepath.rsplit('/', 1)[0]
+                new_path = f"{base_dir}/{new_name}"
+
+                if self.is_internal:
+                    cmd = f"run-as {PACKAGE} mv {self.filepath} {new_path}"
+                    await run_adb_cmd("-s", self.serial, "shell", cmd)
+                else:
+                    cmd = f"mv {self.filepath} {new_path}"
+                    await run_adb_cmd("-s", self.serial, "shell", cmd)
+
+                self.app.notify(f"Renamed {self.filename} to {new_name}")
+                self.post_message(self.FileChanged())
+            else:
+                self.query_one("#rename_row").display = False
+                self.query_one("#file_row").display = True
+
+        elif btn_id == "btn_delete":
+            event.button.disabled = True
+            if self.is_internal:
+                cmd = f"run-as {PACKAGE} rm {self.filepath}"
+                await run_adb_cmd("-s", self.serial, "shell", cmd)
+            else:
+                cmd = f"rm {self.filepath}"
+                await run_adb_cmd("-s", self.serial, "shell", cmd)
+
+            self.app.notify(f"Deleted {self.filename}")
+            self.post_message(self.FileChanged())
+
+        elif btn_id == "btn_download":
+            event.button.disabled = True
+            event.button.label = "..."
+            self.app.notify(f"Downloading {self.filename} to {os.getcwd()}...", title="Download Started")
+            self.run_worker(self.download_file(event.button), exclusive=True)
+
+        elif btn_id == "btn_load":
+            self.app.notify(f"Loading {self.filename} on device...", title="Load Test")
+            self.run_worker(self.load_on_device(), exclusive=True)
+
+    async def load_on_device(self) -> None:
+        cmd_args = [
+            "-s", self.serial, "shell", "am", "start",
+            "-n", f"{PACKAGE}/.MainActivity",
+            "--es", "zip_path", self.filename
+        ]
+        await run_adb_cmd(*cmd_args)
+        self.post_message(self.TestLoaded(self.filename))
+        self.app.notify(f"Requested device to load {self.filename}", title="Load Complete")
+
+    async def download_file(self, button: Button) -> None:
+        dest = os.path.join(os.getcwd(), self.filename)
+
+        if self.is_internal:
+            # internal requires run-as
+            cmd = f"adb -s {self.serial} shell \"run-as {PACKAGE} cat {self.filepath}\" > \"{dest}\""
+            proc = await asyncio.create_subprocess_shell(cmd)
+            await proc.communicate()
+        else:
+            # external can be a direct pull
+            await run_adb_cmd("-s", self.serial, "pull", self.filepath, dest)
+
+        button.label = "Downloaded ✓"
+        button.variant = "success"
+        self.app.notify(f"Saved: {dest}", title="Complete")
+        await asyncio.sleep(2)
+        button.label = "Download"
+        button.disabled = False
+        button.variant = "primary"
+
+class MainScreen(Screen):
+    device_serial = reactive("")
+    is_connected = reactive(True)
+    current_test = reactive("")
+    is_foreground = reactive(False)
+
+    def __init__(self, serial=None, **kwargs):
+        super().__init__(**kwargs)
+        self.device_serial = serial or ""
+        self.tests_seen = set()
+        self.results_seen = set()
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Label(id="banner", classes="banner")
+
+        with Vertical(id="launch_container"):
+            yield Label("App is not running in the foreground.", id="lbl_launch_msg")
+            yield Button("Launch App", id="btn_launch_app", variant="success", classes="main-action-btn launch-btn")
+
+        with Horizontal(id="main_container"):
+            with Vertical(classes="column"):
+                yield Label("🧪 Tests", classes="col-title")
+                yield Button("Upload Local Test Bundle", id="btn_upload_test", variant="primary", classes="main-action-btn")
+                yield Button("Generate Goldens", id="btn_gen_goldens", variant="warning", classes="main-action-btn")
+                yield Button("Generate Test Bundle", id="btn_gen_test", variant="success", classes="main-action-btn")
+                yield ScrollableContainer(id="test_list")
+            with Vertical(classes="column"):
+                yield Label("📊 Results", classes="col-title")
+                yield Label("Current: Default", id="lbl_current_test", classes="col-subtitle")
+                yield Button("Run test", id="btn_gen_res", variant="success", classes="main-action-btn")
+                yield ScrollableContainer(id="result_list")
+        yield Footer()
+
+    def on_file_item_test_loaded(self, event: FileItem.TestLoaded) -> None:
+        self.current_test = event.filename
+
+    def watch_current_test(self, new_test: str) -> None:
+        from textual.css.query import NoMatches
+        try:
+            if new_test:
+                self.query_one("#lbl_current_test", Label).update(f"Current: {new_test}")
+        except NoMatches:
+            pass
+
+    def watch_is_foreground(self, foreground: bool) -> None:
+        from textual.css.query import NoMatches
+        try:
+            lc = self.query_one("#launch_container")
+            mc = self.query_one("#main_container")
+            if foreground:
+                lc.display = False
+                mc.display = True
+            else:
+                lc.display = True
+                mc.display = False
+        except NoMatches:
+            pass
+
+    def on_file_item_file_changed(self, event: FileItem.FileChanged) -> None:
+        """Called when a child file is deleted or renamed to force a full refresh."""
+        self.query_one("#test_list").remove_children()
+        self.query_one("#result_list").remove_children()
+        self.tests_seen.clear()
+        self.results_seen.clear()
+
+    def watch_device_serial(self, serial: str) -> None:
+        from textual.css.query import NoMatches
+        try:
+            self.query_one(Header).title = "Filament Validation Runner"
+            self.query_one(Header).sub_title = f"Device: {serial}"
+        except NoMatches:
+            pass
+
+    def watch_is_connected(self, connected: bool) -> None:
+        from textual.css.query import NoMatches
+        try:
+            banner = self.query_one("#banner", Label)
+            if connected:
+                banner.update("Status: Device Connected ✅")
+                banner.remove_class("disconnected")
+            else:
+                banner.update("Status: Disconnected - Retrying... ❌")
+                banner.add_class("disconnected")
+        except NoMatches:
+            pass
+
+    def on_mount(self) -> None:
+        # Check ADB constantly every 2 seconds
+        self.set_interval(2.0, self.poll_adb)
+
+        # Hide conditionally
+        self.query_one("#launch_container").display = False
+        self.query_one("#main_container").display = False
+
+    async def get_files(self, directory: str, is_internal: bool):
+        if is_internal:
+            code, out, err = await run_adb_cmd("-s", self.device_serial, "shell", f"run-as {PACKAGE} ls -1 {directory}")
+        else:
+            code, out, err = await run_adb_cmd("-s", self.device_serial, "shell", f"ls -1 {directory}")
+
+        if code == 0 and "Permission denied" not in err and "No such file or directory" not in err:
+            return [f.strip() for f in out.splitlines() if f.strip() and f.strip().endswith(".zip")]
+        return []
+
+    async def poll_adb(self) -> None:
+        code, out, err = await run_adb_cmd("-s", self.device_serial, "shell", "echo ok")
+        if code != 0 or "ok" not in out:
+            self.is_connected = False
+            self.is_foreground = False
+            return
+
+        self.is_connected = True
+
+        # Check foreground
+        proc = await asyncio.create_subprocess_shell(
+            f"adb -s {self.device_serial} shell \"dumpsys window | grep mCurrentFocus\"",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, _ = await proc.communicate()
+        out = stdout.decode('utf-8', errors='ignore')
+
+        self.is_foreground = PACKAGE in out
+
+        # We only really need to pull files if we are in the foreground
+        if not self.is_foreground:
+            return
+
+        current_tests = set()
+        current_results = set()
+        files_dict = {}
+
+        # 1. External
+        ext_files = await self.get_files(EXTERNAL_DIR, False)
+        for f in ext_files:
+            files_dict[f] = (f"{EXTERNAL_DIR}/{f}", False)
+
+        # 2. Internal
+        int_files = await self.get_files(INTERNAL_DIR, True)
+        for f in int_files:
+            if f not in files_dict:
+                files_dict[f] = (f"{INTERNAL_DIR}/{f}", True)
+
+        for f, (path, is_int) in files_dict.items():
+            if f.startswith("results_"):
+                current_results.add((f, path, is_int))
+            else:
+                # Any other .zip file is considered a test
+                current_tests.add((f, path, is_int))
+
+        # Check if any files were removed (e.g. wiped data)
+        removed_tests = self.tests_seen - current_tests
+        removed_results = self.results_seen - current_results
+
+        if removed_tests or removed_results:
+            self.query_one("#test_list").remove_children()
+            self.query_one("#result_list").remove_children()
+            self.tests_seen.clear()
+            self.results_seen.clear()
+
+        # Update lists safely if they are new
+        new_tests = current_tests - self.tests_seen
+        test_list = self.query_one("#test_list", ScrollableContainer)
+        for f, path, is_int in new_tests:
+            await test_list.mount(FileItem(f, path, is_int, self.device_serial))
+            test_list.scroll_end(animate=False)
+        self.tests_seen.update(new_tests)
+
+        new_results = current_results - self.results_seen
+        result_list = self.query_one("#result_list", ScrollableContainer)
+        for f, path, is_int in new_results:
+            await result_list.mount(FileItem(f, path, is_int, self.device_serial))
+            result_list.scroll_end(animate=False)
+        self.results_seen.update(new_results)
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id
+        if btn_id == "btn_gen_goldens":
+            event.button.disabled = True
+            event.button.label = "Generating Goldens..."
+            self.run_worker(self.generate_and_auto_export(event.button, "golden"), exclusive=True)
+        elif btn_id == "btn_gen_test":
+            event.button.disabled = True
+            event.button.label = "Generating & Exporting..."
+            self.run_worker(self.generate_and_auto_export(event.button, "test"), exclusive=True)
+        elif btn_id == "btn_gen_res":
+            event.button.disabled = True
+            event.button.label = "Generating & Exporting..."
+            self.run_worker(self.generate_and_auto_export(event.button, "result"), exclusive=True)
+        elif btn_id == "btn_upload_test":
+            self.app.push_screen(FileSelectScreen(), self.handle_upload)
+        elif btn_id == "btn_launch_app":
+            self.run_worker(self.launch_app(), exclusive=True)
+
+    async def launch_app(self) -> None:
+        self.app.notify("Commanding device to start the app...", title="Launching")
+        await run_adb_cmd("-s", self.device_serial, "shell", "am", "start", "-n", f"{PACKAGE}/.MainActivity")
+
+    def handle_upload(self, file_path: str | None) -> None:
+        if file_path:
+            self.run_worker(self.upload_file(file_path), exclusive=True)
+
+    async def upload_file(self, file_path: str):
+        filename = os.path.basename(file_path)
+        self.app.notify(f"Uploading {filename}...", title="Upload Started")
+
+        # We push to EXTERNAL_DIR because `adb push` works seamlessly there
+        dest = f"{EXTERNAL_DIR}/{filename}"
+        code, out, err = await run_adb_cmd("-s", self.device_serial, "push", file_path, dest)
+
+        if code == 0:
+            self.app.notify(f"Successfully uploaded to device.", title="Upload Finished")
+            # Force a refresh
+            self.tests_seen.clear()
+            self.query_one("#test_list").remove_children()
+        else:
+            self.app.notify(f"Upload failed: {err}", title="Error", severity="error")
+
+    async def generate_and_auto_export(self, button: Button, mode: str):
+        self.app.notify("Commanding device...", title="Working")
+
+        # Notice we removed '-S' so it doesn't force stop the activity first
+        cmd_args = [
+            "-s", self.device_serial, "shell", "am", "start",
+            "-n", f"{PACKAGE}/.MainActivity"
+        ]
+
+        if mode == "golden":
+            cmd_args.extend(["--ez", "generate_goldens", "true", "--ez", "auto_run", "true"])
+        elif mode == "test":
+            cmd_args.extend(["--ez", "auto_run", "true", "--ez", "auto_export", "true"])
+        elif mode == "result":
+            cmd_args.extend(["--ez", "auto_run", "true", "--ez", "auto_export_results", "true"])
+            if self.current_test:
+                cmd_args.extend(["--es", "zip_path", self.current_test])
+
+        await run_adb_cmd(*cmd_args)
+
+        # Allow time to run and let auto-polling grab the new file (if exporting)
+        await asyncio.sleep(6)
+
+        button.disabled = False
+        if mode == "golden":
+            button.label = "Generate Goldens"
+        elif mode == "test":
+            button.label = "Generate & Download New Test"
+        elif mode == "result":
+            button.label = "Generate & Download Results"
+
+        self.app.notify("Action Finished")
+
+class ValidationApp(App):
+    CSS = """
+    Screen {
+        layout: vertical;
+    }
+    .banner {
+        width: 100%;
+        content-align: center middle;
+        background: $success;
+        color: $text;
+        padding: 1;
+        text-style: bold;
+    }
+    .banner.disconnected {
+        background: $error;
+    }
+    #launch_container {
+        align: center middle;
+        height: 1fr;
+    }
+    #lbl_launch_msg {
+        text-align: center;
+        margin-bottom: 2;
+    }
+    .launch-btn {
+        width: 30;
+    }
+    #main_container {
+        height: 1fr;
+        layout: horizontal;
+    }
+    .column {
+        width: 50%;
+        height: 100%;
+        border: solid $accent;
+        padding: 1;
+    }
+    .col-title {
+        text-align: center;
+        text-style: bold;
+        width: 100%;
+        margin-bottom: 1;
+    }
+    .col-subtitle {
+        text-align: center;
+        width: 100%;
+        margin-bottom: 1;
+        color: $secondary;
+        text-style: italic;
+    }
+    .main-action-btn {
+        width: 100%;
+        margin-bottom: 1;
+    }
+    .file-item-container {
+        height: auto;
+        padding-bottom: 1;
+        border-bottom: solid $surface;
+    }
+    .file-item-row {
+        height: 3;
+        width: 100%;
+        align: left middle;
+    }
+    .file-name {
+        width: 1fr;
+        content-align: left middle;
+    }
+    .compact-btn {
+        min-width: 4;
+        width: auto;
+        margin-left: 1;
+    }
+    .rename-row {
+        height: 3;
+        width: 100%;
+    }
+    .rename-input {
+        width: 1fr;
+    }
+    """
+    BINDINGS = [
+        ("q", "quit", "Quit application")
+    ]
+
+    async def on_mount(self) -> None:
+        code, out, err = await run_adb_cmd("devices")
+        devices = []
+        for line in out.splitlines()[1:]:
+            if line.strip() and "device" in line:
+                devices.append(line.split()[0])
+
+        if len(devices) > 1:
+            self.push_screen(DeviceSelectScreen(), self.start_main)
+        elif len(devices) == 1:
+            self.start_main(devices[0])
+        else:
+            self.notify("No devices connected via ADB!", severity="error")
+            self.start_main("")
+
+    def start_main(self, serial: str) -> None:
+        self.push_screen(MainScreen(serial=serial))
+
+if __name__ == "__main__":
+    app = ValidationApp()
+    app.run()

test/renderdiff/src/viewer_requirements.txt

@@ -2,7 +2,7 @@ blinker==1.9.0
 certifi==2025.8.3
 charset-normalizer==3.4.3
 click==8.2.1
-Flask==3.1.2
+Flask==3.1.3
 idna==3.10
 itsdangerous==2.2.0
 Jinja2==3.1.6
@@ -10,4 +10,4 @@ MarkupSafe==3.0.2
 requests==2.32.5
 urllib3==2.6.3
 waitress==3.0.2
-Werkzeug==3.1.4
+Werkzeug==3.1.6

test/renderdiff/tests/presubmit.json

@@ -54,6 +54,8 @@
         {
             "name": "Transimssion",
             "description": "transmission",
+            // Disable transmission for webgpu because it seems flaky (b/488070152)
+            "backends": ["opengl", "vulkan"],
             "apply_presets": ["base", "transmission_models"],
             "rendering": {
                 "camera.focalLength": 52.0

web/filament-js/filament.d.ts

@@ -1747,7 +1747,7 @@ export interface View$VsmShadowOptions {
      */
     highPrecision?: boolean;
     /**
-     * VSM minimum variance scale, must be positive.
+     * @deprecated has no effect.
      */
     minVarianceScale?: number;
     /**

web/filament-js/package.json

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