Merge branch 'rc/1.53.2' into release

switch to new morphing API
- remove deprecated morphing APIs - repair gltfio, samples and tests The new API doesn't allow a MorphTargetBuffer per RenderPrimitive, instead the MorphTargetBuffer is specified per Renderable. gltfio separates RenderPrimitives from Renderables, in particular all RenderPrimitives are created before their Renderable; this was problematic for this change because all primitives must share a single MorphTargetBuffer living in the Renderable. To fix this, we're no longer initializing the morphing paramters at RenderPrimitive creation, instead we store a reference to the BufferSlot in the Primtive structure, so that later, when the Renderable is created we can finally retrieve the BufferSlot and initialize its morphing paramters, which are not available. The "morphing parameters" are now expanded to contain the MorphTargetBuffer as before (except now it's always the same for all the primitives of a Rendrable), as well as the offset within the buffer and the vertex count.
2024-07-23 01:24:09 +00:00 · 2024-07-22 11:31:03 -06:00 · 2024-07-18 16:41:31 -07:00 · 2024-07-01 11:31:30 -07:00 · 2024-07-01 10:57:37 -07:00 · 2024-06-28 13:09:39 -07:00
333 changed files with 31291 additions and 13277 deletions
@@ -13,7 +13,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
@@ -13,7 +13,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - name: Run build script
        run: |
          cd build/ios && printf "y" | ./build.sh continuous
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-22.04

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - name: Run build script
        run: |
          cd build/linux && printf "y" | ./build.sh continuous
@@ -13,7 +13,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - name: Run build script
        run: |
          cd build/mac && printf "y" | ./build.sh continuous
@@ -13,7 +13,7 @@ jobs:
    name: npm-deploy
    runs-on: macos-14
    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
        with:
          ref: ${{ github.event.inputs.release_tag }}
      # Setup .npmrc file to publish to npm
@@ -18,7 +18,7 @@ jobs:
        os: [macos-14, ubuntu-22.04]

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - name: Run build script
        run: |
          WORKFLOW_OS=`echo \`uname\` | sed "s/Darwin/mac/" | tr [:upper:] [:lower:]`
@@ -32,7 +32,7 @@ jobs:
    runs-on: windows-2019

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - name: Run build script
        run: |
          build\windows\build-github.bat presubmit
@@ -43,7 +43,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
@@ -57,7 +57,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - name: Run build script
        run: |
          cd build/ios && printf "y" | ./build.sh presubmit
@@ -70,7 +70,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - name: Run build script
        run: |
          cd build/web && printf "y" | ./build.sh presubmit
@@ -41,7 +41,7 @@ jobs:
          TAG=${REF##*/}
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
@@ -76,7 +76,7 @@ jobs:
          TAG=${REF##*/}
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
@@ -109,7 +109,7 @@ jobs:
          TAG=${REF##*/}
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - uses: actions/setup-java@v3
@@ -163,7 +163,7 @@ jobs:
          TAG=${REF##*/}
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
@@ -197,7 +197,7 @@ jobs:
          echo "ref=${REF}" >> $GITHUB_OUTPUT
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
        shell: bash
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
        with:
          ref: ${{ steps.git_ref.outputs.ref }}
      - name: Run build script
@@ -13,7 +13,7 @@ jobs:
    runs-on: macos-14

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - name: Run build script
        run: |
          cd build/web && printf "y" | ./build.sh continuous
@@ -13,7 +13,7 @@ jobs:
    runs-on: windows-2019

    steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v4.1.6
      - name: Run build script
        run: |
          build\windows\build-github.bat continuous
@@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.52.3'
+    implementation 'com.google.android.filament:filament-android:1.53.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:

 ```shell
-pod 'Filament', '~> 1.52.3'
+pod 'Filament', '~> 1.53.2'
 ```

 ### Snapshots
@@ -176,6 +176,7 @@ steps:
  - [x] KHR_materials_unlit
  - [x] KHR_materials_variants
  - [x] KHR_materials_volume
+  - [x] KHR_materials_specular
  - [x] KHR_mesh_quantization
  - [x] KHR_texture_basisu
  - [x] KHR_texture_transform
@@ -7,6 +7,16 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).

+## v1.53.2
+
+
+## v1.53.1
+
+
+## v1.53.0
+
+- engine: fix skinning normals with large transforms (b/342459864) [⚠️ **New Material Version**]
+
 ## v1.52.3


@@ -83,12 +83,12 @@ buildscript {
        'minSdk': 21,
        'targetSdk': 34,
        'compileSdk': 34,
-        'kotlin': '1.9.21',
-        'kotlin_coroutines': '1.7.3',
+        'kotlin': '2.0.0',
+        'kotlin_coroutines': '1.9.0-RC',
        'buildTools': '34.0.0',
-        'ndk': '26.1.10909125',
-        'androidx_core': '1.12.0',
-        'androidx_annotations': '1.7.0'
+        'ndk': '27.0.11718014',
+        'androidx_core': '1.13.1',
+        'androidx_annotations': '1.8.0'
    ]

    ext.deps = [
@@ -104,7 +104,7 @@ buildscript {
    ]

    dependencies {
-        classpath 'com.android.tools.build:gradle:8.2.0'
+        classpath 'com.android.tools.build:gradle:8.4.1'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
    }

@@ -420,6 +420,13 @@ Java_com_google_android_filament_Engine_nSetPaused(JNIEnv*, jclass,
    engine->setPaused(paused);
 }

+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Engine_nUnprotected(JNIEnv*, jclass,
+        jlong nativeEngine, jboolean paused) {
+    Engine* engine = (Engine*) nativeEngine;
+    engine->unprotected();
+}
+
 // Managers...

 extern "C" JNIEXPORT jlong JNICALL
@@ -564,3 +571,9 @@ Java_com_google_android_filament_Engine_nBuilderBuild(JNIEnv*, jclass, jlong nat
    Engine::Builder* builder = (Engine::Builder*) nativeBuilder;
    return (jlong) builder->build();
 }
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_com_google_android_filament_Engine_getSteadyClockTimeNano(JNIEnv *env, jclass clazz) {
+    return (jlong)Engine::getSteadyClockTimeNano();
+}
@@ -25,12 +25,17 @@ using namespace filament;

 extern "C" JNIEXPORT jlong JNICALL
 Java_com_google_android_filament_Material_nBuilderBuild(JNIEnv *env, jclass,
-        jlong nativeEngine, jobject buffer_, jint size) {
+        jlong nativeEngine, jobject buffer_, jint size, jint shBandCount) {
    Engine* engine = (Engine*) nativeEngine;
    AutoBuffer buffer(env, buffer_, size);
-    Material* material = Material::Builder()
+    auto builder = Material::Builder();
+    if (shBandCount) {
+        builder.sphericalHarmonicsBandCount(shBandCount);
+    }
+    Material* material = builder
            .package(buffer.getData(), buffer.getSize())
            .build(*engine);
+
    return (jlong) material;
 }

@@ -253,16 +253,10 @@ Java_com_google_android_filament_RenderableManager_nBuilderMorphingStandard(JNIE
 }

 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderSetMorphTargetBufferAt(JNIEnv*, jclass,
-        jlong nativeBuilder, int level, int primitiveIndex, jlong nativeMorphTargetBuffer,
-        int offset, int count) {
+Java_com_google_android_filament_RenderableManager_nBuilderSetMorphTargetBufferOffsetAt(JNIEnv*, jclass,
+        jlong nativeBuilder, int level, int primitiveIndex, int offset) {
    RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    if (nativeMorphTargetBuffer) {
-        MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-        builder->morphing(level, primitiveIndex, morphTargetBuffer, offset, count);
-    } else {
-        builder->morphing(level, primitiveIndex, offset, count);
-    }
+    builder->morphing(level, primitiveIndex, offset);
 }

 extern "C" JNIEXPORT void JNICALL
@@ -334,18 +328,12 @@ Java_com_google_android_filament_RenderableManager_nSetMorphWeights(JNIEnv* env,
 }

 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nSetMorphTargetBufferAt(JNIEnv*,
+Java_com_google_android_filament_RenderableManager_nSetMorphTargetBufferOffsetAt(JNIEnv*,
        jclass, jlong nativeRenderableManager, jint i, int level, jint primitiveIndex,
-        jlong nativeMorphTargetBuffer, jint offset, jint count) {
+        jlong, jint offset) {
    RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    if (nativeMorphTargetBuffer) {
-        MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
-        rm->setMorphTargetBufferAt((RenderableManager::Instance) i, (uint8_t) level,
-                (size_t) primitiveIndex, morphTargetBuffer, (size_t) offset, (size_t) count);
-    } else {
-        rm->setMorphTargetBufferAt((RenderableManager::Instance) i, (uint8_t) level,
-                (size_t) primitiveIndex, (size_t) offset, (size_t) count);
-    }
+    rm->setMorphTargetBufferOffsetAt((RenderableManager::Instance) i, (uint8_t) level,
+            (size_t) primitiveIndex, (size_t) offset);
 }

 extern "C" JNIEXPORT jint JNICALL
@@ -187,3 +187,10 @@ Java_com_google_android_filament_Renderer_nSetPresentationTime(JNIEnv *, jclass
    Renderer *renderer = (Renderer *) nativeRenderer;
    renderer->setPresentationTime(monotonicClockNanos);
 }
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Renderer_nSetVsyncTime(JNIEnv *, jclass,
+    jlong nativeRenderer, jlong steadyClockTimeNano) {
+    Renderer *renderer = (Renderer *) nativeRenderer;
+    renderer->setVsyncTime(steadyClockTimeNano);
+}
@@ -1289,6 +1289,24 @@ public class Engine {
        nSetPaused(getNativeObject(), paused);
    }

+    /**
+     * Switch the command queue to unprotected mode. Protected mode can be activated via
+     * Renderer::beginFrame() using a protected SwapChain.
+     * @see Renderer
+     * @see SwapChain
+     */
+    public void unprotected() {
+        nUnprotected(getNativeObject());
+    }
+
+    /**
+     * Get the current time. This is a convenience function that simply returns the
+     * time in nanosecond since epoch of std::chrono::steady_clock.
+     * @return current time in nanosecond since epoch of std::chrono::steady_clock.
+     * @see Renderer#beginFrame
+     */
+    public static native long getSteadyClockTimeNano();
+
    @UsedByReflection("TextureHelper.java")
    public long getNativeObject() {
        if (mNativeObject == 0) {
@@ -1366,6 +1384,7 @@ public class Engine {
    private static native void nFlush(long nativeEngine);
    private static native boolean nIsPaused(long nativeEngine);
    private static native void nSetPaused(long nativeEngine, boolean paused);
+    private static native void nUnprotected(long nativeEngine);
    private static native long nGetTransformManager(long nativeEngine);
    private static native long nGetLightManager(long nativeEngine);
    private static native long nGetRenderableManager(long nativeEngine);
@@ -346,6 +346,7 @@ public class Material {
    public static class Builder {
        private Buffer mBuffer;
        private int mSize;
+        private int mShBandCount = 0;

        /**
         * Specifies the material data. The material data is a binary blob produced by
@@ -361,6 +362,22 @@ public class Material {
            return this;
        }

+        /**
+         * Sets the quality of the indirect lights computations. This is only taken into account
+         * if this material is lit and in the surface domain. This setting will affect the
+         * IndirectLight computation if one is specified on the Scene and Spherical Harmonics
+         * are used for the irradiance.
+         *
+         * @param shBandCount Number of spherical harmonic bands. Must be 1, 2 or 3 (default).
+         * @return Reference to this Builder for chaining calls.
+         * @see IndirectLight
+         */
+        @NonNull
+        public Builder sphericalHarmonicsBandCount(@IntRange(from = 0) int shBandCount) {
+            mShBandCount = shBandCount;
+            return this;
+        }
+
        /**
         * Creates and returns the Material object.
         *
@@ -372,7 +389,8 @@ public class Material {
         */
        @NonNull
        public Material build(@NonNull Engine engine) {
-            long nativeMaterial = nBuilderBuild(engine.getNativeObject(), mBuffer, mSize);
+            long nativeMaterial = nBuilderBuild(engine.getNativeObject(),
+                mBuffer, mSize, mShBandCount);
            if (nativeMaterial == 0) throw new IllegalStateException("Couldn't create Material");
            return new Material(nativeMaterial);
        }
@@ -1023,7 +1041,7 @@ public class Material {
        mNativeObject = 0;
    }

-    private static native long nBuilderBuild(long nativeEngine, @NonNull Buffer buffer, int size);
+    private static native long nBuilderBuild(long nativeEngine, @NonNull Buffer buffer, int size, int shBandCount);
    private static native long nCreateInstance(long nativeMaterial);
    private static native long nCreateInstanceWithName(long nativeMaterial, @NonNull String name);
    private static native long nGetDefaultInstance(long nativeMaterial);
@@ -74,7 +74,7 @@ public class MorphTargetBuffer {
         *
         * @exception IllegalStateException if the MorphTargetBuffer could not be created
         *
-         * @see #setMorphTargetBufferAt
+         * @see #setMorphTargetBufferOffsetAt
         */
        @NonNull
        public MorphTargetBuffer build(@NonNull Engine engine) {
@@ -569,40 +569,13 @@ public class RenderableManager {
         *
         * @param level the level of detail (lod), only 0 can be specified
         * @param primitiveIndex zero-based index of the primitive, must be less than the count passed to Builder constructor
-         * @param morphTargetBuffer specifies the morph target buffer
         * @param offset specifies where in the morph target buffer to start reading (expressed as a number of vertices)
-         * @param count number of vertices in the morph target buffer to read, must equal the geometry's count (for triangles, this should be a multiple of 3)
         */
        @NonNull
        public Builder morphing(@IntRange(from = 0) int level,
                                @IntRange(from = 0) int primitiveIndex,
-                                @IntRange(from = 0) int offset,
-                                @IntRange(from = 0) int count) {
-            nBuilderSetMorphTargetBufferAt(mNativeBuilder, level, primitiveIndex, 0, offset, count);
-            return this;
-        }
-
-        /** @deprecated */
-        @Deprecated
-        @NonNull
-        public Builder morphing(@IntRange(from = 0) int level,
-                                @IntRange(from = 0) int primitiveIndex,
-                                @NonNull MorphTargetBuffer morphTargetBuffer,
-                                @IntRange(from = 0) int offset,
-                                @IntRange(from = 0) int count) {
-            nBuilderSetMorphTargetBufferAt(mNativeBuilder, level, primitiveIndex,
-                    morphTargetBuffer.getNativeObject(), offset, count);
-            return this;
-        }
-
-        /** @deprecated */
-        @Deprecated
-        @NonNull
-        public Builder morphing(@IntRange(from = 0) int level,
-                                @IntRange(from = 0) int primitiveIndex,
-                                @NonNull MorphTargetBuffer morphTargetBuffer) {
-            nBuilderSetMorphTargetBufferAt(mNativeBuilder, level, primitiveIndex,
-                    morphTargetBuffer.getNativeObject(), 0, morphTargetBuffer.getVertexCount());
+                                @IntRange(from = 0) int offset) {
+            nBuilderSetMorphTargetBufferOffsetAt(mNativeBuilder, level, primitiveIndex, offset);
            return this;
        }

@@ -705,34 +678,11 @@ public class RenderableManager {
     *
     * @see Builder#morphing
     */
-    public void setMorphTargetBufferAt(@EntityInstance int i,
+    public void setMorphTargetBufferOffsetAt(@EntityInstance int i,
                                       @IntRange(from = 0) int level,
                                       @IntRange(from = 0) int primitiveIndex,
-                                       @IntRange(from = 0) int offset,
-                                       @IntRange(from = 0) int count) {
-        nSetMorphTargetBufferAt(mNativeObject, i, level, primitiveIndex, 0, offset, count);
-    }
-
-    /** @deprecated */
-    @Deprecated
-    public void setMorphTargetBufferAt(@EntityInstance int i,
-                                       @IntRange(from = 0) int level,
-                                       @IntRange(from = 0) int primitiveIndex,
-                                       @NonNull MorphTargetBuffer morphTargetBuffer,
-                                       @IntRange(from = 0) int offset,
-                                       @IntRange(from = 0) int count) {
-        nSetMorphTargetBufferAt(mNativeObject, i, level, primitiveIndex,
-                morphTargetBuffer.getNativeObject(), offset, count);
-    }
-
-    /** @deprecated */
-    @Deprecated
-    public void setMorphTargetBufferAt(@EntityInstance int i,
-                                       @IntRange(from = 0) int level,
-                                       @IntRange(from = 0) int primitiveIndex,
-                                       @NonNull MorphTargetBuffer morphTargetBuffer) {
-        nSetMorphTargetBufferAt(mNativeObject, i, level, primitiveIndex,
-                morphTargetBuffer.getNativeObject(), 0, morphTargetBuffer.getVertexCount());
+                                       @IntRange(from = 0) int offset) {
+        nSetMorphTargetBufferOffsetAt(mNativeObject, i, level, primitiveIndex, 0, offset);
    }

    /**
@@ -1033,7 +983,7 @@ public class RenderableManager {
    private static native void nBuilderSkinningBuffer(long nativeBuilder, long nativeSkinningBuffer, int boneCount, int offset);
    private static native void nBuilderMorphing(long nativeBuilder, int targetCount);
    private static native void nBuilderMorphingStandard(long nativeBuilder, long nativeMorphTargetBuffer);
-    private static native void nBuilderSetMorphTargetBufferAt(long nativeBuilder, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset, int count);
+    private static native void nBuilderSetMorphTargetBufferOffsetAt(long nativeBuilder, int level, int primitiveIndex, int offset);
    private static native void nBuilderEnableSkinningBuffers(long nativeBuilder, boolean enabled);
    private static native void nBuilderFog(long nativeBuilder, boolean enabled);
    private static native void nBuilderLightChannel(long nativeRenderableManager, int channel, boolean enable);
@@ -1043,7 +993,7 @@ public class RenderableManager {
    private static native int nSetBonesAsMatrices(long nativeObject, int i, Buffer matrices, int remaining, int boneCount, int offset);
    private static native int nSetBonesAsQuaternions(long nativeObject, int i, Buffer quaternions, int remaining, int boneCount, int offset);
    private static native void nSetMorphWeights(long nativeObject, int instance, float[] weights, int offset);
-    private static native void nSetMorphTargetBufferAt(long nativeObject, int i, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset, int count);
+    private static native void nSetMorphTargetBufferOffsetAt(long nativeObject, int i, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset);
    private static native int nGetMorphTargetCount(long nativeObject, int i);
    private static native void nSetAxisAlignedBoundingBox(long nativeRenderableManager, int i, float cx, float cy, float cz, float ex, float ey, float ez);
    private static native void nSetLayerMask(long nativeRenderableManager, int i, int select, int value);
@@ -284,6 +284,19 @@ public class Renderer {
        nSetPresentationTime(getNativeObject(), monotonicClockNanos);
    }

+    /**
+     * The use of this method is optional. It sets the VSYNC time expressed as the duration in
+     * nanosecond since epoch of std::chrono::steady_clock.
+     * If called, passing 0 to frameTimeNanos in Renderer.BeginFrame will use this
+     * time instead.
+     * @param steadyClockTimeNano duration in nanosecond since epoch of std::chrono::steady_clock
+     * @see Engine#getSteadyClockTimeNano
+     * @see Renderer#beginFrame
+     */
+    public void setVsyncTime(long steadyClockTimeNano) {
+        nSetVsyncTime(getNativeObject(), steadyClockTimeNano);
+    }
+
    /**
     * Sets up a frame for this <code>Renderer</code>.
     * <p><code>beginFrame</code> manages frame pacing, and returns whether or not a frame should be
@@ -702,6 +715,7 @@ public class Renderer {
    }

    private static native void nSetPresentationTime(long nativeObject, long monotonicClockNanos);
+    private static native void nSetVsyncTime(long nativeObject, long steadyClockTimeNano);
    private static native boolean nBeginFrame(long nativeRenderer, long nativeSwapChain, long frameTimeNanos);
    private static native void nEndFrame(long nativeRenderer);
    private static native void nRender(long nativeRenderer, long nativeView);
@@ -1,5 +1,5 @@
 GROUP=com.google.android.filament
-VERSION_NAME=1.52.3
+VERSION_NAME=1.53.2

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

@@ -1,6 +1,6 @@
 #Wed Nov 17 10:40:18 PST 2021
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
@@ -57,7 +57,8 @@ FILAMENT_NDK_VERSION=${FILAMENT_NDK_VERSION:-$(cat `dirname $0`/ndk.version)}

 # Install the required NDK version specifically (if not present)
 if [[ ! -d "${ANDROID_HOME}/ndk/$FILAMENT_NDK_VERSION" ]]; then
-    ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager "ndk;$FILAMENT_NDK_VERSION" > /dev/null
+    yes | ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager --licenses
+    ${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager "ndk;$FILAMENT_NDK_VERSION"
 fi

 # Only build 1 64 bit target during presubmit to cut down build times during presubmit
@@ -1 +1 @@
-26.1.10909125
+27.0.11718014
@@ -75,6 +75,8 @@ public:
         */
        size_t textureUseAfterFreePoolSize = 0;

+        size_t metalUploadBufferSizeBytes = 512 * 1024;
+
        /**
         * Set to `true` to forcibly disable parallel shader compilation in the backend.
         * Currently only honored by the GL and Metal backends.
@@ -90,8 +90,13 @@ protected:
    AcquiredImage transformAcquiredImage(AcquiredImage source) noexcept override;

 private:
+    struct InitializeJvmForPerformanceManagerIfNeeded {
+        InitializeJvmForPerformanceManagerIfNeeded();
+    };
+
    int mOSVersion;
    ExternalStreamManagerAndroid& mExternalStreamManager;
+    InitializeJvmForPerformanceManagerIfNeeded const mInitializeJvmForPerformanceManagerIfNeeded;
    utils::PerformanceHintManager mPerformanceHintManager;
    utils::PerformanceHintManager::Session mPerformanceHintSession;

@@ -90,6 +90,20 @@ public:
        VkExtent2D extent = {0, 0};
    };

+    struct ImageSyncData {
+        static constexpr uint32_t INVALID_IMAGE_INDEX = UINT32_MAX;
+
+        // The index of the next image as returned by vkAcquireNextImage or equivalent.
+        uint32_t imageIndex = INVALID_IMAGE_INDEX;
+
+        // Semaphore to be signaled once the image is available.
+        VkSemaphore imageReadySemaphore = VK_NULL_HANDLE;
+
+        // A function called right before vkQueueSubmit. After this call, the image must be 
+        // available. This pointer can be null if imageReadySemaphore is not VK_NULL_HANDLE.
+        std::function<void(SwapChainPtr handle)> explicitImageReadyWait = nullptr;
+    };
+
    VulkanPlatform();

    ~VulkanPlatform() override;
@@ -127,6 +141,12 @@ public:
         * before recreating the swapchain. Default is true.
         */
        bool flushAndWaitOnWindowResize = true;
+
+        /**
+         * Whether the swapchain image should be transitioned to a layout suitable for
+         * presentation. Default is true.
+         */
+        bool transitionSwapChainImageLayoutForPresent = true;
    };

    /**
@@ -155,13 +175,10 @@ public:
     * corresponding VkImage will be used as the output color attachment. The client should signal
     * the `clientSignal` semaphore when the image is ready to be used by the backend.
     * @param handle         The handle returned by createSwapChain()
-     * @param clientSignal   The semaphore that the client will signal to indicate that the backend
-     *                       may render into the image.
-     * @param index          Pointer to memory that will be filled with the index that corresponding
-     *                       to an image in the `SwapChainBundle.colors` array.
+     * @param outImageSyncData The synchronization data used for image readiness
     * @return               Result of acquire
     */
-    virtual VkResult acquire(SwapChainPtr handle, VkSemaphore clientSignal, uint32_t* index);
+    virtual VkResult acquire(SwapChainPtr handle, ImageSyncData* outImageSyncData);

    /**
     * Present the image corresponding to `index` to the display. The client should wait on
@@ -181,6 +181,18 @@ public:
        return static_cast<Dp>(p);
    }

+    template<typename B>
+    bool is_valid(Handle<B>& handle) {
+        if (handle && isPoolHandle(handle.getId())) {
+            auto [p, tag] = handleToPointer(handle.getId());
+            uint8_t const age = (tag & HANDLE_AGE_MASK) >> HANDLE_AGE_SHIFT;
+            auto const pNode = static_cast<typename Allocator::Node*>(p);
+            uint8_t const expectedAge = pNode[-1].age;
+            return expectedAge == age;
+        }
+        return true;
+    }
+
    template<typename Dp, typename B>
    inline typename std::enable_if_t<
            std::is_pointer_v<Dp> &&
@@ -16,13 +16,23 @@

 #include "private/backend/VirtualMachineEnv.h"

+#include <utils/compiler.h>
 #include <utils/debug.h>

+#include <jni.h>
+
 namespace filament {

 JavaVM* VirtualMachineEnv::sVirtualMachine = nullptr;

-// This is called when the library is loaded. We need this to get a reference to the global VM
+/*
+ * This is typically called by filament_jni.so when it is loaded. If filament_jni.so is not used,
+ * then this must be called manually -- however, this is a problem because VirtualMachineEnv.h
+ * is currently private and part of backend.
+ * For now, we authorize this usage, but we will need to fix it; by making a proper public
+ * API for this.
+ */
+UTILS_PUBLIC
 UTILS_NOINLINE
 jint VirtualMachineEnv::JNI_OnLoad(JavaVM* vm) noexcept {
    JNIEnv* env = nullptr;
@@ -204,6 +204,15 @@ public:

 private:

+    enum class UploadStrategy {
+        POOL,
+        BUMP_ALLOCATOR,
+    };
+
+    void uploadWithPoolBuffer(void* src, size_t size, size_t byteOffset) const;
+    void uploadWithBumpAllocator(void* src, size_t size, size_t byteOffset) const;
+
+    UploadStrategy mUploadStrategy;
    TrackedMetalBuffer mBuffer;
    size_t mBufferSize = 0;
    void* mCpuBuffer = nullptr;
@@ -27,7 +27,16 @@ MetalPlatform* TrackedMetalBuffer::platform = nullptr;
 MetalPlatform* ScopedAllocationTimer::platform = nullptr;

 MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType, BufferUsage usage,
-        size_t size, bool forceGpuBuffer) : mBufferSize(size), mContext(context) {
+        size_t size, bool forceGpuBuffer)
+    : mBufferSize(size), mContext(context) {
+    const MetalBumpAllocator& allocator = *mContext.bumpAllocator;
+    // VERTEX is also used for index buffers
+    if (allocator.getCapacity() > 0 && bindingType == BufferObjectBinding::VERTEX) {
+        mUploadStrategy = UploadStrategy::BUMP_ALLOCATOR;
+    } else {
+        mUploadStrategy = UploadStrategy::POOL;
+    }
+
    // If the buffer is less than 4K in size and is updated frequently, we don't use an explicit
    // buffer. Instead, we use immediate command encoder methods like setVertexBytes:length:atIndex:.
    // This won't work for SSBOs, since they are read/write.
@@ -61,34 +70,23 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
    FILAMENT_CHECK_PRECONDITION(size + byteOffset <= mBufferSize)
            << "Attempting to copy " << size << " bytes into a buffer of size " << mBufferSize
            << " at offset " << byteOffset;
+    // The copy blit requires that byteOffset be a multiple of 4.
+    FILAMENT_CHECK_PRECONDITION(!(byteOffset & 0x3)) << "byteOffset must be a multiple of 4";

-    // Either copy into the Metal buffer or into our cpu buffer.
+    // If we have a cpu buffer, we can directly copy into it.
    if (mCpuBuffer) {
        memcpy(static_cast<uint8_t*>(mCpuBuffer) + byteOffset, src, size);
        return;
    }

-    // Acquire a staging buffer to hold the contents of this update.
-    MetalBufferPool* bufferPool = mContext.bufferPool;
-    const MetalBufferPoolEntry* const staging = bufferPool->acquireBuffer(size);
-    memcpy(staging->buffer.get().contents, src, size);
-
-    // The blit below requires that byteOffset be a multiple of 4.
-    FILAMENT_CHECK_PRECONDITION(!(byteOffset & 0x3u)) << "byteOffset must be a multiple of 4";
-
-    // Encode a blit from the staging buffer into the private GPU buffer.
-    id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);
-    id<MTLBlitCommandEncoder> blitEncoder = [cmdBuffer blitCommandEncoder];
-    blitEncoder.label = @"Buffer upload blit";
-    [blitEncoder copyFromBuffer:staging->buffer.get()
-                   sourceOffset:0
-                       toBuffer:mBuffer.get()
-              destinationOffset:byteOffset
-                           size:size];
-    [blitEncoder endEncoding];
-    [cmdBuffer addCompletedHandler:^(id<MTLCommandBuffer> cb) {
-        bufferPool->releaseBuffer(staging);
-    }];
+    switch (mUploadStrategy) {
+        case UploadStrategy::BUMP_ALLOCATOR:
+            uploadWithBumpAllocator(src, size, byteOffset);
+            break;
+        case UploadStrategy::POOL:
+            uploadWithPoolBuffer(src, size, byteOffset);
+            break;
+    }
 }

 void MetalBuffer::copyIntoBufferUnsynchronized(void* src, size_t size, size_t byteOffset) {
@@ -199,5 +197,42 @@ void MetalBuffer::bindBuffers(id<MTLCommandBuffer> cmdBuffer, id<MTLCommandEncod
    }
 }

+void MetalBuffer::uploadWithPoolBuffer(void* src, size_t size, size_t byteOffset) const {
+    MetalBufferPool* bufferPool = mContext.bufferPool;
+    const MetalBufferPoolEntry* const staging = bufferPool->acquireBuffer(size);
+    memcpy(staging->buffer.get().contents, src, size);
+
+    // Encode a blit from the staging buffer into the private GPU buffer.
+    id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);
+    id<MTLBlitCommandEncoder> blitEncoder = [cmdBuffer blitCommandEncoder];
+    blitEncoder.label = @"Buffer upload blit - pool buffer";
+    [blitEncoder copyFromBuffer:staging->buffer.get()
+                   sourceOffset:0
+                       toBuffer:mBuffer.get()
+              destinationOffset:byteOffset
+                           size:size];
+    [blitEncoder endEncoding];
+    [cmdBuffer addCompletedHandler:^(id<MTLCommandBuffer> cb) {
+        bufferPool->releaseBuffer(staging);
+    }];
+}
+
+void MetalBuffer::uploadWithBumpAllocator(void* src, size_t size, size_t byteOffset) const {
+    MetalBumpAllocator& allocator = *mContext.bumpAllocator;
+    auto [buffer, offset] = allocator.allocateStagingArea(size);
+    memcpy(static_cast<char*>(buffer.contents) + offset, src, size);
+
+    // Encode a blit from the staging buffer into the private GPU buffer.
+    id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);
+    id<MTLBlitCommandEncoder> blitEncoder = [cmdBuffer blitCommandEncoder];
+    blitEncoder.label = @"Buffer upload blit - bump allocator";
+    [blitEncoder copyFromBuffer:buffer
+                   sourceOffset:offset
+                       toBuffer:mBuffer.get()
+              destinationOffset:byteOffset
+                           size:size];
+    [blitEncoder endEncoding];
+}
+
 } // namespace backend
 } // namespace filament
@@ -38,6 +38,28 @@ struct MetalBufferPoolEntry {
    mutable uint32_t referenceCount;
 };

+class MetalBumpAllocator {
+public:
+    MetalBumpAllocator(id<MTLDevice> device, size_t capacity);
+
+    /**
+     * Allocates a staging area of the given size. Returns a pair of the buffer and the offset
+     * within the buffer. The buffer is guaranteed to be at least the given size, but may be larger.
+     * Clients must not write to the buffer beyond the returned offset + size.
+     * Clients are responsible for holding a reference to the returned buffer.
+     * Allocations are guaranteed to be aligned to 4 bytes.
+     */
+    std::pair<id<MTLBuffer>, size_t> allocateStagingArea(size_t size);
+
+    size_t getCapacity() const noexcept { return mCapacity; }
+
+private:
+    id<MTLDevice> mDevice;
+    TrackedMetalBuffer mCurrentUploadBuffer = nil;
+    size_t mHead = 0;
+    size_t mCapacity;
+};
+
 // Manages a pool of Metal buffers, periodically releasing ones that have been unused for awhile.
 class MetalBufferPool {
 public:
@@ -116,5 +116,39 @@ void MetalBufferPool::reset() noexcept {
    mFreeStages.clear();
 }

+MetalBumpAllocator::MetalBumpAllocator(id<MTLDevice> device, size_t capacity)
+    : mDevice(device), mCapacity(capacity) {
+    if (mCapacity > 0) {
+        mCurrentUploadBuffer = { [device newBufferWithLength:capacity options:MTLStorageModeShared],
+            TrackedMetalBuffer::Type::STAGING };
+    }
+}
+
+std::pair<id<MTLBuffer>, size_t> MetalBumpAllocator::allocateStagingArea(size_t size) {
+    if (size == 0) {
+        return { nil, 0 };
+    }
+    if (size > mCapacity) {
+        return { [mDevice newBufferWithLength:size options:MTLStorageModeShared], 0 };
+    }
+    assert_invariant(mCurrentUploadBuffer);
+
+    // Align the head to a 4-byte boundary.
+    mHead = (mHead + 3) & ~3;
+
+    if (UTILS_LIKELY(mHead + size <= mCapacity)) {
+        const size_t oldHead = mHead;
+        mHead += size;
+        return { mCurrentUploadBuffer.get(), oldHead };
+    }
+
+    // We're finished with the current allocation.
+    mCurrentUploadBuffer = { [mDevice newBufferWithLength:mCapacity options:MTLStorageModeShared],
+        TrackedMetalBuffer::Type::STAGING };
+    mHead = size;
+
+    return { mCurrentUploadBuffer.get(), 0 };
+}
+
 } // namespace backend
 } // namespace filament
@@ -44,6 +44,7 @@ namespace backend {
 class MetalDriver;
 class MetalBlitter;
 class MetalBufferPool;
+class MetalBumpAllocator;
 class MetalRenderTarget;
 class MetalSamplerGroup;
 class MetalSwapChain;
@@ -141,6 +142,7 @@ struct MetalContext {
    utils::FixedCircularBuffer<Handle<HwTexture>> texturesToDestroy;

    MetalBufferPool* bufferPool;
+    MetalBumpAllocator* bumpAllocator;

    MetalSwapChain* currentDrawSwapChain = nil;
    MetalSwapChain* currentReadSwapChain = nil;
@@ -171,6 +171,8 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
    mContext->samplerStateCache.setDevice(mContext->device);
    mContext->argumentEncoderCache.setDevice(mContext->device);
    mContext->bufferPool = new MetalBufferPool(*mContext);
+    mContext->bumpAllocator =
+            new MetalBumpAllocator(mContext->device, driverConfig.metalUploadBufferSizeBytes);
    mContext->blitter = new MetalBlitter(*mContext);

    if (@available(iOS 12, *)) {
@@ -209,6 +211,7 @@ MetalDriver::~MetalDriver() noexcept {
    mContext->emptyTexture = nil;
    CFRelease(mContext->textureCache);
    delete mContext->bufferPool;
+    delete mContext->bumpAllocator;
    delete mContext->blitter;
    delete mContext->timerQueryImpl;
    delete mContext->shaderCompiler;
@@ -109,7 +109,7 @@ private:
    NSUInteger headlessWidth = 0;
    NSUInteger headlessHeight = 0;
    CAMetalLayer* layer = nullptr;
-    std::mutex layerDrawableMutex;
+    std::shared_ptr<std::mutex> layerDrawableMutex;
    MetalExternalImage externalImage;
    SwapChainType type;

@@ -73,6 +73,7 @@ MetalSwapChain::MetalSwapChain(MetalContext& context, CAMetalLayer* nativeWindow
    : context(context),
      depthStencilFormat(decideDepthStencilFormat(flags)),
      layer(nativeWindow),
+      layerDrawableMutex(std::make_shared<std::mutex>()),
      externalImage(context),
      type(SwapChainType::CAMETALLAYER) {

@@ -179,7 +180,7 @@ id<MTLTexture> MetalSwapChain::acquireDrawable() {
    // calling -nextDrawable, or when releasing the last known reference
    // to any CAMetalDrawable returned from a previous -nextDrawable.
    {
-        std::lock_guard<std::mutex> lock(layerDrawableMutex);
+        std::lock_guard<std::mutex> lock(*layerDrawableMutex);
        drawable = [layer nextDrawable];
    }

@@ -188,8 +189,10 @@ id<MTLTexture> MetalSwapChain::acquireDrawable() {
 }

 void MetalSwapChain::releaseDrawable() {
-    std::lock_guard<std::mutex> lock(layerDrawableMutex);
-    drawable = nil;
+    if (drawable) {
+        std::lock_guard<std::mutex> lock(*layerDrawableMutex);
+        drawable = nil;
+    }
 }

 id<MTLTexture> MetalSwapChain::acquireDepthTexture() {
@@ -265,7 +268,7 @@ public:
    PresentDrawableData& operator=(const PresentDrawableData&) = delete;

    static PresentDrawableData* create(id<CAMetalDrawable> drawable,
-            std::mutex* drawableMutex, MetalDriver* driver) {
+            std::shared_ptr<std::mutex> drawableMutex, MetalDriver* driver) {
        assert_invariant(drawableMutex);
        assert_invariant(driver);
        return new PresentDrawableData(drawable, drawableMutex, driver);
@@ -287,22 +290,22 @@ public:
    }

 private:
-    PresentDrawableData(id<CAMetalDrawable> drawable, std::mutex* drawableMutex,
+    PresentDrawableData(id<CAMetalDrawable> drawable, std::shared_ptr<std::mutex> drawableMutex,
            MetalDriver* driver)
        : mDrawable(drawable), mDrawableMutex(drawableMutex), mDriver(driver) {}

    static void cleanupAndDestroy(PresentDrawableData *that) {
-        {
+        if (that->mDrawable) {
            std::lock_guard<std::mutex> lock(*(that->mDrawableMutex));
            that->mDrawable = nil;
        }
-        that->mDrawableMutex = nullptr;
+        that->mDrawableMutex.reset();
        that->mDriver = nullptr;
        delete that;
    }

    id<CAMetalDrawable> mDrawable;
-    std::mutex* mDrawableMutex = nullptr;
+    std::shared_ptr<std::mutex> mDrawableMutex;
    MetalDriver* mDriver = nullptr;
 };

@@ -320,7 +323,7 @@ void MetalSwapChain::scheduleFrameScheduledCallback() {

    struct Callback {
        Callback(std::shared_ptr<FrameScheduledCallback> callback, id<CAMetalDrawable> drawable,
-                std::mutex* drawableMutex, MetalDriver* driver)
+                 std::shared_ptr<std::mutex> drawableMutex, MetalDriver* driver)
            : f(callback), data(PresentDrawableData::create(drawable, drawableMutex, driver)) {}
        std::shared_ptr<FrameScheduledCallback> f;
        // PresentDrawableData* is destroyed by maybePresentAndDestroyAsync() later.
@@ -337,7 +340,7 @@ void MetalSwapChain::scheduleFrameScheduledCallback() {
    // This callback pointer will be captured by the block. Even if the scheduled handler is never
    // called, the unique_ptr will still ensure we don't leak memory.
    __block auto callback = std::make_unique<Callback>(
-        frameScheduled.callback, drawable, &layerDrawableMutex, context.driver);
+        frameScheduled.callback, drawable, layerDrawableMutex, context.driver);

    backend::CallbackHandler* handler = frameScheduled.handler;
    MetalDriver* driver = context.driver;
@@ -304,6 +304,13 @@ void OpenGLDriver::bindSampler(GLuint unit, GLuint sampler) noexcept {
 void OpenGLDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
        backend::PushConstantVariant value) {
    assert_invariant(stage == ShaderStage::VERTEX || stage == ShaderStage::FRAGMENT);
+
+#if FILAMENT_ENABLE_MATDBG
+    if (UTILS_UNLIKELY(!mValidProgram)) {
+        return;
+    }
+#endif
+
    utils::Slice<std::pair<GLint, ConstantType>> constants;
    if (stage == ShaderStage::VERTEX) {
        constants = mCurrentPushConstants->vertexConstants;
@@ -340,15 +347,11 @@ void OpenGLDriver::bindTexture(GLuint unit, GLTexture const* t) noexcept {
 }

 bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
-    if (UTILS_UNLIKELY(!p->isValid())) {
-        // If the program is not valid, we can't call use().
-        return false;
-    }
-
    // set-up textures and samplers in the proper TMUs (as specified in setSamplers)
-    p->use(this, mContext);
+    bool const success = p->use(this, mContext);
+    assert_invariant(success == p->isValid());

-    if (UTILS_UNLIKELY(mContext.isES2())) {
+    if (UTILS_UNLIKELY(mContext.isES2() && success)) {
        for (uint32_t i = 0; i < Program::UNIFORM_BINDING_COUNT; i++) {
            auto [id, buffer, age] = mContext.getEs2UniformBinding(i);
            if (buffer) {
@@ -359,7 +362,8 @@ bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
        // when mPlatform.isSRGBSwapChainSupported() is false (no need to check though).
        p->setRec709ColorSpace(mRec709OutputColorspace);
    }
-    return true;
+
+    return success;
 }


@@ -2332,9 +2336,9 @@ void OpenGLDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh,
    auto const* const pSamplers = (SamplerDescriptor const*)data.buffer;
    for (size_t i = 0, c = sb->textureUnitEntries.size(); i < c; i++) {
        GLuint samplerId = 0u;
-        const GLTexture* t = nullptr;
-        if (UTILS_LIKELY(pSamplers[i].t)) {
-            t = handle_cast<const GLTexture*>(pSamplers[i].t);
+        Handle<HwTexture> th = pSamplers[i].t;
+        if (UTILS_LIKELY(th)) {
+            GLTexture const* const t = handle_cast<const GLTexture*>(th);
            assert_invariant(t);

            SamplerParams params = pSamplers[i].s;
@@ -2390,7 +2394,7 @@ void OpenGLDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh,
            // which is not an error.
        }

-        sb->textureUnitEntries[i] = { t, samplerId };
+        sb->textureUnitEntries[i] = { th, samplerId };
    }
    scheduleDestroy(std::move(data));
 }
@@ -126,7 +126,7 @@ public:
    struct GLSamplerGroup : public HwSamplerGroup {
        using HwSamplerGroup::HwSamplerGroup;
        struct Entry {
-            GLTexture const* texture = nullptr;
+            Handle<HwTexture> th;
            GLuint sampler = 0u;
        };
        utils::FixedCapacityVector<Entry> textureUnitEntries;
@@ -256,6 +256,11 @@ private:
        return mHandleAllocator.handle_cast<Dp, B>(handle);
    }

+    template<typename B>
+    bool is_valid(Handle<B>& handle) {
+        return mHandleAllocator.is_valid(handle);
+    }
+
    template<typename Dp, typename B>
    inline typename std::enable_if_t<
            std::is_pointer_v<Dp> &&
@@ -20,21 +20,24 @@
 #include "OpenGLDriver.h"
 #include "ShaderCompilerService.h"

+#include <backend/DriverEnums.h>
 #include <backend/Program.h>
+#include <backend/Handle.h>

-#include <private/backend/BackendUtils.h>
-
-#include <utils/debug.h>
 #include <utils/compiler.h>
+#include <utils/debug.h>
+#include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
 #include <utils/Systrace.h>

+#include <algorithm>
 #include <array>
 #include <string_view>
 #include <utility>
 #include <new>

 #include <stddef.h>
+#include <stdint.h>

 namespace filament::backend {

@@ -241,8 +244,9 @@ void OpenGLProgram::updateSamplers(OpenGLDriver* const gld) const noexcept {
        assert_invariant(sb);
        if (!sb) continue; // should never happen, this would be a user error.
        for (uint8_t j = 0, m = sb->textureUnitEntries.size(); j < m; ++j, ++tmu) { // "<=" on purpose here
-            const GLTexture* const t = sb->textureUnitEntries[j].texture;
-            if (t) { // program may not use all samplers of sampler group
+            Handle<HwTexture> th = sb->textureUnitEntries[j].th;
+            if (th) { // program may not use all samplers of sampler group
+                GLTexture const* const t = gld->handle_cast<GLTexture const*>(th);
                gld->bindTexture(tmu, t);
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
                if (UTILS_LIKELY(!es2)) {
@@ -53,11 +53,21 @@ public:

    bool isValid() const noexcept { return mToken || gl.program != 0; }

-    void use(OpenGLDriver* const gld, OpenGLContext& context) noexcept {
-        if (UTILS_UNLIKELY(!gl.program)) {
+    bool use(OpenGLDriver* const gld, OpenGLContext& context) noexcept {
+        // both non-null is impossible by construction
+        assert_invariant(!mToken || !gl.program);
+
+        if (UTILS_UNLIKELY(mToken && !gl.program)) {
+            // first time a program is used
            initialize(*gld);
        }

+        if (UTILS_UNLIKELY(!gl.program)) {
+            // compilation failed (token should be null)
+            assert_invariant(!mToken);
+            return false;
+        }
+
        context.useProgram(gl.program);
        if (UTILS_UNLIKELY(mUsedBindingsCount)) {
            // We rely on GL state tracking to avoid unnecessary glBindTexture / glBindSampler
@@ -74,6 +84,7 @@ public:

            updateSamplers(gld);
        }
+        return true;
    }

    // For ES2 only
@@ -359,7 +359,7 @@ ShaderCompilerService::program_token_t ShaderCompilerService::createProgram(
 GLuint ShaderCompilerService::getProgram(ShaderCompilerService::program_token_t& token) {
    GLuint const program = initialize(token);
    assert_invariant(token == nullptr);
-#ifndef FILAMENT_ENABLE_MATDBG
+#if !FILAMENT_ENABLE_MATDBG
    assert_invariant(program);
 #endif
    return program;
@@ -572,16 +572,23 @@ void ShaderCompilerService::compileShaders(OpenGLContext& context,

            // split shader source, so we can insert the specialization constants and the packing
            // functions
-            auto const [prolog, body] = splitShaderSource({ shader_src, shader_len });
+            auto [version, prolog, body] = splitShaderSource({ shader_src, shader_len });

-            const std::array<const char*, 4> sources = {
+            // enable ESSL 3.10 if available
+            if (context.isAtLeastGLES<3, 1>()) {
+                version = "#version 310 es\n";
+            }
+
+            const std::array<const char*, 5> sources = {
+                    version.data(),
                    prolog.data(),
                    specializationConstantString.c_str(),
                    packingFunctions.data(),
                    body.data()
            };

-            const std::array<GLint, 4> lengths = {
+            const std::array<GLint, 5> lengths = {
+                    (GLint)version.length(),
                    (GLint)prolog.length(),
                    (GLint)specializationConstantString.length(),
                    (GLint)packingFunctions.length(),
@@ -661,6 +668,7 @@ void ShaderCompilerService::process_OVR_multiview2(OpenGLContext& context,

 // Tragically, OpenGL 4.1 doesn't support unpackHalf2x16 (appeared in 4.2) and
 // macOS doesn't support GL_ARB_shading_language_packing
+// Also GLES3.0 didn't have the full set of packing/unpacking functions
 std::string_view ShaderCompilerService::process_ARB_shading_language_packing(OpenGLContext& context) noexcept {
    using namespace std::literals;
 #ifdef BACKEND_OPENGL_VERSION_GL
@@ -700,31 +708,102 @@ highp uint packHalf2x16(vec2 v) {
    highp uint y = fp32tou16(v.y);
    return (y << 16u) | x;
 }
+highp uint packUnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, 0.0, 1.0) * 255.0);
+    highp uint a = uint(v.x);
+    highp uint b = uint(v.y) <<  8;
+    highp uint c = uint(v.z) << 16;
+    highp uint d = uint(v.w) << 24;
+    return (a|b|c|d);
+}
+highp uint packSnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, -1.0, 1.0) * 127.0);
+    highp uint a = uint((int(v.x) & 0xff));
+    highp uint b = uint((int(v.y) & 0xff)) <<  8;
+    highp uint c = uint((int(v.z) & 0xff)) << 16;
+    highp uint d = uint((int(v.w) & 0xff)) << 24;
+    return (a|b|c|d);
+}
+mediump vec4 unpackUnorm4x8(highp uint v) {
+    return vec4(float((v & 0x000000ffu)      ),
+                float((v & 0x0000ff00u) >>  8),
+                float((v & 0x00ff0000u) >> 16),
+                float((v & 0xff000000u) >> 24)) / 255.0;
+}
+mediump vec4 unpackSnorm4x8(highp uint v) {
+    int a = int(((v       ) & 0xffu) << 24u) >> 24 ;
+    int b = int(((v >>  8u) & 0xffu) << 24u) >> 24 ;
+    int c = int(((v >> 16u) & 0xffu) << 24u) >> 24 ;
+    int d = int(((v >> 24u) & 0xffu) << 24u) >> 24 ;
+    return clamp(vec4(float(a), float(b), float(c), float(d)) / 127.0, -1.0, 1.0);
+}
 )"sv;
    }
 #endif // BACKEND_OPENGL_VERSION_GL
+
+#ifdef BACKEND_OPENGL_VERSION_GLES
+    if (!context.isES2() && !context.isAtLeastGLES<3, 1>()) {
+        return R"(
+
+highp uint packUnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, 0.0, 1.0) * 255.0);
+    highp uint a = uint(v.x);
+    highp uint b = uint(v.y) <<  8;
+    highp uint c = uint(v.z) << 16;
+    highp uint d = uint(v.w) << 24;
+    return (a|b|c|d);
+}
+highp uint packSnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, -1.0, 1.0) * 127.0);
+    highp uint a = uint((int(v.x) & 0xff));
+    highp uint b = uint((int(v.y) & 0xff)) <<  8;
+    highp uint c = uint((int(v.z) & 0xff)) << 16;
+    highp uint d = uint((int(v.w) & 0xff)) << 24;
+    return (a|b|c|d);
+}
+mediump vec4 unpackUnorm4x8(highp uint v) {
+    return vec4(float((v & 0x000000ffu)      ),
+                float((v & 0x0000ff00u) >>  8),
+                float((v & 0x00ff0000u) >> 16),
+                float((v & 0xff000000u) >> 24)) / 255.0;
+}
+mediump vec4 unpackSnorm4x8(highp uint v) {
+    int a = int(((v       ) & 0xffu) << 24u) >> 24 ;
+    int b = int(((v >>  8u) & 0xffu) << 24u) >> 24 ;
+    int c = int(((v >> 16u) & 0xffu) << 24u) >> 24 ;
+    int d = int(((v >> 24u) & 0xffu) << 24u) >> 24 ;
+    return clamp(vec4(float(a), float(b), float(c), float(d)) / 127.0, -1.0, 1.0);
+}
+)"sv;
+    }
+#endif // BACKEND_OPENGL_VERSION_GLES
    return ""sv;
 }

-// split shader source code in two, the first section goes from the start to the line after the
-// last #extension, and the 2nd part goes from there to the end.
-std::array<std::string_view, 2> ShaderCompilerService::splitShaderSource(std::string_view source) noexcept {
-    auto start = source.find("#version");
-    assert_invariant(start != std::string_view::npos);
+// split shader source code in three:
+// - the version line
+// - extensions
+// - everything else
+std::array<std::string_view, 3> ShaderCompilerService::splitShaderSource(std::string_view source) noexcept {
+    auto version_start = source.find("#version");
+    assert_invariant(version_start != std::string_view::npos);

-    auto pos = source.rfind("\n#extension");
-    if (pos == std::string_view::npos) {
-        pos = start;
+    auto version_eol = source.find('\n', version_start) + 1;
+    assert_invariant(version_eol != std::string_view::npos);
+
+    auto prolog_start = version_eol;
+    auto prolog_eol = source.rfind("\n#extension"); // last #extension line
+    if (prolog_eol == std::string_view::npos) {
+        prolog_eol = prolog_start;
    } else {
-        ++pos;
+        prolog_eol = source.find('\n', prolog_eol + 1) + 1;
    }
+    auto body_start = prolog_eol;

-    auto eol = source.find('\n', pos) + 1;
-    assert_invariant(eol != std::string_view::npos);
-
-    std::string_view const version = source.substr(start, eol - start);
-    std::string_view const body = source.substr(version.length(), source.length() - version.length());
-    return { version, body };
+    std::string_view const version = source.substr(version_start, version_eol - version_start);
+    std::string_view const prolog = source.substr(prolog_start, prolog_eol - prolog_start);
+    std::string_view const body = source.substr(body_start, source.length() - body_start);
+    return { version, prolog, body };
 }

 /*
@@ -146,7 +146,7 @@ private:

    static std::string_view process_ARB_shading_language_packing(OpenGLContext& context) noexcept;

-    static std::array<std::string_view, 2> splitShaderSource(std::string_view source) noexcept;
+    static std::array<std::string_view, 3> splitShaderSource(std::string_view source) noexcept;

    static GLuint linkProgram(OpenGLContext& context,
            std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders,
@@ -19,6 +19,8 @@
 #include <backend/platforms/PlatformEGL.h>
 #include <backend/platforms/PlatformEGLAndroid.h>

+#include <private/backend/VirtualMachineEnv.h>
+
 #include "opengl/GLUtils.h"
 #include "ExternalStreamManagerAndroid.h"

@@ -82,9 +84,23 @@ using EGLStream = Platform::Stream;

 // ---------------------------------------------------------------------------------------------

+PlatformEGLAndroid::InitializeJvmForPerformanceManagerIfNeeded::InitializeJvmForPerformanceManagerIfNeeded() {
+    // PerformanceHintManager() needs the calling thread to be a Java thread; so we need
+    // to attach this thread to the JVM before we initialize PerformanceHintManager.
+    // This should be done in PerformanceHintManager(), but libutils doesn't have access to
+    // VirtualMachineEnv.
+    if (PerformanceHintManager::isSupported()) {
+        (void)VirtualMachineEnv::get().getEnvironment();
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+
 PlatformEGLAndroid::PlatformEGLAndroid() noexcept
        : PlatformEGL(),
-          mExternalStreamManager(ExternalStreamManagerAndroid::create()) {
+          mExternalStreamManager(ExternalStreamManagerAndroid::create()),
+          mInitializeJvmForPerformanceManagerIfNeeded(),
+          mPerformanceHintManager() {

    char scratch[PROP_VALUE_MAX + 1];
    int length = __system_property_get("ro.build.version.release", scratch);
@@ -37,7 +37,7 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
        VulkanAttachment src, VulkanAttachment dst,
        const VkOffset3D srcRect[2], const VkOffset3D dstRect[2]) {
    if constexpr (FVK_ENABLED(FVK_DEBUG_BLITTER)) {
-        utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
+        FVK_LOGD << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                      << " layout=" << src.getLayout()
                      << " to=" << dst.texture->getVkImage() << ",level=" << (int) dst.level
                      << " layout=" << dst.getLayout() << utils::io::endl;
@@ -76,7 +76,7 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
 inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
        VulkanAttachment src, VulkanAttachment dst) {
    if constexpr (FVK_ENABLED(FVK_DEBUG_BLITTER)) {
-        utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
+        FVK_LOGD << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                      << " layout=" << src.getLayout()
                      << " to=" << dst.texture->getVkImage() << ",level=" << (int) dst.level
                      << " layout=" << dst.getLayout() << utils::io::endl;
@@ -178,7 +178,7 @@ VulkanCommandBuffer& VulkanCommands::get() {
    // presenting the swap chain or waiting on a fence.
    while (mAvailableBufferCount == 0) {
 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
-        slog.i << "VulkanCommands has stalled. "
+        FVK_LOGI << "VulkanCommands has stalled. "
               << "If this occurs frequently, consider increasing VK_MAX_COMMAND_BUFFERS."
               << io::endl;
 #endif
@@ -289,7 +289,7 @@ bool VulkanCommands::flush() {
    };

 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
-    slog.i << "Submitting cmdbuffer=" << cmdbuffer
+    FVK_LOGI << "Submitting cmdbuffer=" << cmdbuffer
           << " wait=(" << signals[0] << ", " << signals[1] << ") "
           << " signal=" << renderingFinished
           << " fence=" << currentbuf->fence->fence
@@ -305,7 +305,7 @@ bool VulkanCommands::flush() {

 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
    if (result != VK_SUCCESS) {
-        utils::slog.d << "Failed command buffer submission result: " << result << utils::io::endl;
+        FVK_LOGD << "Failed command buffer submission result: " << result << utils::io::endl;
    }
 #endif
    assert_invariant(result == VK_SUCCESS);
@@ -320,7 +320,7 @@ VkSemaphore VulkanCommands::acquireFinishedSignal() {
    VkSemaphore semaphore = mSubmissionSignal;
    mSubmissionSignal = VK_NULL_HANDLE;
 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
-    slog.i << "Acquiring " << semaphore << " (e.g. for vkQueuePresentKHR)" << io::endl;
+    FVK_LOGI << "Acquiring " << semaphore << " (e.g. for vkQueuePresentKHR)" << io::endl;
 #endif
    return semaphore;
 }
@@ -329,7 +329,7 @@ void VulkanCommands::injectDependency(VkSemaphore next) {
    assert_invariant(mInjectedSignal == VK_NULL_HANDLE);
    mInjectedSignal = next;
 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
-    slog.i << "Injecting " << next << " (e.g. due to vkAcquireNextImageKHR)" << io::endl;
+    FVK_LOGI << "Injecting " << next << " (e.g. due to vkAcquireNextImageKHR)" << io::endl;
 #endif
 }

@@ -398,7 +398,7 @@ void VulkanCommands::pushGroupMarker(char const* str, VulkanGroupMarkers::Timest
    // If the timestamp is not 0, then we are carrying over a marker across buffer submits.
    // If it is 0, then this is a normal marker push and we should just print debug line as usual.
    if (timestamp.time_since_epoch().count() == 0.0) {
-        utils::slog.d << "----> " << str << utils::io::endl;
+        FVK_LOGD << "----> " << str << utils::io::endl;
    }
 #endif

@@ -436,7 +436,7 @@ void VulkanCommands::popGroupMarker() {
        auto const [marker, startTime] = mGroupMarkers->pop();
        auto const endTime = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> diff = endTime - startTime;
-        utils::slog.d << "<---- " << marker << " elapsed: " << (diff.count() * 1000) << " ms"
+        FVK_LOGD << "<---- " << marker << " elapsed: " << (diff.count() * 1000) << " ms"
                      << utils::io::endl;
 #else
        mGroupMarkers->pop();
@@ -17,6 +17,8 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANCONSTANTS_H
 #define TNT_FILAMENT_BACKEND_VULKANCONSTANTS_H

+#include <utils/Log.h>
+
 #include <stdint.h>

 // In debug builds, we enable validation layers and set up a debug callback.
@@ -70,6 +72,11 @@
 // the currently active resources.
 #define FVK_DEBUG_RESOURCE_LEAK           0x00010000

+// Set this to enable logging "only" to one output stream. This is useful in the case where we want
+// to debug with print statements and want ordered logging (e.g slog.i and slog.e will not appear in
+// order of calls).
+#define FVK_DEBUG_FORCE_LOG_TO_I          0x00020000
+
 // Useful default combinations
 #define FVK_DEBUG_EVERYTHING              0xFFFFFFFF
 #define FVK_DEBUG_PERFORMANCE     \
@@ -133,6 +140,18 @@ static_assert(FVK_ENABLED(FVK_DEBUG_VALIDATION));
 #define FVK_HANDLE_ARENA_SIZE_IN_MB 8
 #endif

+#if FVK_ENABLED(FVK_DEBUG_FORCE_LOG_TO_I)
+    #define FVK_LOGI (utils::slog.i)
+    #define FVK_LOGD FVK_LOGI
+    #define FVK_LOGE FVK_LOGI
+    #define FVK_LOGW FVK_LOGI
+#else
+    #define FVK_LOGE (utils::slog.e)
+    #define FVK_LOGW (utils::slog.w)
+    #define FVK_LOGD (utils::slog.d)
+    #define FVK_LOGI (utils::slog.i)
+#endif
+
 // All vkCreate* functions take an optional allocator. For now we select the default allocator by
 // passing in a null pointer, and we highlight the argument by using the VKALLOC constant.
 constexpr struct VkAllocationCallbacks* VKALLOC = nullptr;
@@ -100,7 +100,7 @@ std::tuple<uint32_t, uint32_t> VulkanTimestamps::getNextQuery() {
 	    return std::make_tuple(timerIndex * 2, timerIndex * 2 + 1);
        }
    }
-    utils::slog.e << "More than " << maxTimers << " timers are not supported." << utils::io::endl;
+    FVK_LOGE << "More than " << maxTimers << " timers are not supported." << utils::io::endl;
    return std::make_tuple(0, 1);
 }

@@ -131,6 +131,10 @@ public:
        return mDebugUtilsSupported;
    }

+    inline bool isMultiviewEnabled() const noexcept {
+        return mMultiviewEnabled;
+    }
+
    inline bool isClipDistanceSupported() const noexcept {
        return mPhysicalDeviceFeatures.shaderClipDistance == VK_TRUE;
    }
@@ -141,6 +145,7 @@ private:
    VkPhysicalDeviceFeatures mPhysicalDeviceFeatures = {};
    bool mDebugMarkersSupported = false;
    bool mDebugUtilsSupported = false;
+    bool mMultiviewEnabled = false;

    VkFormatList mDepthStencilFormats;
    VkFormatList mBlittableDepthStencilFormats;
@@ -115,15 +115,15 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags,
        VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location,
        int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData) {
    if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
-        utils::slog.e << "VULKAN ERROR: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
+        FVK_LOGE << "VULKAN ERROR: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
    } else {
        // TODO: emit best practices warnings about aggressive pipeline barriers.
        if (strstr(pMessage, "ALL_GRAPHICS_BIT") || strstr(pMessage, "ALL_COMMANDS_BIT")) {
            return VK_FALSE;
        }
-        utils::slog.w << "VULKAN WARNING: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
+        FVK_LOGW << "VULKAN WARNING: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
    }
-    utils::slog.e << utils::io::endl;
+    FVK_LOGE << utils::io::endl;
    return VK_FALSE;
 }
 #endif // FVK_EANBLED(FVK_DEBUG_VALIDATION)
@@ -133,18 +133,18 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsCallback(VkDebugUtilsMessageSeverityFla
        VkDebugUtilsMessageTypeFlagsEXT types, const VkDebugUtilsMessengerCallbackDataEXT* cbdata,
        void* pUserData) {
    if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
-        utils::slog.e << "VULKAN ERROR: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
-                      << utils::io::endl;
+        FVK_LOGE << "VULKAN ERROR: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
+                 << utils::io::endl;
    } else {
        // TODO: emit best practices warnings about aggressive pipeline barriers.
        if (strstr(cbdata->pMessage, "ALL_GRAPHICS_BIT")
                || strstr(cbdata->pMessage, "ALL_COMMANDS_BIT")) {
            return VK_FALSE;
        }
-        utils::slog.w << "VULKAN WARNING: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
-                      << utils::io::endl;
+        FVK_LOGW << "VULKAN WARNING: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
+                 << utils::io::endl;
    }
-    utils::slog.e << utils::io::endl;
+    FVK_LOGE << utils::io::endl;
    return VK_FALSE;
 }
 #endif // FVK_EANBLED(FVK_DEBUG_DEBUG_UTILS)
@@ -292,7 +292,7 @@ Driver* VulkanDriver::create(VulkanPlatform* platform, VulkanContext const& cont
    //    VulkanRenderTarget            : 312       few
    // -- less than or equal to 312 bytes

-    utils::slog.d
+    FVK_LOGD
           << "\nVulkanSwapChain: " << sizeof(VulkanSwapChain)
           << "\nVulkanBufferObject: " << sizeof(VulkanBufferObject)
           << "\nVulkanVertexBuffer: " << sizeof(VulkanVertexBuffer)
@@ -397,7 +397,10 @@ void VulkanDriver::collectGarbage() {
 }
 void VulkanDriver::beginFrame(int64_t monotonic_clock_ns,
        int64_t refreshIntervalNs, uint32_t frameId) {
+    FVK_SYSTRACE_CONTEXT();
+    FVK_SYSTRACE_START("beginFrame");
    // Do nothing.
+    FVK_SYSTRACE_END();
 }

 void VulkanDriver::setFrameScheduledCallback(Handle<HwSwapChain> sch,
@@ -657,8 +660,8 @@ void VulkanDriver::createFenceR(Handle<HwFence> fh, int) {

 void VulkanDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
    if ((flags & backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0 && !isSRGBSwapChainSupported()) {
-        utils::slog.w << "sRGB swapchain requested, but Platform does not support it"
-                      << utils::io::endl;
+        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
+                 << utils::io::endl;
        flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
    }
    auto swapChain = mResourceAllocator.construct<VulkanSwapChain>(sch, mPlatform, mContext,
@@ -669,7 +672,7 @@ void VulkanDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
 void VulkanDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch, uint32_t width,
        uint32_t height, uint64_t flags) {
    if ((flags & backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0 && !isSRGBSwapChainSupported()) {
-        utils::slog.w << "sRGB swapchain requested, but Platform does not support it"
+        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
                      << utils::io::endl;
        flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
    }
@@ -911,7 +914,7 @@ bool VulkanDriver::isStereoSupported() {
        case backend::StereoscopicType::INSTANCED:
            return mContext.isClipDistanceSupported();
        case backend::StereoscopicType::MULTIVIEW:
-            // TODO: implement multiview feature in Vulkan.
+            return mContext.isMultiviewEnabled();
        case backend::StereoscopicType::NONE:
            return false;
    }
@@ -1859,9 +1862,9 @@ void VulkanDriver::bindPipeline(PipelineState const& pipelineState) {
        // matching characteristics. (e.g. if the missing texture is a 3D texture)
        if (UTILS_UNLIKELY(texture->getPrimaryImageLayout() == VulkanLayout::UNDEFINED)) {
 #if FVK_ENABLED(FVK_DEBUG_TEXTURE) && FVK_ENABLED_DEBUG_SAMPLER_NAME
-            utils::slog.w << "Uninitialized texture bound to '" << bindingToName[binding] << "'";
-            utils::slog.w << " in material '" << program->name.c_str() << "'";
-            utils::slog.w << " at binding point " << +binding << utils::io::endl;
+            FVK_LOGW << "Uninitialized texture bound to '" << bindingToName[binding] << "'";
+            FVK_LOGW << " in material '" << program->name.c_str() << "'";
+            FVK_LOGW << " at binding point " << +binding << utils::io::endl;
 #endif
            texture = mEmptyTexture;
        }
@@ -2011,7 +2014,7 @@ void VulkanDriver::debugCommandBegin(CommandStream* cmds, bool synchronous, cons
        assert_invariant(inRenderPass);
        inRenderPass = false;
    } else if (inRenderPass && OUTSIDE_COMMANDS.find(command) != OUTSIDE_COMMANDS.end()) {
-        utils::slog.e << command.data() << " issued inside a render pass." << utils::io::endl;
+        FVK_LOGE << command.data() << " issued inside a render pass." << utils::io::endl;
    }
 #endif
 }
@@ -95,7 +95,7 @@ VkFramebuffer VulkanFboCache::getFramebuffer(FboKey config) noexcept {
    }

    #if FVK_ENABLED(FVK_DEBUG_FBO_CACHE)
-    utils::slog.d << "Creating framebuffer " << config.width << "x" << config.height << " "
+    FVK_LOGD << "Creating framebuffer " << config.width << "x" << config.height << " "
        << "for render pass " << config.renderPass << ", "
        << "samples = " << int(config.samples) << ", "
        << "depth = " << (config.depth ? 1 : 0) << ", "
@@ -310,7 +310,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
    mRenderPassCache[config] = {renderPass, mCurrentTime};

    #if FVK_ENABLED(FVK_DEBUG_FBO_CACHE)
-    utils::slog.d << "Created render pass " << renderPass << " with "
+    FVK_LOGD << "Created render pass " << renderPass << " with "
        << "samples = " << int(config.samples) << ", "
        << "depth = " << (hasDepth ? 1 : 0) << ", "
        << "colorAttachmentCount[0] = " << subpasses[0].colorAttachmentCount
@@ -292,8 +292,8 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
    }

 #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-    utils::slog.d << "Created VulkanProgram " << builder << ", shaders = (" << modules[0]
-                  << ", " << modules[1] << ")" << utils::io::endl;
+    FVK_LOGD << "Created VulkanProgram " << builder << ", shaders = (" << modules[0]
+             << ", " << modules[1] << ")" << utils::io::endl;
 #endif
 }

@@ -230,14 +230,15 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
    PipelineCacheEntry cacheEntry = {};

    #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-        utils::slog.d << "vkCreateGraphicsPipelines with shaders = ("
-                << shaderStages[0].module << ", " << shaderStages[1].module << ")" << utils::io::endl;
+        FVK_LOGD << "vkCreateGraphicsPipelines with shaders = ("
+                 << shaderStages[0].module << ", " << shaderStages[1].module << ")"
+                 << utils::io::endl;
    #endif
    VkResult error = vkCreateGraphicsPipelines(mDevice, VK_NULL_HANDLE, 1, &pipelineCreateInfo,
            VKALLOC, &cacheEntry.handle);
    assert_invariant(error == VK_SUCCESS);
    if (error != VK_SUCCESS) {
-        utils::slog.e << "vkCreateGraphicsPipelines error " << error << utils::io::endl;
+        FVK_LOGE << "vkCreateGraphicsPipelines error " << error << utils::io::endl;
        return nullptr;
    }

@@ -252,7 +253,7 @@ void VulkanPipelineCache::bindProgram(VulkanProgram* program) noexcept {
 #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
    if (mPipelineRequirements.shaders[0] == VK_NULL_HANDLE ||
            mPipelineRequirements.shaders[1] == VK_NULL_HANDLE) {
-        utils::slog.e << "Binding missing shader: " << program->name.c_str() << utils::io::endl;
+        FVK_LOGE << "Binding missing shader: " << program->name.c_str() << utils::io::endl;
    }
 #endif
 }
@@ -167,9 +167,9 @@ void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint
    vkCreateImage(device, &imageInfo, VKALLOC, &stagingImage);

 #if FVK_ENABLED(FVK_DEBUG_READ_PIXELS)
-    utils::slog.d << "readPixels created image=" << stagingImage
-                  << " to copy from image=" << srcTexture->getVkImage()
-                  << " src-layout=" << srcTexture->getLayout(0, 0) << utils::io::endl;
+    FVK_LOGD << "readPixels created image=" << stagingImage
+             << " to copy from image=" << srcTexture->getVkImage()
+             << " src-layout=" << srcTexture->getLayout(0, 0) << utils::io::endl;
 #endif

    VkMemoryRequirements memReqs;
@@ -185,7 +185,7 @@ void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint
    if (memoryTypeIndex >= VK_MAX_MEMORY_TYPES) {
        memoryTypeIndex = selectMemoryFunc(memReqs.memoryTypeBits,
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
-        utils::slog.w
+        FVK_LOGW
                << "readPixels is slow because VK_MEMORY_PROPERTY_HOST_CACHED_BIT is not available"
                << utils::io::endl;
    }
@@ -303,7 +303,7 @@ void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint
        VkResult status = vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX);
        // Fence hasn't been reached. Try waiting again.
        if (status != VK_SUCCESS) {
-            utils::slog.e << "Failed to wait for readPixels fence" << utils::io::endl;
+            FVK_LOGE << "Failed to wait for readPixels fence" << utils::io::endl;
            return;
        }

@@ -321,7 +321,7 @@ void VulkanReadPixels::run(VulkanRenderTarget* srcTarget, uint32_t const x, uint
                    getComponentCount(srcFormat), srcPixels,
                    static_cast<int>(subResourceLayout.rowPitch), static_cast<int>(width),
                    static_cast<int>(height), swizzle)) {
-            utils::slog.e << "Unsupported PixelDataFormat or PixelDataType" << utils::io::endl;
+            FVK_LOGE << "Unsupported PixelDataFormat or PixelDataType" << utils::io::endl;
        }

        vkUnmapMemory(device, stagingMemory);
@@ -111,11 +111,11 @@ private:
 #if DEBUG_RESOURCE_LEAKS
 public:
    void print() {
-        utils::slog.d << "Resource Allocator state (debug only)" << utils::io::endl;
+        FVK_LOGD << "Resource Allocator state (debug only)" << utils::io::endl;
        for (size_t i = 0; i < RESOURCE_TYPE_COUNT; i++) {
-            utils::slog.d << "[" << i << "]=" << mDebugOnlyResourceCount[i] << utils::io::endl;
+            FVK_LOGD << "[" << i << "]=" << mDebugOnlyResourceCount[i] << utils::io::endl;
        }
-        utils::slog.d << "+++++++++++++++++++++++++++++++++++++" << utils::io::endl;
+        FVK_LOGD << "+++++++++++++++++++++++++++++++++++++" << utils::io::endl;
    }
 private:
    utils::FixedCapacityVector<size_t> mDebugOnlyResourceCount;
@@ -61,7 +61,7 @@ VulkanStage const* VulkanStagePool::acquireStage(uint32_t numBytes) {

 #if FVK_ENABLED(FVK_DEBUG_ALLOCATION)
    if (result != VK_SUCCESS) {
-        utils::slog.e << "Allocation error: " << result << utils::io::endl;
+        FVK_LOGE << "Allocation error: " << result << utils::io::endl;
    }
 #endif

@@ -35,29 +35,13 @@ VulkanSwapChain::VulkanSwapChain(VulkanPlatform* platform, VulkanContext const&
      mStagePool(stagePool),
      mHeadless(extent.width != 0 && extent.height != 0 && !nativeWindow),
      mFlushAndWaitOnResize(platform->getCustomization().flushAndWaitOnWindowResize),
-      mCurrentImageReadyIndex(0),
+      mTransitionSwapChainImageLayoutForPresent(
+            platform->getCustomization().transitionSwapChainImageLayoutForPresent),
      mAcquired(false),
      mIsFirstRenderPass(true) {
    swapChain = mPlatform->createSwapChain(nativeWindow, flags, extent);
    FILAMENT_CHECK_POSTCONDITION(swapChain) << "Unable to create swapchain";

-    VkSemaphoreCreateInfo const createInfo = {
-            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
-    };
-
-    // No need to wait on this semaphore before drawing when in Headless mode.
-    if (mHeadless) {
-		// Set all sempahores to VK_NULL_HANDLE
-		memset(mImageReady, 0, sizeof(mImageReady[0]) * IMAGE_READY_SEMAPHORE_COUNT);
-	} else {
-		for (uint32_t i = 0; i < IMAGE_READY_SEMAPHORE_COUNT; ++i) {
-			VkResult result =
-					vkCreateSemaphore(mPlatform->getDevice(), &createInfo, nullptr, mImageReady + i);
-                        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
-                                << "Failed to create semaphore";
-                }
-    }
-
    update();
 }

@@ -68,11 +52,6 @@ VulkanSwapChain::~VulkanSwapChain() {
    mCommands->wait();

    mPlatform->destroy(swapChain);
-	for (uint32_t i = 0; i < IMAGE_READY_SEMAPHORE_COUNT; ++i) {
-		if (mImageReady[i] != VK_NULL_HANDLE) {
-			vkDestroySemaphore(mPlatform->getDevice(), mImageReady[i], VKALLOC);
-		}
-	}
 }

 void VulkanSwapChain::update() {
@@ -95,7 +74,7 @@ void VulkanSwapChain::update() {
 }

 void VulkanSwapChain::present() {
-    if (!mHeadless) {
+    if (!mHeadless && mTransitionSwapChainImageLayoutForPresent) {
        VkCommandBuffer const cmdbuf = mCommands->get().buffer();
        VkImageSubresourceRange const subresources{
                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
@@ -106,10 +85,15 @@ void VulkanSwapChain::present() {
        };
        mColors[mCurrentSwapIndex]->transitionLayout(cmdbuf, subresources, VulkanLayout::PRESENT);
    }
-    mCommands->flush();

-    // We only present if it is not headless.  No-op for headless (but note that we still need the
-    // flush() in the above line).
+    mCommands->flush();
+    
+    // call the image ready wait function
+    if (mExplicitImageReadyWait != nullptr) {
+        mExplicitImageReadyWait(swapChain);
+    }
+
+    // We only present if it is not headless. No-op for headless.
    if (!mHeadless) {
        VkSemaphore const finishedDrawing = mCommands->acquireFinishedSignal();
        VkResult const result = mPlatform->present(swapChain, mCurrentSwapIndex, finishedDrawing);
@@ -139,13 +123,14 @@ void VulkanSwapChain::acquire(bool& resized) {
        update();
    }

-	mCurrentImageReadyIndex = (mCurrentImageReadyIndex + 1) % IMAGE_READY_SEMAPHORE_COUNT;
-	const VkSemaphore imageReady = mImageReady[mCurrentImageReadyIndex];
-    VkResult const result = mPlatform->acquire(swapChain, imageReady, &mCurrentSwapIndex);
-    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR)
-            << "Cannot acquire in swapchain.";
-    if (imageReady != VK_NULL_HANDLE) {
-        mCommands->injectDependency(imageReady);
+    VulkanPlatform::ImageSyncData imageSyncData;
+    VkResult const result = mPlatform->acquire(swapChain, &imageSyncData);
+    mCurrentSwapIndex = imageSyncData.imageIndex;
+    mExplicitImageReadyWait = imageSyncData.explicitImageReadyWait;
+    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR) 
+        << "Cannot acquire in swapchain.";
+    if (imageSyncData.imageReadySemaphore != VK_NULL_HANDLE) {
+        mCommands->injectDependency(imageSyncData.imageReadySemaphore);
    }
    mAcquired = true;
 }
@@ -50,7 +50,10 @@ struct VulkanSwapChain : public HwSwapChain, VulkanResource {
    void acquire(bool& reized);

    inline VulkanTexture* getCurrentColor() const noexcept {
-        return mColors[mCurrentSwapIndex].get();
+        uint32_t const imageIndex = mCurrentSwapIndex;
+        FILAMENT_CHECK_PRECONDITION(
+            imageIndex != VulkanPlatform::ImageSyncData::INVALID_IMAGE_INDEX);
+        return mColors[imageIndex].get();
    }

    inline VulkanTexture* getDepth() const noexcept {
@@ -80,15 +83,15 @@ private:
    VulkanStagePool& mStagePool;
    bool const mHeadless;
    bool const mFlushAndWaitOnResize;
+    bool const mTransitionSwapChainImageLayoutForPresent;

    // We create VulkanTextures based on VkImages. VulkanTexture has facilities for doing layout
    // transitions, which are useful here.
    utils::FixedCapacityVector<std::unique_ptr<VulkanTexture>> mColors;
    std::unique_ptr<VulkanTexture> mDepth;
    VkExtent2D mExtent;
-    VkSemaphore mImageReady[IMAGE_READY_SEMAPHORE_COUNT];
-	uint32_t mCurrentImageReadyIndex;
    uint32_t mCurrentSwapIndex;
+    std::function<void(Platform::SwapChain* handle)> mExplicitImageReadyWait = nullptr;
    bool mAcquired;
    bool mIsFirstRenderPass;
 };
@@ -113,7 +113,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
        VkFormatProperties props;
        vkGetPhysicalDeviceFormatProperties(physicalDevice, mVkFormat, &props);
        if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
-            utils::slog.w << "Texture usage is SAMPLEABLE but format " << mVkFormat << " is not "
+            FVK_LOGW << "Texture usage is SAMPLEABLE but format " << mVkFormat << " is not "
                    "sampleable with optimal tiling." << utils::io::endl;
        }
 #endif
@@ -163,7 +163,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,

    VkResult error = vkCreateImage(mDevice, &imageInfo, VKALLOC, &mTextureImage);
    if (error || FVK_ENABLED(FVK_DEBUG_TEXTURE)) {
-        utils::slog.d << "vkCreateImage: "
+        FVK_LOGD << "vkCreateImage: "
            << "image = " << mTextureImage << ", "
            << "result = " << error << ", "
            << "handle = " << utils::io::hex << mTextureImage << utils::io::dec << ", "
@@ -450,7 +450,7 @@ void VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, const VkImageSubres
    }

 #if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION)
-    utils::slog.d << "transition texture=" << mTextureImage
+    FVK_LOGD << "transition texture=" << mTextureImage
                  << " (" << range.baseArrayLayer
                  << "," << range.baseMipLevel << ")"
                  << " count=(" << range.layerCount
@@ -539,7 +539,7 @@ void VulkanTexture::print() const {
                layer < (mPrimaryViewRange.baseArrayLayer + mPrimaryViewRange.layerCount) &&
                level >= mPrimaryViewRange.baseMipLevel &&
                level < (mPrimaryViewRange.baseMipLevel + mPrimaryViewRange.levelCount);
-            utils::slog.d << "[" << mTextureImage << "]: (" << layer << "," << level
+            FVK_LOGD << "[" << mTextureImage << "]: (" << layer << "," << level
                          << ")=" << getLayout(layer, level)
                          << " primary=" << primary
                          << utils::io::endl;
@@ -548,7 +548,7 @@ void VulkanTexture::print() const {

    for (auto view: mCachedImageViews) {
        auto& range = view.first.range;
-        utils::slog.d << "[" << mTextureImage << ", imageView=" << view.second << "]=>"
+        FVK_LOGD << "[" << mTextureImage << ", imageView=" << view.second << "]=>"
                      << " (" << range.baseArrayLayer << "," << range.baseMipLevel << ")"
                      << " count=(" << range.layerCount << "," << range.levelCount << ")"
                      << " aspect=" << range.aspectMask << " viewType=" << view.first.type
@@ -95,7 +95,7 @@ void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
                .pNext = &driverProperties,
        };
        vkGetPhysicalDeviceProperties2(device, &physicalDeviceProperties2);
-        utils::slog.i << "Vulkan device driver: " << driverProperties.driverName << " "
+        FVK_LOGI << "Vulkan device driver: " << driverProperties.driverName << " "
                      << driverProperties.driverInfo << utils::io::endl;
    }

@@ -128,7 +128,7 @@ void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
    const FixedCapacityVector<VkPhysicalDevice> physicalDevices
            = filament::backend::enumerate(vkEnumeratePhysicalDevices, instance);

-    utils::slog.i << "Selected physical device '" << deviceProperties.deviceName << "' from "
+    FVK_LOGI << "Selected physical device '" << deviceProperties.deviceName << "' from "
                  << physicalDevices.size() << " physical devices. "
                  << "(vendor " << utils::io::hex << vendorID << ", "
                  << "device " << deviceID << ", "
@@ -142,15 +142,15 @@ void printDepthFormats(VkPhysicalDevice device) {
    // Note that Vulkan is more constrained than OpenGL ES 3.1 in this area.
    const VkFormatFeatureFlags required = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
                                              | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
-    utils::slog.i << "Sampleable depth formats: ";
+    FVK_LOGI << "Sampleable depth formats: ";
    for (VkFormat format : ALL_VK_FORMATS) {
        VkFormatProperties props;
        vkGetPhysicalDeviceFormatProperties(device, format, &props);
        if ((props.optimalTilingFeatures & required) == required) {
-            utils::slog.i << format << " ";
+            FVK_LOGI << format << " ";
        }
    }
-    utils::slog.i << utils::io::endl;
+    FVK_LOGI << utils::io::endl;
 }
 #endif

@@ -176,6 +176,12 @@ ExtensionSet getInstanceExtensions(ExtensionSet const& externallyRequiredExts =
                    static_cast<char const*>(nullptr) /* pLayerName */);
    for (auto const& extProps: availableExts) {
        utils::CString name { extProps.extensionName };
+
+        // To workaround an Adreno bug where the extension name could be of 0 length.
+        if (name.size() == 0) {
+            continue;
+        }
+
        if (setContains(TARGET_EXTS, name) || setContains(externallyRequiredExts, name)) {
            exts.insert(name);
        }
@@ -192,6 +198,7 @@ ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
            VK_KHR_MAINTENANCE1_EXTENSION_NAME,
            VK_KHR_MAINTENANCE2_EXTENSION_NAME,
            VK_KHR_MAINTENANCE3_EXTENSION_NAME,
+            VK_KHR_MULTIVIEW_EXTENSION_NAME,
    };
    ExtensionSet exts;
    // Identify supported physical device extensions
@@ -200,6 +207,12 @@ ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
                    static_cast<const char*>(nullptr) /* pLayerName */);
    for (auto const& extension: extensions) {
        utils::CString name { extension.extensionName };
+
+        // To workaround an Adreno bug where the extension name could be of 0 length.
+        if (name.size() == 0) {
+            continue;
+        }
+
        if (setContains(TARGET_EXTS, name)) {
            exts.insert(name);
        }
@@ -229,11 +242,11 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
        instanceCreateInfo.ppEnabledLayerNames = enabledLayers.data();
    } else {
 #if defined(__ANDROID__)
-        utils::slog.d << "Validation layers are not available; did you set jniLibs in your "
-                      << "gradle file?" << utils::io::endl;
+        FVK_LOGD << "Validation layers are not available; did you set jniLibs in your "
+                 << "gradle file?" << utils::io::endl;
 #else
-        utils::slog.d << "Validation layer not available; did you install the Vulkan SDK?\n"
-                      << "Please ensure that VK_LAYER_PATH is set correctly." << utils::io::endl;
+        FVK_LOGD << "Validation layer not available; did you install the Vulkan SDK?\n"
+                 << "Please ensure that VK_LAYER_PATH is set correctly." << utils::io::endl;
 #endif // __ANDROID__

    }
@@ -322,6 +335,7 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
    deviceCreateInfo.enabledExtensionCount = (uint32_t) requestExtensions.size();
    deviceCreateInfo.ppEnabledExtensionNames = requestExtensions.data();

+    void* pNext = nullptr;
    VkPhysicalDevicePortabilitySubsetFeaturesKHR portability = {
            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
            .pNext = nullptr,
@@ -329,9 +343,24 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
            .mutableComparisonSamplers = VK_TRUE,
    };
    if (setContains(deviceExtensions, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)) {
-        deviceCreateInfo.pNext = &portability;
+        portability.pNext = pNext;
+        pNext = &portability;
    }

+    VkPhysicalDeviceMultiviewFeaturesKHR multiview = {
+            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR,
+            .pNext = nullptr,
+            .multiview = VK_TRUE,
+            .multiviewGeometryShader = VK_FALSE,
+            .multiviewTessellationShader = VK_FALSE
+    };
+    if (setContains(deviceExtensions, VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
+        multiview.pNext = pNext;
+        pNext = &multiview;
+    }
+
+    deviceCreateInfo.pNext = pNext;
+
    VkResult result = vkCreateDevice(physicalDevice, &deviceCreateInfo, VKALLOC, &device);
    FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "vkCreateDevice error=" << result << ".";

@@ -406,8 +435,8 @@ inline int deviceTypeOrder(VkPhysicalDeviceType deviceType) {
        case VK_PHYSICAL_DEVICE_TYPE_OTHER:
            return 1;
        default:
-            utils::slog.w << "deviceTypeOrder: Unexpected deviceType: " << deviceType
-                          << utils::io::endl;
+            FVK_LOGW << "deviceTypeOrder: Unexpected deviceType: " << deviceType
+                     << utils::io::endl;
            return -1;
    }
 }
@@ -689,6 +718,10 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
                = pruneExtensions(mImpl->mPhysicalDevice, instExts, deviceExts);
        instExts = prunedInstExts;
        deviceExts = prunedDeviceExts;
+
+        if (driverConfig.stereoscopicType != StereoscopicType::MULTIVIEW) {
+            deviceExts.erase(VK_KHR_MULTIVIEW_EXTENSION_NAME);
+        }
    }

    mImpl->mDevice
@@ -704,6 +737,7 @@ Driver* VulkanPlatform::createDriver(void* sharedContext,
    // Store the extension support in the context
    context.mDebugUtilsSupported = setContains(instExts, VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
    context.mDebugMarkersSupported = setContains(deviceExts, VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
+    context.mMultiviewEnabled = setContains(deviceExts, VK_KHR_MULTIVIEW_EXTENSION_NAME);

 #ifdef NDEBUG
    // If we are in release build, we should not have turned on debug extensions
@@ -738,8 +772,8 @@ VulkanPlatform::SwapChainBundle VulkanPlatform::getSwapChainBundle(SwapChainPtr
    SWAPCHAIN_RET_FUNC(getSwapChainBundle, handle, )
 }

-VkResult VulkanPlatform::acquire(SwapChainPtr handle, VkSemaphore clientSignal, uint32_t* index) {
-    SWAPCHAIN_RET_FUNC(acquire, handle, clientSignal, index)
+VkResult VulkanPlatform::acquire(SwapChainPtr handle, ImageSyncData* outImageSyncData) {
+    SWAPCHAIN_RET_FUNC(acquire, handle, outImageSyncData)
 }

 VkResult VulkanPlatform::present(SwapChainPtr handle, uint32_t index,
@@ -133,6 +133,7 @@ VulkanPlatformSurfaceSwapChain::VulkanPlatformSurfaceSwapChain(VulkanContext con
 VulkanPlatformSurfaceSwapChain::~VulkanPlatformSurfaceSwapChain() {
    vkDestroySwapchainKHR(mDevice, mSwapchain, VKALLOC);
    vkDestroySurfaceKHR(mInstance, mSurface, VKALLOC);
+    destroy();
 }

 VkResult VulkanPlatformSurfaceSwapChain::create() {
@@ -153,7 +154,7 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
    // the number of images, though there may be limits related to the total amount of memory used
    // by presentable images."
    if (maxImageCount != 0 && desiredImageCount > maxImageCount) {
-        utils::slog.e << "Swap chain does not support " << desiredImageCount << " images."
+        FVK_LOGE << "Swap chain does not support " << desiredImageCount << " images."
                      << utils::io::endl;
        desiredImageCount = caps.minImageCount;
    }
@@ -246,7 +247,7 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
            selectDepthFormat(mContext.getAttachmentDepthStencilFormats(), mHasStencil);
    mSwapChainBundle.depth = createImage(mSwapChainBundle.extent, mSwapChainBundle.depthFormat);

-    slog.i << "vkCreateSwapchain"
+    FVK_LOGI << "vkCreateSwapchain"
           << ": " << mSwapChainBundle.extent.width << "x" << mSwapChainBundle.extent.height << ", "
           << surfaceFormat.format << ", " << surfaceFormat.colorSpace << ", "
           << "swapchain-size=" << mSwapChainBundle.colors.size() << ", "
@@ -254,19 +255,29 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
           << "depth=" << mSwapChainBundle.depthFormat
           << io::endl;

+    VkSemaphoreCreateInfo const semaphoreCreateInfo = {
+            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
+    };
+
+    for (uint32_t i = 0; i < IMAGE_READY_SEMAPHORE_COUNT; ++i) {
+        VkResult result = vkCreateSemaphore(mDevice, &semaphoreCreateInfo, nullptr,
+                mImageReady + i);
+        FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS) << "Failed to create semaphore";
+    }
+
    return result;
 }

-VkResult VulkanPlatformSurfaceSwapChain::acquire(VkSemaphore clientSignal, uint32_t* index) {
-    // This immediately retrieves the index of the next available presentable image, and
-    // asynchronously requests the GPU to trigger the "imageAvailable" semaphore.
-    VkResult result = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, clientSignal,
-            VK_NULL_HANDLE, index);
+VkResult VulkanPlatformSurfaceSwapChain::acquire(VulkanPlatform::ImageSyncData* outImageSyncData) {
+    mCurrentImageReadyIndex = (mCurrentImageReadyIndex + 1) % IMAGE_READY_SEMAPHORE_COUNT;
+    outImageSyncData->imageReadySemaphore = mImageReady[mCurrentImageReadyIndex];
+    VkResult result = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX,
+            outImageSyncData->imageReadySemaphore, VK_NULL_HANDLE, &outImageSyncData->imageIndex);

    // Users should be notified of a suboptimal surface, but it should not cause a cascade of
    // log messages or a loop of re-creations.
    if (result == VK_SUBOPTIMAL_KHR && !mSuboptimal) {
-        slog.w << "Vulkan Driver: Suboptimal swap chain." << io::endl;
+        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << io::endl;
        mSuboptimal = true;
    }
    return result;
@@ -288,7 +299,7 @@ VkResult VulkanPlatformSurfaceSwapChain::present(uint32_t index, VkSemaphore fin
    // On Android Q and above, a suboptimal surface is always reported after screen rotation:
    // https://android-developers.googleblog.com/2020/02/handling-device-orientation-efficiently.html
    if (result == VK_SUBOPTIMAL_KHR && !mSuboptimal) {
-        utils::slog.w << "Vulkan Driver: Suboptimal swap chain." << utils::io::endl;
+        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << utils::io::endl;
        mSuboptimal = true;
    }
    return result;
@@ -312,6 +323,17 @@ VkResult VulkanPlatformSurfaceSwapChain::recreate() {
    return create();
 }

+void VulkanPlatformSurfaceSwapChain::destroy() {
+    VulkanPlatformSwapChainImpl::destroy();
+
+    for (uint32_t i = 0; i < IMAGE_READY_SEMAPHORE_COUNT; ++i) {
+        if (mImageReady[i] != VK_NULL_HANDLE) {
+            vkDestroySemaphore(mDevice, mImageReady[i], VKALLOC);
+            mImageReady[i] = VK_NULL_HANDLE;
+        }
+    }
+}
+
 VulkanPlatformHeadlessSwapChain::VulkanPlatformHeadlessSwapChain(VulkanContext const& context,
        VkDevice device, VkQueue queue, VkExtent2D extent, uint64_t flags)
    : VulkanPlatformSwapChainImpl(context, device, queue),
@@ -343,8 +365,8 @@ VkResult VulkanPlatformHeadlessSwapChain::present(uint32_t index, VkSemaphore fi
    return VK_SUCCESS;
 }

-VkResult VulkanPlatformHeadlessSwapChain::acquire(VkSemaphore clientSignal, uint32_t* index) {
-    *index = mCurrentIndex;
+VkResult VulkanPlatformHeadlessSwapChain::acquire(VulkanPlatform::ImageSyncData* outImageSyncData) {
+    outImageSyncData->imageIndex = mCurrentIndex;
    mCurrentIndex = (mCurrentIndex + 1) % HEADLESS_SWAPCHAIN_SIZE;
    return VK_SUCCESS;
 }
@@ -42,7 +42,7 @@ struct VulkanPlatformSwapChainImpl : public Platform::SwapChain {
    ~VulkanPlatformSwapChainImpl();

    // Non-virtual override-able method
-    VkResult acquire(VkSemaphore clientSignal, uint32_t* index) {
+    VkResult acquire(VulkanPlatform::ImageSyncData* outImageSyncData) {
        PANIC_PRECONDITION("Should not be called");
        return VK_ERROR_UNKNOWN;
    }
@@ -86,7 +86,7 @@ struct VulkanPlatformSurfaceSwapChain : public VulkanPlatformSwapChainImpl {
    ~VulkanPlatformSurfaceSwapChain();

    // Non-virtual override
-    VkResult acquire(VkSemaphore clientSignal, uint32_t* index);
+    VkResult acquire(VulkanPlatform::ImageSyncData* outImageSyncData);

    // Non-virtual override
    VkResult present(uint32_t index, VkSemaphore finished);
@@ -97,7 +97,13 @@ struct VulkanPlatformSurfaceSwapChain : public VulkanPlatformSwapChainImpl {
    // Non-virtual override-able method
    bool hasResized();

+protected:
+    // Non-virtual override-able method
+    void destroy();
+
 private:
+    static constexpr int IMAGE_READY_SEMAPHORE_COUNT = FVK_MAX_COMMAND_BUFFERS;
+    
    VkResult create();

    VkInstance mInstance;
@@ -106,6 +112,8 @@ private:
    VkSurfaceKHR mSurface;
    VkSwapchainKHR mSwapchain = VK_NULL_HANDLE;
    VkExtent2D const mFallbackExtent;
+    VkSemaphore mImageReady[IMAGE_READY_SEMAPHORE_COUNT];
+    uint32_t mCurrentImageReadyIndex;

    bool mUsesRGB = false;
    bool mHasStencil = false;
@@ -121,7 +129,7 @@ struct VulkanPlatformHeadlessSwapChain : public VulkanPlatformSwapChainImpl {
    ~VulkanPlatformHeadlessSwapChain();

    // Non-virtual override
-    VkResult acquire(VkSemaphore clientSignal, uint32_t* index);
+    VkResult acquire(VulkanPlatform::ImageSyncData* outImageSyncData);

    // Non-virtual override
    VkResult present(uint32_t index, VkSemaphore finished);
@@ -298,6 +298,24 @@ public:
         */
        size_t textureUseAfterFreePoolSize = 0;

+        /**
+         * When uploading vertex or index data, the Filament Metal backend copies data
+         * into a shared staging area before transferring it to the GPU. This setting controls
+         * the total size of the buffer used to perform these allocations.
+         *
+         * Higher values can improve performance when performing many uploads across a small
+         * number of frames.
+         *
+         * This buffer remains alive throughout the lifetime of the Engine, so this size adds to the
+         * memory footprint of the app and should be set as conservative as possible.
+         *
+         * A value of 0 disables the shared staging buffer entirely; uploads will acquire an
+         * individual buffer from a pool of shared buffers.
+         *
+         * Only respected by the Metal backend.
+         */
+        size_t metalUploadBufferSizeBytes = 512 * 1024;
+
        /**
         * Set to `true` to forcibly disable parallel shader compilation in the backend.
         * Currently only honored by the GL and Metal backends.
@@ -930,6 +948,14 @@ public:
     */
    void pumpMessageQueues();

+    /**
+     * Switch the command queue to unprotected mode. Protected mode can be activated via
+     * Renderer::beginFrame() using a protected SwapChain.
+     * @see Renderer
+     * @see SwapChain
+     */
+    void unprotected() noexcept;
+
    /**
     * Returns the default Material.
     *
@@ -1013,6 +1039,21 @@ public:
    void resetBackendState() noexcept;
 #endif

+    /**
+     * Get the current time. This is a convenience function that simply returns the
+     * time in nanosecond since epoch of std::chrono::steady_clock.
+     * A possible implementation is:
+     *
+     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     *     return std::chrono::steady_clock::now().time_since_epoch().count();
+     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     *
+     * @return current time in nanosecond since epoch of std::chrono::steady_clock.
+     * @see Renderer::beginFrame()
+     */
+    static uint64_t getSteadyClockTimeNano() noexcept;
+
+
    DebugRegistry& getDebugRegistry() noexcept;

 protected:
@@ -158,6 +158,8 @@ public:
         *
         * @return This Builder, for chaining calls.
         *
+         * @see Material::Builder::sphericalHarmonicsBandCount()
+         *
         * @note
         * Because the coefficients are pre-scaled, `sh[0]` is the environment's
         * average irradiance.
@@ -140,6 +140,18 @@ public:
            return constant(name, strlen(name), value);
        }

+        /**
+         * Sets the quality of the indirect lights computations. This is only taken into account
+         * if this material is lit and in the surface domain. This setting will affect the
+         * IndirectLight computation if one is specified on the Scene and Spherical Harmonics
+         * are used for the irradiance.
+         *
+         * @param shBandCount Number of spherical harmonic bands. Must be 1, 2 or 3 (default).
+         * @return Reference to this Builder for chaining calls.
+         * @see IndirectLight
+         */
+        Builder& sphericalHarmonicsBandCount(size_t shBandCount) noexcept;
+
        /**
         * Creates the Material object and returns a pointer to it.
         *
@@ -140,6 +140,7 @@ public:
     * @param values        Array of values to set to the named parameter array.
     * @param count         Size of the array to set.
     * @throws utils::PreConditionPanic if name doesn't exist or no-op if exceptions are disabled.
+     * @see Material::hasParameter
     */
    template<typename T, typename = is_supported_parameter_t<T>>
    void setParameter(const char* UTILS_NONNULL name, size_t nameLength,
@@ -234,6 +235,32 @@ public:
        setParameter(name, strlen(name), type, color);
    }

+    /**
+     * Gets the value of a parameter by name.
+     * 
+     * Note: Only supports non-texture parameters such as numeric and math types.
+     * 
+     * @param name          Name of the parameter as defined by Material. Cannot be nullptr.
+     * @param nameLength    Length in `char` of the name parameter.
+     * @throws utils::PreConditionPanic if name doesn't exist or no-op if exceptions are disabled.
+     * 
+     * @see Material::hasParameter
+     */
+    template<typename T>
+    T getParameter(const char* UTILS_NONNULL name, size_t nameLength) const;
+
+    /** inline helper to provide the name as a null-terminated C string */
+    template<typename T, typename = is_supported_parameter_t<T>>
+    inline T getParameter(StringLiteral name) const {
+        return getParameter<T>(name.data, name.size);
+    }
+
+    /** inline helper to provide the name as a null-terminated C string */
+    template<typename T, typename = is_supported_parameter_t<T>>
+    inline T getParameter(const char* UTILS_NONNULL name) const {
+        return getParameter<T>(name, strlen(name));
+    }
+
    /**
     * Set-up a custom scissor rectangle; by default it is disabled.
     *
@@ -489,43 +489,20 @@ public:
         * For standard morphing, A MorphTargetBuffer must be provided.
         * Standard morphing supports up to \c CONFIG_MAX_MORPH_TARGET_COUNT morph targets.
         *
-         * For legacy morphing, the attached VertexBuffer must provide data in the
-         * appropriate VertexAttribute slots (\c MORPH_POSITION_0 etc). Legacy morphing only
-         * supports up to 4 morph targets and will be deprecated in the future. Legacy morphing must
-         * be enabled on the material definition: either via the legacyMorphing material attribute
-         * or by calling filamat::MaterialBuilder::useLegacyMorphing().
-         *
         * See also RenderableManager::setMorphWeights(), which can be called on a per-frame basis
         * to advance the animation.
         */
        Builder& morphing(MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer) noexcept;

-        /**
-         * @deprecated Use morphing(uint8_t level, size_t primitiveIndex, size_t offset, size_t count) instead
-         */
-        Builder& morphing(uint8_t level, size_t primitiveIndex,
-                MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer,
-                size_t offset, size_t count) noexcept;
-
-        /**
-         * @deprecated Use morphing(uint8_t level, size_t primitiveIndex, size_t offset, size_t count) instead
-         */
-        inline Builder& morphing(uint8_t level, size_t primitiveIndex,
-                MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer) noexcept {
-            return morphing(level, primitiveIndex, morphTargetBuffer, 0,
-                    morphTargetBuffer->getVertexCount());
-        }
-
        /**
         * Specifies the the range of the MorphTargetBuffer to use with this primitive.
         *
         * @param level the level of detail (lod), only 0 can be specified
         * @param primitiveIndex zero-based index of the primitive, must be less than the count passed to Builder constructor
         * @param offset specifies where in the morph target buffer to start reading (expressed as a number of vertices)
-         * @param count number of vertices in the morph target buffer to read, must equal the geometry's count (for triangles, this should be a multiple of 3)
         */
-        Builder& morphing(uint8_t level, size_t primitiveIndex,
-                size_t offset, size_t count) noexcept;
+        RenderableManager::Builder& morphing(uint8_t level,
+                size_t primitiveIndex, size_t offset) noexcept;


        /**
@@ -786,25 +763,13 @@ public:
    /**
     * Associates a MorphTargetBuffer to the given primitive.
     */
-    void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            size_t offset, size_t count);
-
-    /** @deprecated */
-    void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer, size_t offset, size_t count);
-
-    /** @deprecated */
-    inline void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer) {
-        setMorphTargetBufferAt(instance, level, primitiveIndex, morphTargetBuffer, 0,
-                morphTargetBuffer->getVertexCount());
-    }
+    void setMorphTargetBufferOffsetAt(Instance instance, uint8_t level, size_t primitiveIndex,
+            size_t offset);

    /**
-     * Get a MorphTargetBuffer to the given primitive or null if it doesn't exist.
+     * Get a MorphTargetBuffer to the given renderable or null if it doesn't exist.
     */
-    MorphTargetBuffer* UTILS_NULLABLE getMorphTargetBufferAt(Instance instance,
-            uint8_t level, size_t primitiveIndex) const noexcept;
+    MorphTargetBuffer* UTILS_NULLABLE getMorphTargetBuffer(Instance instance) const noexcept;

    /**
     * Gets the number of morphing in the given entity.
@@ -227,6 +227,17 @@ public:
    static constexpr CopyFrameFlag CLEAR = 0x4;


+    /**
+     * The use of this method is optional. It sets the VSYNC time expressed as the duration in
+     * nanosecond since epoch of std::chrono::steady_clock.
+     * If called, passing 0 to vsyncSteadyClockTimeNano in Renderer::BeginFrame will use this
+     * time instead.
+     * @param steadyClockTimeNano duration in nanosecond since epoch of std::chrono::steady_clock
+     * @see Engine::getSteadyClockTimeNano()
+     * @see Renderer::BeginFrame()
+     */
+    void setVsyncTime(uint64_t steadyClockTimeNano) noexcept;
+
    /**
     * Set-up a frame for this Renderer.
     *
@@ -39,6 +39,8 @@
 #include <utils/compiler.h>
 #include <utils/Panic.h>

+#include <chrono>
+
 #include <stddef.h>
 #include <stdint.h>

@@ -329,6 +331,10 @@ void Engine::pumpMessageQueues() {
    downcast(this)->pumpMessageQueues();
 }

+void Engine::unprotected() noexcept {
+    downcast(this)->unprotected();
+}
+
 void Engine::setAutomaticInstancingEnabled(bool enable) noexcept {
    downcast(this)->setAutomaticInstancingEnabled(enable);
 }
@@ -357,7 +363,7 @@ const Engine::Config& Engine::getConfig() const noexcept {
    return downcast(this)->getConfig();
 }

-bool Engine::isStereoSupported(StereoscopicType stereoscopicType) const noexcept {
+bool Engine::isStereoSupported(StereoscopicType) const noexcept {
    return downcast(this)->isStereoSupported();
 }

@@ -365,6 +371,10 @@ size_t Engine::getMaxStereoscopicEyes() noexcept {
    return FEngine::getMaxStereoscopicEyes();
 }

+uint64_t Engine::getSteadyClockTimeNano() noexcept {
+    return std::chrono::steady_clock::now().time_since_epoch().count();
+}
+
 #if defined(__EMSCRIPTEN__)
 void Engine::resetBackendState() noexcept {
    downcast(this)->resetBackendState();
@@ -183,6 +183,35 @@ template UTILS_PUBLIC void MaterialInstance::setParameter<mat4f>   (const char*

 // ------------------------------------------------------------------------------------------------

+template<typename T>
+T FMaterialInstance::getParameterImpl(std::string_view name) const {
+    ssize_t offset = mMaterial->getUniformInterfaceBlock().getFieldOffset(name, 0);
+    assert_invariant(offset>=0);
+    return downcast(this)->getUniformBuffer().getUniform<T>(offset);
+}
+
+template<typename T>
+T MaterialInstance::getParameter(const char* name, size_t nameLength) const {
+    return downcast(this)->getParameterImpl<T>({ name, nameLength });
+}
+
+// explicit template instantiation of our supported types
+template UTILS_PUBLIC float MaterialInstance::getParameter<float>        (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC int32_t MaterialInstance::getParameter<int32_t>  (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC uint32_t MaterialInstance::getParameter<uint32_t>(const char* name, size_t nameLength) const;
+template UTILS_PUBLIC int2 MaterialInstance::getParameter<int2>        (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC int3 MaterialInstance::getParameter<int3>        (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC int4 MaterialInstance::getParameter<int4>        (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC uint2 MaterialInstance::getParameter<uint2>      (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC uint3 MaterialInstance::getParameter<uint3>      (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC uint4 MaterialInstance::getParameter<uint4>      (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC float2 MaterialInstance::getParameter<float2>      (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC float3 MaterialInstance::getParameter<float3>      (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC float4 MaterialInstance::getParameter<float4>      (const char* name, size_t nameLength) const;
+template UTILS_PUBLIC mat3f MaterialInstance::getParameter<mat3f>      (const char* name, size_t nameLength) const;
+
+// ------------------------------------------------------------------------------------------------
+
 Material const* MaterialInstance::getMaterial() const noexcept {
    return downcast(this)->getMaterial();
 }
@@ -671,7 +671,6 @@ RenderPass::Command* RenderPass::generateCommandsImpl(RenderPass::CommandTypeFla
         */
        for (size_t pi = 0, c = primitives.size(); pi < c; ++pi) {
            auto const& primitive = primitives[pi];
-            auto const& morphTargets = morphing.targets[pi];
            FMaterialInstance const* const mi = primitive.getMaterialInstance();
            FMaterial const* const ma = mi->getMaterial();

@@ -684,8 +683,9 @@ RenderPass::Command* RenderPass::generateCommandsImpl(RenderPass::CommandTypeFla
            cmd.info.indexOffset = primitive.getIndexOffset();
            cmd.info.indexCount = primitive.getIndexCount();
            cmd.info.type = primitive.getPrimitiveType();
-            cmd.info.morphTargetBuffer = morphTargets.buffer->getHwHandle();
-            cmd.info.morphingOffset = morphTargets.offset;
+            cmd.info.morphTargetBuffer = morphing.morphTargetBuffer ?
+                    morphing.morphTargetBuffer->getHwHandle() : SamplerGroupHandle{};
+            cmd.info.morphingOffset = primitive.getMorphingBufferOffset();

            if constexpr (isColorPass) {
                RenderPass::setupColorCommand(cmd, renderableVariant, mi, inverseFrontFaces);
@@ -56,6 +56,7 @@ public:
    backend::VertexBufferInfoHandle getVertexBufferInfoHandle() const { return mVertexBufferInfoHandle; }
    uint32_t getIndexOffset() const noexcept { return mIndexOffset; }
    uint32_t getIndexCount() const noexcept { return mIndexCount; }
+    uint32_t getMorphingBufferOffset() const noexcept { return mMorphingBufferOffset; }

    backend::PrimitiveType getPrimitiveType() const noexcept { return mPrimitiveType; }
    AttributeBitset getEnabledAttributes() const noexcept { return mEnabledAttributes; }
@@ -72,6 +73,10 @@ public:
        mGlobalBlendOrderEnabled = enabled;
    }

+    void setMorphingBufferOffset(uint32_t offset) noexcept {
+        mMorphingBufferOffset = offset;
+    }
+
 private:
    // These first fields are dereferences from PrimitiveInfo, keep them together
    struct {
@@ -80,6 +85,7 @@ private:
        backend::Handle<backend::HwVertexBufferInfo> mVertexBufferInfoHandle = {};
        uint32_t mIndexOffset = 0;
        uint32_t mIndexCount = 0;
+        uint32_t mMorphingBufferOffset = 0;
    };

    AttributeBitset mEnabledAttributes = {};
@@ -158,20 +158,14 @@ void RenderableManager::setMorphWeights(Instance instance, float const* weights,
    downcast(this)->setMorphWeights(instance, weights, count, offset);
 }

-void RenderableManager::setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-        MorphTargetBuffer* morphTargetBuffer, size_t offset, size_t count) {
-    downcast(this)->setMorphTargetBufferAt(instance, level, primitiveIndex,
-            downcast(morphTargetBuffer), offset, count);
+void RenderableManager::setMorphTargetBufferOffsetAt(Instance instance, uint8_t level,
+        size_t primitiveIndex,
+        size_t offset) {
+    downcast(this)->setMorphTargetBufferOffsetAt(instance, level, primitiveIndex, offset);
 }

-void RenderableManager::setMorphTargetBufferAt(
-        Instance instance, uint8_t level, size_t primitiveIndex, size_t offset, size_t count) {
-    downcast(this)->setMorphTargetBufferAt(instance, level, primitiveIndex, offset, count);
-}
-
-MorphTargetBuffer* RenderableManager::getMorphTargetBufferAt(Instance instance, uint8_t level,
-        size_t primitiveIndex) const noexcept {
-    return downcast(this)->getMorphTargetBufferAt(instance, level, primitiveIndex);
+MorphTargetBuffer* RenderableManager::getMorphTargetBuffer(Instance instance) const noexcept {
+    return downcast(this)->getMorphTargetBuffer(instance);
 }

 size_t RenderableManager::getMorphTargetCount(Instance instance) const noexcept {
@@ -89,4 +89,8 @@ void Renderer::renderStandaloneView(View const* view) {
    downcast(this)->renderStandaloneView(downcast(view));
 }

+void Renderer::setVsyncTime(uint64_t steadyClockTimeNano) noexcept {
+    downcast(this)->setVsyncTime(steadyClockTimeNano);
+}
+
 } // namespace filament
@@ -281,19 +281,13 @@ RenderableManager::Builder& RenderableManager::Builder::morphing(
    return *this;
 }

-RenderableManager::Builder& RenderableManager::Builder::morphing(
-        uint8_t level, size_t primitiveIndex, size_t offset, size_t count) noexcept {
-    return morphing(level, primitiveIndex, mImpl->mMorphTargetBuffer, offset, count);
-}
-
-RenderableManager::Builder& RenderableManager::Builder::morphing(uint8_t, size_t primitiveIndex,
-        MorphTargetBuffer* morphTargetBuffer, size_t offset, size_t count) noexcept {
-    std::vector<Entry>& entries = mImpl->mEntries;
+RenderableManager::Builder& RenderableManager::Builder::morphing(uint8_t level,
+        size_t primitiveIndex, size_t offset) noexcept {
+    // the last parameter "count" is unused, because it must be equal to the primitive's vertex count
+    std::vector<BuilderDetails::Entry>& entries = mImpl->mEntries;
    if (primitiveIndex < entries.size()) {
        auto& morphing = entries[primitiveIndex].morphing;
-        morphing.buffer = morphTargetBuffer;
-        morphing.offset = offset;
-        morphing.count = count;
+        morphing.offset = uint32_t(offset);
    }
    return *this;
 }
@@ -668,13 +662,6 @@ void FRenderableManager::create(
        if (morphTargetBuffer == nullptr) {
            morphTargetBuffer = mEngine.getDummyMorphTargetBuffer();
        }
-        MorphTargets* const morphTargets = new MorphTargets[entryCount];
-        std::generate_n(morphTargets, entryCount,
-                [morphTargetBuffer]() -> MorphTargets {
-                    return { morphTargetBuffer, 0, 0 };
-                });
-
-        mManager[ci].morphTargets = { morphTargets, size_type(entryCount) };

        // Always create skinning and morphing resources if one of them is enabled because
        // the shader always handles both. See Variant::SKINNING_OR_MORPHING.
@@ -700,13 +687,13 @@ void FRenderableManager::create(
                        backend::BufferUsage::DYNAMIC),
                .count = targetCount };

-            for (size_t i = 0; i < entryCount; ++i) {
-                const auto& morphing = builder->mEntries[i].morphing;
-                if (!morphing.buffer) {
-                    continue;
+            Slice<FRenderPrimitive>& primitives = mManager[ci].primitives;
+            mManager[ci].morphTargetBuffer = morphTargetBuffer;
+            if (builder->mMorphTargetBuffer) {
+                for (size_t i = 0; i < entryCount; ++i) {
+                    const auto& morphing = builder->mEntries[i].morphing;
+                    primitives[i].setMorphingBufferOffset(morphing.offset);
                }
-                morphTargets[i] = { downcast(morphing.buffer), (uint32_t)morphing.offset,
-                                    (uint32_t)morphing.count };
            }
            
            // When targetCount equal 0, boneCount>0 in this case, do an initialization for the
@@ -762,7 +749,6 @@ void FRenderableManager::destroyComponent(Instance ci) noexcept {

    // See create(RenderableManager::Builder&, Entity)
    destroyComponentPrimitives(mHwRenderPrimitiveFactory, driver, manager[ci].primitives);
-    destroyComponentMorphTargets(engine, manager[ci].morphTargets);

    // destroy the bones structures if any
    Bones const& bones = manager[ci].bones;
@@ -795,11 +781,6 @@ void FRenderableManager::destroyComponentPrimitives(
    delete[] primitives.data();
 }

-void FRenderableManager::destroyComponentMorphTargets(FEngine&,
-        utils::Slice<MorphTargets>& morphTargets) noexcept {
-    delete[] morphTargets.data();
-}
-
 void FRenderableManager::setMaterialInstanceAt(Instance instance, uint8_t level,
        size_t primitiveIndex, FMaterialInstance const* mi) {
    if (instance) {
@@ -968,42 +949,21 @@ void FRenderableManager::setMorphWeights(Instance instance, float const* weights
    }
 }

-void FRenderableManager::setMorphTargetBufferAt(Instance instance, uint8_t level,
-        size_t primitiveIndex, FMorphTargetBuffer* morphTargetBuffer, size_t offset, size_t count) {
+void FRenderableManager::setMorphTargetBufferOffsetAt(Instance instance, uint8_t level,
+        size_t primitiveIndex,
+        size_t offset) {
    if (instance) {
-        assert_invariant(morphTargetBuffer);
-
-        MorphWeights const& morphWeights = mManager[instance].morphWeights;
-        FILAMENT_CHECK_PRECONDITION(morphWeights.count == count)
-                << "Only " << morphWeights.count << " morph targets can be set (count=" << count
-                << ")";
-
-        Slice<MorphTargets>& morphTargets = getMorphTargets(instance, level);
-        if (primitiveIndex < morphTargets.size()) {
-            morphTargets[primitiveIndex] = { morphTargetBuffer, (uint32_t)offset,
-                                             (uint32_t)count };
+        assert_invariant(mManager[instance].morphTargetBuffer);
+        Slice<FRenderPrimitive>& primitives = mManager[instance].primitives;
+        if (primitiveIndex < primitives.size()) {
+            primitives[primitiveIndex].setMorphingBufferOffset(offset);
        }
    }
 }

-void FRenderableManager::setMorphTargetBufferAt(Instance instance, uint8_t level,
-        size_t primitiveIndex, size_t offset, size_t count) {
+MorphTargetBuffer* FRenderableManager::getMorphTargetBuffer(Instance instance) const noexcept {
    if (instance) {
-        Slice<MorphTargets>& morphTargets = getMorphTargets(instance, level);
-        if (primitiveIndex < morphTargets.size()) {
-            setMorphTargetBufferAt(instance, level,
-                    primitiveIndex, morphTargets[primitiveIndex].buffer, offset, count);
-        }
-    }
-}
-
-MorphTargetBuffer* FRenderableManager::getMorphTargetBufferAt(Instance instance, uint8_t level,
-        size_t primitiveIndex) const noexcept {
-    if (instance) {
-        const Slice<MorphTargets>& morphTargets = getMorphTargets(instance, level);
-        if (primitiveIndex < morphTargets.size()) {
-            return morphTargets[primitiveIndex].buffer;
-        }
+        return mManager[instance].morphTargetBuffer;
    }
    return nullptr;
 }
@@ -80,12 +80,6 @@ public:

    static_assert(sizeof(Visibility) == sizeof(uint16_t), "Visibility should be 16 bits");

-    struct MorphTargets {
-        FMorphTargetBuffer* buffer = nullptr;
-        uint32_t offset = 0;
-        uint32_t count = 0;
-    };
-
    explicit FRenderableManager(FEngine& engine) noexcept;
    ~FRenderableManager();

@@ -155,11 +149,9 @@ public:

    inline void setMorphing(Instance instance, bool enable);
    void setMorphWeights(Instance instance, float const* weights, size_t count, size_t offset);
-    void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            FMorphTargetBuffer* morphTargetBuffer, size_t offset, size_t count);
-    void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            size_t offset, size_t count);
-    MorphTargetBuffer* getMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex) const noexcept;
+    void setMorphTargetBufferOffsetAt(Instance instance, uint8_t level, size_t primitiveIndex,
+            size_t offset);
+    MorphTargetBuffer* getMorphTargetBuffer(Instance instance) const noexcept;
    size_t getMorphTargetCount(Instance instance) const noexcept;

    void setLightChannel(Instance instance, unsigned int channel, bool enable) noexcept;
@@ -189,7 +181,7 @@ public:
    struct MorphingBindingInfo {
        backend::Handle<backend::HwBufferObject> handle;
        uint32_t count;
-        MorphTargets const* targets; // Pointer to Slice<MorphTargets> at a renderable.
+        FMorphTargetBuffer const* morphTargetBuffer;
    };
    inline MorphingBindingInfo getMorphingBufferInfo(Instance instance) const noexcept;

@@ -218,16 +210,12 @@ public:
    AttributeBitset getEnabledAttributesAt(Instance instance, uint8_t level, size_t primitiveIndex) const noexcept;
    inline utils::Slice<FRenderPrimitive> const& getRenderPrimitives(Instance instance, uint8_t level) const noexcept;
    inline utils::Slice<FRenderPrimitive>& getRenderPrimitives(Instance instance, uint8_t level) noexcept;
-    inline utils::Slice<MorphTargets> const& getMorphTargets(Instance instance, uint8_t level) const noexcept;
-    inline utils::Slice<MorphTargets>& getMorphTargets(Instance instance, uint8_t level) noexcept;

 private:
    void destroyComponent(Instance ci) noexcept;
    static void destroyComponentPrimitives(
            HwRenderPrimitiveFactory& factory, backend::DriverApi& driver,
            utils::Slice<FRenderPrimitive>& primitives) noexcept;
-    static void destroyComponentMorphTargets(FEngine& engine,
-            utils::Slice<MorphTargets>& morphTargets) noexcept;

    struct Bones {
        backend::Handle<backend::HwBufferObject> handle;
@@ -254,7 +242,7 @@ private:
        VISIBILITY,             // user data
        PRIMITIVES,             // user data
        BONES,                  // filament data, UBO storing a pointer to the bones information
-        MORPH_TARGETS
+        MORPHTARGET_BUFFER      // morphtarget buffer for the component
    };

    using Base = utils::SingleInstanceComponentManager<
@@ -266,7 +254,7 @@ private:
            Visibility,                      // VISIBILITY
            utils::Slice<FRenderPrimitive>,  // PRIMITIVES
            Bones,                           // BONES
-            utils::Slice<MorphTargets>       // MORPH_TARGETS
+            FMorphTargetBuffer*              // MORPHTARGET_BUFFER
    >;

    struct Sim : public Base {
@@ -289,7 +277,7 @@ private:
                Field<VISIBILITY>           visibility;
                Field<PRIMITIVES>           primitives;
                Field<BONES>                bones;
-                Field<MORPH_TARGETS>        morphTargets;
+                Field<MORPHTARGET_BUFFER>   morphTargetBuffer;
            };
        };

@@ -461,8 +449,8 @@ inline uint32_t FRenderableManager::getBoneCount(Instance instance) const noexce
 FRenderableManager::MorphingBindingInfo
 FRenderableManager::getMorphingBufferInfo(Instance instance) const noexcept {
    MorphWeights const& morphWeights = mManager[instance].morphWeights;
-    utils::Slice<MorphTargets> const& morphTargets = getMorphTargets(instance, 0);
-    return { morphWeights.handle, morphWeights.count, morphTargets.data() };
+    FMorphTargetBuffer const* const buffer = mManager[instance].morphTargetBuffer;
+    return { morphWeights.handle, morphWeights.count, buffer  };
 }

 FRenderableManager::InstancesInfo
@@ -480,16 +468,6 @@ utils::Slice<FRenderPrimitive>& FRenderableManager::getRenderPrimitives(
    return mManager[instance].primitives;
 }

-utils::Slice<FRenderableManager::MorphTargets> const& FRenderableManager::getMorphTargets(
-        Instance instance, UTILS_UNUSED uint8_t level) const noexcept {
-    return mManager[instance].morphTargets;
-}
-
-utils::Slice<FRenderableManager::MorphTargets>& FRenderableManager::getMorphTargets(
-        Instance instance, UTILS_UNUSED uint8_t level) noexcept {
-    return mManager[instance].morphTargets;
-}
-
 } // namespace filament

 #endif // TNT_FILAMENT_COMPONENTS_RENDERABLEMANAGER_H
@@ -102,6 +102,7 @@ Engine* FEngine::create(Engine::Builder const& builder) {
        DriverConfig const driverConfig{
                .handleArenaSize = instance->getRequestedDriverHandleArenaSize(),
                .textureUseAfterFreePoolSize = instance->getConfig().textureUseAfterFreePoolSize,
+                .metalUploadBufferSizeBytes = instance->getConfig().metalUploadBufferSizeBytes,
                .disableParallelShaderCompile = instance->getConfig().disableParallelShaderCompile,
                .disableHandleUseAfterFreeCheck = instance->getConfig().disableHandleUseAfterFreeCheck,
                .forceGLES2Context = instance->getConfig().forceGLES2Context,
@@ -476,6 +477,8 @@ void FEngine::shutdown() {

    destroy(mDefaultMaterial);

+    destroy(mUnprotectedDummySwapchain);
+
    /*
     * clean-up after the user -- we call terminate on each "leaked" object and clear each list.
     *
@@ -676,6 +679,7 @@ int FEngine::loop() {
    DriverConfig const driverConfig {
            .handleArenaSize = getRequestedDriverHandleArenaSize(),
            .textureUseAfterFreePoolSize = mConfig.textureUseAfterFreePoolSize,
+            .metalUploadBufferSizeBytes = mConfig.metalUploadBufferSizeBytes,
            .disableParallelShaderCompile = mConfig.disableParallelShaderCompile,
            .disableHandleUseAfterFreeCheck = mConfig.disableHandleUseAfterFreeCheck,
            .forceGLES2Context = mConfig.forceGLES2Context,
@@ -1253,6 +1257,13 @@ void FEngine::resetBackendState() noexcept {
 }
 #endif

+void FEngine::unprotected() noexcept {
+    if (UTILS_UNLIKELY(!mUnprotectedDummySwapchain)) {
+        mUnprotectedDummySwapchain = createSwapChain(1, 1, 0);
+    }
+    mUnprotectedDummySwapchain->makeCurrent(getDriverApi());
+}
+
 // ------------------------------------------------------------------------------------------------

 Engine::Builder::Builder() noexcept = default;
@@ -406,6 +406,8 @@ public:
        getDriver().purge();
    }

+    void unprotected() noexcept;
+
    void setAutomaticInstancingEnabled(bool enable) noexcept {
        // instancing is not allowed at feature level 0
        if (hasFeatureLevel(FeatureLevel::FEATURE_LEVEL_1)) {
@@ -539,6 +541,7 @@ private:

    mutable FMaterial const* mDefaultMaterial = nullptr;
    mutable FMaterial const* mSkyboxMaterial = nullptr;
+    mutable FSwapChain* mUnprotectedDummySwapchain = nullptr;

    mutable FTexture* mDefaultIblTexture = nullptr;
    mutable FIndirectLight* mDefaultIbl = nullptr;
@@ -595,6 +598,7 @@ public:
            // capture to file. At the moment, only supported by the Metal backend.
            bool doFrameCapture = false;
            bool disable_buffer_padding = false;
+            bool disable_subpasses = false;
        } renderer;
        struct {
            bool debug_froxel_visualization = false;
@@ -119,6 +119,7 @@ struct Material::BuilderDetails {
    const void* mPayload = nullptr;
    size_t mSize = 0;
    bool mDefaultMaterial = false;
+    int32_t mShBandsCount = 3;
    std::unordered_map<
        utils::CString,
        std::variant<int32_t, float, bool>,
@@ -143,6 +144,11 @@ Material::Builder& Material::Builder::package(const void* payload, size_t size)
    return *this;
 }

+Material::Builder& Material::Builder::sphericalHarmonicsBandCount(size_t shBandCount) noexcept {
+    mImpl->mShBandsCount = math::clamp(shBandCount, size_t(1), size_t(3));
+    return *this;
+}
+
 template<typename T, typename>
 Material::Builder& Material::Builder::constant(const char* name, size_t nameLength, T value) {
    FILAMENT_CHECK_PRECONDITION(name != nullptr) << "name cannot be null";
@@ -661,7 +667,7 @@ bool FMaterial::hasPendingEdits() noexcept {

 void FMaterial::latchPendingEdits() noexcept {
    std::lock_guard const lock(mPendingEditsLock);
-    std::swap(mPendingEdits, mMaterialParser);
+    mMaterialParser.reset(mPendingEdits.release());
 }

 /**
@@ -897,6 +903,8 @@ void FMaterial::processSpecializationConstants(FEngine& engine, Material::Builde
    mSpecializationConstants.push_back({
            +ReservedSpecializationConstants::CONFIG_STEREO_EYE_COUNT,
            (int)engine.getConfig().stereoscopicEyeCount });
+    mSpecializationConstants.push_back({
+            +ReservedSpecializationConstants::CONFIG_SH_BANDS_COUNT, builder->mShBandsCount });
    if (UTILS_UNLIKELY(parser->getShaderLanguage() == ShaderLanguage::ESSL1)) {
        // The actual value of this spec-constant is set in the OpenGLDriver backend.
        mSpecializationConstants.push_back({
@@ -231,6 +231,9 @@ private:
    void setParameterImpl(std::string_view name,
            FTexture const* texture, TextureSampler const& sampler);

+    template<typename T>
+    T getParameterImpl(std::string_view name) const;
+
    // initialize the default instance
    FMaterialInstance(FEngine& engine, FMaterial const* material) noexcept;

@@ -29,7 +29,8 @@

 #include <utils/Allocator.h>

-#include <vector>
+#include <stddef.h>
+#include <stdint.h>

 namespace filament {

@@ -59,16 +60,21 @@ public:
    inline size_t getVertexCount() const noexcept { return mVertexCount; }
    inline size_t getCount() const noexcept { return mCount; }

-private:
-    friend class FView;
-    friend class RenderPass;
+    backend::TextureHandle getPositionsHandle() const noexcept {
+        return mPbHandle;
+    }

+    backend::TextureHandle getTangentsHandle() const noexcept {
+        return mTbHandle;
+    }
+
+    inline backend::Handle<backend::HwSamplerGroup> getHwHandle() const noexcept { return mSbHandle; }
+
+private:
    void updateDataAt(backend::DriverApi& driver, backend::Handle <backend::HwTexture> handle,
            backend::PixelDataFormat format, backend::PixelDataType type, const char* out,
            size_t elementSize, size_t targetIndex, size_t count, size_t offset);

-    inline backend::Handle<backend::HwSamplerGroup> getHwHandle() const noexcept { return mSbHandle; }
-
    backend::Handle<backend::HwSamplerGroup> mSbHandle;
    backend::Handle<backend::HwTexture> mPbHandle;
    backend::Handle<backend::HwTexture> mTbHandle;
@@ -95,6 +95,8 @@ FRenderer::FRenderer(FEngine& engine) :
            &engine.debug.renderer.doFrameCapture);
    debugRegistry.registerProperty("d.renderer.disable_buffer_padding",
            &engine.debug.renderer.disable_buffer_padding);
+    debugRegistry.registerProperty("d.renderer.disable_subpasses",
+            &engine.debug.renderer.disable_subpasses);
    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture",
            &engine.debug.shadowmap.display_shadow_texture);
    debugRegistry.registerProperty("d.shadowmap.display_shadow_texture_scale",
@@ -230,6 +232,10 @@ void FRenderer::setPresentationTime(int64_t monotonic_clock_ns) {
    driver.setPresentationTime(monotonic_clock_ns);
 }

+void FRenderer::setVsyncTime(uint64_t steadyClockTimeNano) noexcept {
+    mVsyncSteadyClockTimeNano = steadyClockTimeNano;
+}
+
 bool FRenderer::beginFrame(FSwapChain* swapChain, uint64_t vsyncSteadyClockTimeNano) {
    assert_invariant(swapChain);

@@ -250,6 +256,11 @@ bool FRenderer::beginFrame(FSwapChain* swapChain, uint64_t vsyncSteadyClockTimeN
    }
 #endif

+    if (!vsyncSteadyClockTimeNano) {
+        vsyncSteadyClockTimeNano = mVsyncSteadyClockTimeNano;
+        mVsyncSteadyClockTimeNano = 0;
+    }
+
    // get the timestamp as soon as possible
    using namespace std::chrono;
    const steady_clock::time_point now{ steady_clock::now() };
@@ -596,12 +607,14 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
                    hasColorGrading &&
                    msaaSampleCount <= 1 &&
                    !bloomOptions.enabled && !dofOptions.enabled && !taaOptions.enabled &&
-                    driver.isFrameBufferFetchSupported(),
+                    driver.isFrameBufferFetchSupported() &&
+                    !engine.debug.renderer.disable_subpasses,
            .customResolve =
                    msaaOptions.customResolve &&
                    msaaSampleCount > 1 &&
                    hasColorGrading &&
-                    driver.isFrameBufferFetchMultiSampleSupported(),
+                    driver.isFrameBufferFetchMultiSampleSupported() &&
+                    !engine.debug.renderer.disable_subpasses,
            .translucent = needsAlphaChannel,
            .fxaa = hasFXAA,
            .dithering = hasDithering,
@@ -29,9 +29,6 @@

 #include "backend/DriverApiForward.h"

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

@@ -41,8 +38,18 @@
 #include <utils/compiler.h>
 #include <utils/Allocator.h>

+#include <math/vec4.h>
+
 #include <tsl/robin_set.h>

+#include <algorithm>
+#include <chrono>
+#include <functional>
+#include <utility>
+
+#include <stddef.h>
+#include <stdint.h>
+
 namespace filament {

 namespace backend {
@@ -78,6 +85,8 @@ public:

    void setPresentationTime(int64_t monotonic_clock_ns);

+    void setVsyncTime(uint64_t steadyClockTimeNano) noexcept;
+
    // start a frame
    bool beginFrame(FSwapChain* swapChain, uint64_t vsyncSteadyClockTimeNano);

@@ -187,6 +196,7 @@ private:
    backend::TargetBufferFlags mClearFlags{};
    tsl::robin_set<FRenderTarget*> mPreviousRenderTargets;
    std::function<void()> mBeginFrameInternal;
+    uint64_t mVsyncSteadyClockTimeNano = 0;
 };

 FILAMENT_DOWNCAST(Renderer)
@@ -114,6 +114,7 @@ void FSkinningBuffer::setBones(FEngine& engine,
    setBones(engine, mHandle, transforms, count, offset);
 }

+UTILS_UNUSED
 static uint32_t packHalf2x16(half2 v) noexcept {
    uint32_t lo = getBits(v[0]);
    uint32_t hi = getBits(v[1]);
@@ -144,13 +145,8 @@ PerRenderableBoneUib::BoneData FSkinningBuffer::makeBone(mat4f transform) noexce
                    transform[1],
                    transform[2]
            },
-            .cof = {
-                    packHalf2x16({ cofactors[0].x, cofactors[0].y }),
-                    packHalf2x16({ cofactors[0].z, cofactors[1].x }),
-                    packHalf2x16({ cofactors[1].y, cofactors[1].z }),
-                    packHalf2x16({ cofactors[2].x, cofactors[2].y })
-                    // cofactor[2][2] is not stored because we don't have space for it
-            }
+            .cof0 = cofactors[0],
+            .cof1x = cofactors[1].x
    };
 }

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

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

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

 /**
 * Supported shading models
@@ -203,7 +203,7 @@ enum class ReflectionMode : uint8_t {
 // can't really use std::underlying_type<AttributeIndex>::type because the driver takes a uint32_t
 using AttributeBitset = utils::bitset32;

-static constexpr size_t MATERIAL_PROPERTIES_COUNT = 27;
+static constexpr size_t MATERIAL_PROPERTIES_COUNT = 29;
 enum class Property : uint8_t {
    BASE_COLOR,              //!< float4, all shading models
    ROUGHNESS,               //!< float,  lit shading models only
@@ -232,6 +232,8 @@ enum class Property : uint8_t {
    IOR,                     //!< float,  material's index of refraction
    MICRO_THICKNESS,         //!< float, thickness of the thin layer
    BENT_NORMAL,             //!< float3, all shading models only, except unlit
+    SPECULAR_FACTOR,         //!< float, lit shading models only, except subsurface and cloth
+    SPECULAR_COLOR_FACTOR,   //!< float3, lit shading models only, except subsurface and cloth

    // when adding new Properties, make sure to update MATERIAL_PROPERTIES_COUNT
 };
@@ -70,6 +70,7 @@ enum class ReservedSpecializationConstants : uint8_t {
    CONFIG_DEBUG_DIRECTIONAL_SHADOWMAP = 6,
    CONFIG_DEBUG_FROXEL_VISUALIZATION = 7,
    CONFIG_STEREO_EYE_COUNT = 8, // don't change (hardcoded in ShaderCompilerService.cpp)
+    CONFIG_SH_BANDS_COUNT = 9
 };

 enum class PushConstantIds : uint8_t  {
@@ -327,8 +327,9 @@ struct PerRenderableBoneUib { // NOLINT(cppcoreguidelines-pro-type-member-init)
    struct alignas(16) BoneData {
        // bone transform, last row assumed [0,0,0,1]
        math::float4 transform[3];
-        // 8 first cofactor matrix of transform's upper left
-        math::uint4 cof;
+        // 4 first cofactor matrix of transform's upper left
+        math::float3 cof0;
+        float cof1x;
    };
    BoneData bones[CONFIG_MAX_BONE_COUNT];
 };
@@ -119,7 +119,7 @@ static void PlotEx(ImGuiPlotType plot_type, const char* label, int series_count,
    const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0));
    ImGui::ItemSize(total_bb, style.FramePadding.y);
    if (!ImGui::ItemAdd(total_bb, 0, &frame_bb)) return;
-    const bool hovered = ImGui::ItemHoverable(inner_bb, 0);
+    const bool hovered = ImGui::ItemHoverable(inner_bb, 0, ImGuiHoveredFlags_None);

    // Determine scale from values if not specified
    if (scale_min == FLT_MAX || scale_max == FLT_MAX) {
@@ -21,33 +21,35 @@
 namespace filamat {

 std::unordered_map<std::string, Property> Enums::mStringToProperty = {
-        { "baseColor",              Property::BASE_COLOR },
-        { "roughness",              Property::ROUGHNESS },
-        { "metallic",               Property::METALLIC },
-        { "reflectance",            Property::REFLECTANCE },
-        { "ambientOcclusion",       Property::AMBIENT_OCCLUSION },
-        { "clearCoat",              Property::CLEAR_COAT },
-        { "clearCoatRoughness",     Property::CLEAR_COAT_ROUGHNESS },
-        { "clearCoatNormal",        Property::CLEAR_COAT_NORMAL },
-        { "anisotropy",             Property::ANISOTROPY },
-        { "anisotropyDirection",    Property::ANISOTROPY_DIRECTION },
-        { "thickness",              Property::THICKNESS },
-        { "subsurfacePower",        Property::SUBSURFACE_POWER },
-        { "subsurfaceColor",        Property::SUBSURFACE_COLOR },
-        { "sheenColor",             Property::SHEEN_COLOR },
-        { "sheenRoughness",         Property::SHEEN_ROUGHNESS },
-        { "glossiness",             Property::GLOSSINESS },
-        { "specularColor",          Property::SPECULAR_COLOR },
-        { "emissive",               Property::EMISSIVE },
-        { "normal",                 Property::NORMAL },
-        { "postLightingColor",      Property::POST_LIGHTING_COLOR },
+        { "baseColor",           Property::BASE_COLOR },
+        { "roughness",           Property::ROUGHNESS },
+        { "metallic",            Property::METALLIC },
+        { "reflectance",         Property::REFLECTANCE },
+        { "ambientOcclusion",    Property::AMBIENT_OCCLUSION },
+        { "clearCoat",           Property::CLEAR_COAT },
+        { "clearCoatRoughness",  Property::CLEAR_COAT_ROUGHNESS },
+        { "clearCoatNormal",     Property::CLEAR_COAT_NORMAL },
+        { "anisotropy",          Property::ANISOTROPY },
+        { "anisotropyDirection", Property::ANISOTROPY_DIRECTION },
+        { "thickness",           Property::THICKNESS },
+        { "subsurfacePower",     Property::SUBSURFACE_POWER },
+        { "subsurfaceColor",     Property::SUBSURFACE_COLOR },
+        { "sheenColor",          Property::SHEEN_COLOR },
+        { "sheenRoughness",      Property::SHEEN_ROUGHNESS },
+        { "glossiness",          Property::GLOSSINESS },
+        { "specularColor",       Property::SPECULAR_COLOR },
+        { "emissive",            Property::EMISSIVE },
+        { "normal",              Property::NORMAL },
+        { "postLightingColor",   Property::POST_LIGHTING_COLOR },
        { "postLightingMixFactor",  Property::POST_LIGHTING_MIX_FACTOR },
-        { "clipSpaceTransform",     Property::CLIP_SPACE_TRANSFORM },
-        { "absorption",             Property::ABSORPTION },
-        { "transmission",           Property::TRANSMISSION },
-        { "ior",                    Property::IOR },
-        { "microThickness",         Property::MICRO_THICKNESS },
-        { "bentNormal",             Property::BENT_NORMAL },
+        { "clipSpaceTransform",  Property::CLIP_SPACE_TRANSFORM },
+        { "absorption",          Property::ABSORPTION },
+        { "transmission",        Property::TRANSMISSION },
+        { "ior",                 Property::IOR },
+        { "microThickness",      Property::MICRO_THICKNESS },
+        { "bentNormal",          Property::BENT_NORMAL },
+        { "specularFactor",      Property::SPECULAR_FACTOR },
+        { "specularColorFactor",  Property::SPECULAR_COLOR_FACTOR }
 };

 template <>
@@ -332,6 +332,9 @@ utils::io::sstream& CodeGenerator::generateProlog(utils::io::sstream& out, Shade
    generateSpecializationConstant(out, "CONFIG_STEREO_EYE_COUNT",
            +ReservedSpecializationConstants::CONFIG_STEREO_EYE_COUNT, material.stereoscopicEyeCount);

+    generateSpecializationConstant(out, "CONFIG_SH_BANDS_COUNT",
+            +ReservedSpecializationConstants::CONFIG_SH_BANDS_COUNT, 3);
+
    // CONFIG_MAX_STEREOSCOPIC_EYES is used to size arrays and on Adreno GPUs + vulkan, this has to
    // be explicitly, statically defined (as in #define). Otherwise (using const int for
    // example), we'd run into a GPU crash.
@@ -1189,6 +1192,8 @@ char const* CodeGenerator::getConstantName(MaterialBuilder::Property property) n
        case Property::IOR:                         return "IOR";
        case Property::MICRO_THICKNESS:             return "MICRO_THICKNESS";
        case Property::BENT_NORMAL:                 return "BENT_NORMAL";
+        case Property::SPECULAR_FACTOR:             return "SPECULAR_FACTOR";
+        case Property::SPECULAR_COLOR_FACTOR:       return "SPECULAR_COLOR_FACTOR";
    }
 }

@@ -196,7 +196,7 @@ void FilamentApp::run(const Config& config, SetupCallback setupCallback,
            SDL_SysWMinfo wmInfo;
            SDL_VERSION(&wmInfo.version);
            SDL_GetWindowWMInfo(window->getSDLWindow(), &wmInfo);
-            io.ImeWindowHandle = wmInfo.info.win.window;
+            ImGui::GetMainViewport()->PlatformHandleRaw = wmInfo.info.win.window;
        #endif
        io.KeyMap[ImGuiKey_Tab] = SDL_SCANCODE_TAB;
        io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT;
@@ -147,6 +147,9 @@ build_ubershader(volume_opaque             volume          lit opaque)
 build_ubershader(volume_fade               volume          lit fade)
 build_ubershader(volume_masked             volume          lit masked)
 build_ubershader(sheen                     sheen           _ _)
+build_ubershader(specular_opaque           specular        lit opaque)
+build_ubershader(specular_fade             specular        lit fade)
+build_ubershader(specular_masked           specular        lit masked)

 add_custom_target(uberz_file DEPENDS ${UBERZ_OUTPUT_PATH})
 set_target_properties(uberz_file PROPERTIES FOLDER Libs)
@@ -93,10 +93,17 @@ struct alignas(4) MaterialKey {
    bool hasSheen : 1;
    bool hasIOR : 1;
    bool hasVolume : 1;
-    uint8_t padding : 5;
+    bool hasSpecular : 1;
+    bool hasSpecularTexture : 1;
+    bool hasSpecularColorTexture : 1;
+    bool padding : 2;
+    // -- 32 bit boundary --
+    uint8_t specularTextureUV;
+    uint8_t specularColorTextureUV;
+    uint16_t padding2;
 };

-static_assert(sizeof(MaterialKey) == 16, "MaterialKey has unexpected size.");
+static_assert(sizeof(MaterialKey) == 20, "MaterialKey has unexpected size.");

 UTILS_WARNING_POP

@@ -30,3 +30,8 @@ TransmissionTexture = unsupported
 # Volume Features
 Volume = unsupported
 VolumeThicknessTexture = unsupported
+
+# Specular Features
+Specular = unsupported
+SpecularTexture = unsupported
+SpecularColorTexture = unsupported
@@ -55,7 +55,16 @@ material {
        { type : mat3, name : sheenRoughnessUvMatrix, precision: high },

        // Reflectance
-        { type : float, name : reflectance }
+        { type : float, name : reflectance },
+
+        // KHR_materials_specular
+        { type : float, name : specularStrength },
+        { type : float3, name : specularColorFactor },
+        { type : int, name : specularIndex },
+        { type : sampler2d, name : specularMap },
+        { type : mat3, name : specularUvMatrix, precision: high },
+        { type : int, name : specularColorIndex },
+        { type : mat3, name : specularColorUvMatrix, precision: high }

        ${CUSTOM_PARAMS}
    ],
@@ -136,6 +145,15 @@ fragment {
            material.emissive.rgb *= texture(materialParams_emissiveMap, uv).rgb;
        }

+        material.specularFactor = materialParams.specularStrength;
+        material.specularColorFactor = materialParams.specularColorFactor;
+
+        if (materialParams.specularIndex > -1) {
+            highp float2 uv = uvs[materialParams.specularIndex];
+            uv = (vec3(uv, 1.0) * materialParams.specularUvMatrix).xy;
+            material.specularFactor *= texture(materialParams_specularMap, uv).a;
+        }
+
        ${CUSTOM_FRAGMENT}
    }
 }
@@ -17,3 +17,8 @@ TextureTransforms=optional
 Sheen=optional
 SheenColorTexture=optional
 SheenRoughnessTexture=optional
+
+# KHR_material_specular Features
+Specular=optional
+SpecularTexture=optional
+SpecularColorTexture=unsupported
@@ -0,0 +1,168 @@
+material {
+    name : specular_ubershader,
+    requires : [ uv0, uv1, color ],
+    shadingModel : lit,
+    blending : ${BLENDING},
+    doubleSided : ${DOUBLESIDED},
+    transparency : ${TRANSPARENCY},
+    flipUV : false,
+    specularAmbientOcclusion : simple,
+    specularAntiAliasing : true,
+    clearCoatIorChange : false,
+    reflections: screenspace,
+    parameters : [
+
+        // Base Color
+        { type : int, name : baseColorIndex },
+        { type : float4, name : baseColorFactor },
+        { type : sampler2d, name : baseColorMap },
+        { type : mat3, name : baseColorUvMatrix, precision: high },
+
+        // Metallic-Roughness Map
+        { type : int, name : metallicRoughnessIndex },
+        { type : float, name : metallicFactor },
+        { type : float, name : roughnessFactor },
+        { type : sampler2d, name : metallicRoughnessMap },
+        { type : mat3, name : metallicRoughnessUvMatrix, precision: high },
+
+        // Normal Map
+        { type : int, name : normalIndex },
+        { type : float, name : normalScale },
+        { type : sampler2d, name : normalMap },
+        { type : mat3, name : normalUvMatrix, precision: high },
+
+        // Ambient Occlusion
+        { type : int, name : aoIndex },
+        { type : float, name : aoStrength },
+        { type : sampler2d, name : occlusionMap },
+        { type : mat3, name : occlusionUvMatrix, precision: high },
+
+        // Emissive Map
+        { type : int, name : emissiveIndex },
+        { type : float3, name : emissiveFactor },
+        { type : float, name : emissiveStrength },
+        { type : sampler2d, name : emissiveMap },
+        { type : mat3, name : emissiveUvMatrix, precision: high },
+
+        // Clear coat, we drop texture support for clear coat due to 8 texture limits.
+        { type : float, name : clearCoatFactor },
+        { type : float, name : clearCoatRoughnessFactor },
+        { type : int, name : clearCoatIndex },
+        { type : sampler2d, name : clearCoatMap },
+        { type : mat3, name : clearCoatUvMatrix, precision: high },
+        { type : int, name : clearCoatRoughnessIndex },
+        { type : mat3, name : clearCoatRoughnessUvMatrix, precision: high },
+        { type : int, name : clearCoatNormalIndex },
+        { type : mat3, name : clearCoatNormalUvMatrix, precision: high },
+        { type : float, name : clearCoatNormalScale },
+
+        // KHR_materials_specular
+        { type : float, name : specularStrength },
+        { type : float3, name : specularColorFactor },
+        { type : int, name : specularIndex },
+        { type : sampler2d, name : specularMap },
+        { type : mat3, name : specularUvMatrix, precision: high },
+        { type : int, name : specularColorIndex },
+        { type : sampler2d, name : specularColorMap },
+        { type : mat3, name : specularColorUvMatrix, precision: high },
+
+        // IOR
+        { type : float, name : ior }
+
+        ${CUSTOM_PARAMS}
+    ],
+}
+
+vertex {
+void materialVertex(inout MaterialVertexInputs material) {
+    ${CUSTOM_VERTEX}
+}
+}
+
+fragment {
+void material(inout MaterialInputs material) {
+    highp float2 uvs[2];
+    uvs[0] = getUV0();
+    uvs[1] = getUV1();
+
+    if (materialParams.normalIndex > -1) {
+        highp float2 uv = uvs[materialParams.normalIndex];
+        uv = (vec3(uv, 1.0) * materialParams.normalUvMatrix).xy;
+        material.normal = texture(materialParams_normalMap, uv).xyz * 2.0 - 1.0;
+        material.normal.xy *= materialParams.normalScale;
+    }
+
+    prepareMaterial(material);
+    material.baseColor = materialParams.baseColorFactor;
+
+    if (materialParams.baseColorIndex > -1) {
+        highp float2 uv = uvs[materialParams.baseColorIndex];
+        uv = (vec3(uv, 1.0) * materialParams.baseColorUvMatrix).xy;
+        material.baseColor *= texture(materialParams_baseColorMap, uv);
+    }
+
+#if defined(BLEND_MODE_TRANSPARENT)
+    material.baseColor.rgb *= material.baseColor.a;
+#endif
+
+    material.baseColor *= getColor();
+
+    material.roughness = materialParams.roughnessFactor;
+    material.metallic = materialParams.metallicFactor;
+    material.ior = materialParams.ior;
+
+    material.emissive = vec4(materialParams.emissiveStrength *
+                             materialParams.emissiveFactor.rgb, 0.0);
+
+    // KHR_materials_clearcoat forbids clear coat from
+    // being applied in the specular/glossiness model
+    material.clearCoat = materialParams.clearCoatFactor;
+    material.clearCoatRoughness = materialParams.clearCoatRoughnessFactor;
+
+    if (materialParams.clearCoatIndex > -1) {
+        highp float2 uv = uvs[materialParams.clearCoatIndex];
+        uv = (vec3(uv, 1.0) * materialParams.clearCoatUvMatrix).xy;
+        material.clearCoat *= texture(materialParams_clearCoatMap, uv).r;
+    }
+
+    material.specularFactor = materialParams.specularStrength;
+    material.specularColorFactor = materialParams.specularColorFactor;
+
+    if (materialParams.specularIndex > -1) {
+        highp float2 uv = uvs[materialParams.specularIndex];
+        uv = (vec3(uv, 1.0) * materialParams.specularUvMatrix).xy;
+        material.specularFactor *= texture(materialParams_specularMap, uv).a;
+    }
+
+    if (materialParams.specularColorIndex > -1) {
+        highp float2 uv = uvs[materialParams.specularColorIndex];
+        uv = (vec3(uv, 1.0) * materialParams.specularColorUvMatrix).xy;
+        vec4 sc = texture(materialParams_specularColorMap, uv);
+        material.specularColorFactor.r *= sc.r;
+        material.specularColorFactor.g *= sc.g;
+        material.specularColorFactor.b *= sc.b;
+    }
+
+    if (materialParams.metallicRoughnessIndex > -1) {
+        highp float2 uv = uvs[materialParams.metallicRoughnessIndex];
+        uv = (vec3(uv, 1.0) * materialParams.metallicRoughnessUvMatrix).xy;
+        vec4 mr = texture(materialParams_metallicRoughnessMap, uv);
+        material.roughness *= mr.g;
+        material.metallic *= mr.b;
+    }
+
+    if (materialParams.aoIndex > -1) {
+        highp float2 uv = uvs[materialParams.aoIndex];
+        uv = (vec3(uv, 1.0) * materialParams.occlusionUvMatrix).xy;
+        float occlusion = texture(materialParams_occlusionMap, uv).r;
+        material.ambientOcclusion = 1.0 + materialParams.aoStrength * (occlusion - 1.0);
+    }
+    if (materialParams.emissiveIndex > -1) {
+        highp float2 uv = uvs[materialParams.emissiveIndex];
+        uv = (vec3(uv, 1.0) * materialParams.emissiveUvMatrix).xy;
+        material.emissive.rgb *= texture(materialParams_emissiveMap, uv).rgb;
+    }
+
+    ${CUSTOM_FRAGMENT}
+}
+}
@@ -0,0 +1,35 @@
+ShadingModel=lit
+
+# Required Aspects
+BlendingMode = ${BLENDING}
+
+VertexColors = optional
+BaseColorTexture = optional
+NormalTexture = optional
+OcclusionTexture = optional
+EmissiveTexture = optional
+MetallicRoughnessTexture = optional
+TextureTransforms = optional
+
+# KHR_materials_specular Features
+Specular = optional
+SpecularTexture = optional
+SpecularColorTexture = optional
+
+# ClearCoat Features
+ClearCoat = optional
+ClearCoatTexture = optional
+
+# Sheen Features
+Sheen = unsupported
+SheenColorTexture = unsupported
+SheenRoughnessTexture = unsupported
+
+# Transmission and IOR Features
+Transmission = unsupported
+Ior = optional
+TransmissionTexture = unsupported
+
+# Volume Features
+Volume = unsupported
+VolumeThicknessTexture = unsupported
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Sungun Park	c3f1a4c94d	Merge branch 'rc/1.53.2' into release	2024-07-23 01:24:09 +00:00
Mathias Agopian	bef004e1b0	switch to new morphing API - remove deprecated morphing APIs - repair gltfio, samples and tests The new API doesn't allow a MorphTargetBuffer per RenderPrimitive, instead the MorphTargetBuffer is specified per Renderable. gltfio separates RenderPrimitives from Renderables, in particular all RenderPrimitives are created before their Renderable; this was problematic for this change because all primitives must share a single MorphTargetBuffer living in the Renderable. To fix this, we're no longer initializing the morphing paramters at RenderPrimitive creation, instead we store a reference to the BufferSlot in the Primtive structure, so that later, when the Renderable is created we can finally retrieve the BufferSlot and initialize its morphing paramters, which are not available. The "morphing parameters" are now expanded to contain the MorphTargetBuffer as before (except now it's always the same for all the primitives of a Rendrable), as well as the offset within the buffer and the vertex count.	2024-07-22 11:31:03 -06:00
Ben Doherty	936d0a7b1d	Update imgui to v1.90.9 (#7977 )	2024-07-18 16:41:31 -07:00
Mathias Agopian	2b651d4946	shader compilation could fail on ES 3.0 devices the failure could happen if the shader didn't have any #extension strings, which was likely to happen on release builds (e.g. on emulator).	2024-07-01 11:31:30 -07:00
Ben Doherty	d6ab9f1c0b	Update cgltf to 1.14 (#7945 )	2024-07-01 10:57:37 -07:00
Ben Doherty	786b7ec7ae	Fix MetalBumpAllocator (#7951 )	2024-06-28 13:09:39 -07:00
Benjamin Doherty	55173efc2c	Bump version to 1.53.2	2024-06-25 11:46:54 -07:00
Benjamin Doherty	7fc8e339e7	Merge branch 'rc/1.53.1' into release	2024-06-25 11:46:53 -07:00
Benjamin Doherty	659b8b6e03	Release Filament 1.53.1	2024-06-25 11:46:46 -07:00
Ben Doherty	c73f4e64d5	Metal: use a bump allocator for vertex and index uploads (#7926 )	2024-06-25 11:45:45 -07:00
Mathias Agopian	fe743523bf	fix use-after-free dereference risk Texture handles were resolved to pointers when updating a SamplerGroup, as that point the handle was checked for use-after-free. However, the texture could be destroyed later while still active in the SamplerGroup, this would result in using the pointer which now contains garbage. We now keep the handle and resolve the texture when binding samplers to the program; which will also perform the use-after-free check.	2024-06-24 16:16:12 -07:00
Ryan	0395df3689	Fix use-after-free of a std::mutex in PresentCallable. (#7934 ) If a user is using `setFrameScheduledCallback()`, managing the provided PresentCallable during engine shutdown is tricky -- we'll likely get a final frame scheduled when we flush the engine's work queue, but the PresentCallable will schedule the final CAMetalDrawable to be released on main thread afterwards, even if we call `present(false)` to skip it. If the swap chain is destroyed before that main queue block gets executed, the mutex presenting that drawable will no longer exist, causing a crash. To make things easier, store the std::mutex in a shared_ptr, so that a PresentCallable can safely outlive the FSwapChain instance that created it and clean itself up afterwards. Alternatives considered, all of which seem unfortunate: * Require users to clear out the callback before shutting down the engine, so that any final drawables are immediately discarded instead of using PresentCallable * Require users to split up the engine teardown across two main queue blocks, ensuring that the PresentCallable cleanup executes before swapchains are destroyed * Drop the PresentCallable on the ground and leak the memory	2024-06-24 11:01:44 -07:00
Ryan	2c1044e812	Fix use-after-free of a std::mutex in PresentCallable. (#7934 ) If a user is using `setFrameScheduledCallback()`, managing the provided PresentCallable during engine shutdown is tricky -- we'll likely get a final frame scheduled when we flush the engine's work queue, but the PresentCallable will schedule the final CAMetalDrawable to be released on main thread afterwards, even if we call `present(false)` to skip it. If the swap chain is destroyed before that main queue block gets executed, the mutex presenting that drawable will no longer exist, causing a crash. To make things easier, store the std::mutex in a shared_ptr, so that a PresentCallable can safely outlive the FSwapChain instance that created it and clean itself up afterwards. Alternatives considered, all of which seem unfortunate: * Require users to clear out the callback before shutting down the engine, so that any final drawables are immediately discarded instead of using PresentCallable * Require users to split up the engine teardown across two main queue blocks, ensuring that the PresentCallable cleanup executes before swapchains are destroyed * Drop the PresentCallable on the ground and leak the memory	2024-06-24 11:00:58 -07:00
Sungun Park	db9183a105	Fix memory leak of asset loading for gltf_viewer (#7933 ) When a user drags and drops a gltf file to the gltf_viewer window, it loads the new asset. While this happens, the function `checkAsset` tries parsing the gltf file, but it doesn't free it. Fix this.	2024-06-21 10:37:01 -07:00
toddZ_CG Todd Zhang Romain Guy Mathias Agopian	e4a0bb8fa0	Add support for KHR_materials_Specular (#7564 ) Co-authored-by: Todd Zhang <toddzx@amazon.com> Co-authored-by: Romain Guy <romain.guy@gmail.com> Co-authored-by: Mathias Agopian <mathias@google.com>	2024-06-21 17:06:17 +00:00
Mathias Agopian	d15c53e530	an easier way to pipe vsync time to beginFrame BUGS=[343764098]	2024-06-21 09:41:19 -07:00
Mathias Agopian	cc8a3ed96b	fix typo that broke glsl compilation on device	2024-06-20 15:48:17 -07:00
Mathias Agopian	213eb6af9e	Lit Materials can now specify the quality of SH computations The number of SH bands used for the indirect light irradiance computations can be set to 1, 2 or 3 (default) in Material::Builder. For e.g. in lower-end devices w/ non HDR content, it might be beneficial to set this value to 2. BUGS=[341971013]	2024-06-20 10:25:04 -07:00
Mathias Agopian	e04c6d406f	inject the missing packing/unpacking function in ESSL 3.0 FIXES=[343784713]	2024-06-18 13:37:20 -07:00
Mathias Agopian	cab799f531	matdbg would cause a crash if program was invalid	2024-06-18 00:27:24 -07:00
Benjamin Doherty	64f03b3832	Merge branch 'rc/1.53.0' into release	2024-06-17 17:26:55 -07:00
Benjamin Doherty	982b159b3e	Bump version to 1.53.1	2024-06-17 17:26:55 -07:00
Benjamin Doherty	e95edef9d7	Release Filament 1.53.0	2024-06-17 17:26:47 -07:00
Grant Commodore	9cfef925bb	Updates vulkan swapchain synchronization (#7915 ) Abstracts the synchronization of the vulkan swapchain so that it is easier to override during the acquisition and presentation of images. A new structure (ImageSyncData) is created to hold swapchain synchronization data. FIXES=[338303279]	2024-06-17 22:29:28 +00:00
Hanno J. Gödecke	3900fc6c37	feat: support getParameter from MaterialInstance (#7686 )	2024-06-17 11:31:17 -07:00
Powei Feng	b8ec1658f3	vk: single output stream debug logging (#7925 ) In some debug instances, it's nice to have the logs all go to one output stream so that logs are ordered. We add a FVK_DEBUG flag for this use case.	2024-06-14 22:31:45 +00:00
Grant Commodore	371bd1f01f	Checks/enable if the multiview extension is supported (#7923 ) Checks if the vulkan driver supports multiview. The result is stored in the vulkan context. BUG=[332425392] FIXES=[346860138]	2024-06-13 10:20:24 -07:00
Benjamin Doherty	6e3cccf30c	Bump version to 1.53.0	2024-06-11 16:42:17 -07:00
Benjamin Doherty	df34f92f8f	Release Filament 1.52.3	2024-06-11 16:42:10 -07:00
Powei Feng	43331d04e5	gltfio: [extended] Fix generated color default (#7917 ) Fixes #7905	2024-06-11 12:21:14 -07:00
Powei Feng	9917d4b7d9	Null out pending edits once latched (#7916 ) Otherwise, we'd keep swapping between the edited version and the original, causing matdbg to not work.	2024-06-10 21:32:49 +00:00
Mathias Agopian	682150ceec	add debug option to disable sub-passes	2024-06-10 13:18:59 -07:00
Powei Feng	af2ecf201f	vk: workaround extension name length = 0 (adreno) (#7910 )	2024-06-07 10:29:38 -07:00
Serge Metral	020668733a	Adding the begin frame message for later xtrace post processing. (#7903 ) BUG=343930963	2024-06-05 21:58:31 +00:00
Powei Feng	4c6d653d60	samples: Enable backend selection for hellopbr (#7898 )	2024-06-05 19:15:45 +00:00
Mathias Agopian	d1022527ac	export PanicStream since it's a public API	2024-06-05 11:00:06 -07:00
Romain Guy	68c7a6c7b6	Update Android dependencies to latest (#7902 )	2024-06-04 22:33:02 +00:00
Romain Guy	f077fff012	Update actions/checkout to a supported version of Node.js (#7904 )	2024-06-04 15:03:43 -07:00
Mathias Agopian	bea02427ed	keep the normal transforms in float during skinning FIXES=[342459864]	2024-06-04 13:37:47 -07:00
Mathias Agopian	b5d7de06bc	Engine::unprotected() drops the command queue back to unprotected mode FIXES=[344021154]	2024-06-04 11:46:00 -07:00
Mathias Agopian	749b063af3	PerformanceHintManager needs a valid Java thread FIXES=[343965368, 343550453]	2024-06-04 10:22:21 -07:00
Ryan	7aefa99e06	Acquire a mutex before releasing CAMetalDrawables on main thread. (#7888 ) PresentDrawable was moved to main thread by default in google#7535 and stopped most crashes when a drawable is released. But there still appears to be crashes if a drawable is released on main thread at the same time that -nextDrawable is called from the Filament render thread. (It's likely that the drawable pool in CAMetalLayer is completely non-thread-safe.) So, add a mutex to the swapchain and always acquire it before creating or releasing a CAMetalDrawable. Users can opt out of this behavior by passing -DFILAMENT_LOCK_METAL_DRAWABLE_POOL=0.	2024-06-03 19:37:46 +00:00