Make some headers public so JobSystem.h can be used

2022-11-03 09:39:01 -07:00
58 changed files with 643 additions and 1172 deletions
@@ -45,23 +45,18 @@ jobs:
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
        run: |
          WORKFLOW_OS=`echo \`uname\` | sed "s/Darwin/mac/" | tr [:upper:] [:lower:]`
          cd build/$WORKFLOW_OS && printf "y" | ./build.sh release
-          cd ../..
+      - name: Upload release assets
+        run: |
+          xargs -L 1 sudo pip3 install < build/common/requirements.txt
          if [ -f out/filament-release-darwin.tgz ]; then mv out/filament-release-darwin.tgz out/filament-${TAG}-mac.tgz; fi;
          if [ -f out/filament-release-linux.tgz ]; then mv out/filament-release-linux.tgz out/filament-${TAG}-linux.tgz; fi;
-      - uses: actions/github-script@v6
+          python3 build/common/upload-assets.py ${TAG} out/*.tgz
        env:
          TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create('out/*.tgz');
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}

  build-web:
    name: build-web
@@ -80,21 +75,16 @@ jobs:
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
        run: |
          cd build/web && printf "y" | ./build.sh release
-          cd ../..
+      - name: Upload release assets
+        run: |
+          xargs -L 1 sudo pip3 install < build/common/requirements.txt
          mv out/filament-release-web.tgz out/filament-${TAG}-web.tgz
-      - uses: actions/github-script@v6
+          python3 build/common/upload-assets.py ${TAG} out/*.tgz
        env:
          TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create('out/*.tgz');
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}

  build-android:
    name: build-android
@@ -113,16 +103,8 @@ jobs:
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
        run: |
          cd build/android && printf "y" | ./build.sh release
-          cd ../..
-          mv out/filament-android-release.aar out/filament-${TAG}-android.aar
-          mv out/filamat-android-release.aar out/filamat-${TAG}-android.aar
-          mv out/filamat-android-lite-release.aar out/filamat-${TAG}-lite-android.aar
-          mv out/gltfio-android-release.aar out/gltfio-${TAG}-android.aar
-          mv out/filament-utils-android-release.aar out/filament-utils-${TAG}-android.aar
      - name: Sign sample-gltf-viewer
        run: |
          echo "${APK_KEYSTORE_BASE64}" > filament.jks.base64
@@ -137,15 +119,18 @@ jobs:
          TAG: ${{ steps.git_ref.outputs.tag }}
          APK_KEYSTORE_BASE64: ${{ secrets.APK_KEYSTORE_BASE64 }}
          APK_KEYSTORE_PASS: ${{ secrets.APK_KEYSTORE_PASS }}
-      - uses: actions/github-script@v6
+      - name: Upload release assets
+        run: |
+          xargs -L 1 sudo pip3 install < build/common/requirements.txt
+          mv out/filament-android-release.aar out/filament-${TAG}-android.aar
+          mv out/filamat-android-release.aar out/filamat-${TAG}-android.aar
+          mv out/filamat-android-lite-release.aar out/filamat-${TAG}-lite-android.aar
+          mv out/gltfio-android-release.aar out/gltfio-${TAG}-android.aar
+          mv out/filament-utils-android-release.aar out/filament-utils-${TAG}-android.aar
+          python3 build/common/upload-assets.py ${TAG} out/*.aar out/*.apk
        env:
          TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create(['out/*.aar', 'out/*.apk'].join('\n'));
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}

  build-ios:
    name: build-ios
@@ -164,21 +149,16 @@ jobs:
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
        run: |
          cd build/ios && printf "y" | ./build.sh release
-          cd ../..
+      - name: Upload release assets
+        run: |
+          xargs -L 1 sudo pip3 install < build/common/requirements.txt
          mv out/filament-release-ios.tgz out/filament-${TAG}-ios.tgz
-      - uses: actions/github-script@v6
+          python3 build/common/upload-assets.py ${TAG} out/*.tgz
        env:
          TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create('out/*.tgz');
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}

  build-windows:
    name: build-windows
@@ -198,19 +178,15 @@ jobs:
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
-        env:
-          TAG: ${{ steps.git_ref.outputs.tag }}
        run: |
          build\windows\build-github.bat release
-          cd ..\..
-          move out\filament-windows.tgz out\filament-%TAG%-windows.tgz
        shell: cmd
-      - uses: actions/github-script@v6
+      - name: Upload release assets
+        run: |
+          pip3 install PyGithub
+          mv out/filament-windows.tgz out/filament-${TAG}-windows.tgz
+          python build/common/upload-assets.py ${TAG} out/*.tgz
+        shell: bash
        env:
          TAG: ${{ steps.git_ref.outputs.tag }}
-        with:
-          script: |
-            const upload = require('./build/common/upload-release-assets');
-            const { TAG } = process.env;
-            const globber = await glob.create('out/*.tgz');
-            await upload({ github, context }, await globber.glob(), TAG);
+          GITHUB_API_KEY: ${{ secrets.GITHUB_API_KEY }}
@@ -99,10 +99,6 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 # ==================================================================================================
 if (UNIX AND NOT APPLE AND NOT ANDROID AND NOT WEBGL)
    set(LINUX TRUE)
-else()
-    # since cmake 3.25 LINUX is automatically set based on CMAKE_SYSTEM_NAME, which the android
-    # cmake files are setting to "Linux".
-    set(LINUX FALSE)
 endif()

 if (LINUX)
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.29.0'
+    implementation 'com.google.android.filament:filament-android:1.28.2'
 }
 ```

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

 ```
-pod 'Filament', '~> 1.29.0'
+pod 'Filament', '~> 1.28.2'
 ```

 ### Snapshots
@@ -5,20 +5,12 @@ A new header is inserted each time a *tag* is created.

 ## main branch

-## v1.29.0
-
- gltfio: calculate primitive's AABB correctly.
- gltfio: recompute bounding boxes with morph targets
- engine: add missing getters on `MaterialInstance`
- WebGL: add missing `ColorGrading` JS bindings
- engine: improvements/cleanup of Shadow mapping code [⚠️ **Recompile Materials**]
- engine: fix TransformManager high precision mode when using transactions.
-
-## v1.28.3
-
-
 - backend: add support for GGP platform
+- gltfio: calculate primitive's AABB correctly. 
+- gltfio: fix glTF breaking issue
+- gltfio: recompute bounding boxes with morph targets
 - engine: primitives with `CullingMode::FRONT_AND_BACK` are now skipped.
+- engine: add missing getters on `MaterialInstance`

 ## v1.28.2

@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.29.0
+VERSION_NAME=1.28.2

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

@@ -0,0 +1,14 @@
+setuptools==40.6.2
+wheel==0.37.1
+certifi==2021.10.8
+cffi==1.15.0
+charset-normalizer==2.0.12
+Deprecated==1.2.13
+idna==3.3
+pycparser==2.21
+PyGithub==1.55
+PyJWT==2.4.0
+PyNaCl==1.5.0
+requests==2.27.1
+urllib3==1.26.9
+wrapt==1.14.0
@@ -0,0 +1,93 @@
+# Copyright (C) 2019 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# requirements.txt created via:
+#
+# pip3 install virtualenv
+# python3 -m venv env
+# pip3 install PyGithub
+# pip3 install wheel
+# --all includes wheel and setuputils, which is needed for GitHub Actions
+# pip3 freeze --all > requirements.txt
+# Manually move 'setuptools' and 'wheel' lines to the beginning of the file.
+# Manually remove the 'pip' line.
+#
+# Requirements are installed in GitHub Actions via:
+# xargs -L 1 sudo pip3 install < build/common/requirements.txt
+# xargs must be used because the ordering of the dependencies matters (namely, setuptools).
+# sudo must be used to uninstall non-matching versions of packages.
+# pip is removed to avoid conflicts with the pre-installed pip version on Actions.
+# This technique does not work with Windows, unfortunately.
+
+from github import Github
+import os, sys
+
+def print_usage():
+    print('Upload assets to a Filament GitHub release.')
+    print()
+    print('Usage:')
+    print('  upload-assets.py <tag> <asset>...')
+    print()
+    print('Notes:')
+    print('  The GitHub release must already be created prior to running this script. This is typically done')
+    print('  through the GitHub web UI.')
+    print()
+    print('  <tag> is the Git tag for the desired release to attach assets to, for example, "v1.4.2".')
+    print()
+    print('  <asset> is a path to the asset file to upload. The file name will be used as the name of the')
+    print('  asset.')
+    print()
+    print('  The GITHUB_API_KEY environment variable must be set to a valid authentication token for a')
+    print('  collaborator account of the Filament repository.')
+
+# The first argument is the path to this script.
+if len(sys.argv) < 3:
+    print_usage()
+    sys.exit(1)
+
+tag = sys.argv[1]
+assets = sys.argv[2:]
+
+authentication_token = os.environ.get('GITHUB_API_KEY')
+if not authentication_token:
+    sys.stderr.write('Error: the GITHUB_API_KEY is not set.\n')
+    sys.exit(1)
+
+g = Github(authentication_token)
+
+FILAMENT_REPO = "google/filament"
+filament = g.get_repo(FILAMENT_REPO)
+
+def find_release_from_tag(repo, tag):
+    """ Find a release in the repo for the given Git tag string. """
+    releases = repo.get_releases()
+    for r in releases:
+        if r.tag_name == tag:
+            return r
+    return None
+
+release = find_release_from_tag(filament, tag)
+if not release:
+    sys.stderr.write(f"Error: Could not find release with tag '{tag}'.\n")
+    sys.exit(1)
+
+print(f"Found release with tag '{tag}'.")
+
+for asset_path in assets:
+    sys.stdout.write(f'Uploding asset: {asset_path}... ')
+    asset_name = os.path.basename(asset_path)
+    asset = release.upload_asset(asset_path, name=asset_name)
+    if asset:
+        sys.stdout.write('Success!\n')
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-const uploadReleaseAssets = async ({github, context}, assetPathsToUpload, releaseTag) => {
-    const fs = require('fs/promises');
-    const path = require('path');
-
-    const filesToUpload = assetPathsToUpload.map(assetPath => ({
-        buffer: fs.readFile(assetPath),
-        assetName: path.basename(assetPath)
-    }));
-
-    const findReleaseMatchingTag = async tag => {
-        const { data: releases } = await github.rest.repos.listReleases(context.repo);
-        const release = releases.find(release => release.tag_name === releaseTag);
-        if (!release) {
-            throw new Error(`Could not locate release with tag '${releaseTag}'`);
-        }
-        return release;
-    };
-
-    const release = await findReleaseMatchingTag(releaseTag);
-
-    console.log(`Found release named '${release.name}' matching tag '${release.tag_name}'.`);
-
-    const uploadPromises = [];
-    for (const file of filesToUpload) {
-        console.log(`Uploading asset ${file.assetName}.`);
-        const p = github.rest.repos.uploadReleaseAsset({
-            ...context.repo,
-            release_id: release.id,
-            name: file.assetName,
-            data: await file.buffer
-        });
-        uploadPromises.push(p);
-    }
-
-    await Promise.all(uploadPromises);
-    console.log("Done!");
-}
-
-module.exports = uploadReleaseAssets;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-// To test this script locally, uncomment the code below and run:
-//
-// npm install
-// node index.js
-
-// const { Octokit } = require("@octokit/rest");
-// const glob = require("@actions/glob");
-// (async () => {
-//     const github = new Octokit({
-//         auth: ""     // <-- paste GitHub auth token here
-//     });
-//     const context = {
-//         repo: {
-//             owner: "bejado",
-//             repo: "filament",
-//         },
-//     };
-//     const globber = await glob.create('*.txt');
-//     await uploadReleaseAssets({ github, context }, await globber.glob(), 'vtest-28');
-// })();
@@ -1,546 +0,0 @@
-{
-  "name": "upload-release-assets",
-  "version": "1.0.0",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "version": "1.0.0",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@actions/glob": "^0.3.0",
-        "@octokit/rest": "^19.0.5"
-      }
-    },
-    "node_modules/@actions/core": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.10.0.tgz",
-      "integrity": "sha512-2aZDDa3zrrZbP5ZYg159sNoLRb61nQ7awl5pSvIq5Qpj81vwDzdMRKzkWJGJuwVvWpvZKx7vspJALyvaaIQyug==",
-      "dependencies": {
-        "@actions/http-client": "^2.0.1",
-        "uuid": "^8.3.2"
-      }
-    },
-    "node_modules/@actions/glob": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/@actions/glob/-/glob-0.3.0.tgz",
-      "integrity": "sha512-tJP1ZhF87fd6LBnaXWlahkyvdgvsLl7WnreW1EZaC8JWjpMXmzqWzQVe/IEYslrkT9ymibVrKyJN4UMD7uQM2w==",
-      "dependencies": {
-        "@actions/core": "^1.2.6",
-        "minimatch": "^3.0.4"
-      }
-    },
-    "node_modules/@actions/http-client": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.0.1.tgz",
-      "integrity": "sha512-PIXiMVtz6VvyaRsGY268qvj57hXQEpsYogYOu2nrQhlf+XCGmZstmuZBbAybUl1nQGnvS1k1eEsQ69ZoD7xlSw==",
-      "dependencies": {
-        "tunnel": "^0.0.6"
-      }
-    },
-    "node_modules/@octokit/auth-token": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-3.0.2.tgz",
-      "integrity": "sha512-pq7CwIMV1kmzkFTimdwjAINCXKTajZErLB4wMLYapR2nuB/Jpr66+05wOTZMSCBXP6n4DdDWT2W19Bm17vU69Q==",
-      "dependencies": {
-        "@octokit/types": "^8.0.0"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/@octokit/core": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-4.1.0.tgz",
-      "integrity": "sha512-Czz/59VefU+kKDy+ZfDwtOIYIkFjExOKf+HA92aiTZJ6EfWpFzYQWw0l54ji8bVmyhc+mGaLUbSUmXazG7z5OQ==",
-      "dependencies": {
-        "@octokit/auth-token": "^3.0.0",
-        "@octokit/graphql": "^5.0.0",
-        "@octokit/request": "^6.0.0",
-        "@octokit/request-error": "^3.0.0",
-        "@octokit/types": "^8.0.0",
-        "before-after-hook": "^2.2.0",
-        "universal-user-agent": "^6.0.0"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/@octokit/endpoint": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-7.0.3.tgz",
-      "integrity": "sha512-57gRlb28bwTsdNXq+O3JTQ7ERmBTuik9+LelgcLIVfYwf235VHbN9QNo4kXExtp/h8T423cR5iJThKtFYxC7Lw==",
-      "dependencies": {
-        "@octokit/types": "^8.0.0",
-        "is-plain-object": "^5.0.0",
-        "universal-user-agent": "^6.0.0"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/@octokit/graphql": {
-      "version": "5.0.4",
-      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-5.0.4.tgz",
-      "integrity": "sha512-amO1M5QUQgYQo09aStR/XO7KAl13xpigcy/kI8/N1PnZYSS69fgte+xA4+c2DISKqUZfsh0wwjc2FaCt99L41A==",
-      "dependencies": {
-        "@octokit/request": "^6.0.0",
-        "@octokit/types": "^8.0.0",
-        "universal-user-agent": "^6.0.0"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/@octokit/openapi-types": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-14.0.0.tgz",
-      "integrity": "sha512-HNWisMYlR8VCnNurDU6os2ikx0s0VyEjDYHNS/h4cgb8DeOxQ0n72HyinUtdDVxJhFy3FWLGl0DJhfEWk3P5Iw=="
-    },
-    "node_modules/@octokit/plugin-paginate-rest": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-5.0.1.tgz",
-      "integrity": "sha512-7A+rEkS70pH36Z6JivSlR7Zqepz3KVucEFVDnSrgHXzG7WLAzYwcHZbKdfTXHwuTHbkT1vKvz7dHl1+HNf6Qyw==",
-      "dependencies": {
-        "@octokit/types": "^8.0.0"
-      },
-      "engines": {
-        "node": ">= 14"
-      },
-      "peerDependencies": {
-        "@octokit/core": ">=4"
-      }
-    },
-    "node_modules/@octokit/plugin-request-log": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz",
-      "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA==",
-      "peerDependencies": {
-        "@octokit/core": ">=3"
-      }
-    },
-    "node_modules/@octokit/plugin-rest-endpoint-methods": {
-      "version": "6.7.0",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-6.7.0.tgz",
-      "integrity": "sha512-orxQ0fAHA7IpYhG2flD2AygztPlGYNAdlzYz8yrD8NDgelPfOYoRPROfEyIe035PlxvbYrgkfUZIhSBKju/Cvw==",
-      "dependencies": {
-        "@octokit/types": "^8.0.0",
-        "deprecation": "^2.3.1"
-      },
-      "engines": {
-        "node": ">= 14"
-      },
-      "peerDependencies": {
-        "@octokit/core": ">=3"
-      }
-    },
-    "node_modules/@octokit/request": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-6.2.2.tgz",
-      "integrity": "sha512-6VDqgj0HMc2FUX2awIs+sM6OwLgwHvAi4KCK3mT2H2IKRt6oH9d0fej5LluF5mck1lRR/rFWN0YIDSYXYSylbw==",
-      "dependencies": {
-        "@octokit/endpoint": "^7.0.0",
-        "@octokit/request-error": "^3.0.0",
-        "@octokit/types": "^8.0.0",
-        "is-plain-object": "^5.0.0",
-        "node-fetch": "^2.6.7",
-        "universal-user-agent": "^6.0.0"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/@octokit/request-error": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-3.0.2.tgz",
-      "integrity": "sha512-WMNOFYrSaX8zXWoJg9u/pKgWPo94JXilMLb2VManNOby9EZxrQaBe/QSC4a1TzpAlpxofg2X/jMnCyZgL6y7eg==",
-      "dependencies": {
-        "@octokit/types": "^8.0.0",
-        "deprecation": "^2.0.0",
-        "once": "^1.4.0"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/@octokit/rest": {
-      "version": "19.0.5",
-      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-19.0.5.tgz",
-      "integrity": "sha512-+4qdrUFq2lk7Va+Qff3ofREQWGBeoTKNqlJO+FGjFP35ZahP+nBenhZiGdu8USSgmq4Ky3IJ/i4u0xbLqHaeow==",
-      "dependencies": {
-        "@octokit/core": "^4.1.0",
-        "@octokit/plugin-paginate-rest": "^5.0.0",
-        "@octokit/plugin-request-log": "^1.0.4",
-        "@octokit/plugin-rest-endpoint-methods": "^6.7.0"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/@octokit/types": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-8.0.0.tgz",
-      "integrity": "sha512-65/TPpOJP1i3K4lBJMnWqPUJ6zuOtzhtagDvydAWbEXpbFYA0oMKKyLb95NFZZP0lSh/4b6K+DQlzvYQJQQePg==",
-      "dependencies": {
-        "@octokit/openapi-types": "^14.0.0"
-      }
-    },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
-    },
-    "node_modules/before-after-hook": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz",
-      "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ=="
-    },
-    "node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="
-    },
-    "node_modules/deprecation": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
-      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
-    },
-    "node_modules/is-plain-object": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
-      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/node-fetch": {
-      "version": "2.6.7",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz",
-      "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==",
-      "dependencies": {
-        "whatwg-url": "^5.0.0"
-      },
-      "engines": {
-        "node": "4.x || >=6.0.0"
-      },
-      "peerDependencies": {
-        "encoding": "^0.1.0"
-      },
-      "peerDependenciesMeta": {
-        "encoding": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
-    "node_modules/tr46": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
-      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="
-    },
-    "node_modules/tunnel": {
-      "version": "0.0.6",
-      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz",
-      "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==",
-      "engines": {
-        "node": ">=0.6.11 <=0.7.0 || >=0.7.3"
-      }
-    },
-    "node_modules/universal-user-agent": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
-      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
-    },
-    "node_modules/uuid": {
-      "version": "8.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
-      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
-      "bin": {
-        "uuid": "dist/bin/uuid"
-      }
-    },
-    "node_modules/webidl-conversions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
-      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="
-    },
-    "node_modules/whatwg-url": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
-      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
-      "dependencies": {
-        "tr46": "~0.0.3",
-        "webidl-conversions": "^3.0.0"
-      }
-    },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
-    }
-  },
-  "dependencies": {
-    "@actions/core": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.10.0.tgz",
-      "integrity": "sha512-2aZDDa3zrrZbP5ZYg159sNoLRb61nQ7awl5pSvIq5Qpj81vwDzdMRKzkWJGJuwVvWpvZKx7vspJALyvaaIQyug==",
-      "requires": {
-        "@actions/http-client": "^2.0.1",
-        "uuid": "^8.3.2"
-      }
-    },
-    "@actions/glob": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/@actions/glob/-/glob-0.3.0.tgz",
-      "integrity": "sha512-tJP1ZhF87fd6LBnaXWlahkyvdgvsLl7WnreW1EZaC8JWjpMXmzqWzQVe/IEYslrkT9ymibVrKyJN4UMD7uQM2w==",
-      "requires": {
-        "@actions/core": "^1.2.6",
-        "minimatch": "^3.0.4"
-      }
-    },
-    "@actions/http-client": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.0.1.tgz",
-      "integrity": "sha512-PIXiMVtz6VvyaRsGY268qvj57hXQEpsYogYOu2nrQhlf+XCGmZstmuZBbAybUl1nQGnvS1k1eEsQ69ZoD7xlSw==",
-      "requires": {
-        "tunnel": "^0.0.6"
-      }
-    },
-    "@octokit/auth-token": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-3.0.2.tgz",
-      "integrity": "sha512-pq7CwIMV1kmzkFTimdwjAINCXKTajZErLB4wMLYapR2nuB/Jpr66+05wOTZMSCBXP6n4DdDWT2W19Bm17vU69Q==",
-      "requires": {
-        "@octokit/types": "^8.0.0"
-      }
-    },
-    "@octokit/core": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-4.1.0.tgz",
-      "integrity": "sha512-Czz/59VefU+kKDy+ZfDwtOIYIkFjExOKf+HA92aiTZJ6EfWpFzYQWw0l54ji8bVmyhc+mGaLUbSUmXazG7z5OQ==",
-      "requires": {
-        "@octokit/auth-token": "^3.0.0",
-        "@octokit/graphql": "^5.0.0",
-        "@octokit/request": "^6.0.0",
-        "@octokit/request-error": "^3.0.0",
-        "@octokit/types": "^8.0.0",
-        "before-after-hook": "^2.2.0",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "@octokit/endpoint": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-7.0.3.tgz",
-      "integrity": "sha512-57gRlb28bwTsdNXq+O3JTQ7ERmBTuik9+LelgcLIVfYwf235VHbN9QNo4kXExtp/h8T423cR5iJThKtFYxC7Lw==",
-      "requires": {
-        "@octokit/types": "^8.0.0",
-        "is-plain-object": "^5.0.0",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "@octokit/graphql": {
-      "version": "5.0.4",
-      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-5.0.4.tgz",
-      "integrity": "sha512-amO1M5QUQgYQo09aStR/XO7KAl13xpigcy/kI8/N1PnZYSS69fgte+xA4+c2DISKqUZfsh0wwjc2FaCt99L41A==",
-      "requires": {
-        "@octokit/request": "^6.0.0",
-        "@octokit/types": "^8.0.0",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "@octokit/openapi-types": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-14.0.0.tgz",
-      "integrity": "sha512-HNWisMYlR8VCnNurDU6os2ikx0s0VyEjDYHNS/h4cgb8DeOxQ0n72HyinUtdDVxJhFy3FWLGl0DJhfEWk3P5Iw=="
-    },
-    "@octokit/plugin-paginate-rest": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-5.0.1.tgz",
-      "integrity": "sha512-7A+rEkS70pH36Z6JivSlR7Zqepz3KVucEFVDnSrgHXzG7WLAzYwcHZbKdfTXHwuTHbkT1vKvz7dHl1+HNf6Qyw==",
-      "requires": {
-        "@octokit/types": "^8.0.0"
-      }
-    },
-    "@octokit/plugin-request-log": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz",
-      "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA==",
-      "requires": {}
-    },
-    "@octokit/plugin-rest-endpoint-methods": {
-      "version": "6.7.0",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-6.7.0.tgz",
-      "integrity": "sha512-orxQ0fAHA7IpYhG2flD2AygztPlGYNAdlzYz8yrD8NDgelPfOYoRPROfEyIe035PlxvbYrgkfUZIhSBKju/Cvw==",
-      "requires": {
-        "@octokit/types": "^8.0.0",
-        "deprecation": "^2.3.1"
-      }
-    },
-    "@octokit/request": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-6.2.2.tgz",
-      "integrity": "sha512-6VDqgj0HMc2FUX2awIs+sM6OwLgwHvAi4KCK3mT2H2IKRt6oH9d0fej5LluF5mck1lRR/rFWN0YIDSYXYSylbw==",
-      "requires": {
-        "@octokit/endpoint": "^7.0.0",
-        "@octokit/request-error": "^3.0.0",
-        "@octokit/types": "^8.0.0",
-        "is-plain-object": "^5.0.0",
-        "node-fetch": "^2.6.7",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "@octokit/request-error": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-3.0.2.tgz",
-      "integrity": "sha512-WMNOFYrSaX8zXWoJg9u/pKgWPo94JXilMLb2VManNOby9EZxrQaBe/QSC4a1TzpAlpxofg2X/jMnCyZgL6y7eg==",
-      "requires": {
-        "@octokit/types": "^8.0.0",
-        "deprecation": "^2.0.0",
-        "once": "^1.4.0"
-      }
-    },
-    "@octokit/rest": {
-      "version": "19.0.5",
-      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-19.0.5.tgz",
-      "integrity": "sha512-+4qdrUFq2lk7Va+Qff3ofREQWGBeoTKNqlJO+FGjFP35ZahP+nBenhZiGdu8USSgmq4Ky3IJ/i4u0xbLqHaeow==",
-      "requires": {
-        "@octokit/core": "^4.1.0",
-        "@octokit/plugin-paginate-rest": "^5.0.0",
-        "@octokit/plugin-request-log": "^1.0.4",
-        "@octokit/plugin-rest-endpoint-methods": "^6.7.0"
-      }
-    },
-    "@octokit/types": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-8.0.0.tgz",
-      "integrity": "sha512-65/TPpOJP1i3K4lBJMnWqPUJ6zuOtzhtagDvydAWbEXpbFYA0oMKKyLb95NFZZP0lSh/4b6K+DQlzvYQJQQePg==",
-      "requires": {
-        "@octokit/openapi-types": "^14.0.0"
-      }
-    },
-    "balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
-    },
-    "before-after-hook": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz",
-      "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ=="
-    },
-    "brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "requires": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="
-    },
-    "deprecation": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
-      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
-    },
-    "is-plain-object": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
-      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q=="
-    },
-    "minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "requires": {
-        "brace-expansion": "^1.1.7"
-      }
-    },
-    "node-fetch": {
-      "version": "2.6.7",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz",
-      "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==",
-      "requires": {
-        "whatwg-url": "^5.0.0"
-      }
-    },
-    "once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "requires": {
-        "wrappy": "1"
-      }
-    },
-    "tr46": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
-      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="
-    },
-    "tunnel": {
-      "version": "0.0.6",
-      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz",
-      "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg=="
-    },
-    "universal-user-agent": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
-      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
-    },
-    "uuid": {
-      "version": "8.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
-      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="
-    },
-    "webidl-conversions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
-      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="
-    },
-    "whatwg-url": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
-      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
-      "requires": {
-        "tr46": "~0.0.3",
-        "webidl-conversions": "^3.0.0"
-      }
-    },
-    "wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
-    }
-  }
-}
@@ -1,15 +0,0 @@
-{
-  "name": "upload-release-assets",
-  "version": "1.0.0",
-  "description": "Upload Filament release assets",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "Google",
-  "license": "Apache-2.0",
-  "dependencies": {
-    "@actions/glob": "^0.3.0",
-    "@octokit/rest": "^19.0.5"
-  }
-}
@@ -405,7 +405,6 @@ if (APPLE)
        backend
        getopt
        gtest
-        filamat
        SPIRV
        spirv-cross-glsl)

@@ -96,8 +96,6 @@ struct MetalContext {
    SamplerStateCache samplerStateCache;
    ArgumentEncoderCache argumentEncoderCache;

-    PolygonOffset currentPolygonOffset = {0.0f, 0.0f};
-
    MetalSamplerGroup* samplerBindings[Program::SAMPLER_BINDING_COUNT] = {};

    // Keeps track of sampler groups we've finalized for the current render pass.
@@ -1005,7 +1005,6 @@ void MetalDriver::beginRenderPass(Handle<HwRenderTarget> rth,
    mContext->depthStencilState.invalidate();
    mContext->cullModeState.invalidate();
    mContext->windingState.invalidate();
-    mContext->currentPolygonOffset = {0.0f, 0.0f};

    mContext->finalizedSamplerGroups.clear();
 }
@@ -1184,12 +1183,8 @@ void MetalDriver::startCapture(int) {
    if (@available(iOS 13, *)) {
        MTLCaptureDescriptor* descriptor = [MTLCaptureDescriptor new];
        descriptor.captureObject = mContext->device;
-#if defined(IOS)
-        descriptor.destination = MTLCaptureDestinationDeveloperTools;
-#else
        descriptor.destination = MTLCaptureDestinationGPUTraceDocument;
        descriptor.outputURL = [[NSURL alloc] initFileURLWithPath:@"filament.gputrace"];
-#endif
        NSError* error = nil;
        [[MTLCaptureManager sharedCaptureManager] startCaptureWithDescriptor:descriptor
                                                                           error:&error];
@@ -1591,12 +1586,10 @@ void MetalDriver::draw(PipelineState ps, Handle<HwRenderPrimitive> rph, uint32_t
        [mContext->currentRenderPassEncoder setDepthStencilState:state];
    }

-    if (ps.polygonOffset.constant != mContext->currentPolygonOffset.constant ||
-        ps.polygonOffset.slope != mContext->currentPolygonOffset.slope) {
+    if (ps.polygonOffset.constant != 0.0 || ps.polygonOffset.slope != 0.0) {
        [mContext->currentRenderPassEncoder setDepthBias:ps.polygonOffset.constant
                                              slopeScale:ps.polygonOffset.slope
                                                   clamp:0.0];
-        mContext->currentPolygonOffset = ps.polygonOffset;
    }

    // Set scissor-rectangle.
@@ -286,15 +286,13 @@ bool OpenGLProgram::checkProgramStatus(const char* name,
    for (size_t i = 0; i < Program::SHADER_TYPE_COUNT; i++) {
        const ShaderStage type = static_cast<ShaderStage>(i);
        const GLuint shader = shaderIds[i];
-        if (shader) {
-            glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
-            if (status != GL_TRUE) {
-                logCompilationError(slog.e, type, name, shader, shaderSourceCode[i]);
-            }
-            glDetachShader(program, shader);
-            glDeleteShader(shader);
-            shaderIds[i] = 0;
+        glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
+        if (status != GL_TRUE) {
+            logCompilationError(slog.e, type, name, shader, shaderSourceCode[i]);
        }
+        glDetachShader(program, shader);
+        glDeleteShader(shader);
+        shaderIds[i] = 0;
    }
    // log the link error as well
    logProgramLinkError(slog.e, name, program);
@@ -22,12 +22,8 @@
 #include <spirv_glsl.hpp>
 #include <spirv_msl.hpp>

-#include "../src/GLSLPostProcessor.h"
-
 #include "builtinResource.h"

-#include <utils/FixedCapacityVector.h>
-
 #include <iostream>
 #include <utility>
 #include <vector>
@@ -63,6 +59,38 @@ void SpvToGlsl(const SpirvBlob* spirv, std::string* outGlsl) {
    *outGlsl = glslCompiler.compile();
 }

+void SpvToMsl(const SpirvBlob* spirv, std::string* outMsl) {
+    CompilerMSL mslCompiler(*spirv);
+    mslCompiler.set_msl_options(CompilerMSL::Options {
+        .msl_version = CompilerMSL::Options::make_msl_version(1, 1)
+    });
+
+    auto executionModel = mslCompiler.get_execution_model();
+
+    auto duplicateResourceBinding = [executionModel, &mslCompiler](const auto& resource) {
+        auto set = mslCompiler.get_decoration(resource.id, spv::DecorationDescriptorSet);
+        auto binding = mslCompiler.get_decoration(resource.id, spv::DecorationBinding);
+        MSLResourceBinding newBinding;
+        newBinding.stage = executionModel;
+        newBinding.desc_set = set;
+        newBinding.binding = binding;
+        newBinding.msl_texture = binding;
+        newBinding.msl_sampler = binding;
+        newBinding.msl_buffer = binding;
+        mslCompiler.add_msl_resource_binding(newBinding);
+    };
+
+    auto resources = mslCompiler.get_shader_resources();
+    for (const auto& resource : resources.sampled_images) {
+        duplicateResourceBinding(resource);
+    }
+    for (const auto& resource : resources.uniform_buffers) {
+        duplicateResourceBinding(resource);
+    }
+
+    *outMsl = mslCompiler.compile();
+}
+
 } // anonymous namespace

 void ShaderGenerator::init() {
@@ -74,16 +102,15 @@ void ShaderGenerator::shutdown() {
 }

 ShaderGenerator::ShaderGenerator(std::string vertex, std::string fragment,
-        Backend backend, bool isMobile, const filament::SamplerInterfaceBlock* sib) noexcept
+        Backend backend, bool isMobile) noexcept
        : mBackend(backend),
-          mVertexBlob(transpileShader(ShaderStage::VERTEX, std::move(vertex), backend, isMobile, sib)),
+          mVertexBlob(transpileShader(ShaderStage::VERTEX, std::move(vertex), backend, isMobile)),
          mFragmentBlob(transpileShader(ShaderStage::FRAGMENT, std::move(fragment), backend,
-                  isMobile, sib)) {
+                  isMobile)) {
 }

 ShaderGenerator::Blob ShaderGenerator::transpileShader(
-        ShaderStage stage, std::string shader, Backend backend, bool isMobile,
-        const filament::SamplerInterfaceBlock* sib) noexcept {
+        ShaderStage stage, std::string shader, Backend backend, bool isMobile) noexcept {
    TProgram program;
    const EShLanguage language = stage == ShaderStage::VERTEX ? EShLangVertex : EShLangFragment;
    TShader tShader(language);
@@ -146,10 +173,7 @@ ShaderGenerator::Blob ShaderGenerator::transpileShader(
        }
        return { result.c_str(), result.c_str() + result.length() + 1 };
    } else if (backend == Backend::METAL) {
-        const auto sm = isMobile ? ShaderModel::MOBILE : ShaderModel::DESKTOP;
-        filamat::SibVector sibs = filamat::SibVector::with_capacity(1);
-        if (sib) { sibs.emplace_back(0, sib); }
-        filamat::GLSLPostProcessor::spirvToMsl(&spirv, &result, sm, false, sibs, nullptr);
+        SpvToMsl(&spirv, &result);
        return { result.c_str(), result.c_str() + result.length() + 1 };
    } else if (backend == Backend::VULKAN) {
        return { (uint8_t*)spirv.data(), (uint8_t*)(spirv.data() + spirv.size()) };
@@ -19,7 +19,6 @@

 #include "PlatformRunner.h"

-#include "private/filament/SamplerInterfaceBlock.h"
 #include "private/backend/DriverApi.h"
 #include "backend/Program.h"

@@ -39,8 +38,7 @@ public:
     * @param vertex The vertex shader, written in GLSL 450 core.
     * @param fragment The fragment shader, written in GLSL 450 core.
     */
-    ShaderGenerator(std::string vertex, std::string fragment, Backend backend, bool isMobile,
-            const filament::SamplerInterfaceBlock* sib = nullptr) noexcept;
+    ShaderGenerator(std::string vertex, std::string fragment, Backend backend, bool isMobile) noexcept;

    ShaderGenerator(const ShaderGenerator& rhs) = delete;
    ShaderGenerator& operator=(const ShaderGenerator& rhs) = delete;
@@ -52,7 +50,7 @@ private:

    using Blob = std::vector<char>;
    static Blob transpileShader(ShaderStage stage, std::string shader, Backend backend,
-            bool isMobile, const filament::SamplerInterfaceBlock* sib = nullptr) noexcept;
+            bool isMobile) noexcept;

    Backend mBackend;

@@ -133,12 +133,7 @@ TEST_F(BackendTest, FeedbackLoops) {
        // Create a program.
        ProgramHandle program;
        {
-            SamplerInterfaceBlock sib = filament::SamplerInterfaceBlock::Builder()
-                    .name("backend_test_sib")
-                    .stageFlags(backend::ShaderStageFlags::ALL_SHADER_STAGE_FLAGS)
-                    .add( {{"tex", SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH }} )
-                    .build();
-            ShaderGenerator shaderGen(fullscreenVs, fullscreenFs, sBackend, sIsMobilePlatform, &sib);
+            ShaderGenerator shaderGen(fullscreenVs, fullscreenFs, sBackend, sIsMobilePlatform);
            Program prog = shaderGen.getProgram(api);
            Program::Sampler psamplers[] = { utils::CString("tex"), 0 };
            prog.setSamplerGroup(0, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, psamplers, sizeof(psamplers) / sizeof(psamplers[0]));
@@ -19,7 +19,6 @@
 #include "ShaderGenerator.h"
 #include "TrianglePrimitive.h"

-#include "private/filament/SamplerInterfaceBlock.h"
 #include "private/backend/SamplerGroup.h"

 #include <math/half.h>
@@ -55,7 +54,7 @@ layout(location = 0) out vec4 fragColor;

 // Filament's Vulkan backend requires a descriptor set index of 1 for all samplers.
 // This parameter is ignored for other backends.
-layout(location = 0, set = 1) uniform {samplerType} test_tex;
+layout(location = 0, set = 1) uniform {samplerType} tex;

 void main() {
    vec2 fbsize = vec2(512);
@@ -63,7 +62,7 @@ void main() {
 #if defined(TARGET_METAL_ENVIRONMENT) || defined(TARGET_VULKAN_ENVIRONMENT)
    uv.y = 1.0 - uv.y;
 #endif
-    fragColor = vec4(texture(test_tex, uv).rgb, 1.0f);
+    fragColor = vec4(texture(tex, uv).rgb, 1.0f);
 }

 )");
@@ -73,7 +72,8 @@ std::string fragmentUpdateImage3DTemplate (R"(#version 450 core
 layout(location = 0) out vec4 fragColor;

 // Filament's Vulkan backend requires a descriptor set index of 1 for all samplers.
-layout(location = 0, set = 1) uniform {samplerType} test_tex;
+// This parameter is ignored for other backends.
+layout(location = 0, set = 1) uniform {samplerType} tex;

 float getLayer(in sampler3D s) { return 2.5f / 4.0f; }
 float getLayer(in sampler2DArray s) { return 2.0f; }
@@ -84,7 +84,7 @@ void main() {
 #if defined(TARGET_METAL_ENVIRONMENT) || defined(TARGET_VULKAN_ENVIRONMENT)
    uv.y = 1.0 - uv.y;
 #endif
-    fragColor = vec4(texture(test_tex, vec3(uv, getLayer(test_tex))).rgb, 1.0f);
+    fragColor = vec4(texture(tex, vec3(uv, getLayer(tex))).rgb, 1.0f);
 }

 )");
@@ -94,7 +94,8 @@ std::string fragmentUpdateImageMip (R"(#version 450 core
 layout(location = 0) out vec4 fragColor;

 // Filament's Vulkan backend requires a descriptor set index of 1 for all samplers.
-layout(location = 0, set = 1) uniform sampler2D test_tex;
+// This parameter is ignored for other backends.
+layout(location = 0, set = 1) uniform sampler2D tex;

 void main() {
    vec2 fbsize = vec2(512);
@@ -102,7 +103,7 @@ void main() {
 #if defined(TARGET_METAL_ENVIRONMENT) || defined(TARGET_VULKAN_ENVIRONMENT)
    uv.y = 1.0 - uv.y;
 #endif
-    fragColor = vec4(textureLod(test_tex, uv, 1.0f).rgb, 1.0f);
+    fragColor = vec4(textureLod(tex, uv, 1.0f).rgb, 1.0f);
 }

 )");
@@ -344,15 +345,10 @@ TEST_F(BackendTest, UpdateImage2D) {
        auto defaultRenderTarget = api.createDefaultRenderTarget(0);

        // Create a program.
-        SamplerInterfaceBlock sib = filament::SamplerInterfaceBlock::Builder()
-                .name("Test")
-                .stageFlags(backend::ShaderStageFlags::ALL_SHADER_STAGE_FLAGS)
-                .add( {{"tex", SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH }} )
-                .build();
        ProgramHandle program;
        std::string fragment = stringReplace("{samplerType}",
                getSamplerTypeName(t.textureFormat), fragmentTemplate);
-        ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform, &sib);
+        ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
        Program prog = shaderGen.getProgram(api);
        Program::Sampler psamplers[] = { utils::CString("tex"), 0 };
        prog.setSamplerGroup(0, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, psamplers, sizeof(psamplers) / sizeof(psamplers[0]));
@@ -429,14 +425,9 @@ TEST_F(BackendTest, UpdateImageSRGB) {
    auto defaultRenderTarget = api.createDefaultRenderTarget(0);

    // Create a program.
-    SamplerInterfaceBlock sib = filament::SamplerInterfaceBlock::Builder()
-            .name("Test")
-            .stageFlags(backend::ShaderStageFlags::ALL_SHADER_STAGE_FLAGS)
-            .add( {{"tex", SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH }} )
-            .build();
    std::string fragment = stringReplace("{samplerType}",
            getSamplerTypeName(textureFormat), fragmentTemplate);
-    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform, &sib);
+    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
    Program prog = shaderGen.getProgram(api);
    Program::Sampler psamplers[] = { utils::CString("tex"), 0 };
    prog.setSamplerGroup(0, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, psamplers, sizeof(psamplers) / sizeof(psamplers[0]));
@@ -520,14 +511,9 @@ TEST_F(BackendTest, UpdateImageMipLevel) {
    auto defaultRenderTarget = api.createDefaultRenderTarget(0);

    // Create a program.
-    SamplerInterfaceBlock sib = filament::SamplerInterfaceBlock::Builder()
-            .name("Test")
-            .stageFlags(backend::ShaderStageFlags::ALL_SHADER_STAGE_FLAGS)
-            .add( {{"tex", SamplerType::SAMPLER_3D, SamplerFormat::FLOAT, Precision::HIGH }} )
-            .build();
    std::string fragment = stringReplace("{samplerType}",
            getSamplerTypeName(textureFormat), fragmentUpdateImageMip);
-    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform, &sib);
+    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
    Program prog = shaderGen.getProgram(api);
    Program::Sampler psamplers[] = { utils::CString("tex"), 0 };
    prog.setSamplerGroup(0, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, psamplers, sizeof(psamplers) / sizeof(psamplers[0]));
@@ -597,14 +583,9 @@ TEST_F(BackendTest, UpdateImage3D) {
    auto defaultRenderTarget = api.createDefaultRenderTarget(0);

    // Create a program.
-    SamplerInterfaceBlock sib = filament::SamplerInterfaceBlock::Builder()
-            .name("Test")
-            .stageFlags(backend::ShaderStageFlags::ALL_SHADER_STAGE_FLAGS)
-            .add( {{"tex", SamplerType::SAMPLER_3D, SamplerFormat::FLOAT, Precision::HIGH }} )
-            .build();
    std::string fragment = stringReplace("{samplerType}",
            getSamplerTypeName(samplerType), fragmentUpdateImage3DTemplate);
-    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform, &sib);
+    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);
    Program prog = shaderGen.getProgram(api);
    Program::Sampler psamplers[] = { utils::CString("tex"), 0 };
    prog.setSamplerGroup(0, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, psamplers, sizeof(psamplers) / sizeof(psamplers[0]));
@@ -45,7 +45,7 @@ std::string fragment (R"(#version 450 core
 layout(location = 0) out vec4 fragColor;
 layout(location = 0) in vec2 uv;

-layout(location = 0, set = 1) uniform sampler2D tex;
+layout(set = 1, binding = 6) uniform sampler2D tex;

 void main() {
    fragColor = texture(tex, uv);
@@ -65,16 +65,11 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {

    auto swapChain = createSwapChain();

-    SamplerInterfaceBlock sib = filament::SamplerInterfaceBlock::Builder()
-            .name("backend_test_sib")
-            .stageFlags(backend::ShaderStageFlags::ALL_SHADER_STAGE_FLAGS)
-            .add( {{"tex", SamplerType::SAMPLER_EXTERNAL, SamplerFormat::FLOAT, Precision::HIGH }} )
-            .build();
-    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform, &sib);
+    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);

    // Create a program that samples a texture.
    Program p = shaderGen.getProgram(getDriverApi());
-    Program::Sampler sampler { utils::CString("tex"), 0 };
+    Program::Sampler sampler { utils::CString("tex"), 6 };
    p.setSamplerGroup(0, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, &sampler, 1);
    backend::Handle<HwProgram> program = getDriverApi().createProgram(std::move(p));

@@ -144,16 +139,11 @@ TEST_F(BackendTest, RenderExternalImage) {

    auto swapChain = createSwapChain();

-    SamplerInterfaceBlock sib = filament::SamplerInterfaceBlock::Builder()
-            .name("backend_test_sib")
-            .stageFlags(backend::ShaderStageFlags::ALL_SHADER_STAGE_FLAGS)
-            .add( {{"tex", SamplerType::SAMPLER_EXTERNAL, SamplerFormat::FLOAT, Precision::HIGH }} )
-            .build();
-    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform, &sib);
+    ShaderGenerator shaderGen(vertex, fragment, sBackend, sIsMobilePlatform);

    // Create a program that samples a texture.
    Program p = shaderGen.getProgram(getDriverApi());
-    Program::Sampler sampler { utils::CString("tex"), 0 };
+    Program::Sampler sampler { utils::CString("tex"), 6 };
    p.setSamplerGroup(0, ShaderStageFlags::ALL_SHADER_STAGE_FLAGS, &sampler, 1);
    auto program = getDriverApi().createProgram(std::move(p));

@@ -98,6 +98,45 @@ void PerShadowMapUniforms::prepareTime(Transaction const& transaction,
    s.userTime = userTime;
 }

+void PerShadowMapUniforms::prepareDirectionalLight(Transaction const& transaction,
+        FEngine& engine,
+        float exposure,
+        float3 const& sceneSpaceDirection,
+        PerShadowMapUniforms::LightManagerInstance directionalLight) noexcept {
+    FLightManager& lcm = engine.getLightManager();
+    auto& s = edit(transaction);
+
+    const float3 l = -sceneSpaceDirection; // guaranteed normalized
+
+    if (directionalLight.isValid()) {
+        const float4 colorIntensity = {
+                lcm.getColor(directionalLight), lcm.getIntensity(directionalLight) * exposure };
+
+        s.lightDirection = l;
+        s.lightColorIntensity = colorIntensity;
+        s.lightChannels = lcm.getLightChannels(directionalLight);
+
+        const bool isSun = lcm.isSunLight(directionalLight);
+        // The last parameter must be < 0.0f for regular directional lights
+        float4 sun{ 0.0f, 0.0f, 0.0f, -1.0f };
+        if (UTILS_UNLIKELY(isSun && colorIntensity.w > 0.0f)) {
+            // currently we have only a single directional light, so it's probably likely that it's
+            // also the Sun. However, conceptually, most directional lights won't be sun lights.
+            float radius = lcm.getSunAngularRadius(directionalLight);
+            float haloSize = lcm.getSunHaloSize(directionalLight);
+            float haloFalloff = lcm.getSunHaloFalloff(directionalLight);
+            sun.x = std::cos(radius);
+            sun.y = std::sin(radius);
+            sun.z = 1.0f / (std::cos(radius * haloSize) - sun.x);
+            sun.w = haloFalloff;
+        }
+        s.sun = sun;
+    } else {
+        // Disable the sun if there's no directional light
+        s.sun = float4{ 0.0f, 0.0f, 0.0f, -1.0f };
+    }
+}
+
 void PerShadowMapUniforms::prepareShadowMapping(Transaction const& transaction,
        bool highPrecision) noexcept {
    auto& s = edit(transaction);
@@ -73,6 +73,10 @@ public:
    static void prepareShadowMapping(Transaction const& transaction,
            bool highPrecision) noexcept;

+    static void prepareDirectionalLight(Transaction const& transaction,
+            FEngine& engine, float exposure,
+            math::float3 const& sceneSpaceDirection, LightManagerInstance instance) noexcept;
+
    static Transaction open(backend::DriverApi& driver) noexcept;

    // update local data into GPU UBO
@@ -290,10 +290,14 @@ void PerViewUniforms::prepareShadowMapping(bool highPrecision) noexcept {

 void PerViewUniforms::prepareShadowSampling(PerViewUib& uniforms,
        ShadowMappingUniforms const& shadowMappingUniforms) noexcept {
+    uniforms.lightFromWorldMatrix       = shadowMappingUniforms.lightFromWorldMatrix;
    uniforms.cascadeSplits              = shadowMappingUniforms.cascadeSplits;
+    uniforms.shadowBulbRadiusLs         = shadowMappingUniforms.shadowBulbRadiusLs;
+    uniforms.shadowBias                 = shadowMappingUniforms.shadowBias;
    uniforms.ssContactShadowDistance    = shadowMappingUniforms.ssContactShadowDistance;
    uniforms.directionalShadows         = shadowMappingUniforms.directionalShadows;
    uniforms.cascades                   = shadowMappingUniforms.cascades;
+    uniforms.cascades                  |= uint32_t(shadowMappingUniforms.elvsm) << 31u;
 }

 void PerViewUniforms::prepareShadowVSM(Handle<HwTexture> texture,
@@ -750,11 +750,6 @@ void RenderPass::Executor::execute(backend::DriverApi& driver,
                continue;
            }

-            // primitiveHandle may be invalid if no geometry was set on the renderable.
-            if (UTILS_UNLIKELY(!first->primitive.primitiveHandle)) {
-                continue;
-            }
-
            // per-renderable uniform
            const PrimitiveInfo info = first->primitive;
            pipeline.rasterState = info.rasterState;
@@ -413,10 +413,41 @@ ShadowMap::ShaderParameters ShadowMap::updateDirectional(FEngine& engine,
    return shaderParameters;
 }

-ShadowMap::ShaderParameters ShadowMap::updateSpotOrPoint(
-        mat4f const& Mv, float outerConeAngle, float nearPlane, float farPlane,
-        const ShadowMapInfo& shadowMapInfo, const FLightManager::ShadowParams& params) noexcept {
-    const mat4f Mp = mat4f::perspective(outerConeAngle * f::RAD_TO_DEG * 2.0f, 1.0f, nearPlane, farPlane);
+ShadowMap::ShaderParameters ShadowMap::updateSpot(FEngine& engine,
+        const FScene::LightSoa& lightData, size_t index,
+        filament::CameraInfo const& camera,
+        const ShadowMapInfo& shadowMapInfo,
+        FScene const& scene, SceneInfo sceneInfo) noexcept {
+
+    ShaderParameters shaderParameters;
+
+    auto& lcm = engine.getLightManager();
+    auto li         = lightData.elementAt<FScene::LIGHT_INSTANCE>(index);
+    auto position   = lightData.elementAt<FScene::POSITION_RADIUS>(index).xyz;
+    auto direction  = lightData.elementAt<FScene::DIRECTION>(index);
+    auto radius     = lightData.elementAt<FScene::POSITION_RADIUS>(index).w;
+    auto outerConeAngle = lcm.getSpotLightOuterCone(li);
+    const FLightManager::ShadowParams& params = lcm.getShadowParams(li);
+
+    /*
+     * Compute the light model matrix.
+     */
+
+    // Choose a reasonable value for the near plane.
+    const mat4f Mv = getDirectionalLightViewMatrix(direction, position);
+
+    // find decent near/far
+    ShadowMap::updateSceneInfoSpot(Mv, scene, sceneInfo);
+
+    // if the scene was empty, near > far
+    mHasVisibleShadows = -sceneInfo.lsNearFar[0] < -sceneInfo.lsNearFar[1];
+
+    // FIXME: we need a configuration for minimum near plane (for now hardcoded to 1cm)
+    float nearPlane = std::max(0.01f, -sceneInfo.lsNearFar[0]);
+    float farPlane  = std::min(radius, -sceneInfo.lsNearFar[1]);
+
+    float outerConeAngleDegrees = outerConeAngle * f::RAD_TO_DEG;
+    const mat4f Mp = mat4f::perspective(outerConeAngleDegrees * 2.0f, 1.0f, nearPlane, farPlane);
    const mat4f MpMv(math::highPrecisionMultiply(Mp, Mv));

    // Final shadow transform
@@ -438,9 +469,7 @@ ShadowMap::ShaderParameters ShadowMap::updateSpotOrPoint(
    //                               = zInLightSpace * texelSizeAtOneMeter
    //                               = zInLightSpace * (2*tan(halfConeAngle)/dimension)
    // Note: this would not work with LISPSM, which warps the texture space.
-    ShaderParameters shaderParameters;
-    shaderParameters.texelSizeAtOneMeterWs =
-            (2.0f * std::tan(outerConeAngle) / float(shadowMapInfo.shadowDimension));
+    shaderParameters.texelSizeAtOneMeterWs = (2.0f * std::tan(outerConeAngle) / float(shadowMapInfo.shadowDimension));
    shaderParameters.lightFromWorldZ = -transpose(Mv)[2]; // negate because camera looks in -Z

    if (!shadowMapInfo.vsm) {
@@ -449,7 +478,78 @@ ShadowMap::ShaderParameters ShadowMap::updateSpotOrPoint(
        shaderParameters.lightSpace = computeVsmLightSpaceMatrix(St, Mv, nearPlane, farPlane);
    }

+    const float constantBias = shadowMapInfo.vsm ? 0.0f : params.options.constantBias;
+    const mat4f b = mat4f::translation(direction * constantBias);
+    const mat4f Sb = S * b;
+
+    // It's important to set the light camera's model matrix separately from its projection, so that
+    // the cameraPosition uniform gets set correctly.
+    // mLightSpace is used in the shader to access the shadow map texture, and has the model matrix
+    // baked in.
+
+    // The model matrix below is in fact inverted to get the view matrix and passed to the
+    // shader as 'viewFromWorldMatrix', and is used in the VSM case to compute the depth metric.
+    // (see depth_main.fs). Note that in the case of VSM, 'b' below is identity.
+    mCamera->setModelMatrix(mat4{ FCamera::rigidTransformInverse(Mv * b) });
+    mCamera->setCustomProjection(mat4(Mp), nearPlane, farPlane);
+
+    // for the debug camera, we need to undo the world origin
+    mDebugCamera->setCustomProjection(mat4(Sb * camera.worldOrigin), nearPlane, radius);
+
+    return shaderParameters;
+}
+
+ShadowMap::ShaderParameters ShadowMap::updatePoint(FEngine& engine,
+        const FScene::LightSoa& lightData, size_t index,
+        filament::CameraInfo const& camera, const ShadowMapInfo& shadowMapInfo, FScene const& scene,
+        SceneInfo, uint8_t face) noexcept {
+
+    ShaderParameters shaderParameters;
+
+    // check if this shadow map has anything to render
+    mHasVisibleShadows = false;
+    FScene::RenderableSoa const& UTILS_RESTRICT soa = scene.getRenderableData();
+    auto const* const UTILS_RESTRICT visibleMasks = soa.data<FScene::VISIBLE_MASK>();
+    size_t c = soa.size();
+    for (size_t i = 0; i < c; i++) {
+        if (visibleMasks[i] & VISIBLE_DYN_SHADOW_RENDERABLE) {
+            mHasVisibleShadows = true;
+            break;
+        }
+    }
+    if (!mHasVisibleShadows) {
+        return shaderParameters;
+    }
+
+    auto& lcm = engine.getLightManager();
+
+    auto li         = lightData.elementAt<FScene::LIGHT_INSTANCE>(index);
+    auto position   = lightData.elementAt<FScene::POSITION_RADIUS>(index).xyz;
+    auto radius     = lightData.elementAt<FScene::POSITION_RADIUS>(index).w;
+    const FLightManager::ShadowParams& params = lcm.getShadowParams(li);
+
+    /*
+     * Compute the light model matrix.
+     */
+
+    const mat4f Mv = getPointLightViewMatrix(TextureCubemapFace(face), position);
    const float3 direction = -transpose(Mv)[2].xyz;
+
+    // TODO: don't hardcode near plane
+    // Choose a reasonable value for the near plane.
+    float nearPlane = 0.01f;
+    float farPlane  = radius;
+    const mat4f Mp = mat4f::perspective(90.0f, 1.0f, nearPlane, farPlane);
+
+    // For calculating the point light normal bias, we need the texel size in world space at the
+    // sample location. Using Thales's theorem, we find:
+    //      texelSize(zInLightSpace) = zInLightSpace * texelSizeOnTheNearPlane / near
+    //                               = zInLightSpace * texelSizeAtOneMeter
+    //                               = zInLightSpace * (2*tan(halfConeAngle)/dimension)
+    // Note: this would not work with LISPSM, which warps the texture space.
+    shaderParameters.texelSizeAtOneMeterWs =
+            (2.0f * std::tan(f::PI_4) / float(shadowMapInfo.shadowDimension));
+
    const float constantBias = shadowMapInfo.vsm ? 0.0f : params.options.constantBias;
    const mat4f b = mat4f::translation(direction * constantBias);

@@ -467,65 +567,6 @@ ShadowMap::ShaderParameters ShadowMap::updateSpotOrPoint(
    return shaderParameters;
 }

-ShadowMap::ShaderParameters ShadowMap::updateSpot(FEngine& engine,
-        const FScene::LightSoa& lightData, size_t index,
-        filament::CameraInfo const& camera,
-        const ShadowMapInfo& shadowMapInfo,
-        FScene const& scene, SceneInfo sceneInfo) noexcept {
-
-    auto& lcm = engine.getLightManager();
-    auto position   = lightData.elementAt<FScene::POSITION_RADIUS>(index).xyz;
-    auto direction  = lightData.elementAt<FScene::DIRECTION>(index);
-    auto radius     = lightData.elementAt<FScene::POSITION_RADIUS>(index).w;
-    auto li         = lightData.elementAt<FScene::LIGHT_INSTANCE>(index);
-    const FLightManager::ShadowParams& params = lcm.getShadowParams(li);
-    const mat4f Mv = getDirectionalLightViewMatrix(direction, position);
-
-    // find decent near/far
-    ShadowMap::updateSceneInfoSpot(Mv, scene, sceneInfo);
-
-    // if the scene was empty, near > far
-    mHasVisibleShadows = -sceneInfo.lsNearFar[0] < -sceneInfo.lsNearFar[1];
-    if (!mHasVisibleShadows) {
-        return {};
-    }
-
-    // FIXME: we need a configuration for minimum near plane (for now hardcoded to 1cm)
-    float nearPlane = std::max(0.01f, -sceneInfo.lsNearFar[0]);
-    float farPlane  = std::min(radius, -sceneInfo.lsNearFar[1]);
-    auto outerConeAngle = lcm.getSpotLightOuterCone(li);
-    return updateSpotOrPoint(Mv, outerConeAngle, nearPlane, farPlane, shadowMapInfo, params);
-}
-
-ShadowMap::ShaderParameters ShadowMap::updatePoint(FEngine& engine,
-        const FScene::LightSoa& lightData, size_t index,
-        filament::CameraInfo const& camera, const ShadowMapInfo& shadowMapInfo, FScene const& scene,
-        SceneInfo, uint8_t face) noexcept {
-
-    // check if this shadow map has anything to render
-    mHasVisibleShadows = false;
-    FScene::RenderableSoa const& UTILS_RESTRICT soa = scene.getRenderableData();
-    auto const* const UTILS_RESTRICT visibleMasks = soa.data<FScene::VISIBLE_MASK>();
-    size_t c = soa.size();
-    for (size_t i = 0; i < c; i++) {
-        if (visibleMasks[i] & VISIBLE_DYN_SHADOW_RENDERABLE) {
-            mHasVisibleShadows = true;
-            break;
-        }
-    }
-    if (!mHasVisibleShadows) {
-        return {};
-    }
-
-    auto& lcm = engine.getLightManager();
-    auto position   = lightData.elementAt<FScene::POSITION_RADIUS>(index).xyz;
-    auto radius     = lightData.elementAt<FScene::POSITION_RADIUS>(index).w;
-    auto li         = lightData.elementAt<FScene::LIGHT_INSTANCE>(index);
-    const FLightManager::ShadowParams& params = lcm.getShadowParams(li);
-    const mat4f Mv = getPointLightViewMatrix(TextureCubemapFace(face), position);
-    return updateSpotOrPoint(Mv, 45.0f * f::DEG_TO_RAD, 0.01f, radius, shadowMapInfo, params);
-}
-
 mat4f ShadowMap::applyLISPSM(mat4f& Wp,
        filament::CameraInfo const& camera, FLightManager::ShadowParams const& params,
        mat4f const& LMpMv,
@@ -1143,8 +1184,6 @@ void ShadowMap::visitScene(const FScene& scene, uint32_t visibleLayers,

 void ShadowMap::initSceneInfo(ShadowMap::SceneInfo& sceneInfo,
        uint8_t visibleLayers, FScene const& scene, mat4f const& viewMatrix) {
-    sceneInfo.csNearFar = { -1.0f, 1.0f };
-    sceneInfo.lsNearFar = {};
    sceneInfo.visibleLayers = visibleLayers;
    sceneInfo.vsNearFar = { std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max() };

@@ -1242,6 +1281,13 @@ void ShadowMap::prepareTime(Transaction const& transaction,
    PerShadowMapUniforms::prepareTime(transaction, engine, userTime);
 }

+void ShadowMap::prepareDirectionalLight(Transaction const& transaction,
+        FEngine& engine, math::float3 const& sceneSpaceDirection,
+        LightManager::Instance instance) noexcept {
+    PerShadowMapUniforms::prepareDirectionalLight(transaction,
+            engine, 1.0f, sceneSpaceDirection, instance);
+}
+
 void ShadowMap::prepareShadowMapping(Transaction const& transaction,
        bool highPrecision) noexcept {
    PerShadowMapUniforms::prepareShadowMapping(transaction, highPrecision);
@@ -1256,7 +1302,7 @@ void ShadowMap::commit(Transaction& transaction,
    mPerShadowMapUniforms.commit(transaction, driver);
 }

-void ShadowMap::bind(backend::DriverApi& driver) const noexcept {
+void ShadowMap::bindPerViewUniformsAndSamplers(backend::DriverApi& driver) const noexcept {
    mPerShadowMapUniforms.bind(driver);
 }

@@ -195,12 +195,15 @@ public:
            const filament::Viewport& viewport) noexcept;
    static void prepareTime(Transaction const& transaction,
            FEngine& engine, math::float4 const& userTime) noexcept;
+    static void prepareDirectionalLight(Transaction const& transaction,
+            FEngine& engine, math::float3 const& sceneSpaceDirection,
+            LightManager::Instance instance) noexcept;
    static void prepareShadowMapping(Transaction const& transaction,
            bool highPrecision) noexcept;
    static PerShadowMapUniforms::Transaction open(backend::DriverApi& driver) noexcept;
    void commit(Transaction& transaction,
            backend::DriverApi& driver) const noexcept;
-    void bind(backend::DriverApi& driver) const noexcept;
+    void bindPerViewUniformsAndSamplers(backend::DriverApi& driver) const noexcept;

 private:
    struct Segment {
@@ -214,11 +217,6 @@ private:
    // 8 corners, 12 segments w/ 2 intersection max -- all of this twice (8 + 12 * 2) * 2 (768 bytes)
    using FrustumBoxIntersection = std::array<math::float3, 64>;

-    ShaderParameters updateSpotOrPoint(
-            math::mat4f const& Mv, float outerConeAngle, float nearPlane, float farPlane,
-            const ShadowMapInfo& shadowMapInfo,
-            const FLightManager::ShadowParams& params) noexcept;
-
    static math::mat4f applyLISPSM(math::mat4f& Wp,
            filament::CameraInfo const& camera, FLightManager::ShadowParams const& params,
            const math::mat4f& LMpMv,
@@ -97,10 +97,8 @@ void ShadowMapManager::setDirectionalShadowMap(size_t lightIndex,
        LightManager::ShadowOptions const* options) noexcept {
    assert_invariant(options->shadowCascades <= CONFIG_MAX_SHADOW_CASCADES);
    for (size_t c = 0; c < options->shadowCascades; c++) {
-        const size_t i = c;
-        assert_invariant(i < CONFIG_MAX_SHADOW_CASCADES);
-        auto* pShadowMap = getCascadeShadowMap(i);
-        pShadowMap->initialize(lightIndex, ShadowType::DIRECTIONAL, i, 0, options);
+        auto* pShadowMap = getCascadeShadowMap(c);
+        pShadowMap->initialize(lightIndex, ShadowType::DIRECTIONAL, c, 0, options);
        mCascadeShadowMaps.push_back(pShadowMap);
    }
 }
@@ -109,19 +107,17 @@ void ShadowMapManager::addShadowMap(size_t lightIndex, bool spotlight,
        LightManager::ShadowOptions const* options) noexcept {
    if (spotlight) {
        const size_t c = mSpotShadowMaps.size();
-        const size_t i = c + CONFIG_MAX_SHADOW_CASCADES;
-        assert_invariant(i < CONFIG_MAX_SHADOWMAPS);
-        auto* pShadowMap = getPointOrSpotShadowMap(i);
-        pShadowMap->initialize(lightIndex, ShadowType::SPOT, i, 0, options);
+        assert_invariant(c < CONFIG_MAX_SHADOWMAP_PUNCTUAL);
+        auto* pShadowMap = getPointOrSpotShadowMap(c);
+        pShadowMap->initialize(lightIndex, ShadowType::SPOT, c, 0, options);
        mSpotShadowMaps.push_back(pShadowMap);
    } else {
-        // point-light, generate 6 independent shadowmaps
+        // point-light
        for (size_t face = 0; face < 6; face++) {
            const size_t c = mSpotShadowMaps.size();
-            const size_t i = c + CONFIG_MAX_SHADOW_CASCADES;
-            assert_invariant(i < CONFIG_MAX_SHADOWMAPS);
-            auto* pShadowMap = getPointOrSpotShadowMap(i);
-            pShadowMap->initialize(lightIndex, ShadowType::POINT, i, face, options);
+            assert_invariant(c < CONFIG_MAX_SHADOWMAP_PUNCTUAL);
+            auto* pShadowMap = getPointOrSpotShadowMap(c);
+            pShadowMap->initialize(lightIndex, ShadowType::POINT, c, face, options);
            mSpotShadowMaps.push_back(pShadowMap);
        }
    }
@@ -161,7 +157,7 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG

    auto& prepareShadowPass = fg.addPass<PrepareShadowPassData>("Prepare Shadow Pass",
            [&](FrameGraph::Builder& builder, auto& data) {
-                data.passList.reserve(CONFIG_MAX_SHADOWMAPS);
+                data.passList.reserve(CONFIG_MAX_SHADOW_LAYERS);
                data.shadows = builder.createTexture("Shadowmap", {
                        .width = textureRequirements.size, .height = textureRequirements.size,
                        .depth = textureRequirements.layers,
@@ -233,15 +229,15 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
                    }

                    if (shadowMap.hasVisibleShadows()) {
-                        // Note: this loop can generate a lot of commands that come out of the
-                        //       "per frame command arena". The allocation persists until the
-                        //       end of the frame.
-                        //       One way to possibly mitigate this, would be to always use the
-                        //       same command buffer for all shadow map, but then we'd generate
-                        //       a lot of unneeded draw calls.
-                        //       To do this efficiently, we'd need a way to cull draw calls already
-                        //       recorded in the command buffer, per shadow map.
+                        // TODO: this loop can generate a lot of commands. investigate if
+                        //       we could compact or reduce the number of commands.
+                        //       - we could move this into the execute of each pass, but
+                        //         then we would have to update the UBO each time.
+                        //       - we could also always use the same commands for all
+                        //         shadow maps, but then we'd generate a lot of
+                        //         unneeded draw call.

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

                        // cameraInfo only valid after calling update
                        const CameraInfo cameraInfo{ shadowMap.getCamera() };
@@ -252,13 +248,17 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
                        ShadowMap::prepareTime(transaction, engine, userTime);
                        ShadowMap::prepareShadowMapping(transaction,
                                view.getVsmShadowOptions().highPrecision);
+                        if (shadowMap.getShadowType() == ShadowType::DIRECTIONAL) {
+                            ShadowMap::prepareDirectionalLight(transaction, engine,
+                                    scene->getLightData().elementAt<FScene::DIRECTION>(0),
+                                    scene->getLightData().elementAt<FScene::LIGHT_INSTANCE>(0));
+                        }
                        shadowMap.commit(transaction, driver);

                        // updatePrimitivesLod must be run before RenderPass::appendCommands.
                        view.updatePrimitivesLod(engine,
                                cameraInfo, scene->getRenderableData(), entry.range);

-                        // generate and sort the commands for rendering the shadow map
                        RenderPass pass(passTemplate);
                        pass.setCamera(cameraInfo);
                        pass.setVisibilityMask(entry.visibilityMask);
@@ -270,10 +270,14 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
                        entry.executor = pass.getExecutor();

                        if (!view.hasVSM()) {
-                            auto const* options = shadowMap.getShadowOptions();
+                            auto li = scene->getLightData().elementAt<FScene::LIGHT_INSTANCE>(
+                                    entry.shadowMap->getLightIndex());
+
+                            auto const& params = engine.getLightManager().getShadowParams(li);
+
                            const PolygonOffset polygonOffset = { // handle reversed Z
-                                    .slope    = -options->polygonOffsetSlope,
-                                    .constant = -options->polygonOffsetConstant
+                                    .slope    = -params.options.polygonOffsetSlope,
+                                    .constant = -params.options.polygonOffsetConstant
                            };
                            entry.executor.overridePolygonOffset(&polygonOffset);
                        }
@@ -389,15 +393,16 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
                    // `entry` lives in `PrepareShadowPassData` which is guaranteed to still
                    // be alive when we execute here (all passes stay alive until the FrameGraph
                    // is destroyed).
-                    // It wouldn't work to capture by copy because entry.executor wouldn't be
+                    // It wouldn't work to capture by copy because entry.pass wouldn't be
                    // initialized, as this happens in an `execute` block.

+                    entry.shadowMap->bindPerViewUniformsAndSamplers(driver);
+
                    auto rt = resources.getRenderPassInfo(data.rt);
                    rt.params.viewport = entry.shadowMap->getViewport();

                    engine.flush();
                    driver.beginRenderPass(rt.target, rt.params);
-                    entry.shadowMap->bind(driver);
                    entry.executor.execute(engine, "Shadow Pass");
                    driver.endRenderPass();
                });
@@ -459,7 +464,7 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng
        // entire camera frustum, as if we only had a single cascade.
        ShadowMap& shadowMap = *mCascadeShadowMaps[0];

-        shadowMap.updateDirectional(mEngine,
+        auto shaderParameters = shadowMap.updateDirectional(mEngine,
                lightData, 0, cameraInfo, shadowMapInfo, *scene, sceneInfo);

        hasVisibleShadows = shadowMap.hasVisibleShadows();
@@ -468,6 +473,18 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng
            Frustum const& frustum = shadowMap.getCamera().getCullingFrustum();
            FView::cullRenderables(engine.getJobSystem(), renderableData, frustum,
                    VISIBLE_DIR_SHADOW_RENDERABLE_BIT);
+
+            // Set shadowBias, using the first directional cascade.
+            // when computing the required bias we need a half-texel size, so we multiply by 0.5 here.
+            // note: normalBias is set to zero for VSM
+            const float normalBias = shadowMapInfo.vsm ? 0.0f : 0.5f * lcm.getShadowNormalBias(0);
+            // Texel size is constant for directional light (although that's not true when LISPSM
+            // is used, but in that case we're pretending it is).
+            const float wsTexelSize = shaderParameters.texelSizeAtOneMeterWs;
+            mShadowMappingUniforms.shadowBias = normalBias * wsTexelSize;
+            mShadowMappingUniforms.shadowBulbRadiusLs =
+                    mSoftShadowOptions.penumbraScale * options.shadowBulbRadius / wsTexelSize;
+            mShadowMappingUniforms.elvsm = options.vsm.elvsm;
        }
    }

@@ -520,10 +537,6 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng

        mShadowMappingUniforms.cascadeSplits = wsSplitPositionUniform;

-        // when computing the required bias we need a half-texel size, so we multiply by 0.5 here.
-        // note: normalBias is set to zero for VSM
-        const float normalBias = shadowMapInfo.vsm ? 0.0f : 0.5f * lcm.getShadowNormalBias(0);
-
        for (size_t i = 0, c = mCascadeShadowMaps.size(); i < c; i++) {
            assert_invariant(mCascadeShadowMaps[i]);

@@ -537,22 +550,7 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng
                    lightData, 0, cameraInfo, shadowMapInfo, *scene, sceneInfo);

            if (shadowMap.hasVisibleShadows()) {
-                const size_t shadowIndex = shadowMap.getShadowIndex();
-                assert_invariant(shadowIndex == i);
-
-                // Texel size is constant for directional light (although that's not true when LISPSM
-                // is used, but in that case we're pretending it is).
-                const float wsTexelSize = shaderParameters.texelSizeAtOneMeterWs;
-
-                auto& s = mShadowUb.edit();
-                s.shadows[shadowIndex].layer = shadowMap.getLayer();
-                s.shadows[shadowIndex].lightFromWorldMatrix = shaderParameters.lightSpace;
-                s.shadows[shadowIndex].normalBias = normalBias * wsTexelSize;
-                s.shadows[shadowIndex].texelSizeAtOneMeter = wsTexelSize;
-                s.shadows[shadowIndex].elvsm = options.vsm.elvsm;
-                s.shadows[shadowIndex].bulbRadiusLs =
-                        mSoftShadowOptions.penumbraScale * options.shadowBulbRadius / wsTexelSize;
-
+                mShadowMappingUniforms.lightFromWorldMatrix[i] = shaderParameters.lightSpace;
                shadowTechnique |= ShadowTechnique::SHADOW_MAP;
                cascadeHasVisibleShadows |= 0x1u << i;
            }
@@ -680,7 +678,6 @@ void ShadowMapManager::prepareSpotShadowMap(ShadowMap& shadowMap,
        auto& s = mShadowUb.edit();
        const double n = shadowMap.getCamera().getNear();
        const double f = shadowMap.getCamera().getCullingFar();
-        s.shadows[shadowIndex].layer = shadowMap.getLayer();
        s.shadows[shadowIndex].lightFromWorldMatrix = shaderParameters.lightSpace;
        s.shadows[shadowIndex].direction = direction;
        s.shadows[shadowIndex].normalBias = normalBias * wsTexelSizeAtOneMeter;
@@ -690,8 +687,7 @@ void ShadowMapManager::prepareSpotShadowMap(ShadowMap& shadowMap,
        s.shadows[shadowIndex].elvsm = options->vsm.elvsm;
        s.shadows[shadowIndex].bulbRadiusLs =
                mSoftShadowOptions.penumbraScale * options->shadowBulbRadius
-                        / wsTexelSizeAtOneMeter;
-
+                / wsTexelSizeAtOneMeter;
    }
 }

@@ -753,6 +749,7 @@ void ShadowMapManager::preparePointShadowMap(ShadowMap& shadowMap,


    // and if we need to generate it, update all the UBO data
+    // Note: this below is done for all six faces even if it sets identical values each time
    if (shadowMap.hasVisibleShadows()) {
        const size_t shadowIndex = shadowMap.getShadowIndex();
        const float wsTexelSizeAtOneMeter = shaderParameters.texelSizeAtOneMeterWs;
@@ -762,11 +759,16 @@ void ShadowMapManager::preparePointShadowMap(ShadowMap& shadowMap,
        auto& s = mShadowUb.edit();
        const double n = shadowMap.getCamera().getNear();
        const double f = shadowMap.getCamera().getCullingFar();
-        s.shadows[shadowIndex].layer = shadowMap.getLayer();
-        s.shadows[shadowIndex].lightFromWorldMatrix = shaderParameters.lightSpace;
+
+        s.shadows[shadowIndex].lightFromWorldMatrix = {}; // no texture matrix for point lights
        s.shadows[shadowIndex].direction = {};  // no direction of point lights
        s.shadows[shadowIndex].normalBias = normalBias * wsTexelSizeAtOneMeter;
-        s.shadows[shadowIndex].lightFromWorldZ = shaderParameters.lightFromWorldZ;
+        s.shadows[shadowIndex].lightFromWorldZ = {
+                -((n + f) / (f - n)) * 0.5f + 0.5f,
+                  (f * n) / (f - n),
+                       -n / (f - n),
+                     1.0f / (f - n),
+        };
        s.shadows[shadowIndex].texelSizeAtOneMeter = wsTexelSizeAtOneMeter;
        s.shadows[shadowIndex].nearOverFarMinusNear = float(n / (f - n));
        s.shadows[shadowIndex].elvsm = options->vsm.elvsm;
@@ -786,12 +788,14 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateSpotShadowMaps(FEngine
        shadowTechnique |= ShadowTechnique::SHADOW_MAP;
        for (auto const* pShadowMap : mSpotShadowMaps) {
            const size_t lightIndex = pShadowMap->getLightIndex();
-            // gather the per-light (not per shadow map) information. For point lights we will
-            // "see" 6 shadowmaps (one per face), we must use the first face one, the shader
-            // knows how to find the entry for other faces (they're guaranteed to be sequential).
+
+            // FIXME: currently we have one slot per shadowmap in the UBO, but we now have up to
+            //        6 shadowmap per light. So for now, we only write the data of the face 0,
+            //        and the shader will figure out where to find the other face (layer+face)
            if (pShadowMap->getFace() == 0) {
                shadowInfo[lightIndex].castsShadows = true;     // FIXME: is that set correctly?
                shadowInfo[lightIndex].index = pShadowMap->getShadowIndex();
+                shadowInfo[lightIndex].layer = pShadowMap->getLayer();
            }
        }
    }
@@ -45,10 +45,14 @@ class FrameGraph;
 class RenderPass;

 struct ShadowMappingUniforms {
+    std::array<math::mat4f, CONFIG_MAX_SHADOW_CASCADES> lightFromWorldMatrix;
    math::float4 cascadeSplits;
+    float shadowBulbRadiusLs;
+    float shadowBias;
    float ssContactShadowDistance;
    uint32_t directionalShadows;
    uint32_t cascades;
+    bool elvsm;
 };

 class ShadowMapManager {
@@ -99,9 +103,9 @@ public:
    }

    ShadowMap* getPointOrSpotShadowMap(size_t index) noexcept {
-        assert_invariant(index < CONFIG_MAX_SHADOWMAPS);
+        assert_invariant(index < CONFIG_MAX_SHADOWMAP_PUNCTUAL);
        return std::launder(reinterpret_cast<ShadowMap*>(
-                &mShadowMapCache[index]));
+                &mShadowMapCache[CONFIG_MAX_SHADOW_CASCADES + index]));
    }

    ShadowMap const* getPointOrSpotShadowMap(size_t spot) const noexcept {
@@ -211,13 +215,13 @@ private:

    utils::FixedCapacityVector<ShadowMap*> mSpotShadowMaps{
            utils::FixedCapacityVector<ShadowMap*>::with_capacity(
-                    CONFIG_MAX_SHADOWMAPS - CONFIG_MAX_SHADOW_CASCADES) };
+                    CONFIG_MAX_SHADOWMAP_PUNCTUAL) };

    // inline storage for all our ShadowMap objects, we can't easily use a std::array<> directly.
    // because ShadowMap doesn't have a default ctor, and we avoid out-of-line allocations.
    // Each ShadowMap is currently 40 bytes (total of 2.5KB for 64 shadow maps)
    using ShadowMapStorage = std::aligned_storage<sizeof(ShadowMap), alignof(ShadowMap)>::type;
-    std::array<ShadowMapStorage, CONFIG_MAX_SHADOWMAPS> mShadowMapCache;
+    std::array<ShadowMapStorage, CONFIG_MAX_SHADOW_LAYERS> mShadowMapCache;
 };

 } // namespace filament
@@ -56,7 +56,7 @@ void FTransformManager::create(Entity entity, Instance parent, const mat4f& loca
    if (UTILS_UNLIKELY(manager.hasComponent(entity))) {
        destroy(entity);
    }
-    Instance const i = manager.addComponent(entity);
+    Instance i = manager.addComponent(entity);
    assert_invariant(i);
    assert_invariant(i != parent);

@@ -78,7 +78,7 @@ void FTransformManager::create(Entity entity, Instance parent, const mat4& local
    if (UTILS_UNLIKELY(manager.hasComponent(entity))) {
        destroy(entity);
    }
-    Instance const i = manager.addComponent(entity);
+    Instance i = manager.addComponent(entity);
    assert_invariant(i);
    assert_invariant(i != parent);

@@ -96,7 +96,7 @@ void FTransformManager::setParent(Instance i, Instance parent) noexcept {
    validateNode(i);
    if (i) {
        auto& manager = mManager;
-        Instance const oldParent = manager[i].parent;
+        Instance oldParent = manager[i].parent;
        if (oldParent != parent) {
            // TODO: on debug builds, ensure that the new parent isn't one of our descendant
            removeNode(i);
@@ -144,7 +144,7 @@ TransformManager::children_iterator FTransformManager::getChildrenEnd(Instance)
 void FTransformManager::destroy(Entity e) noexcept {
    // update the reference of the element we're removing
    auto& manager = mManager;
-    Instance const i = manager.getInstance(e);
+    Instance i = manager.getInstance(e);
    validateNode(i);
    if (i) {
        // 1) remove the entry from the linked lists
@@ -158,7 +158,7 @@ void FTransformManager::destroy(Entity e) noexcept {
        }

        // 2) remove the component
-        Instance const moved = manager.removeComponent(e);
+        Instance moved = manager.removeComponent(e);

        // 3) update the references to the entry now with Instance i
        if (moved != i) {
@@ -200,15 +200,14 @@ void FTransformManager::updateNodeTransform(Instance i) noexcept {

    // find our parent's world transform, if any
    // note: by using the raw_array() we don't need to check that parent is valid.
-    Instance const parent = manager[i].parent;
-    FTransformManager::computeWorldTransform(
-            manager[i].world, manager[i].worldTranslationLo,
+    Instance parent = manager[i].parent;
+    computeWorldTransform(manager[i].world, manager[i].worldTranslationLo,
            manager[parent].world, manager[i].local,
            manager[parent].worldTranslationLo, manager[i].localTranslationLo,
            mAccurateTranslations);

    // update our children's world transforms
-    Instance const child = manager[i].firstChild;
+    Instance child = manager[i].firstChild;
    if (UTILS_UNLIKELY(child)) { // assume we don't have a hierarchy in the common case
        transformChildren(manager, child);
    }
@@ -238,11 +237,10 @@ void FTransformManager::computeAllWorldTransforms() noexcept {
        while (UTILS_UNLIKELY(Instance(manager[i].parent) > i)) {
            swapNode(i, manager[i].parent);
        }
-        Instance const parent = manager[i].parent;
+        Instance parent = manager[i].parent;
        assert_invariant(parent < i);

-        FTransformManager::computeWorldTransform(
-                manager[i].world, manager[i].worldTranslationLo,
+        computeWorldTransform(manager[i].world, manager[i].worldTranslationLo,
                manager[parent].world, manager[i].local,
                manager[parent].worldTranslationLo, manager[i].localTranslationLo,
                accurate);
@@ -260,7 +258,7 @@ void FTransformManager::insertNode(Instance i, Instance parent) noexcept {
    manager[i].next = 0;
    if (parent) {
        // we insert ourselves first in the parent's list
-        Instance const next = manager[parent].firstChild;
+        Instance next = manager[parent].firstChild;
        manager[i].next = next;
        // we're our parent's first child now
        manager[parent].firstChild = i;
@@ -281,10 +279,8 @@ void FTransformManager::swapNode(Instance i, Instance j) noexcept {
    auto& manager = mManager;

    // swap the content of the nodes directly
-    std::swap(manager.elementAt<LOCAL>(i),    manager.elementAt<LOCAL>(j));
-    std::swap(manager.elementAt<LOCAL_LO>(i), manager.elementAt<LOCAL_LO>(j));
-    std::swap(manager.elementAt<WORLD>(i),    manager.elementAt<WORLD>(j));
-    std::swap(manager.elementAt<WORLD_LO>(i), manager.elementAt<WORLD_LO>(j));
+    std::swap(manager.elementAt<LOCAL>(i), manager.elementAt<LOCAL>(j));
+    std::swap(manager.elementAt<WORLD>(i), manager.elementAt<WORLD>(j));
    manager.swap(i, j); // this swaps the data relative to SingleInstanceComponentManager

    // now swap the linked-list references, to do that correctly we must use a temporary
@@ -314,13 +310,13 @@ void FTransformManager::swapNode(Instance i, Instance j) noexcept {
    updateNode(j);
 }

-// removes a node from the graph, but doesn't remove it or its children from the array
+// removes an node from the graph, but doesn't removes it or its children from the array
 // (making everybody orphaned).
 void FTransformManager::removeNode(Instance i) noexcept {
    auto& manager = mManager;
-    Instance const parent = manager[i].parent;
-    Instance const prev = manager[i].prev;
-    Instance const next = manager[i].next;
+    Instance parent = manager[i].parent;
+    Instance prev = manager[i].prev;
+    Instance next = manager[i].next;
    if (prev) {
        manager[prev].next = next;
    } else if (parent) {
@@ -345,9 +341,9 @@ void FTransformManager::removeNode(Instance i) noexcept {
 void FTransformManager::updateNode(Instance i) noexcept {
    auto& manager = mManager;
    // update our preview sibling's next reference (to ourselves)
-    Instance const parent = manager[i].parent;
-    Instance const prev = manager[i].prev;
-    Instance const next = manager[i].next;
+    Instance parent = manager[i].parent;
+    Instance prev = manager[i].prev;
+    Instance next = manager[i].next;
    if (prev) {
        manager[prev].next = i;
    } else if (parent) {
@@ -375,15 +371,14 @@ void FTransformManager::transformChildren(Sim& manager, Instance i) noexcept {
    const bool accurate = mAccurateTranslations;
    while (i) {
        // update child's world transform
-        Instance const parent = manager[i].parent;
-        FTransformManager::computeWorldTransform(
-                manager[i].world, manager[i].worldTranslationLo,
+        Instance parent = manager[i].parent;
+        computeWorldTransform(manager[i].world, manager[i].worldTranslationLo,
                manager[parent].world, manager[i].local,
                manager[parent].worldTranslationLo, manager[i].localTranslationLo,
                accurate);

        // assume we don't have a deep hierarchy
-        Instance const child = manager[i].firstChild;
+        Instance child = manager[i].firstChild;
        if (UTILS_UNLIKELY(child)) {
            transformChildren(manager, child);
        }
@@ -428,14 +423,14 @@ void FTransformManager::computeWorldTransform(
 }


-void FTransformManager::validateNode(UTILS_UNUSED_IN_RELEASE Instance i) noexcept {
+void FTransformManager::validateNode(Instance i) noexcept {
 #ifndef NDEBUG
    auto& manager = mManager;
    if (i) {
-        Instance const parent = manager[i].parent;
-        Instance const firstChild = manager[i].firstChild;
-        Instance const prev = manager[i].prev;
-        Instance const next = manager[i].next;
+        Instance parent = manager[i].parent;
+        Instance firstChild = manager[i].firstChild;
+        Instance prev = manager[i].prev;
+        Instance next = manager[i].next;
        assert_invariant(parent != i);
        assert_invariant(prev != i);
        assert_invariant(next != i);
@@ -130,7 +130,7 @@ private:

    void computeAllWorldTransforms() noexcept;

-    static void computeWorldTransform(math::mat4f& outWorld, math::float3& inoutWorldTranslationLo,
+    void computeWorldTransform(math::mat4f& outWorld, math::float3& inoutWorldTranslationLo,
            math::mat4f const& pt, math::mat4f const& local,
            math::float3 const& ptTranslationLo, math::float3 const& localTranslationLo,
            bool accurate);
@@ -166,7 +166,7 @@ private:
        typename Base::SoA& getSoA() { return mData; }

        struct Proxy {
-            // all of these gets inlined
+            // all of this gets inlined
            UTILS_ALWAYS_INLINE
            Proxy(Base& sim, utils::EntityInstanceBase::Type i) noexcept
                    : local{ sim, i } { }
@@ -343,10 +343,9 @@ void FScene::prepareDynamicLights(const CameraInfo& camera, ArenaScope& rootAren
        lp[gpuIndex].typeShadow           = LightsUib::packTypeShadow(
                lcm.isPointLight(li) ? 0u : 1u,
                shadowInfo[i].contactShadows,
-                shadowInfo[i].index);
-        lp[gpuIndex].channels             = LightsUib::packChannels(
-                lcm.getLightChannels(li),
-                shadowInfo[i].castsShadows);
+                shadowInfo[i].index,
+                shadowInfo[i].layer);
+        lp[gpuIndex].channels             = LightsUib::packChannels(lcm.getLightChannels(li), shadowInfo[i].castsShadows);
    }

    driver.updateBufferObject(lightUbh, { lp, positionalLightCount * sizeof(LightsUib) }, 0);
@@ -155,6 +155,7 @@ public:
        bool castsShadows = false;      // whether this light casts shadows
        bool contactShadows = false;    // whether this light casts contact shadows
        uint8_t index = 0;              // an index into the arrays in the Shadows uniform buffer
+        uint8_t layer = 0;              // which layer of the shadow texture array to sample from
    };

    enum {
@@ -178,8 +179,7 @@ public:
    LightSoa const& getLightData() const noexcept { return mLightData; }
    LightSoa& getLightData() noexcept { return mLightData; }

-    void updateUBOs(utils::Range<uint32_t> visibleRenderables,
-            backend::Handle<backend::HwBufferObject> renderableUbh) noexcept;
+    void updateUBOs(utils::Range<uint32_t> visibleRenderables, backend::Handle<backend::HwBufferObject> renderableUbh) noexcept;

    bool hasContactShadows() const noexcept;

@@ -294,11 +294,10 @@ void FView::prepareShadowing(FEngine& engine, DriverApi& driver,
    }

    // Find all shadow-casting spotlights.
-    size_t shadowMapCount = 0;
+    size_t shadowLayerCount = 0;

-    // We allow a max of CONFIG_MAX_SHADOWMAPS point/spotlight shadows. Any additional
+    // We allow a max of CONFIG_MAX_SHADOW_CASTING_SPOTS spotlight shadows. Any additional
    // shadow-casting spotlights are ignored.
-    // Note that pointlight shadows cost 6 shadowmaps, reducing the total count.
    for (size_t l = FScene::DIRECTIONAL_LIGHTS_COUNT; l < lightData.size(); l++) {

        // when we get here all the lights should be visible
@@ -318,12 +317,12 @@ void FView::prepareShadowing(FEngine& engine, DriverApi& driver,
        mShadowMapManager.addShadowMap(l, lcm.isSpotLight(li), &shadowOptions);

        if (lcm.isSpotLight(li)) {
-            shadowMapCount += 6;
+            shadowLayerCount += 6;
        } else {
-            shadowMapCount += 1;
+            shadowLayerCount += 1;
        }

-        if (shadowMapCount > CONFIG_MAX_SHADOWMAPS - 1) {
+        if (shadowLayerCount > CONFIG_MAX_SHADOWMAP_PUNCTUAL - 1) {
            break; // we ran out of spotlight shadow casting
        }
    }
@@ -694,6 +693,13 @@ void FView::prepareSSR(Handle<HwTexture> ssr, float refractionLodOffset,
    mPerViewUniforms.prepareSSR(ssr, refractionLodOffset, ssrOptions);
 }

+void FView::prepareHistorySSR(Handle<HwTexture> ssr,
+        mat4f const& historyProjection, mat4f const& uvFromViewMatrix,
+        ScreenSpaceReflectionsOptions const& ssrOptions) const noexcept {
+    mPerViewUniforms.prepareHistorySSR(ssr,
+            historyProjection, uvFromViewMatrix, ssrOptions);
+}
+
 void FView::prepareStructure(Handle<HwTexture> structure) const noexcept {
    // sampler must be NEAREST
    mPerViewUniforms.prepareStructure(structure);
@@ -145,6 +145,9 @@ public:
    void prepareSSAO(backend::Handle<backend::HwTexture> ssao) const noexcept;
    void prepareSSR(backend::Handle<backend::HwTexture> ssr, float refractionLodOffset,
            ScreenSpaceReflectionsOptions const& ssrOptions) const noexcept;
+    void prepareHistorySSR(backend::Handle<backend::HwTexture> ssr,
+            math::mat4f const& historyProjection, math::mat4f const& uvFromViewMatrix,
+            ScreenSpaceReflectionsOptions const& ssrOptions) const noexcept;
    void prepareStructure(backend::Handle<backend::HwTexture> structure) const noexcept;
    void prepareShadow(backend::Handle<backend::HwTexture> structure) const noexcept;
    void prepareShadowMapping(bool highPrecision) const noexcept;
@@ -181,7 +181,6 @@ TEST(FilamentTest, SkinningMath) {

 TEST(FilamentTest, TransformManager) {
    filament::FTransformManager tcm;
-    tcm.setAccurateTranslationsEnabled(true);
    EntityManager& em = EntityManager::get();
    std::array<Entity, 3> entities;
    em.create(entities.size(), entities.data());
@@ -246,9 +245,8 @@ TEST(FilamentTest, TransformManager) {
    EXPECT_LT(tcm.getInstance(entities[1]), tcm.getInstance(entities[2]));

    // local transaction reorders parent/child
-    auto const t = mat4::translation(double3(1.0 / 3.0));
    tcm.openLocalTransformTransaction();
-    tcm.setTransform(newParent, t);
+    tcm.setTransform(newParent, mat4f{ float4{ 8 }});
    tcm.commitLocalTransformTransaction();

    // local transaction invalidates Instances
@@ -260,14 +258,10 @@ TEST(FilamentTest, TransformManager) {
    EXPECT_GT(child, newParent);

    // check transform propagation
-
-    // our "high precision" mode only preserves 48 bits of the double mantissa (out of 53).
-    // This constant loses 5 bits out of 1/3
-    const mat4 PRECISION_KILLER_5BITS = mat4::translation(double3(16.0));
-    EXPECT_EQ(tcm.getTransformAccurate(newParent)      + PRECISION_KILLER_5BITS, t + PRECISION_KILLER_5BITS);
-    EXPECT_EQ(tcm.getWorldTransformAccurate(newParent) + PRECISION_KILLER_5BITS, t + PRECISION_KILLER_5BITS);
-    EXPECT_EQ(tcm.getWorldTransformAccurate(child)     + PRECISION_KILLER_5BITS, t + PRECISION_KILLER_5BITS);
-    EXPECT_EQ(tcm.getTransformAccurate(child), mat4{ 1.0 });
+    EXPECT_EQ(tcm.getTransform(newParent), mat4f{ float4{ 8 }});
+    EXPECT_EQ(tcm.getWorldTransform(newParent), mat4f{ float4{ 8 }});
+    EXPECT_EQ(tcm.getTransform(child), mat4f{ float4{ 1 }});
+    EXPECT_EQ(tcm.getWorldTransform(child), mat4f{ float4{ 8 }});

    // check children iterators
    size_t c = 0;
@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
  spec.name = "Filament"
-  spec.version = "1.29.0"
+  spec.version = "1.28.2"
  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.29.0/filament-v1.29.0-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.28.2/filament-v1.28.2-ios.tgz" }

  # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
  spec.pod_target_xcconfig = {
@@ -27,7 +27,7 @@
 namespace filament {

 // update this when a new version of filament wouldn't work with older materials
-static constexpr size_t MATERIAL_VERSION = 29;
+static constexpr size_t MATERIAL_VERSION = 28;

 /**
 * Supported shading models
@@ -60,23 +60,29 @@ enum class SamplerBindingPoints : uint8_t {
 constexpr size_t CONFIG_MAX_LIGHT_COUNT = 256;
 constexpr size_t CONFIG_MAX_LIGHT_INDEX = CONFIG_MAX_LIGHT_COUNT - 1;

-// The maximum number of shadowmaps.
-// There is currently a maximum limit of 128 shadowmaps.
-// Factors contributing to this limit:
-// - minspec for UBOs is 16KiB, which currently can hold a maximum of 128 entries
-constexpr size_t CONFIG_MAX_SHADOWMAPS = 64;
-
 // The maximum number of shadow layers.
-// There is currently a maximum limit of 255 layers.
+// There is currently a limit to 146 layers.
 // Several factors are contributing to this limit:
 // - minspec for 2d texture arrays layer is 256
 // - we're using uint8_t to store the number of layers (255 max)
-// - nonsensical to be larger than the number of shadowmaps
-constexpr size_t CONFIG_MAX_SHADOW_LAYERS = CONFIG_MAX_SHADOWMAPS;
+// - minspec for UBOs is 16KiB, which currently can hold a maximum of 146 entries
+// - we need to reserve 4 entries for the cascaded shadow map
+//
+// CONFIG_MAX_SHADOW_LAYERS determines how many shadows can be used in the
+// scene. Currently, a spotlight uses 1 layer, a cascaded directional light uses up to 4
+// and a point light uses 6.
+//
+constexpr size_t CONFIG_MAX_SHADOW_LAYERS = 64;

 // The maximum number of shadow cascades that can be used for directional lights.
 constexpr size_t CONFIG_MAX_SHADOW_CASCADES = 4;

+// Maximum number of shadowmap for point and spotlights
+// spotlights use 1, point lights use 6
+constexpr size_t CONFIG_MAX_SHADOWMAP_PUNCTUAL =
+        CONFIG_MAX_SHADOW_LAYERS - CONFIG_MAX_SHADOW_CASCADES;
+
+
 // The maximum UBO size, in bytes. This value is set to 16 KiB due to the ES3.0 spec.
 // Note that this value constrains the maximum number of skinning bones, morph targets,
 // instances, and shadow casting spotlights.
@@ -124,10 +124,12 @@ struct PerViewUib { // NOLINT(cppcoreguidelines-pro-type-member-init)
    // bit 0-3: cascade count
    // bit 4: visualize cascades
    // bit 8-11: cascade has visible shadows
+    // bit 31: elvsm
    uint32_t cascades;
-    float reserved0;
-    float reserved1;                    // normal bias
+    float shadowBulbRadiusLs;           // light radius in light-space
+    float shadowBias;                   // normal bias
    float shadowPenumbraRatioScale;     // For DPCF or PCSS, scale penumbra ratio for artistic use
+    std::array<math::mat4f, CONFIG_MAX_SHADOW_CASCADES> lightFromWorldMatrix;

    // --------------------------------------------------------------------------------------------
    // VSM shadows [variant: VSM]
@@ -162,7 +164,7 @@ struct PerViewUib { // NOLINT(cppcoreguidelines-pro-type-member-init)
    float ssrStride;                    // ssr texel stride, >= 1.0

    // bring PerViewUib to 2 KiB
-    math::float4 reserved[63];
+    math::float4 reserved[47];
 };

 // 2 KiB == 128 float4s
@@ -227,11 +229,11 @@ struct LightsUib { // NOLINT(cppcoreguidelines-pro-type-member-init)
    math::float2 spotScaleOffset;     // { scale, offset }
    float reserved3;                  // 0
    float intensity;                  // float
-    uint32_t typeShadow;              // 0x00.00.ii.ct (t: 0=point, 1=spot, c:contact, ii: index)
+    uint32_t typeShadow;              // 0x00.ll.ii.ct (t: 0=point, 1=spot, c:contact, ii: index, ll: layer)
    uint32_t channels;                // 0x000c00ll (ll: light channels, c: caster)

-    static uint32_t packTypeShadow(uint8_t type, bool contactShadow, uint8_t index) noexcept {
-        return (type & 0xF) | (contactShadow ? 0x10 : 0x00) | (index << 8);
+    static uint32_t packTypeShadow(uint8_t type, bool contactShadow, uint8_t index, uint8_t layer) noexcept {
+        return (type & 0xF) | (contactShadow ? 0x10 : 0x00) | (index << 8) | (layer << 16);
    }
    static uint32_t packChannels(uint8_t lightChannels, bool castShadows) noexcept {
        return lightChannels | (castShadows ? 0x10000 : 0);
@@ -247,22 +249,17 @@ static_assert(sizeof(LightsUib) == 64,
 struct ShadowUib { // NOLINT(cppcoreguidelines-pro-type-member-init)
    static constexpr std::string_view _name{ "ShadowUniforms" };
    struct alignas(16) ShadowData {
-        math::mat4f lightFromWorldMatrix;       // 64
-        math::float3 direction;                 // 12
-        float normalBias;                       //  4
-        math::float4 lightFromWorldZ;           // 16
+        math::mat4f lightFromWorldMatrix;       // 64 - unused for point lights
+        math::float3 direction;                 // 12 - unused for point lights
+        float normalBias;                       //  4 - unused for point lights
+        math::float4 lightFromWorldZ;           // 16 - point lights { depth reconstruction values }

        float texelSizeAtOneMeter;              //  4
        float bulbRadiusLs;                     //  4
        float nearOverFarMinusNear;             //  4
        bool elvsm;                             //  4
-
-        uint32_t layer;                         //  4
-        uint32_t reserved0;                     //  4
-        uint32_t reserved1;                     //  4
-        uint32_t reserved2;                     //  4
    };
-    ShadowData shadows[CONFIG_MAX_SHADOWMAPS];
+    ShadowData shadows[CONFIG_MAX_SHADOWMAP_PUNCTUAL];
 };
 static_assert(sizeof(ShadowUib) <= CONFIG_MINSPEC_UBO_SIZE,
        "ShadowUib exceeds max UBO size");
@@ -35,11 +35,6 @@ Variant Variant::filterUserVariant(
        if (filterMask & (uint32_t)UserVariantFilterBit::FOG) {
            variant.key &= ~(filterMask & FOG);
        }
-    } else {
-        // depth variants can have their VSM bit filtered
-        if (filterMask & (uint32_t)UserVariantFilterBit::VSM) {
-            variant.key &= ~(filterMask & VSM);
-        }
    }
    if (!isSSRVariant(variant)) {
        // SSR variant needs to be handled separately
@@ -58,6 +53,8 @@ Variant Variant::filterUserVariant(
    return variant;
 }

+
+
 namespace details {

 // compile time sanity-check tests
@@ -54,7 +54,9 @@ namespace msl {  // this is only used for MSL

 using BindingIndexMap = std::unordered_map<std::string, uint16_t>;

-static void collectSibs(const GLSLPostProcessor::Config& config, SibVector& sibs) {
+template<typename F>
+static void forEachSib(const GLSLPostProcessor::Config& config, F fn) {
+    const auto& samplerBindings = config.materialInfo->samplerBindings;
    switch (config.domain) {
        case MaterialDomain::SURFACE:
            UTILS_NOUNROLL
@@ -65,15 +67,14 @@ static void collectSibs(const GLSLPostProcessor::Config& config, SibVector& sibs
                auto const* sib =
                        SibGenerator::getSib((SamplerBindingPoints)blockIndex, config.variant);
                if (sib && hasShaderType(sib->getStageFlags(), config.shaderType)) {
-                    sibs.emplace_back(blockIndex, sib);
+                    fn(blockIndex, sib);
                }
            }
        case MaterialDomain::POST_PROCESS:
        case MaterialDomain::COMPUTE:
            break;
    }
-    sibs.emplace_back((uint8_t) SamplerBindingPoints::PER_MATERIAL_INSTANCE,
-            &config.materialInfo->sib);
+    fn((uint8_t) SamplerBindingPoints::PER_MATERIAL_INSTANCE, &config.materialInfo->sib);
 }

 }; // namespace msl
@@ -137,9 +138,8 @@ static std::string stringifySpvOptimizerMessage(spv_message_level_t level, const
    return oss.str();
 }

-void GLSLPostProcessor::spirvToMsl(const SpirvBlob *spirv, std::string *outMsl,
-        filament::backend::ShaderModel shaderModel, bool useFramebufferFetch, const SibVector& sibs,
-        const ShaderMinifier* minifier) {
+void GLSLPostProcessor::spirvToToMsl(const SpirvBlob *spirv, std::string *outMsl,
+        const Config &config, ShaderMinifier& minifier) {

    using namespace msl;

@@ -148,19 +148,19 @@ void GLSLPostProcessor::spirvToMsl(const SpirvBlob *spirv, std::string *outMsl,
    mslCompiler.set_common_options(options);

    const CompilerMSL::Options::Platform platform =
-        shaderModel == ShaderModel::MOBILE ?
+        config.shaderModel == ShaderModel::MOBILE ?
            CompilerMSL::Options::Platform::iOS : CompilerMSL::Options::Platform::macOS;

    CompilerMSL::Options mslOptions = {};
    mslOptions.platform = platform,
-    mslOptions.msl_version = shaderModel == ShaderModel::MOBILE ?
+    mslOptions.msl_version = config.shaderModel == ShaderModel::MOBILE ?
        CompilerMSL::Options::make_msl_version(2, 0) : CompilerMSL::Options::make_msl_version(2, 2);

-    if (useFramebufferFetch) {
+    if (config.hasFramebufferFetch) {
        mslOptions.use_framebuffer_fetch_subpasses = true;
        // On macOS, framebuffer fetch is only available starting with MSL 2.3. Filament will only
        // use framebuffer fetch materials on devices that support it.
-        if (shaderModel == ShaderModel::DESKTOP) {
+        if (config.shaderModel == ShaderModel::DESKTOP) {
            mslOptions.msl_version = CompilerMSL::Options::make_msl_version(2, 3);
        }
    }
@@ -221,7 +221,9 @@ void GLSLPostProcessor::spirvToMsl(const SpirvBlob *spirv, std::string *outMsl,
    //
    // Which is then bound to the vertex/fragment functions:
    // constant spvDescriptorSetBuffer1& spvDescriptorSet1 [[buffer(27)]]
-    for (auto [bindingPoint, sib] : sibs) {
+    forEachSib(config,
+            [&executionModel, &mslCompiler, &argumentBuffers](
+                    uint8_t bindingPoint, const SamplerInterfaceBlock* sib) {
        const auto& infoList = sib->getSamplerInfoList();

        // bindingPoint + 1, because the first descriptor set is for uniforms
@@ -249,7 +251,7 @@ void GLSLPostProcessor::spirvToMsl(const SpirvBlob *spirv, std::string *outMsl,
        argBufferBinding.msl_buffer =
                CodeGenerator::METAL_SAMPLER_GROUP_BINDING_START + bindingPoint;
        mslCompiler.add_msl_resource_binding(argBufferBinding);
-    }
+    });

    auto updateResourceBindingDefault = [executionModel, &mslCompiler]
            (const auto& resource, const BindingIndexMap* map = nullptr) {
@@ -281,9 +283,7 @@ void GLSLPostProcessor::spirvToMsl(const SpirvBlob *spirv, std::string *outMsl,
    mslCompiler.add_discrete_descriptor_set(0);

    *outMsl = mslCompiler.compile();
-    if (minifier) {
-        *outMsl = minifier->removeWhitespace(*outMsl);
-    }
+    *outMsl = minifier.removeWhitespace(*outMsl);

    // Replace spirv-cross' generated argument buffers with our own.
    for (auto* argBuffer : argumentBuffers) {
@@ -374,11 +374,8 @@ bool GLSLPostProcessor::process(const std::string& inputShader, Config const& co
                GlslangToSpv(*program.getIntermediate(internalConfig.shLang),
                        *internalConfig.spirvOutput, &options);
                if (internalConfig.mslOutput) {
-                    auto sibs = SibVector::with_capacity(CONFIG_SAMPLER_BINDING_COUNT);
-                    msl::collectSibs(config, sibs);
-                    spirvToMsl(internalConfig.spirvOutput, internalConfig.mslOutput,
-                            config.shaderModel, config.hasFramebufferFetch, sibs,
-                            &internalConfig.minifier);
+                    spirvToToMsl(internalConfig.spirvOutput, internalConfig.mslOutput, config,
+                            internalConfig.minifier);
                }
            } else {
                slog.e << "GLSL post-processor invoked with optimization level NONE"
@@ -456,10 +453,8 @@ void GLSLPostProcessor::preprocessOptimization(glslang::TShader& tShader,
    }

    if (internalConfig.mslOutput) {
-        auto sibs = SibVector::with_capacity(CONFIG_SAMPLER_BINDING_COUNT);
-        msl::collectSibs(config, sibs);
-        spirvToMsl(internalConfig.spirvOutput, internalConfig.mslOutput, config.shaderModel,
-                config.hasFramebufferFetch, sibs, &internalConfig.minifier);
+        spirvToToMsl(internalConfig.spirvOutput, internalConfig.mslOutput, config,
+                internalConfig.minifier);
    }

    if (internalConfig.glslOutput) {
@@ -485,10 +480,7 @@ void GLSLPostProcessor::fullOptimization(const TShader& tShader,
    }

    if (internalConfig.mslOutput) {
-        auto sibs = SibVector::with_capacity(CONFIG_SAMPLER_BINDING_COUNT);
-        msl::collectSibs(config, sibs);
-        spirvToMsl(&spirv, internalConfig.mslOutput, config.shaderModel, config.hasFramebufferFetch,
-                sibs, &internalConfig.minifier);
+        spirvToToMsl(&spirv, internalConfig.mslOutput, config, internalConfig.minifier);
    }

    // Transpile back to GLSL
@@ -26,8 +26,6 @@

 #include "filamat/MaterialBuilder.h"    // for MaterialBuilder:: enums

-#include <utils/FixedCapacityVector.h>
-
 #include "ShaderMinifier.h"

 #include <ShaderLang.h>
@@ -36,15 +34,9 @@

 #include <memory>

-namespace filament {
-class SamplerInterfaceBlock;
-};
-
 namespace filamat {

 using SpirvBlob = std::vector<uint32_t>;
-using BindingPointAndSib = std::pair<uint8_t, const filament::SamplerInterfaceBlock*>;
-using SibVector = utils::FixedCapacityVector<BindingPointAndSib>;

 class GLSLPostProcessor {
 public:
@@ -77,11 +69,6 @@ public:
            SpirvBlob* outputSpirv,
            std::string* outputMsl);

-    // public so backend_test can also use it
-    static void spirvToMsl(const SpirvBlob* spirv, std::string* outMsl,
-            filament::backend::ShaderModel shaderModel, bool useFramebufferFetch,
-            const SibVector& sibs, const ShaderMinifier* minifier);
-
 private:
    struct InternalConfig {
        std::string* glslOutput = nullptr;
@@ -110,6 +97,8 @@ private:
    static void registerPerformancePasses(spvtools::Optimizer& optimizer, Config const& config);

    void optimizeSpirv(OptimizerPtr optimizer, SpirvBlob& spirv) const;
+    static void spirvToToMsl(const SpirvBlob* spirv, std::string* outMsl, const Config& config,
+            ShaderMinifier& minifier);

    const MaterialBuilder::Optimization mOptimization;
    const bool mPrintShaders;
@@ -105,9 +105,10 @@ BufferInterfaceBlock const& UibGenerator::getPerViewUib() noexcept  {

            { "cascadeSplits",          0, Type::FLOAT4, Precision::HIGH },
            { "cascades",               0, Type::UINT                    },
-            { "reserved0",              0, Type::FLOAT                   },
-            { "reserved1",              0, Type::FLOAT                   },
+            { "shadowBulbRadiusLs",     0, Type::FLOAT                   },
+            { "shadowBias",             0, Type::FLOAT                   },
            { "shadowPenumbraRatioScale", 0, Type::FLOAT                 },
+            { "lightFromWorldMatrix",   4, Type::MAT4,   Precision::HIGH },

            // ------------------------------------------------------------------------------------
            // VSM shadows [variant: VSM]
@@ -170,7 +171,7 @@ BufferInterfaceBlock const& UibGenerator::getLightsUib() noexcept {
 BufferInterfaceBlock const& UibGenerator::getShadowUib() noexcept {
    static BufferInterfaceBlock uib = BufferInterfaceBlock::Builder()
            .name(ShadowUib::_name)
-            .add({{ "shadows", CONFIG_MAX_SHADOWMAPS,
+            .add({{ "shadows", CONFIG_MAX_SHADOWMAP_PUNCTUAL,
                    BufferInterfaceBlock::Type::STRUCT, {},
                    "ShadowData", sizeof(ShadowUib::ShadowData) }})
            .build();
@@ -287,10 +287,6 @@ std::string ShaderGenerator::createVertexProgram(ShaderModel shaderModel,
            UniformBindingPoints::PER_VIEW, UibGenerator::getPerViewUib());
    cg.generateUniforms(vs, ShaderStage::VERTEX,
            UniformBindingPoints::PER_RENDERABLE, UibGenerator::getPerRenderableUib());
-    if (litVariants && filament::Variant::isShadowReceiverVariant(variant)) {
-        cg.generateUniforms(vs, ShaderStage::FRAGMENT,
-                UniformBindingPoints::SHADOW, UibGenerator::getShadowUib());
-    }
    if (variant.hasSkinningOrMorphing()) {
        cg.generateUniforms(vs, ShaderStage::VERTEX,
                UniformBindingPoints::PER_RENDERABLE_BONES,
@@ -603,7 +603,7 @@ void FAssetLoader::recurseEntities(const cgltf_data* srcAsset, const cgltf_node*
        }
    }

-    if (node->light) {
+    if (node->light ) {
        createLight(node->light, entity);
    }

@@ -13,6 +13,7 @@ file(GLOB_RECURSE PUBLIC_HDRS ${PUBLIC_HDR_DIR}/${TARGET}/*.h)

 set(DIST_HDRS
        ${PUBLIC_HDR_DIR}/${TARGET}/algorithm.h
+        ${PUBLIC_HDR_DIR}/${TARGET}/architecture.h
        ${PUBLIC_HDR_DIR}/${TARGET}/bitset.h
        ${PUBLIC_HDR_DIR}/${TARGET}/CallStack.h
        ${PUBLIC_HDR_DIR}/${TARGET}/debug.h
@@ -26,6 +27,7 @@ set(DIST_HDRS
        ${PUBLIC_HDR_DIR}/${TARGET}/EntityManager.h
        ${PUBLIC_HDR_DIR}/${TARGET}/FixedCapacityVector.h
        ${PUBLIC_HDR_DIR}/${TARGET}/Invocable.h
+        ${PUBLIC_HDR_DIR}/${TARGET}/JobSystem.h
        ${PUBLIC_HDR_DIR}/${TARGET}/Log.h
        ${PUBLIC_HDR_DIR}/${TARGET}/memalign.h
        ${PUBLIC_HDR_DIR}/${TARGET}/Mutex.h
@@ -40,6 +42,7 @@ set(DIST_HDRS
        ${PUBLIC_HDR_DIR}/${TARGET}/SpinLock.h
        ${PUBLIC_HDR_DIR}/${TARGET}/StructureOfArrays.h
        ${PUBLIC_HDR_DIR}/${TARGET}/unwindows.h
+        ${PUBLIC_HDR_DIR}/${TARGET}/WorkStealingDequeue.h
 )

 # Use our custom mutex/condition only on ANDROID
@@ -49,6 +52,7 @@ set(DIST_ANDROID_HDRS

 set(DIST_GENERIC_HDRS
        ${PUBLIC_HDR_DIR}/${TARGET_GENERIC}/Mutex.h
+        ${PUBLIC_HDR_DIR}/${TARGET_GENERIC}/Condition.h
 )

 set(SRCS
@@ -9,6 +9,7 @@ struct Light {
    bool contactShadows;
    uint type;
    uint shadowIndex;
+    uint shadowLayer;
    uint channels;
 };

@@ -3,16 +3,12 @@
 struct ShadowData {
    highp mat4 lightFromWorldMatrix;
    highp vec3 direction;
-    mediump float normalBias;
+    float normalBias;
    highp vec4 lightFromWorldZ;
-    mediump float texelSizeAtOneMeter;
-    mediump float bulbRadiusLs;
-    mediump float nearOverFarMinusNear;
+    float texelSizeAtOneMeter;
+    float bulbRadiusLs;
+    float nearOverFarMinusNear;
    bool elvsm;
-    mediump uint layer;
-    mediump uint reserved0;
-    mediump uint reserved1;
-    mediump uint reserved2;
 };

 struct BoneData {
@@ -134,9 +134,8 @@ highp vec4 getCascadeLightSpacePosition(uint cascade) {
    }

    return computeLightSpacePosition(getWorldPosition(), getWorldNormalVector(),
-        frameUniforms.lightDirection,
-        shadowUniforms.shadows[cascade].normalBias,
-        shadowUniforms.shadows[cascade].lightFromWorldMatrix);
+        frameUniforms.lightDirection, frameUniforms.shadowBias,
+        frameUniforms.lightFromWorldMatrix[cascade]);
 }

 #endif
@@ -13,6 +13,10 @@ int getInstanceIndex() {
 // Uniforms access
 //------------------------------------------------------------------------------

+mat4 getLightFromWorldMatrix() {
+    return frameUniforms.lightFromWorldMatrix[0];
+}
+
 PerRenderableData getObjectUniforms() {
 #if defined(MATERIAL_HAS_INSTANCES)
    // the material manages instancing, all instances share the same uniform block.
@@ -56,8 +56,9 @@ void evaluateDirectionalLight(const MaterialInputs material,
        bool cascadeHasVisibleShadows = bool(frameUniforms.cascades & ((1u << cascade) << 8u));
        bool hasDirectionalShadows = bool(frameUniforms.directionalShadows & 1u);
        if (hasDirectionalShadows && cascadeHasVisibleShadows) {
+            uint layer = cascade;
            highp vec4 shadowPosition = getShadowPosition(true, 0u, cascade, 0.0f);
-            visibility = shadow(true, light_shadowMap, cascade, shadowPosition, 0.0f);
+            visibility = shadow(true, light_shadowMap, layer, 0u, shadowPosition, 0.0f);
        }
        if ((frameUniforms.directionalShadows & 0x2u) != 0u && visibility > 0.0) {
            if ((getObjectUniforms().flagsChannels & FILAMENT_OBJECT_CONTACT_SHADOWS_BIT) != 0u) {
@@ -154,18 +154,17 @@ Light getLight(const uint lightIndex) {
    light.worldPosition = positionFalloff.xyz;
    light.channels = channels;
    light.contactShadows = bool(typeShadow & 0x10u);
-#if defined(VARIANT_HAS_DYNAMIC_LIGHTING)
-    light.type = (typeShadow & 0x1u);
 #if defined(VARIANT_HAS_SHADOWING)
+#if defined(VARIANT_HAS_DYNAMIC_LIGHTING)
    light.shadowIndex = (typeShadow >>  8u) & 0xFFu;
+    light.shadowLayer = (typeShadow >> 16u) & 0xFFu;
    light.castsShadows   = bool(channels & 0x10000u);
+    light.type = (typeShadow & 0x1u);
    if (light.type == LIGHT_TYPE_SPOT) {
+        light.attenuation *= getAngleAttenuation(-direction, light.l, scaleOffset);
        light.zLight = dot(shadowUniforms.shadows[light.shadowIndex].lightFromWorldZ, vec4(worldPosition, 1.0));
    }
 #endif
-    if (light.type == LIGHT_TYPE_SPOT) {
-        light.attenuation *= getAngleAttenuation(-direction, light.l, scaleOffset);
-    }
 #endif
    return light;
 }
@@ -210,17 +209,19 @@ void evaluatePunctualLights(const MaterialInputs material,
 #if defined(VARIANT_HAS_SHADOWING)
        if (light.NoL > 0.0) {
            if (light.castsShadows) {
-                uint shadowIndex = light.shadowIndex;
+                uint layer = light.shadowLayer;
+                highp vec4 shadowPosition;
                if (light.type == LIGHT_TYPE_POINT) {
                    // point-light shadows are sampled from a direction
                    highp vec3 r = getWorldPosition() - light.worldPosition;
-                    uint face = getPointLightFace(r);
-                    shadowIndex += face;
-                    light.zLight = dot(shadowUniforms.shadows[shadowIndex].lightFromWorldZ,
-                            vec4(getWorldPosition(), 1.0));
+                    highp vec4 nf = shadowUniforms.shadows[light.shadowIndex].lightFromWorldZ;
+                    // getShadowPosition returns zLight which is needed for PCSS/DPCF
+                    shadowPosition = getShadowPosition(r, nf, layer, light.zLight);
+                } else {
+                    // getShadowPosition needs zLight for applying the normal bias
+                    shadowPosition = getShadowPosition(false, light.shadowIndex, 0u, light.zLight);
                }
-                highp vec4 shadowPosition = getShadowPosition(false, shadowIndex, 0u, light.zLight);
-                visibility = shadow(false, light_shadowMap, shadowIndex,
+                visibility = shadow(false, light_shadowMap, layer, light.shadowIndex,
                        shadowPosition, light.zLight);
            }
            if (light.contactShadows && visibility > 0.0) {
@@ -143,9 +143,7 @@ void main() {
 #if defined(VARIANT_HAS_SHADOWING) && defined(VARIANT_HAS_DIRECTIONAL_LIGHTING)
    vertex_lightSpacePosition = computeLightSpacePosition(
            vertex_worldPosition.xyz, vertex_worldNormal,
-            frameUniforms.lightDirection,
-            shadowUniforms.shadows[0].normalBias,
-            shadowUniforms.shadows[0].lightFromWorldMatrix);
+            frameUniforms.lightDirection, frameUniforms.shadowBias, getLightFromWorldMatrix());
 #endif

 #endif // !defined(USE_OPTIMIZED_DEPTH_VERTEX_SHADER)
@@ -50,8 +50,9 @@ vec4 evaluateMaterial(const MaterialInputs material) {
    bool cascadeHasVisibleShadows = bool(frameUniforms.cascades & ((1u << cascade) << 8u));
    bool hasDirectionalShadows = bool(frameUniforms.directionalShadows & 1u);
    if (hasDirectionalShadows && cascadeHasVisibleShadows) {
+        uint layer = cascade;
        highp vec4 shadowPosition = getShadowPosition(true, 0u, cascade, 0.0f);
-        visibility = shadow(true, light_shadowMap, cascade, shadowPosition, 0.0f);
+        visibility = shadow(true, light_shadowMap, layer, 0u, shadowPosition, 0.0f);
    }
    if ((frameUniforms.directionalShadows & 0x2u) != 0u && visibility > 0.0) {
        if ((getObjectUniforms().flagsChannels & FILAMENT_OBJECT_CONTACT_SHADOWS_BIT) != 0u) {
@@ -161,7 +161,7 @@ float getPenumbraLs(const bool DIRECTIONAL, const uint index, const highp float
    float penumbra;
    // This conditional is resolved at compile time
    if (DIRECTIONAL) {
-        penumbra = shadowUniforms.shadows[index].bulbRadiusLs;
+        penumbra = frameUniforms.shadowBulbRadiusLs;
    } else {
        // the penumbra radius depends on the light-space z for spotlights
        penumbra = shadowUniforms.shadows[index].bulbRadiusLs / zLight;
@@ -494,27 +494,55 @@ highp vec4 getShadowPosition(const bool DIRECTIONAL,
    return p;
 }

-
-uint getPointLightFace(const highp vec3 r) {
+// get {texture coordinate, layer} for point shadow maps
+highp vec4 getShadowPosition(const highp vec3 r, const highp vec4 nf,
+        inout uint layer, out highp float d) {
    highp vec4 tc;
    highp float rx = abs(r.x);
    highp float ry = abs(r.y);
    highp float rz = abs(r.z);
-    highp float d = max(rx, max(ry, rz));
+    d = max(rx, max(ry, rz));
+    highp float ma = 1.0 / d;
    if (d == rx) {
-        return (r.x >= 0.0 ? 0u : 1u);
+        tc.x = r.x >= 0.0 ? r.z : -r.z;
+        tc.y = r.y;
+        layer += (r.x >= 0.0 ? 0u : 1u);
    } else if (d == ry) {
-        return (r.y >= 0.0 ? 2u : 3u);
+        tc.x = r.y >= 0.0 ? r.x : -r.x;
+        tc.y = r.z;
+        layer += (r.y >= 0.0 ? 2u : 3u);
    } else {
-        return (r.z >= 0.0 ? 4u : 5u);
+        tc.x = r.z >= 0.0 ? -r.x : r.x;
+        tc.y = r.y;
+        layer += (r.z >= 0.0 ? 4u : 5u);
    }
+
+    // ma is guaranteed to be >= sc and tc
+    tc.xy = (tc.xy * ma + vec2(1.0)) * 0.5;
+
+    // z coordinate of the normalized fragment position in light-space
+    // i.e.: remap [near, far] to [0,1] : d = (d - n) / (f - n)
+    d = nf[2] + nf[3] * d;
+
+    if (frameUniforms.shadowSamplingType == SHADOW_SAMPLING_RUNTIME_EVSM) {
+        // for VSM, the depth metric is linear normalized in light-space
+        tc.z = d;
+    } else {
+        // for other types of shadows it's clip-space depth. Below is an optimized version of
+        // (lightProjection * position).z
+        tc.z = nf[0] + nf[1] * ma;
+    }
+
+    // FIXME: the normal bias is not applied
+
+    tc.w = 1.0;
+    return tc;
 }

 // PCF sampling
 float shadow(const bool DIRECTIONAL,
        const mediump sampler2DArrayShadow shadowMap,
-        const uint index, highp vec4 shadowPosition, highp float zLight) {
-    uint layer = shadowUniforms.shadows[index].layer;
+        const uint layer, const uint index, highp vec4 shadowPosition, highp float zLight) {
 #if SHADOW_SAMPLING_METHOD == SHADOW_SAMPLING_PCF_HARD
    return ShadowSample_PCF_Hard(shadowMap, layer, shadowPosition);
 #elif SHADOW_SAMPLING_METHOD == SHADOW_SAMPLING_PCF_LOW
@@ -525,11 +553,16 @@ float shadow(const bool DIRECTIONAL,
 // Shadow requiring a sampler2D sampler (VSM, DPCF and PCSS)
 float shadow(const bool DIRECTIONAL,
        const mediump sampler2DArray shadowMap,
-        const uint index, highp vec4 shadowPosition, highp float zLight) {
-    uint layer = shadowUniforms.shadows[index].layer;
+        const uint layer, const uint index, highp vec4 shadowPosition, highp float zLight) {
+
    // This conditional is resolved at compile time
    if (frameUniforms.shadowSamplingType == SHADOW_SAMPLING_RUNTIME_EVSM) {
-        bool elvsm = shadowUniforms.shadows[index].elvsm;
+        bool elvsm = false;
+        if (DIRECTIONAL) {
+            elvsm = bool((frameUniforms.cascades >> 31u) & 1u);
+        } else {
+            elvsm = shadowUniforms.shadows[index].elvsm;
+        }
        return ShadowSample_VSM(elvsm, shadowMap, layer, shadowPosition);
    }

@@ -417,13 +417,7 @@ export class Camera {

 export class ColorGrading$Builder {
    public quality(qualityLevel: ColorGrading$QualityLevel): ColorGrading$Builder;
-    public format(format: ColorGrading$LutFormat): ColorGrading$Builder;
-    public dimensions(dim: number): ColorGrading$Builder;
    public toneMapping(toneMapping: ColorGrading$ToneMapping): ColorGrading$Builder;
-    public luminanceScaling(luminanceScaling: boolean): ColorGrading$Builder;
-    public gamutMapping(gamutMapping: boolean): ColorGrading$Builder;
-    public exposure(exposure: number): ColorGrading$Builder;
-    public nightAdaptation(adaptation: boolean): ColorGrading$Builder;
    public whiteBalance(temperature: number, tint: number): ColorGrading$Builder;
    public channelMixer(outRed: float3, outGreen: float3, outBlue: float3): ColorGrading$Builder;
    public shadowsMidtonesHighlights(shadows: float4, midtones: float4, highlights: float4,
@@ -677,17 +671,12 @@ export enum Camera$Projection {
    ORTHO,
 }

-export enum ColorGrading$QualityLevel {
+ export enum ColorGrading$QualityLevel {
    LOW,
    MEDIUM,
    HIGH,
    ULTRA,
-}
-
-export enum ColorGrading$LutFormat {
-    INTEGER,
-    FLOAT,
-}
+ }

 export enum ColorGrading$ToneMapping {
    LINEAR,
@@ -747,40 +747,11 @@ class_<ColorBuilder>("ColorGrading$Builder")
        return &builder->quality(ql);
    })

-    .BUILDER_FUNCTION("format", ColorBuilder, (ColorBuilder* builder,
-            ColorGrading::LutFormat format), {
-        return &builder->format(format);
-    })
-
-    .BUILDER_FUNCTION("dimensions", ColorBuilder, (ColorBuilder* builder, uint8_t dim), {
-        return &builder->dimensions(dim);
-    })
-
    .BUILDER_FUNCTION("toneMapping", ColorBuilder, (ColorBuilder* builder,
            ColorGrading::ToneMapping tm), {
        return &builder->toneMapping(tm);
    })

-    .BUILDER_FUNCTION("luminanceScaling", ColorBuilder, (ColorBuilder* builder,
-            bool luminanceScaling), {
-        return &builder->luminanceScaling(luminanceScaling);
-    })
-
-    .BUILDER_FUNCTION("gamutMapping", ColorBuilder, (ColorBuilder* builder,
-            bool gamutMapping), {
-        return &builder->gamutMapping(gamutMapping);
-    })
-
-    .BUILDER_FUNCTION("exposure", ColorBuilder, (ColorBuilder* builder,
-            float exposure), {
-        return &builder->exposure(exposure);
-    })
-
-    .BUILDER_FUNCTION("nightAdaptation", ColorBuilder, (ColorBuilder* builder,
-            float adaptation), {
-        return &builder->nightAdaptation(adaptation);
-    })
-
    .BUILDER_FUNCTION("whiteBalance", ColorBuilder, (ColorBuilder* builder, float temp,
            float tint), {
        return &builder->whiteBalance(temp, tint);
@@ -147,10 +147,6 @@ enum_<ColorGrading::ToneMapping>("ColorGrading$ToneMapping")
    .value("FILMIC", ColorGrading::ToneMapping::FILMIC)
    .value("DISPLAY_RANGE", ColorGrading::ToneMapping::DISPLAY_RANGE);

-enum_<ColorGrading::LutFormat>("ColorGrading$LutFormat")
-    .value("INTEGER", ColorGrading::LutFormat::INTEGER)
-    .value("FLOAT", ColorGrading::LutFormat::FLOAT);
-
 enum_<Frustum::Plane>("Frustum$Plane")
    .value("LEFT", Frustum::Plane::LEFT)
    .value("RIGHT", Frustum::Plane::RIGHT)
@@ -1,6 +1,6 @@
 {
  "name": "filament",
-  "version": "1.29.0",
+  "version": "1.28.2",
  "description": "Real-time physically based rendering engine",
  "main": "filament.js",
  "module": "filament.js",