Merge branch 'rc/1.53.0' into release

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.

NEW_RELEASE_NOTES.md

@@ -7,5 +7,3 @@ for next branch cut* header.
 appropriate header in [RELEASE_NOTES.md](./RELEASE_NOTES.md).
 
 ## Release notes for next branch cut
-
-- Add a `name` API to Filament objects for debugging handle use-after-free assertions

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.54.0'
+    implementation 'com.google.android.filament:filament-android:1.53.0'
 }
 ```
 
@@ -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.54.0'
+pod 'Filament', '~> 1.53.0'
 ```
 
 ### Snapshots
@@ -176,7 +176,6 @@ 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

RELEASE_NOTES.md

@@ -7,32 +7,6 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).
 
-## v1.54.1
-
-
-## v1.54.0
-
-- materials: add a new `stereoscopicType` material parameter. [⚠️ **New Material Version**]
-- Fix a crash when compiling shaders on IMG devices
-
-## v1.53.5
-
-- engine: Fix bug causing certain sampler parameters to not be applied correctly in GLES 2.0 and on
-  certain GLES 3.0 drivers.
-
-## v1.53.4
-
-
-## v1.53.3
-
-- Add drag and drop support for IBL files for desktop gltf_viewer.
-
-## v1.53.2
-
-
-## v1.53.1
-
-
 ## v1.53.0
 
 - engine: fix skinning normals with large transforms (b/342459864) [⚠️ **New Material Version**]

android/filament-android/src/main/cpp/Engine.cpp

@@ -571,9 +571,3 @@ 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();
-}

android/filament-android/src/main/cpp/Material.cpp

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

android/filament-android/src/main/cpp/RenderableManager.cpp

@@ -253,10 +253,16 @@ Java_com_google_android_filament_RenderableManager_nBuilderMorphingStandard(JNIE
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nBuilderSetMorphTargetBufferOffsetAt(JNIEnv*, jclass,
-        jlong nativeBuilder, int level, int primitiveIndex, int offset) {
+Java_com_google_android_filament_RenderableManager_nBuilderSetMorphTargetBufferAt(JNIEnv*, jclass,
+        jlong nativeBuilder, int level, int primitiveIndex, jlong nativeMorphTargetBuffer,
+        int offset, int count) {
     RenderableManager::Builder *builder = (RenderableManager::Builder *) nativeBuilder;
-    builder->morphing(level, primitiveIndex, offset);
+    if (nativeMorphTargetBuffer) {
+        MorphTargetBuffer *morphTargetBuffer = (MorphTargetBuffer *) nativeMorphTargetBuffer;
+        builder->morphing(level, primitiveIndex, morphTargetBuffer, offset, count);
+    } else {
+        builder->morphing(level, primitiveIndex, offset, count);
+    }
 }
 
 extern "C" JNIEXPORT void JNICALL
@@ -328,12 +334,18 @@ Java_com_google_android_filament_RenderableManager_nSetMorphWeights(JNIEnv* env,
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_RenderableManager_nSetMorphTargetBufferOffsetAt(JNIEnv*,
+Java_com_google_android_filament_RenderableManager_nSetMorphTargetBufferAt(JNIEnv*,
         jclass, jlong nativeRenderableManager, jint i, int level, jint primitiveIndex,
-        jlong, jint offset) {
+        jlong nativeMorphTargetBuffer, jint offset, jint count) {
     RenderableManager *rm = (RenderableManager *) nativeRenderableManager;
-    rm->setMorphTargetBufferOffsetAt((RenderableManager::Instance) i, (uint8_t) level,
-            (size_t) primitiveIndex, (size_t) offset);
+    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);
+    }
 }
 
 extern "C" JNIEXPORT jint JNICALL

android/filament-android/src/main/cpp/Renderer.cpp

@@ -28,14 +28,6 @@
 using namespace filament;
 using namespace backend;
 
-
-extern "C" JNIEXPORT void JNICALL
-Java_com_google_android_filament_Renderer_nSkipFrame(JNIEnv *, jclass, jlong nativeRenderer,
-        jlong vsyncSteadyClockTimeNano) {
-    Renderer *renderer = (Renderer *) nativeRenderer;
-    renderer->skipFrame(uint64_t(vsyncSteadyClockTimeNano));
-}
-
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Renderer_nBeginFrame(JNIEnv *, jclass, jlong nativeRenderer,
         jlong nativeSwapChain, jlong frameTimeNanos) {
@@ -195,10 +187,3 @@ 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);
-}

android/filament-android/src/main/cpp/View.cpp

@@ -531,12 +531,3 @@ Java_com_google_android_filament_View_nGetFogEntity(JNIEnv *env, jclass clazz,
     View *view = (View *) nativeView;
     return (jint)view->getFogEntity().getId();
 }
-
-extern "C"
-JNIEXPORT void JNICALL
-Java_com_google_android_filament_View_nClearFrameHistory(JNIEnv *env, jclass clazz,
-        jlong nativeView, jlong nativeEngine) {
-    View *view = (View *) nativeView;
-    Engine *engine = (Engine *) nativeEngine;
-    view->clearFrameHistory(*engine);
-}

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

@@ -425,12 +425,9 @@ public class Engine {
         public long resourceAllocatorCacheSizeMB = 64;
 
         /*
-         * This value determines how many frames texture entries are kept for in the cache. This
-         * is a soft limit, meaning some texture older than this are allowed to stay in the cache.
-         * Typically only one texture is evicted per frame.
-         * The default is 1.
+         * This value determines for how many frames are texture entries kept in the cache.
          */
-        public long resourceAllocatorCacheMaxAge = 1;
+        public long resourceAllocatorCacheMaxAge = 2;
 
         /*
          * Disable backend handles use-after-free checks.
@@ -1295,6 +1292,7 @@ public class Engine {
     /**
      * Switch the command queue to unprotected mode. Protected mode can be activated via
      * Renderer::beginFrame() using a protected SwapChain.
+
      * @see Renderer
      * @see SwapChain
      */
@@ -1302,13 +1300,6 @@ public class Engine {
         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() {

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

@@ -346,7 +346,6 @@ 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
@@ -362,22 +361,6 @@ 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.
          *
@@ -389,8 +372,7 @@ public class Material {
          */
         @NonNull
         public Material build(@NonNull Engine engine) {
-            long nativeMaterial = nBuilderBuild(engine.getNativeObject(),
-                mBuffer, mSize, mShBandCount);
+            long nativeMaterial = nBuilderBuild(engine.getNativeObject(), mBuffer, mSize);
             if (nativeMaterial == 0) throw new IllegalStateException("Couldn't create Material");
             return new Material(nativeMaterial);
         }
@@ -1041,7 +1023,7 @@ public class Material {
         mNativeObject = 0;
     }
 
-    private static native long nBuilderBuild(long nativeEngine, @NonNull Buffer buffer, int size, int shBandCount);
+    private static native long nBuilderBuild(long nativeEngine, @NonNull Buffer buffer, int size);
     private static native long nCreateInstance(long nativeMaterial);
     private static native long nCreateInstanceWithName(long nativeMaterial, @NonNull String name);
     private static native long nGetDefaultInstance(long nativeMaterial);

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

@@ -74,7 +74,7 @@ public class MorphTargetBuffer {
          *
          * @exception IllegalStateException if the MorphTargetBuffer could not be created
          *
-         * @see #setMorphTargetBufferOffsetAt
+         * @see #setMorphTargetBufferAt
          */
         @NonNull
         public MorphTargetBuffer build(@NonNull Engine engine) {

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

@@ -569,13 +569,40 @@ 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) {
-            nBuilderSetMorphTargetBufferOffsetAt(mNativeBuilder, level, primitiveIndex, offset);
+                                @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());
             return this;
         }
 
@@ -678,11 +705,34 @@ public class RenderableManager {
      *
      * @see Builder#morphing
      */
-    public void setMorphTargetBufferOffsetAt(@EntityInstance int i,
+    public void setMorphTargetBufferAt(@EntityInstance int i,
                                        @IntRange(from = 0) int level,
                                        @IntRange(from = 0) int primitiveIndex,
-                                       @IntRange(from = 0) int offset) {
-        nSetMorphTargetBufferOffsetAt(mNativeObject, i, level, primitiveIndex, 0, offset);
+                                       @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());
     }
 
     /**
@@ -983,7 +1033,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 nBuilderSetMorphTargetBufferOffsetAt(long nativeBuilder, int level, int primitiveIndex, int offset);
+    private static native void nBuilderSetMorphTargetBufferAt(long nativeBuilder, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset, int count);
     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);
@@ -993,7 +1043,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 nSetMorphTargetBufferOffsetAt(long nativeObject, int i, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset);
+    private static native void nSetMorphTargetBufferAt(long nativeObject, int i, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset, int count);
     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);

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

@@ -284,33 +284,6 @@ 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);
-    }
-
-    /**
-     * Call skipFrame when momentarily skipping frames, for instance if the content of the
-     * scene doesn't change.
-     *
-     * @param vsyncSteadyClockTimeNano The time in nanoseconds when the frame started being rendered,
-     *                       in the {@link System#nanoTime()} timebase. Divide this value by 1000000 to
-     *                       convert it to the {@link android.os.SystemClock#uptimeMillis()}
-     *                       time base. This typically comes from
-     *                       {@link android.view.Choreographer.FrameCallback}.
-     */
-    public void skipFrame(long vsyncSteadyClockTimeNano) {
-        nSkipFrame(getNativeObject(), vsyncSteadyClockTimeNano);
-    }
-
     /**
      * 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
@@ -729,8 +702,6 @@ public class Renderer {
     }
 
     private static native void nSetPresentationTime(long nativeObject, long monotonicClockNanos);
-    private static native void nSetVsyncTime(long nativeObject, long steadyClockTimeNano);
-    private static native void nSkipFrame(long nativeObject, long vsyncSteadyClockTimeNano);
     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);

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

@@ -1233,18 +1233,6 @@ public class View {
         return nGetFogEntity(getNativeObject());
     }
 
-    /**
-     * When certain temporal features are used (e.g.: TAA or Screen-space reflections), the view
-     * keeps a history of previous frame renders associated with the Renderer the view was last
-     * used with. When switching Renderer, it may be necessary to clear that history by calling
-     * this method. Similarly, if the whole content of the screen change, like when a cut-scene
-     * starts, clearing the history might be needed to avoid artifacts due to the previous frame
-     * being very different.
-     */
-    public void clearFrameHistory(Engine engine) {
-        nClearFrameHistory(getNativeObject(), engine.getNativeObject());
-    }
-
     public long getNativeObject() {
         if (mNativeObject == 0) {
             throw new IllegalStateException("Calling method on destroyed View");
@@ -1306,7 +1294,7 @@ public class View {
     private static native void nSetMaterialGlobal(long nativeView, int index, float x, float y, float z, float w);
     private static native void nGetMaterialGlobal(long nativeView, int index, float[] out);
     private static native int nGetFogEntity(long nativeView);
-    private static native void nClearFrameHistory(long nativeView, long nativeEngine);
+
 
     /**
      * List of available ambient occlusion techniques.

android/filament-utils-android/src/main/cpp/Manipulator.cpp

@@ -125,11 +125,6 @@ extern "C" JNIEXPORT void Java_com_google_android_filament_utils_Manipulator_nBu
     builder->groundPlane(a, b, c, d);
 }
 
-extern "C" JNIEXPORT void Java_com_google_android_filament_utils_Manipulator_nBuilderPanning(JNIEnv*, jclass, jlong nativeBuilder, jboolean enabled) {
-    Builder* builder = (Builder*) nativeBuilder;
-    builder->panning(enabled);
-}
-
 extern "C" JNIEXPORT long Java_com_google_android_filament_utils_Manipulator_nBuilderBuild(JNIEnv*, jclass, jlong nativeBuilder, jint mode) {
     Builder* builder = (Builder*) nativeBuilder;
     return (jlong) builder->build((Mode) mode);

android/filament-utils-android/src/main/java/com/google/android/filament/utils/Manipulator.java

@@ -274,17 +274,6 @@ public class Manipulator {
             return this;
         }
 
-        /**
-         * Sets whether panning is enabled in the manipulator.
-         *
-         * @return this <code>Builder</code> object for chaining calls
-         */
-        @NonNull
-        public Builder panning(Boolean enabled) {
-            nBuilderPanning(mNativeBuilder, enabled);
-            return this;
-        }
-
         /**
          * Creates and returns the <code>Manipulator</code> object.
          *
@@ -494,7 +483,6 @@ public class Manipulator {
     private static native void nBuilderFlightPanSpeed(long nativeBuilder, float x, float y);
     private static native void nBuilderFlightMoveDamping(long nativeBuilder, float damping);
     private static native void nBuilderGroundPlane(long nativeBuilder, float a, float b, float c, float d);
-    private static native void nBuilderPanning(long nativeBuilder, Boolean enabled);
     private static native long nBuilderBuild(long nativeBuilder, int mode);
 
     private static native void nDestroyManipulator(long nativeManip);

android/gradle.properties

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

docs/Materials.md.html

@@ -1308,12 +1308,7 @@ Description
       declare a variable called `eyeDirection` you can access it in the fragment shader using
       `variable_eyeDirection`. In the vertex shader, the interpolant name is simply a member of
       the `MaterialVertexInputs` structure (`material.eyeDirection` in your example). Each
-      interpolant is of type `float4` (`vec4`) in the shaders. By default the precision of the
-      interpolant is `highp` in *both* the vertex and fragment shaders.
-      An alternate syntax can be used to specify both the name and precision of the interpolant.
-      In this case the specified precision is used as-is in both fragment and vertex stages, in
-      particular if `default` is specified the default precision is used is the fragment shader
-      (`mediump`) and in the vertex shader (`highp`).
+      interpolant is of type `float4` (`vec4`) in the shaders.
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JSON
 material {
@@ -1325,11 +1320,7 @@ material {
         }
     ],
     variables : [
-         eyeDirection,
-         {
-            name : eyeColor,
-            precision : medium
-         }
+         eyeDirection
     ],
     vertexDomain : device,
     depthWrite : false,

filament/CMakeLists.txt

@@ -61,7 +61,6 @@ set(SRCS
         src/Engine.cpp
         src/Exposure.cpp
         src/Fence.cpp
-        src/FilamentBuilder.cpp
         src/FrameInfo.cpp
         src/FrameSkipper.cpp
         src/Froxelizer.cpp

filament/backend/include/backend/DriverEnums.h

@@ -1244,7 +1244,7 @@ enum class Workaround : uint16_t {
     ADRENO_UNIFORM_ARRAY_CRASH,
     // Workaround a Metal pipeline compilation error with the message:
     // "Could not statically determine the target of a texture". See light_indirect.fs
-    METAL_STATIC_TEXTURE_TARGET_ERROR,
+    A8X_STATIC_TEXTURE_TARGET_ERROR,
     // Adreno drivers sometimes aren't able to blit into a layer of a texture array.
     DISABLE_BLIT_INTO_TEXTURE_ARRAY,
     // Multiple workarounds needed for PowerVR GPUs

filament/backend/include/backend/Platform.h

@@ -75,8 +75,6 @@ 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.

filament/backend/include/backend/platforms/VulkanPlatform.h

@@ -90,20 +90,6 @@ 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;
@@ -141,12 +127,6 @@ 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;
     };
 
     /**
@@ -175,10 +155,13 @@ 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 outImageSyncData The synchronization data used for image readiness
+     * @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.
      * @return               Result of acquire
      */
-    virtual VkResult acquire(SwapChainPtr handle, ImageSyncData* outImageSyncData);
+    virtual VkResult acquire(SwapChainPtr handle, VkSemaphore clientSignal, uint32_t* index);
 
     /**
      * Present the image corresponding to `index` to the display. The client should wait on

filament/backend/include/private/backend/DriverAPI.inc

@@ -162,10 +162,6 @@ DECL_DRIVER_API_0(finish)
 // reset state tracking, if the driver does any state tracking (e.g. GL)
 DECL_DRIVER_API_0(resetState)
 
-DECL_DRIVER_API_N(setDebugTag,
-        backend::HandleBase::HandleId, handleId,
-        utils::CString, tag)
-
 /*
  * Creating driver objects
  * -----------------------

filament/backend/include/private/backend/HandleAllocator.h

@@ -20,12 +20,11 @@
 #include <backend/Handle.h>
 
 #include <utils/Allocator.h>
-#include <utils/CString.h>
 #include <utils/Log.h>
-#include <utils/Panic.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/ostream.h>
+#include <utils/Panic.h>
 
 #include <tsl/robin_map.h>
 
@@ -40,7 +39,7 @@
 
 #define HandleAllocatorGL  HandleAllocator<32,  64, 136>    // ~4520 / pool / MiB
 #define HandleAllocatorVK  HandleAllocator<64, 160, 312>    // ~1820 / pool / MiB
-#define HandleAllocatorMTL HandleAllocator<32,  64, 552>    // ~1660 / pool / MiB
+#define HandleAllocatorMTL HandleAllocator<32,  48, 552>    // ~1660 / pool / MiB
 
 namespace filament::backend {
 
@@ -174,28 +173,14 @@ public:
                 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;
-                // getHandleTag() is only called if the check fails.
-                FILAMENT_CHECK_POSTCONDITION(expectedAge == age)
-                        << "use-after-free of Handle with id=" << handle.getId()
-                        << ", tag=" << getHandleTag(handle.getId()).c_str_safe();
+                FILAMENT_CHECK_POSTCONDITION(expectedAge == age) <<
+                        "use-after-free of Handle with id=" << handle.getId();
             }
         }
 
         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> &&
@@ -204,34 +189,6 @@ public:
         return handle_cast<Dp>(const_cast<Handle<B>&>(handle));
     }
 
-    void associateTagToHandle(HandleBase::HandleId id, utils::CString&& tag) noexcept {
-        // TODO: for now, only pool handles check for use-after-free, so we only keep tags for
-        // those
-        if (isPoolHandle(id)) {
-            // Truncate the tag's age to N bits.
-            constexpr uint8_t N = 2; // support a history of 4 tags
-            constexpr uint8_t mask = (1 << N) - 1;
-
-            uint8_t const age = (id & HANDLE_AGE_MASK) >> HANDLE_AGE_SHIFT;
-            uint8_t const newAge = age & mask;
-            uint32_t const key = (id & ~HANDLE_AGE_MASK) | (newAge << HANDLE_AGE_SHIFT);
-
-            // This line is the costly part. In the future, we could potentially use a custom
-            // allocator.
-            mDebugTags[key] = std::move(tag);
-        }
-    }
-
-    utils::CString getHandleTag(HandleBase::HandleId id) const noexcept {
-        if (!isPoolHandle(id)) {
-            return "(no tag)";
-        }
-        if (auto pos = mDebugTags.find(id); pos != mDebugTags.end()) {
-            return pos->second;
-        }
-        return "(no tag)";
-    }
-
 private:
 
     template<typename D>
@@ -394,7 +351,6 @@ private:
     // Below is only used when running out of space in the HandleArena
     mutable utils::Mutex mLock;
     tsl::robin_map<HandleBase::HandleId, void*> mOverflowMap;
-    tsl::robin_map<HandleBase::HandleId, utils::CString> mDebugTags;
     HandleBase::HandleId mId = 0;
     bool mUseAfterFreeCheckDisabled = false;
 };

filament/backend/src/CircularBuffer.cpp

@@ -32,11 +32,10 @@
 #    define HAS_MMAP 0
 #endif
 
-#include <stddef.h>
 #include <stdint.h>
-#include <stdio.h>
+#include <stddef.h>
 #include <stdlib.h>
-#include <string.h>
+#include <stdio.h>
 
 using namespace utils;
 
@@ -82,9 +81,6 @@ void* CircularBuffer::alloc(size_t size) noexcept {
             // map the circular buffer once...
             vaddr = mmap(reserve_vaddr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
             if (vaddr != MAP_FAILED) {
-                // populate the address space with pages (because this is a circular buffer,
-                // all the pages will be allocated eventually, might as well do it now)
-                memset(vaddr, 0, size);
                 // and map the circular buffer again, behind the previous copy...
                 vaddr_shadow = mmap((char*)vaddr + size, size,
                         PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
@@ -105,7 +101,7 @@ void* CircularBuffer::alloc(size_t size) noexcept {
     if (UTILS_UNLIKELY(mAshmemFd < 0)) {
         // ashmem failed
         if (vaddr_guard != MAP_FAILED) {
-            munmap(vaddr_guard, BLOCK_SIZE);
+            munmap(vaddr_guard, size);
         }
 
         if (vaddr_shadow != MAP_FAILED) {
@@ -123,11 +119,12 @@ void* CircularBuffer::alloc(size_t size) noexcept {
         data = mmap(nullptr, size * 2 + BLOCK_SIZE,
                 PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 
-        FILAMENT_CHECK_POSTCONDITION(data != MAP_FAILED) <<
+        FILAMENT_CHECK_POSTCONDITION(data) <<
                 "couldn't allocate " << (size * 2 / 1024) <<
                 " KiB of virtual address space for the command buffer";
 
-        slog.w << "Using 'soft' CircularBuffer (" << (size * 2 / 1024) << " KiB)" << io::endl;
+        slog.d << "WARNING: Using soft CircularBuffer (" << (size * 2 / 1024) << " KiB)"
+               << io::endl;
 
         // guard page at the end
         void* guard = (void*)(uintptr_t(data) + size * 2);

filament/backend/src/CommandBufferQueue.cpp

@@ -101,8 +101,9 @@ void CommandBufferQueue::flush() noexcept {
     size_t const used = std::distance(
             static_cast<char const*>(begin), static_cast<char const*>(end));
 
-
     std::unique_lock<utils::Mutex> lock(mLock);
+    mCommandBuffersToExecute.push_back({ begin, end });
+    mCondition.notify_one();
 
     // circular buffer is too small, we corrupted the stream
     FILAMENT_CHECK_POSTCONDITION(used <= mFreeSpace) <<
@@ -111,13 +112,11 @@ void CommandBufferQueue::flush() noexcept {
             "Space used at this time: " << used <<
             " bytes, overflow: " << used - mFreeSpace << " bytes";
 
-    mFreeSpace -= used;
-    mCommandBuffersToExecute.push_back({ begin, end });
-    mCondition.notify_one();
-
     // wait until there is enough space in the buffer
+    mFreeSpace -= used;
     if (UTILS_UNLIKELY(mFreeSpace < requiredSize)) {
 
+
 #ifndef NDEBUG
         size_t const totalUsed = circularBuffer.size() - mFreeSpace;
         slog.d << "CommandStream used too much space (will block): "
@@ -154,10 +153,8 @@ std::vector<CommandBufferQueue::Range> CommandBufferQueue::waitForCommands() con
 }
 
 void CommandBufferQueue::releaseBuffer(CommandBufferQueue::Range const& buffer) {
-    size_t const used = std::distance(
-            static_cast<char const*>(buffer.begin), static_cast<char const*>(buffer.end));
     std::lock_guard<utils::Mutex> const lock(mLock);
-    mFreeSpace += used;
+    mFreeSpace += uintptr_t(buffer.end) - uintptr_t(buffer.begin);
     mCondition.notify_one();
 }
 

filament/backend/src/HandleAllocator.cpp

@@ -80,9 +80,6 @@ HandleAllocator<P0, P1, P2>::HandleAllocator(const char* name, size_t size,
         bool disableUseAfterFreeCheck) noexcept
     : mHandleArena(name, size, disableUseAfterFreeCheck),
       mUseAfterFreeCheckDisabled(disableUseAfterFreeCheck) {
-    // Reserve initial space for debug tags. This prevents excessive calls to malloc when the first
-    // few tags are set.
-    mDebugTags.reserve(512);
 }
 
 template <size_t P0, size_t P1, size_t P2>

filament/backend/src/metal/MetalBuffer.h

@@ -204,15 +204,6 @@ 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;

filament/backend/src/metal/MetalBuffer.mm

@@ -27,16 +27,7 @@ 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) {
-    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;
-    }
-
+        size_t size, bool forceGpuBuffer) : mBufferSize(size), mContext(context) {
     // 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.
@@ -70,23 +61,34 @@ 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";
 
-    // If we have a cpu buffer, we can directly copy into it.
+    // Either copy into the Metal buffer or into our cpu buffer.
     if (mCpuBuffer) {
         memcpy(static_cast<uint8_t*>(mCpuBuffer) + byteOffset, src, size);
         return;
     }
 
-    switch (mUploadStrategy) {
-        case UploadStrategy::BUMP_ALLOCATOR:
-            uploadWithBumpAllocator(src, size, byteOffset);
-            break;
-        case UploadStrategy::POOL:
-            uploadWithPoolBuffer(src, size, byteOffset);
-            break;
-    }
+    // 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);
+    }];
 }
 
 void MetalBuffer::copyIntoBufferUnsynchronized(void* src, size_t size, size_t byteOffset) {
@@ -197,42 +199,5 @@ 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

filament/backend/src/metal/MetalBufferPool.h

@@ -38,28 +38,6 @@ 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:

filament/backend/src/metal/MetalBufferPool.mm

@@ -116,39 +116,5 @@ 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

filament/backend/src/metal/MetalContext.h

@@ -44,7 +44,6 @@ namespace backend {
 class MetalDriver;
 class MetalBlitter;
 class MetalBufferPool;
-class MetalBumpAllocator;
 class MetalRenderTarget;
 class MetalSamplerGroup;
 class MetalSwapChain;
@@ -93,7 +92,7 @@ struct MetalContext {
     } highestSupportedGpuFamily;
 
     struct {
-        bool staticTextureTargetError;
+        bool a8xStaticTextureTargetError;
     } bugs;
 
     // sampleCountLookup[requestedSamples] gives a <= sample count supported by the device.
@@ -142,7 +141,6 @@ struct MetalContext {
     utils::FixedCircularBuffer<Handle<HwTexture>> texturesToDestroy;
 
     MetalBufferPool* bufferPool;
-    MetalBumpAllocator* bumpAllocator;
 
     MetalSwapChain* currentDrawSwapChain = nil;
     MetalSwapChain* currentReadSwapChain = nil;

filament/backend/src/metal/MetalDriver.mm

@@ -53,14 +53,14 @@ Driver* MetalDriverFactory::create(MetalPlatform* const platform, const Platform
     //    MetalRenderPrimitive         :  24       many
     //    MetalVertexBuffer            :  32       moderate
     // -- less than or equal 32 bytes
+    //    MetalIndexBuffer             :  40       moderate
     //    MetalFence                   :  48       few
-    //    MetalIndexBuffer             :  56       moderate
-    //    MetalBufferObject            :  64       many
-    // -- less than or equal 64 bytes
+    //    MetalBufferObject            :  48       many
+    // -- less than or equal 48 bytes
     //    MetalSamplerGroup            : 112       few
     //    MetalProgram                 : 152       moderate
     //    MetalTexture                 : 152       moderate
-    //    MetalSwapChain               : 208       few
+    //    MetalSwapChain               : 184       few
     //    MetalRenderTarget            : 272       few
     //    MetalVertexBufferInfo        : 552       moderate
     // -- less than or equal to 552 bytes
@@ -162,10 +162,8 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
         sc[s] = [mContext->device supportsTextureSampleCount:s] ? s : sc[s - 1];
     }
 
-    mContext->bugs.staticTextureTargetError =
-            [mContext->device.name containsString:@"Apple A8X GPU"] ||
-            [mContext->device.name containsString:@"Apple A8 GPU"] ||
-            [mContext->device.name containsString:@"Apple A7 GPU"];
+    mContext->bugs.a8xStaticTextureTargetError =
+            [mContext->device.name containsString:@"Apple A8X GPU"];
 
     mContext->commandQueue = mPlatform.createCommandQueue(mContext->device);
     mContext->pipelineStateCache.setDevice(mContext->device);
@@ -173,8 +171,6 @@ 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, *)) {
@@ -213,7 +209,6 @@ MetalDriver::~MetalDriver() noexcept {
     mContext->emptyTexture = nil;
     CFRelease(mContext->textureCache);
     delete mContext->bufferPool;
-    delete mContext->bumpAllocator;
     delete mContext->blitter;
     delete mContext->timerQueryImpl;
     delete mContext->shaderCompiler;
@@ -842,8 +837,8 @@ bool MetalDriver::isWorkaroundNeeded(Workaround workaround) {
             return true;
         case Workaround::ADRENO_UNIFORM_ARRAY_CRASH:
             return false;
-        case Workaround::METAL_STATIC_TEXTURE_TARGET_ERROR:
-            return mContext->bugs.staticTextureTargetError;
+        case Workaround::A8X_STATIC_TEXTURE_TARGET_ERROR:
+            return mContext->bugs.a8xStaticTextureTargetError;
         case Workaround::DISABLE_BLIT_INTO_TEXTURE_ARRAY:
             return false;
         default:
@@ -2061,10 +2056,6 @@ void MetalDriver::enumerateBoundBuffers(BufferObjectBinding bindingType,
 void MetalDriver::resetState(int) {
 }
 
-void MetalDriver::setDebugTag(HandleBase::HandleId handleId, utils::CString tag) {
-    mHandleAllocator.associateTagToHandle(handleId, std::move(tag));
-}
-
 void MetalDriver::runAtNextTick(const std::function<void()>& fn) noexcept {
     std::lock_guard<std::mutex> const lock(mTickOpsLock);
     mTickOps.push_back(fn);

filament/backend/src/metal/MetalHandles.h

@@ -109,7 +109,7 @@ private:
     NSUInteger headlessWidth = 0;
     NSUInteger headlessHeight = 0;
     CAMetalLayer* layer = nullptr;
-    std::shared_ptr<std::mutex> layerDrawableMutex;
+    std::mutex layerDrawableMutex;
     MetalExternalImage externalImage;
     SwapChainType type;
 

filament/backend/src/metal/MetalHandles.mm

@@ -73,7 +73,6 @@ MetalSwapChain::MetalSwapChain(MetalContext& context, CAMetalLayer* nativeWindow
     : context(context),
       depthStencilFormat(decideDepthStencilFormat(flags)),
       layer(nativeWindow),
-      layerDrawableMutex(std::make_shared<std::mutex>()),
       externalImage(context),
       type(SwapChainType::CAMETALLAYER) {
 
@@ -180,7 +179,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];
     }
 
@@ -189,10 +188,8 @@ id<MTLTexture> MetalSwapChain::acquireDrawable() {
 }
 
 void MetalSwapChain::releaseDrawable() {
-    if (drawable) {
-        std::lock_guard<std::mutex> lock(*layerDrawableMutex);
-        drawable = nil;
-    }
+    std::lock_guard<std::mutex> lock(layerDrawableMutex);
+    drawable = nil;
 }
 
 id<MTLTexture> MetalSwapChain::acquireDepthTexture() {
@@ -268,7 +265,7 @@ public:
     PresentDrawableData& operator=(const PresentDrawableData&) = delete;
 
     static PresentDrawableData* create(id<CAMetalDrawable> drawable,
-            std::shared_ptr<std::mutex> drawableMutex, MetalDriver* driver) {
+            std::mutex* drawableMutex, MetalDriver* driver) {
         assert_invariant(drawableMutex);
         assert_invariant(driver);
         return new PresentDrawableData(drawable, drawableMutex, driver);
@@ -290,22 +287,22 @@ public:
     }
 
 private:
-    PresentDrawableData(id<CAMetalDrawable> drawable, std::shared_ptr<std::mutex> drawableMutex,
+    PresentDrawableData(id<CAMetalDrawable> drawable, 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.reset();
+        that->mDrawableMutex = nullptr;
         that->mDriver = nullptr;
         delete that;
     }
 
     id<CAMetalDrawable> mDrawable;
-    std::shared_ptr<std::mutex> mDrawableMutex;
+    std::mutex* mDrawableMutex = nullptr;
     MetalDriver* mDriver = nullptr;
 };
 
@@ -323,7 +320,7 @@ void MetalSwapChain::scheduleFrameScheduledCallback() {
 
     struct Callback {
         Callback(std::shared_ptr<FrameScheduledCallback> callback, id<CAMetalDrawable> drawable,
-                 std::shared_ptr<std::mutex> drawableMutex, MetalDriver* driver)
+                std::mutex* drawableMutex, MetalDriver* driver)
             : f(callback), data(PresentDrawableData::create(drawable, drawableMutex, driver)) {}
         std::shared_ptr<FrameScheduledCallback> f;
         // PresentDrawableData* is destroyed by maybePresentAndDestroyAsync() later.
@@ -340,7 +337,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;
@@ -556,6 +553,8 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
             descriptor.usage = getMetalTextureUsage(usage);
             descriptor.storageMode = MTLStorageModePrivate;
             texture = [context.device newTextureWithDescriptor:descriptor];
+            FILAMENT_CHECK_POSTCONDITION(texture != nil)
+                    << "Could not create Metal texture. Out of memory?";
             break;
         case SamplerType::SAMPLER_CUBEMAP:
         case SamplerType::SAMPLER_CUBEMAP_ARRAY:
@@ -570,6 +569,8 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
             descriptor.usage = getMetalTextureUsage(usage);
             descriptor.storageMode = MTLStorageModePrivate;
             texture = [context.device newTextureWithDescriptor:descriptor];
+            FILAMENT_CHECK_POSTCONDITION(texture != nil)
+                    << "Could not create Metal texture. Out of memory?";
             break;
         case SamplerType::SAMPLER_3D:
             descriptor = [MTLTextureDescriptor new];
@@ -582,6 +583,8 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
             descriptor.usage = getMetalTextureUsage(usage);
             descriptor.storageMode = MTLStorageModePrivate;
             texture = [context.device newTextureWithDescriptor:descriptor];
+            FILAMENT_CHECK_POSTCONDITION(texture != nil)
+                    << "Could not create Metal texture. Out of memory?";
             break;
         case SamplerType::SAMPLER_EXTERNAL:
             // If we're using external textures (CVPixelBufferRefs), we don't need to make any
@@ -590,12 +593,6 @@ MetalTexture::MetalTexture(MetalContext& context, SamplerType target, uint8_t le
             break;
     }
 
-    FILAMENT_CHECK_POSTCONDITION(target == SamplerType::SAMPLER_EXTERNAL || texture != nil)
-            << "Could not create Metal texture (SamplerType = " << int(target)
-            << ", levels = " << int(levels) << ", MTLPixelFormat = " << int(devicePixelFormat)
-            << ", width = " << width << ", height = " << height << ", depth = " << depth
-            << "). Out of memory?";
-
     // If swizzling is set, set up a swizzled texture view that we'll use when sampling this texture.
     const bool isDefaultSwizzle =
             r == TextureSwizzle::CHANNEL_0 &&

filament/backend/src/noop/NoopDriver.cpp

@@ -388,7 +388,4 @@ void NoopDriver::endTimerQuery(Handle<HwTimerQuery> tqh) {
 void NoopDriver::resetState(int) {
 }
 
-void NoopDriver::setDebugTag(HandleBase::HandleId handleId, utils::CString tag) {
-}
-
 } // namespace filament

filament/backend/src/opengl/OpenGLContext.cpp

@@ -1044,11 +1044,6 @@ void OpenGLContext::resetState() noexcept {
     );
     glDepthMask(state.raster.depthMask);
     glDepthFunc(state.raster.depthFunc);
-
-    utils::slog.e << "stencil front=" << 
-        state.stencil.front.func.func << " "  <<
-        state.stencil.front.func.ref << " "  <<
-        state.stencil.front.func.mask << " " << utils::io::endl;
     
     // state.stencil
     glStencilFuncSeparate(

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -83,20 +83,12 @@
 #define HAS_MAPBUFFERS 1
 #endif
 
-#define DEBUG_GROUP_MARKER_NONE       0x00    // no debug marker
-#define DEBUG_GROUP_MARKER_OPENGL     0x01    // markers in the gl command queue (req. driver support)
-#define DEBUG_GROUP_MARKER_BACKEND    0x02    // markers on the backend side (systrace)
-#define DEBUG_GROUP_MARKER_ALL        0x03    // all markers
+#define DEBUG_MARKER_NONE       0x00    // no debug marker
+#define DEBUG_MARKER_OPENGL     0x01    // markers in the gl command queue (req. driver support)
+#define DEBUG_MARKER_BACKEND    0x02    // markers on the backend side (systrace)
+#define DEBUG_MARKER_ALL        0x03    // all markers
 
-#define DEBUG_MARKER_NONE             0x00    // no debug marker
-#define DEBUG_MARKER_OPENGL           0x01    // markers in the gl command queue (req. driver support)
-#define DEBUG_MARKER_BACKEND          0x02    // markers on the backend side (systrace)
-#define DEBUG_MARKER_ALL              0x03    // all markers
-
-// set to the desired debug marker level (for user markers [default: All])
-#define DEBUG_GROUP_MARKER_LEVEL      DEBUG_GROUP_MARKER_ALL
-
-// set to the desired debug level (for internal debugging [Default: None])
+// set to the desired debug marker level
 #define DEBUG_MARKER_LEVEL      DEBUG_MARKER_NONE
 
 #if DEBUG_MARKER_LEVEL > DEBUG_MARKER_NONE
@@ -204,37 +196,11 @@ Driver* OpenGLDriver::create(OpenGLPlatform* const platform,
 
 OpenGLDriver::DebugMarker::DebugMarker(OpenGLDriver& driver, const char* string) noexcept
         : driver(driver) {
-#ifndef __EMSCRIPTEN__
-#ifdef GL_EXT_debug_marker
-#if DEBUG_MARKER_LEVEL & DEBUG_MARKER_OPENGL
-    if (UTILS_LIKELY(driver.getContext().ext.EXT_debug_marker)) {
-        glPushGroupMarkerEXT(GLsizei(strlen(string)), string);
-    }
-#endif
-#endif
-
-#if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
-    SYSTRACE_CONTEXT();
-    SYSTRACE_NAME_BEGIN(string);
-#endif
-#endif
+    driver.pushGroupMarker(string, strlen(string));
 }
 
 OpenGLDriver::DebugMarker::~DebugMarker() noexcept {
-#ifndef __EMSCRIPTEN__
-#ifdef GL_EXT_debug_marker
-#if DEBUG_MARKER_LEVEL & DEBUG_MARKER_OPENGL
-    if (UTILS_LIKELY(driver.getContext().ext.EXT_debug_marker)) {
-        glPopGroupMarkerEXT();
-    }
-#endif
-#endif
-
-#if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
-    SYSTRACE_CONTEXT();
-    SYSTRACE_NAME_END();
-#endif
-#endif
+    driver.popGroupMarker();
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -338,13 +304,6 @@ 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;
@@ -381,11 +340,15 @@ void OpenGLDriver::bindTexture(GLuint unit, GLTexture const* t) noexcept {
 }
 
 bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
-    // set-up textures and samplers in the proper TMUs (as specified in setSamplers)
-    bool const success = p->use(this, mContext);
-    assert_invariant(success == p->isValid());
+    if (UTILS_UNLIKELY(!p->isValid())) {
+        // If the program is not valid, we can't call use().
+        return false;
+    }
 
-    if (UTILS_UNLIKELY(mContext.isES2() && success)) {
+    // set-up textures and samplers in the proper TMUs (as specified in setSamplers)
+    p->use(this, mContext);
+
+    if (UTILS_UNLIKELY(mContext.isES2())) {
         for (uint32_t i = 0; i < Program::UNIFORM_BINDING_COUNT; i++) {
             auto [id, buffer, age] = mContext.getEs2UniformBinding(i);
             if (buffer) {
@@ -396,8 +359,7 @@ bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
         // when mPlatform.isSRGBSwapChainSupported() is false (no need to check though).
         p->setRec709ColorSpace(mRec709OutputColorspace);
     }
-
-    return success;
+    return true;
 }
 
 
@@ -460,20 +422,20 @@ void OpenGLDriver::setStencilState(StencilState ss) noexcept {
 
     // stencil test / operation
     // GL_STENCIL_TEST must be enabled if we're testing OR writing to the stencil buffer.
-    // if (UTILS_LIKELY(
-    //         ss.front.stencilFunc == StencilState::StencilFunction::A &&
-    //         ss.back.stencilFunc == StencilState::StencilFunction::A &&
-    //         ss.front.stencilOpDepthFail == StencilOperation::KEEP &&
-    //         ss.back.stencilOpDepthFail == StencilOperation::KEEP &&
-    //         ss.front.stencilOpStencilFail == StencilOperation::KEEP &&
-    //         ss.back.stencilOpStencilFail == StencilOperation::KEEP &&
-    //         ss.front.stencilOpDepthStencilPass == StencilOperation::KEEP &&
-    //         ss.back.stencilOpDepthStencilPass == StencilOperation::KEEP) && false) {
-    //     // that's equivalent to having the stencil test disabled
-    //     gl.disable(GL_STENCIL_TEST);
-    // } else {
+    if (UTILS_LIKELY(
+            ss.front.stencilFunc == StencilState::StencilFunction::A &&
+            ss.back.stencilFunc == StencilState::StencilFunction::A &&
+            ss.front.stencilOpDepthFail == StencilOperation::KEEP &&
+            ss.back.stencilOpDepthFail == StencilOperation::KEEP &&
+            ss.front.stencilOpStencilFail == StencilOperation::KEEP &&
+            ss.back.stencilOpStencilFail == StencilOperation::KEEP &&
+            ss.front.stencilOpDepthStencilPass == StencilOperation::KEEP &&
+            ss.back.stencilOpDepthStencilPass == StencilOperation::KEEP)) {
+        // that's equivalent to having the stencil test disabled
+        gl.disable(GL_STENCIL_TEST);
+    } else {
         gl.enable(GL_STENCIL_TEST);
-//    }
+    }
 
     // glStencilFuncSeparate() also sets the reference value, which may be used depending
     // on the stencilOp, so we always need to call glStencilFuncSeparate().
@@ -481,9 +443,9 @@ void OpenGLDriver::setStencilState(StencilState ss) noexcept {
             getStencilFunc(ss.front.stencilFunc), ss.front.ref, ss.front.readMask,
             getStencilFunc(ss.back.stencilFunc), ss.back.ref, ss.back.readMask);
 
-//    if (UTILS_LIKELY(!ss.stencilWrite)) {
-//        gl.stencilMaskSeparate(0x00, 0x00);
-//    } else {
+    if (UTILS_LIKELY(!ss.stencilWrite)) {
+        gl.stencilMaskSeparate(0x00, 0x00);
+    } else {
         // Stencil ops are only relevant when stencil write is enabled
         gl.stencilOpSeparate(
                 getStencilOp(ss.front.stencilOpStencilFail),
@@ -493,7 +455,7 @@ void OpenGLDriver::setStencilState(StencilState ss) noexcept {
                 getStencilOp(ss.back.stencilOpDepthFail),
                 getStencilOp(ss.back.stencilOpDepthStencilPass));
         gl.stencilMaskSeparate(ss.front.writeMask, ss.back.writeMask);
-//    }
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -2210,10 +2172,6 @@ void OpenGLDriver::makeCurrent(Handle<HwSwapChain> schDraw, Handle<HwSwapChain>
 // Updating driver objects
 // ------------------------------------------------------------------------------------------------
 
-void OpenGLDriver::setDebugTag(HandleBase::HandleId handleId, utils::CString tag) {
-    mHandleAllocator.associateTagToHandle(handleId, std::move(tag));
-}
-
 void OpenGLDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh,
         uint32_t index, Handle<HwBufferObject> boh) {
    DEBUG_MARKER()
@@ -2374,20 +2332,11 @@ 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;
-        Handle<HwTexture> th = pSamplers[i].t;
-        if (UTILS_LIKELY(th)) {
-            GLTexture const* const t = handle_cast<const GLTexture*>(th);
+        const GLTexture* t = nullptr;
+        if (UTILS_LIKELY(pSamplers[i].t)) {
+            t = handle_cast<const GLTexture*>(pSamplers[i].t);
             assert_invariant(t);
 
-            if (UTILS_UNLIKELY(es2)
-#if defined(GL_EXT_texture_filter_anisotropic)
-                    || UTILS_UNLIKELY(anisotropyWorkaround)
- #endif
-                    ) {
-                // We must set texture parameters on the texture itself.
-                bindTexture(OpenGLContext::DUMMY_TEXTURE_BINDING, t);
-            }
-
             SamplerParams params = pSamplers[i].s;
             if (UTILS_UNLIKELY(t->target == SamplerType::SAMPLER_EXTERNAL)) {
                 // From OES_EGL_image_external spec:
@@ -2441,7 +2390,7 @@ void OpenGLDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh,
             // which is not an error.
         }
 
-        sb->textureUnitEntries[i] = { th, samplerId };
+        sb->textureUnitEntries[i] = { t, samplerId };
     }
     scheduleDestroy(std::move(data));
 }
@@ -3198,14 +3147,14 @@ void OpenGLDriver::insertEventMarker(char const* string, uint32_t len) {
 void OpenGLDriver::pushGroupMarker(char const* string, uint32_t len) {
 #ifndef __EMSCRIPTEN__
 #ifdef GL_EXT_debug_marker
-#if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_OPENGL
+#if DEBUG_MARKER_LEVEL & DEBUG_MARKER_OPENGL
     if (UTILS_LIKELY(mContext.ext.EXT_debug_marker)) {
         glPushGroupMarkerEXT(GLsizei(len ? len : strlen(string)), string);
     }
 #endif
 #endif
 
-#if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_BACKEND
+#if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
     SYSTRACE_CONTEXT();
     SYSTRACE_NAME_BEGIN(string);
 #endif
@@ -3215,14 +3164,14 @@ void OpenGLDriver::pushGroupMarker(char const* string, uint32_t len) {
 void OpenGLDriver::popGroupMarker(int) {
 #ifndef __EMSCRIPTEN__
 #ifdef GL_EXT_debug_marker
-#if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_OPENGL
+#if DEBUG_MARKER_LEVEL & DEBUG_MARKER_OPENGL
     if (UTILS_LIKELY(mContext.ext.EXT_debug_marker)) {
         glPopGroupMarkerEXT();
     }
 #endif
 #endif
 
-#if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_BACKEND
+#if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
     SYSTRACE_CONTEXT();
     SYSTRACE_NAME_END();
 #endif
@@ -3928,7 +3877,6 @@ void OpenGLDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
 }
 
 void OpenGLDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-    DEBUG_MARKER()
     GLRenderPrimitive const* const rp = mBoundRenderPrimitive;
     if (UTILS_UNLIKELY(!rp || !mValidProgram)) {
         return;
@@ -3950,7 +3898,6 @@ void OpenGLDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t ins
 }
 
 void OpenGLDriver::draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-    DEBUG_MARKER()
     GLRenderPrimitive const* const rp = mBoundRenderPrimitive;
     if (UTILS_UNLIKELY(!rp || !mValidProgram)) {
         return;
@@ -3971,7 +3918,6 @@ void OpenGLDriver::draw2GLES2(uint32_t indexOffset, uint32_t indexCount, uint32_
 }
 
 void OpenGLDriver::scissor(Viewport scissor) {
-    DEBUG_MARKER()
     setScissor(scissor);
 }
 
@@ -3991,7 +3937,6 @@ void OpenGLDriver::draw(PipelineState state, Handle<HwRenderPrimitive> rph,
 }
 
 void OpenGLDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGroupCount) {
-    DEBUG_MARKER()
     getShaderCompilerService().tick();
 
     OpenGLProgram* const p = handle_cast<OpenGLProgram*>(program);

filament/backend/src/opengl/OpenGLDriver.h

@@ -81,7 +81,7 @@ public:
             const Platform::DriverConfig& driverConfig) noexcept;
 
     class DebugMarker {
-        UTILS_UNUSED OpenGLDriver& driver;
+        OpenGLDriver& driver;
     public:
         DebugMarker(OpenGLDriver& driver, const char* string) noexcept;
         ~DebugMarker() noexcept;
@@ -126,7 +126,7 @@ public:
     struct GLSamplerGroup : public HwSamplerGroup {
         using HwSamplerGroup::HwSamplerGroup;
         struct Entry {
-            Handle<HwTexture> th;
+            GLTexture const* texture = nullptr;
             GLuint sampler = 0u;
         };
         utils::FixedCapacityVector<Entry> textureUnitEntries;
@@ -256,11 +256,6 @@ 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> &&

filament/backend/src/opengl/OpenGLProgram.cpp

@@ -20,24 +20,21 @@
 #include "OpenGLDriver.h"
 #include "ShaderCompilerService.h"
 
-#include <backend/DriverEnums.h>
 #include <backend/Program.h>
-#include <backend/Handle.h>
 
-#include <utils/compiler.h>
+#include <private/backend/BackendUtils.h>
+
 #include <utils/debug.h>
-#include <utils/FixedCapacityVector.h>
+#include <utils/compiler.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 {
 
@@ -244,9 +241,8 @@ 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
-            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);
+            const GLTexture* const t = sb->textureUnitEntries[j].texture;
+            if (t) { // program may not use all samplers of sampler group
                 gld->bindTexture(tmu, t);
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
                 if (UTILS_LIKELY(!es2)) {

filament/backend/src/opengl/OpenGLProgram.h

@@ -53,19 +53,9 @@ public:
 
     bool isValid() const noexcept { return mToken || gl.program != 0; }
 
-    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);
-        }
-
+    void use(OpenGLDriver* const gld, OpenGLContext& context) noexcept {
         if (UTILS_UNLIKELY(!gl.program)) {
-            // compilation failed (token should be null)
-            assert_invariant(!mToken);
-            return false;
+            initialize(*gld);
         }
 
         context.useProgram(gl.program);
@@ -84,7 +74,6 @@ public:
 
             updateSamplers(gld);
         }
-        return true;
     }
 
     // For ES2 only

filament/backend/src/opengl/OpenGLTimerQuery.cpp

@@ -143,25 +143,21 @@ void TimerQueryNativeFactory::endTimeElapsedQuery(OpenGLDriver& driver, GLTimerQ
 
     driver.runEveryNowAndThen([&context = mContext, weak]() -> bool {
         auto state = weak.lock();
-        if (!state) {
-            // The timer query state has been destroyed on the way, very likely due to the IBL
-            // prefilter context destruction. We still return true to get this element removed from
-            // the query list.
-            return true;
+        if (state) {
+            GLuint available = 0;
+            context.procs.getQueryObjectuiv(state->gl.query, GL_QUERY_RESULT_AVAILABLE, &available);
+            CHECK_GL_ERROR(utils::slog.e)
+            if (!available) {
+                // we need to try this one again later
+                return false;
+            }
+            GLuint64 elapsedTime = 0;
+            // we won't end-up here if we're on ES and don't have GL_EXT_disjoint_timer_query
+            context.procs.getQueryObjectui64v(state->gl.query, GL_QUERY_RESULT, &elapsedTime);
+            state->elapsed.store((int64_t)elapsedTime, std::memory_order_relaxed);
+        } else {
+            state->elapsed.store(int64_t(TimerQueryResult::ERROR), std::memory_order_relaxed);
         }
-
-        GLuint available = 0;
-        context.procs.getQueryObjectuiv(state->gl.query, GL_QUERY_RESULT_AVAILABLE, &available);
-        CHECK_GL_ERROR(utils::slog.e)
-        if (!available) {
-            // we need to try this one again later
-            return false;
-        }
-        GLuint64 elapsedTime = 0;
-        // we won't end-up here if we're on ES and don't have GL_EXT_disjoint_timer_query
-        context.procs.getQueryObjectui64v(state->gl.query, GL_QUERY_RESULT, &elapsedTime);
-        state->elapsed.store((int64_t)elapsedTime, std::memory_order_relaxed);
-
         return true;
     });
 }

filament/backend/src/opengl/ShaderCompilerService.cpp

@@ -26,28 +26,16 @@
 
 #include <utils/compiler.h>
 #include <utils/CString.h>
-#include <utils/debug.h>
-#include <utils/FixedCapacityVector.h>
 #include <utils/JobSystem.h>
 #include <utils/Log.h>
-#include <utils/ostream.h>
-#include <utils/Panic.h>
 #include <utils/Systrace.h>
 
-#include <array>
 #include <cctype>
 #include <chrono>
-#include <mutex>
-#include <memory>
 #include <string>
 #include <string_view>
-#include <thread>
-#include <utility>
 #include <variant>
 
-#include <stddef.h>
-#include <stdint.h>
-
 namespace filament::backend {
 
 using namespace utils;
@@ -371,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);
-#if !FILAMENT_ENABLE_MATDBG
+#ifndef FILAMENT_ENABLE_MATDBG
     assert_invariant(program);
 #endif
     return program;
@@ -488,12 +476,6 @@ GLuint ShaderCompilerService::initialize(program_token_t& token) noexcept {
     // check status of program linking and shader compilation, logs error and free all resources
     // in case of error.
     bool const success = checkProgramStatus(token);
-
-    // Unless we have matdbg, we panic if a program is invalid. Otherwise, we'd get a UB.
-    // The compilation error has been logged to log.e by this point.
-    FILAMENT_CHECK_POSTCONDITION(FILAMENT_ENABLE_MATDBG || success)
-            << "OpenGL program " << token->name.c_str_safe() << " failed to link or compile";
-
     if (UTILS_LIKELY(success)) {
         program = token->gl.program;
         // no need to keep the shaders around
@@ -590,38 +572,24 @@ void ShaderCompilerService::compileShaders(OpenGLContext& context,
 
             // split shader source, so we can insert the specialization constants and the packing
             // functions
-            auto [version, prolog, body] = splitShaderSource({ shader_src, shader_len });
+            auto const [prolog, body] = splitShaderSource({ shader_src, shader_len });
 
-            // enable ESSL 3.10 if available
-            if (context.isAtLeastGLES<3, 1>()) {
-                version = "#version 310 es\n";
-            }
-
-            std::array<std::string_view, 5> sources = {
-                version,
-                prolog,
-                specializationConstantString,
-                packingFunctions,
-                { body.data(), body.size() - 1 }  // null-terminated
+            const std::array<const char*, 4> sources = {
+                    prolog.data(),
+                    specializationConstantString.c_str(),
+                    packingFunctions.data(),
+                    body.data()
             };
 
-            // Some of the sources may be zero-length. Remove them as to avoid passing lengths of
-            // zero to glShaderSource(). glShaderSource should work with lengths of zero, but some
-            // drivers instead interpret zero as a sentinel for a null-terminated string.
-            auto partitionPoint = std::stable_partition(
-                    sources.begin(), sources.end(), [](std::string_view s) { return !s.empty(); });
-            size_t count = std::distance(sources.begin(), partitionPoint);
-
-            std::array<const char*, 5> shaderStrings;
-            std::array<GLint, 5> lengths;
-            for (size_t i = 0; i < count; i++) {
-                shaderStrings[i] = sources[i].data();
-                lengths[i] = sources[i].size();
-            }
+            const std::array<GLint, 4> lengths = {
+                    (GLint)prolog.length(),
+                    (GLint)specializationConstantString.length(),
+                    (GLint)packingFunctions.length(),
+                    (GLint)body.length() - 1 // null terminated
+            };
 
             GLuint const shaderId = glCreateShader(glShaderType);
-            glShaderSource(shaderId, count, shaderStrings.data(), lengths.data());
-
+            glShaderSource(shaderId, sources.size(), sources.data(), lengths.data());
             glCompileShader(shaderId);
 
 #ifndef NDEBUG
@@ -693,7 +661,6 @@ 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
@@ -733,102 +700,31 @@ 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 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);
+// 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);
 
-    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;
+    auto pos = source.rfind("\n#extension");
+    if (pos == std::string_view::npos) {
+        pos = start;
     } else {
-        prolog_eol = source.find('\n', prolog_eol + 1) + 1;
+        ++pos;
     }
-    auto body_start = prolog_eol;
 
-    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 };
+    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 };
 }
 
 /*

filament/backend/src/opengl/ShaderCompilerService.h

@@ -146,7 +146,7 @@ private:
 
     static std::string_view process_ARB_shading_language_packing(OpenGLContext& context) noexcept;
 
-    static std::array<std::string_view, 3> splitShaderSource(std::string_view source) noexcept;
+    static std::array<std::string_view, 2> splitShaderSource(std::string_view source) noexcept;
 
     static GLuint linkProgram(OpenGLContext& context,
             std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders,

filament/backend/src/vulkan/VulkanBlitter.cpp

@@ -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)) {
-        FVK_LOGD << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
+        utils::slog.d << "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)) {
-        FVK_LOGD << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
+        utils::slog.d << "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;

filament/backend/src/vulkan/VulkanBuffer.cpp

@@ -28,7 +28,6 @@ VulkanBuffer::VulkanBuffer(VmaAllocator allocator, VulkanStagePool& stagePool,
     : mAllocator(allocator),
       mStagePool(stagePool),
       mUsage(usage),
-	  mUpdatedOffset(0),
       mUpdatedBytes(0) {
     // for now make sure that only 1 bit is set in usage
     // (because loadFromCpu() assumes that somewhat)
@@ -81,7 +80,6 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
             .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
             .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
             .buffer = mGpuBuffer,
-			.offset = mUpdatedOffset,
             .size = mUpdatedBytes,
         };
         vkCmdPipelineBarrier(cmdbuf, srcStage, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1,
@@ -95,7 +93,6 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
     };
     vkCmdCopyBuffer(cmdbuf, stage->buffer, mGpuBuffer, 1, &region);
 
-	mUpdatedOffset = byteOffset;
     mUpdatedBytes = numBytes;
 
     // Firstly, ensure that the copy finishes before the next draw call.

filament/backend/src/vulkan/VulkanBuffer.h

@@ -42,7 +42,6 @@ private:
     VmaAllocation mGpuMemory = VK_NULL_HANDLE;
     VkBuffer mGpuBuffer = VK_NULL_HANDLE;
     VkBufferUsageFlags mUsage = {};
-	uint32_t mUpdatedOffset = 0;
     uint32_t mUpdatedBytes = 0;
 };
 

filament/backend/src/vulkan/VulkanCommands.cpp

@@ -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)
-        FVK_LOGI << "VulkanCommands has stalled. "
+        slog.i << "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)
-    FVK_LOGI << "Submitting cmdbuffer=" << cmdbuffer
+    slog.i << "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) {
-        FVK_LOGD << "Failed command buffer submission result: " << result << utils::io::endl;
+        utils::slog.d << "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)
-    FVK_LOGI << "Acquiring " << semaphore << " (e.g. for vkQueuePresentKHR)" << io::endl;
+    slog.i << "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)
-    FVK_LOGI << "Injecting " << next << " (e.g. due to vkAcquireNextImageKHR)" << io::endl;
+    slog.i << "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) {
-        FVK_LOGD << "----> " << str << utils::io::endl;
+        utils::slog.d << "----> " << 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;
-        FVK_LOGD << "<---- " << marker << " elapsed: " << (diff.count() * 1000) << " ms"
+        utils::slog.d << "<---- " << marker << " elapsed: " << (diff.count() * 1000) << " ms"
                       << utils::io::endl;
 #else
         mGroupMarkers->pop();

filament/backend/src/vulkan/VulkanConstants.h

@@ -17,8 +17,6 @@
 #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.
@@ -72,11 +70,6 @@
 // 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     \
@@ -140,18 +133,6 @@ 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;

filament/backend/src/vulkan/VulkanContext.cpp

@@ -59,11 +59,7 @@ VkExtent2D VulkanAttachment::getExtent2D() const {
 
 VkImageView VulkanAttachment::getImageView() {
     assert_invariant(texture);
-    VkImageSubresourceRange range = getSubresourceRange();
-    if (range.layerCount > 1) {
-        return texture->getMultiviewAttachmentView(range);
-    }
-    return texture->getAttachmentView(range);
+    return texture->getAttachmentView(getSubresourceRange());
 }
 
 bool VulkanAttachment::isDepth() const {
@@ -77,7 +73,7 @@ VkImageSubresourceRange VulkanAttachment::getSubresourceRange() const {
             .baseMipLevel = uint32_t(level),
             .levelCount = 1,
             .baseArrayLayer = uint32_t(layer),
-            .layerCount = layerCount,
+            .layerCount = 1,
     };
 }
 
@@ -104,7 +100,7 @@ std::tuple<uint32_t, uint32_t> VulkanTimestamps::getNextQuery() {
 	    return std::make_tuple(timerIndex * 2, timerIndex * 2 + 1);
         }
     }
-    FVK_LOGE << "More than " << maxTimers << " timers are not supported." << utils::io::endl;
+    utils::slog.e << "More than " << maxTimers << " timers are not supported." << utils::io::endl;
     return std::make_tuple(0, 1);
 }
 

filament/backend/src/vulkan/VulkanContext.h

@@ -43,8 +43,6 @@ struct VulkanCommandBuffer;
 struct VulkanAttachment {
     VulkanTexture* texture = nullptr;
     uint8_t level = 0;
-    uint8_t baseViewIndex = 0;
-    uint8_t layerCount = 1;
     uint16_t layer = 0;
 
     bool isDepth() const;
@@ -133,10 +131,6 @@ public:
         return mDebugUtilsSupported;
     }
 
-    inline bool isMultiviewEnabled() const noexcept {
-        return mMultiviewEnabled;
-    }
-
     inline bool isClipDistanceSupported() const noexcept {
         return mPhysicalDeviceFeatures.shaderClipDistance == VK_TRUE;
     }
@@ -147,7 +141,6 @@ private:
     VkPhysicalDeviceFeatures mPhysicalDeviceFeatures = {};
     bool mDebugMarkersSupported = false;
     bool mDebugUtilsSupported = false;
-    bool mMultiviewEnabled = false;
 
     VkFormatList mDepthStencilFormats;
     VkFormatList mBlittableDepthStencilFormats;

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -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) {
-        FVK_LOGE << "VULKAN ERROR: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
+        utils::slog.e << "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;
         }
-        FVK_LOGW << "VULKAN WARNING: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
+        utils::slog.w << "VULKAN WARNING: (" << pLayerPrefix << ") " << pMessage << utils::io::endl;
     }
-    FVK_LOGE << utils::io::endl;
+    utils::slog.e << 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) {
-        FVK_LOGE << "VULKAN ERROR: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
-                 << utils::io::endl;
+        utils::slog.e << "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;
         }
-        FVK_LOGW << "VULKAN WARNING: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
-                 << utils::io::endl;
+        utils::slog.w << "VULKAN WARNING: (" << cbdata->pMessageIdName << ") " << cbdata->pMessage
+                      << utils::io::endl;
     }
-    FVK_LOGE << utils::io::endl;
+    utils::slog.e << 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
 
-    FVK_LOGD
+    utils::slog.d
            << "\nVulkanSwapChain: " << sizeof(VulkanSwapChain)
            << "\nVulkanBufferObject: " << sizeof(VulkanBufferObject)
            << "\nVulkanVertexBuffer: " << sizeof(VulkanVertexBuffer)
@@ -595,8 +595,6 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
             colorTargets[i] = {
                 .texture = mResourceAllocator.handle_cast<VulkanTexture*>(color[i].handle),
                 .level = color[i].level,
-                .baseViewIndex = color[i].baseViewIndex,
-                .layerCount = layerCount,
                 .layer = color[i].layer,
             };
             UTILS_UNUSED_IN_RELEASE VkExtent2D extent = colorTargets[i].getExtent2D();
@@ -611,8 +609,6 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
         depthStencil[0] = {
             .texture = mResourceAllocator.handle_cast<VulkanTexture*>(depth.handle),
             .level = depth.level,
-            .baseViewIndex = depth.baseViewIndex,
-            .layerCount = layerCount,
             .layer = depth.layer,
         };
         UTILS_UNUSED_IN_RELEASE VkExtent2D extent = depthStencil[0].getExtent2D();
@@ -625,8 +621,6 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
         depthStencil[1] = {
             .texture = mResourceAllocator.handle_cast<VulkanTexture*>(stencil.handle),
             .level = stencil.level,
-            .baseViewIndex = stencil.baseViewIndex,
-            .layerCount = layerCount,
             .layer = stencil.layer,
         };
         UTILS_UNUSED_IN_RELEASE VkExtent2D extent = depthStencil[1].getExtent2D();
@@ -643,7 +637,7 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
 
     auto renderTarget = mResourceAllocator.construct<VulkanRenderTarget>(rth, mPlatform->getDevice(),
             mPlatform->getPhysicalDevice(), mContext, mAllocator, &mCommands, width, height,
-            samples, colorTargets, depthStencil, mStagePool, layerCount);
+            samples, colorTargets, depthStencil, mStagePool);
     mResourceManager.acquire(renderTarget);
 }
 
@@ -666,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()) {
-        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
-                 << utils::io::endl;
+        utils::slog.w << "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,
@@ -678,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()) {
-        FVK_LOGW << "sRGB swapchain requested, but Platform does not support it"
+        utils::slog.w << "sRGB swapchain requested, but Platform does not support it"
                       << utils::io::endl;
         flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
     }
@@ -920,7 +914,7 @@ bool VulkanDriver::isStereoSupported() {
         case backend::StereoscopicType::INSTANCED:
             return mContext.isClipDistanceSupported();
         case backend::StereoscopicType::MULTIVIEW:
-            return mContext.isMultiviewEnabled();
+            // TODO: implement multiview feature in Vulkan.
         case backend::StereoscopicType::NONE:
             return false;
     }
@@ -992,15 +986,15 @@ FeatureLevel VulkanDriver::getFeatureLevel() {
 
     // If the max sampler counts do not meet FL2 standards, then this is an FL1 device.
     const auto& fl2 = FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_2];
-    if (limits.maxPerStageDescriptorSamplers < fl2.MAX_VERTEX_SAMPLER_COUNT  ||
-        limits.maxPerStageDescriptorSamplers < fl2.MAX_FRAGMENT_SAMPLER_COUNT) {
+    if (fl2.MAX_VERTEX_SAMPLER_COUNT < limits.maxPerStageDescriptorSamplers ||
+        fl2.MAX_FRAGMENT_SAMPLER_COUNT < limits.maxPerStageDescriptorSamplers) {
         return FeatureLevel::FEATURE_LEVEL_1;
     }
 
     // If the max sampler counts do not meet FL3 standards, then this is an FL2 device.
     const auto& fl3 = FEATURE_LEVEL_CAPS[+FeatureLevel::FEATURE_LEVEL_3];
-    if (limits.maxPerStageDescriptorSamplers < fl3.MAX_VERTEX_SAMPLER_COUNT||
-        limits.maxPerStageDescriptorSamplers < fl3.MAX_FRAGMENT_SAMPLER_COUNT) {
+    if (fl3.MAX_VERTEX_SAMPLER_COUNT < limits.maxPerStageDescriptorSamplers ||
+        fl3.MAX_FRAGMENT_SAMPLER_COUNT < limits.maxPerStageDescriptorSamplers) {
         return FeatureLevel::FEATURE_LEVEL_2;
     }
 
@@ -1273,8 +1267,6 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         }
     }
 
-    uint8_t const renderTargetLayerCount = rt->getLayerCount();
-
     // Create the VkRenderPass or fetch it from cache.
     VulkanFboCache::RenderPassKey rpkey = {
         .initialColorLayoutMask = 0,
@@ -1285,12 +1277,10 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         .discardEnd = discardEndVal,
         .samples = rt->getSamples(),
         .subpassMask = uint8_t(params.subpassMask),
-        .viewCount = renderTargetLayerCount,
     };
     for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
         const VulkanAttachment& info = rt->getColor(i);
         if (info.texture) {
-            assert_invariant(info.layerCount == renderTargetLayerCount);
             rpkey.initialColorLayoutMask |= 1 << i;
             rpkey.colorFormat[i] = info.getFormat();
             if (rpkey.samples > 1 && info.texture->samples == 1) {
@@ -1872,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
-            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;
+            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;
 #endif
             texture = mEmptyTexture;
         }
@@ -2024,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()) {
-        FVK_LOGE << command.data() << " issued inside a render pass." << utils::io::endl;
+        utils::slog.e << command.data() << " issued inside a render pass." << utils::io::endl;
     }
 #endif
 }
@@ -2032,10 +2022,6 @@ void VulkanDriver::debugCommandBegin(CommandStream* cmds, bool synchronous, cons
 void VulkanDriver::resetState(int) {
 }
 
-void VulkanDriver::setDebugTag(HandleBase::HandleId handleId, utils::CString tag) {
-    mResourceAllocator.associateHandle(handleId, std::move(tag));
-}
-
 // explicit instantiation of the Dispatcher
 template class ConcreteDispatcher<VulkanDriver>;
 

filament/backend/src/vulkan/VulkanFboCache.cpp

@@ -43,7 +43,6 @@ bool VulkanFboCache::RenderPassEq::operator()(const RenderPassKey& k1,
     if (k1.samples != k2.samples) return false;
     if (k1.needsResolveMask != k2.needsResolveMask) return false;
     if (k1.subpassMask != k2.subpassMask) return false;
-    if (k1.viewCount != k2.viewCount) return false;
     return true;
 }
 
@@ -96,7 +95,7 @@ VkFramebuffer VulkanFboCache::getFramebuffer(FboKey config) noexcept {
     }
 
     #if FVK_ENABLED(FVK_DEBUG_FBO_CACHE)
-    FVK_LOGD << "Creating framebuffer " << config.width << "x" << config.height << " "
+    utils::slog.d << "Creating framebuffer " << config.width << "x" << config.height << " "
         << "for render pass " << config.renderPass << ", "
         << "samples = " << int(config.samples) << ", "
         << "depth = " << (config.depth ? 1 : 0) << ", "
@@ -187,25 +186,6 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
         .pDependencies = dependencies
     };
 
-    VkRenderPassMultiviewCreateInfo multiviewCreateInfo = {};
-    uint32_t const subpassViewMask = (1 << config.viewCount) - 1;
-    // Prepare a view mask array for the maximum number of subpasses. All subpasses have all views
-    // activated.
-    uint32_t const viewMasks[2] = {subpassViewMask, subpassViewMask};
-    if (config.viewCount > 1) {
-        // Fill the multiview create info.
-        multiviewCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
-        multiviewCreateInfo.pNext = nullptr;
-        multiviewCreateInfo.subpassCount = hasSubpasses ? 2u : 1u;
-        multiviewCreateInfo.pViewMasks = viewMasks;
-        multiviewCreateInfo.dependencyCount = 0;
-        multiviewCreateInfo.pViewOffsets = nullptr;
-        multiviewCreateInfo.correlationMaskCount = 1;
-        multiviewCreateInfo.pCorrelationMasks = &subpassViewMask;
-
-        renderPassInfo.pNext = &multiviewCreateInfo;
-    }
-
     int attachmentIndex = 0;
 
     // Populate the Color Attachments.
@@ -330,7 +310,7 @@ VkRenderPass VulkanFboCache::getRenderPass(RenderPassKey config) noexcept {
     mRenderPassCache[config] = {renderPass, mCurrentTime};
 
     #if FVK_ENABLED(FVK_DEBUG_FBO_CACHE)
-    FVK_LOGD << "Created render pass " << renderPass << " with "
+    utils::slog.d << "Created render pass " << renderPass << " with "
         << "samples = " << int(config.samples) << ", "
         << "depth = " << (hasDepth ? 1 : 0) << ", "
         << "colorAttachmentCount[0] = " << subpasses[0].colorAttachmentCount

filament/backend/src/vulkan/VulkanFboCache.h

@@ -64,7 +64,7 @@ public:
         uint8_t samples; // 1 byte
         uint8_t needsResolveMask; // 1 byte
         uint8_t subpassMask; // 1 byte
-        uint8_t viewCount; // 1 byte
+        uint8_t padding2; // 1 byte
     };
     struct RenderPassVal {
         VkRenderPass handle;

filament/backend/src/vulkan/VulkanHandles.cpp

@@ -292,8 +292,8 @@ VulkanProgram::VulkanProgram(VkDevice device, Program const& builder) noexcept
     }
 
 #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-    FVK_LOGD << "Created VulkanProgram " << builder << ", shaders = (" << modules[0]
-             << ", " << modules[1] << ")" << utils::io::endl;
+    utils::slog.d << "Created VulkanProgram " << builder << ", shaders = (" << modules[0]
+                  << ", " << modules[1] << ")" << utils::io::endl;
 #endif
 }
 
@@ -323,12 +323,11 @@ VulkanRenderTarget::VulkanRenderTarget(VkDevice device, VkPhysicalDevice physica
         VulkanContext const& context, VmaAllocator allocator, VulkanCommands* commands,
         uint32_t width, uint32_t height, uint8_t samples,
         VulkanAttachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT],
-        VulkanAttachment depthStencil[2], VulkanStagePool& stagePool, uint8_t layerCount)
+        VulkanAttachment depthStencil[2], VulkanStagePool& stagePool)
     : HwRenderTarget(width, height),
       VulkanResource(VulkanResourceType::RENDER_TARGET),
       mOffscreen(true),
-      mSamples(samples),
-      mLayerCount(layerCount) {
+      mSamples(samples) {
     for (int index = 0; index < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; index++) {
         mColor[index] = color[index];
     }

filament/backend/src/vulkan/VulkanHandles.h

@@ -304,7 +304,7 @@ struct VulkanRenderTarget : private HwRenderTarget, VulkanResource {
             VulkanContext const& context, VmaAllocator allocator,
             VulkanCommands* commands, uint32_t width, uint32_t height,
             uint8_t samples, VulkanAttachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT],
-            VulkanAttachment depthStencil[2], VulkanStagePool& stagePool, uint8_t layerCount);
+            VulkanAttachment depthStencil[2], VulkanStagePool& stagePool);
 
     // Creates a special "default" render target (i.e. associated with the swap chain)
     explicit VulkanRenderTarget();
@@ -319,7 +319,6 @@ struct VulkanRenderTarget : private HwRenderTarget, VulkanResource {
     VulkanAttachment& getMsaaDepth();
     uint8_t getColorTargetCount(const VulkanRenderPass& pass) const;
     uint8_t getSamples() const { return mSamples; }
-    uint8_t getLayerCount() const { return mLayerCount; }
     bool hasDepth() const { return mDepth.texture; }
     bool isSwapChain() const { return !mOffscreen; }
     void bindToSwapChain(VulkanSwapChain& surf);
@@ -331,7 +330,6 @@ private:
     VulkanAttachment mMsaaDepthAttachment = {};
     const bool mOffscreen : 1;
     uint8_t mSamples : 7;
-    uint8_t mLayerCount = 1;
 };
 
 struct VulkanBufferObject;

filament/backend/src/vulkan/VulkanPipelineCache.cpp

@@ -230,15 +230,14 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
     PipelineCacheEntry cacheEntry = {};
 
     #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
-        FVK_LOGD << "vkCreateGraphicsPipelines with shaders = ("
-                 << shaderStages[0].module << ", " << shaderStages[1].module << ")"
-                 << utils::io::endl;
+        utils::slog.d << "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) {
-        FVK_LOGE << "vkCreateGraphicsPipelines error " << error << utils::io::endl;
+        utils::slog.e << "vkCreateGraphicsPipelines error " << error << utils::io::endl;
         return nullptr;
     }
 
@@ -253,7 +252,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) {
-        FVK_LOGE << "Binding missing shader: " << program->name.c_str() << utils::io::endl;
+        utils::slog.e << "Binding missing shader: " << program->name.c_str() << utils::io::endl;
     }
 #endif
 }

filament/backend/src/vulkan/VulkanReadPixels.cpp

@@ -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)
-    FVK_LOGD << "readPixels created image=" << stagingImage
-             << " to copy from image=" << srcTexture->getVkImage()
-             << " src-layout=" << srcTexture->getLayout(0, 0) << utils::io::endl;
+    utils::slog.d << "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);
-        FVK_LOGW
+        utils::slog.w
                 << "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) {
-            FVK_LOGE << "Failed to wait for readPixels fence" << utils::io::endl;
+            utils::slog.e << "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)) {
-            FVK_LOGE << "Unsupported PixelDataFormat or PixelDataType" << utils::io::endl;
+            utils::slog.e << "Unsupported PixelDataFormat or PixelDataType" << utils::io::endl;
         }
 
         vkUnmapMemory(device, stagingMemory);

filament/backend/src/vulkan/VulkanResourceAllocator.h

@@ -105,21 +105,17 @@ public:
         mHandleAllocatorImpl.deallocate(handle, obj);
     }
 
-    inline void associateHandle(HandleBase::HandleId id, utils::CString&& tag) noexcept {
-        mHandleAllocatorImpl.associateTagToHandle(id, std::move(tag));
-    }
-
 private:
     AllocatorImpl mHandleAllocatorImpl;
 
 #if DEBUG_RESOURCE_LEAKS
 public:
     void print() {
-        FVK_LOGD << "Resource Allocator state (debug only)" << utils::io::endl;
+        utils::slog.d << "Resource Allocator state (debug only)" << utils::io::endl;
         for (size_t i = 0; i < RESOURCE_TYPE_COUNT; i++) {
-            FVK_LOGD << "[" << i << "]=" << mDebugOnlyResourceCount[i] << utils::io::endl;
+            utils::slog.d << "[" << i << "]=" << mDebugOnlyResourceCount[i] << utils::io::endl;
         }
-        FVK_LOGD << "+++++++++++++++++++++++++++++++++++++" << utils::io::endl;
+        utils::slog.d << "+++++++++++++++++++++++++++++++++++++" << utils::io::endl;
     }
 private:
     utils::FixedCapacityVector<size_t> mDebugOnlyResourceCount;

filament/backend/src/vulkan/VulkanStagePool.cpp

@@ -61,7 +61,7 @@ VulkanStage const* VulkanStagePool::acquireStage(uint32_t numBytes) {
 
 #if FVK_ENABLED(FVK_DEBUG_ALLOCATION)
     if (result != VK_SUCCESS) {
-        FVK_LOGE << "Allocation error: " << result << utils::io::endl;
+        utils::slog.e << "Allocation error: " << result << utils::io::endl;
     }
 #endif
 

filament/backend/src/vulkan/VulkanSwapChain.cpp

@@ -35,13 +35,29 @@ VulkanSwapChain::VulkanSwapChain(VulkanPlatform* platform, VulkanContext const&
       mStagePool(stagePool),
       mHeadless(extent.width != 0 && extent.height != 0 && !nativeWindow),
       mFlushAndWaitOnResize(platform->getCustomization().flushAndWaitOnWindowResize),
-      mTransitionSwapChainImageLayoutForPresent(
-            platform->getCustomization().transitionSwapChainImageLayoutForPresent),
+      mCurrentImageReadyIndex(0),
       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();
 }
 
@@ -52,6 +68,11 @@ 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() {
@@ -74,7 +95,7 @@ void VulkanSwapChain::update() {
 }
 
 void VulkanSwapChain::present() {
-    if (!mHeadless && mTransitionSwapChainImageLayoutForPresent) {
+    if (!mHeadless) {
         VkCommandBuffer const cmdbuf = mCommands->get().buffer();
         VkImageSubresourceRange const subresources{
                 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
@@ -85,15 +106,10 @@ void VulkanSwapChain::present() {
         };
         mColors[mCurrentSwapIndex]->transitionLayout(cmdbuf, subresources, VulkanLayout::PRESENT);
     }
-
     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.
+    // We only present if it is not headless.  No-op for headless (but note that we still need the
+    // flush() in the above line).
     if (!mHeadless) {
         VkSemaphore const finishedDrawing = mCommands->acquireFinishedSignal();
         VkResult const result = mPlatform->present(swapChain, mCurrentSwapIndex, finishedDrawing);
@@ -123,14 +139,13 @@ void VulkanSwapChain::acquire(bool& resized) {
         update();
     }
 
-    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);
+	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);
     }
     mAcquired = true;
 }

filament/backend/src/vulkan/VulkanSwapChain.h

@@ -50,10 +50,7 @@ struct VulkanSwapChain : public HwSwapChain, VulkanResource {
     void acquire(bool& reized);
 
     inline VulkanTexture* getCurrentColor() const noexcept {
-        uint32_t const imageIndex = mCurrentSwapIndex;
-        FILAMENT_CHECK_PRECONDITION(
-            imageIndex != VulkanPlatform::ImageSyncData::INVALID_IMAGE_INDEX);
-        return mColors[imageIndex].get();
+        return mColors[mCurrentSwapIndex].get();
     }
 
     inline VulkanTexture* getDepth() const noexcept {
@@ -83,15 +80,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;
 };

filament/backend/src/vulkan/VulkanTexture.cpp

@@ -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)) {
-            FVK_LOGW << "Texture usage is SAMPLEABLE but format " << mVkFormat << " is not "
+            utils::slog.w << "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)) {
-        FVK_LOGD << "vkCreateImage: "
+        utils::slog.d << "vkCreateImage: "
             << "image = " << mTextureImage << ", "
             << "result = " << error << ", "
             << "handle = " << utils::io::hex << mTextureImage << utils::io::dec << ", "
@@ -387,15 +387,12 @@ void VulkanTexture::setPrimaryRange(uint32_t minMiplevel, uint32_t maxMiplevel)
 }
 
 VkImageView VulkanTexture::getAttachmentView(VkImageSubresourceRange range) {
+    // Attachments should only have one mipmap level and one layer.
     range.levelCount = 1;
     range.layerCount = 1;
     return getImageView(range, VK_IMAGE_VIEW_TYPE_2D, {});
 }
 
-VkImageView VulkanTexture::getMultiviewAttachmentView(VkImageSubresourceRange range) {
-    return getImageView(range, VK_IMAGE_VIEW_TYPE_2D_ARRAY, {});
-}
-
 VkImageView VulkanTexture::getViewForType(VkImageSubresourceRange const& range, VkImageViewType type) {
     return getImageView(range, type, mSwizzle);
 }
@@ -453,7 +450,7 @@ void VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, const VkImageSubres
     }
 
 #if FVK_ENABLED(FVK_DEBUG_LAYOUT_TRANSITION)
-    FVK_LOGD << "transition texture=" << mTextureImage
+    utils::slog.d << "transition texture=" << mTextureImage
                   << " (" << range.baseArrayLayer
                   << "," << range.baseMipLevel << ")"
                   << " count=(" << range.layerCount
@@ -542,7 +539,7 @@ void VulkanTexture::print() const {
                 layer < (mPrimaryViewRange.baseArrayLayer + mPrimaryViewRange.layerCount) &&
                 level >= mPrimaryViewRange.baseMipLevel &&
                 level < (mPrimaryViewRange.baseMipLevel + mPrimaryViewRange.levelCount);
-            FVK_LOGD << "[" << mTextureImage << "]: (" << layer << "," << level
+            utils::slog.d << "[" << mTextureImage << "]: (" << layer << "," << level
                           << ")=" << getLayout(layer, level)
                           << " primary=" << primary
                           << utils::io::endl;
@@ -551,7 +548,7 @@ void VulkanTexture::print() const {
 
     for (auto view: mCachedImageViews) {
         auto& range = view.first.range;
-        FVK_LOGD << "[" << mTextureImage << ", imageView=" << view.second << "]=>"
+        utils::slog.d << "[" << mTextureImage << ", imageView=" << view.second << "]=>"
                       << " (" << range.baseArrayLayer << "," << range.baseMipLevel << ")"
                       << " count=(" << range.layerCount << "," << range.levelCount << ")"
                       << " aspect=" << range.aspectMask << " viewType=" << view.first.type

filament/backend/src/vulkan/VulkanTexture.h

@@ -73,10 +73,6 @@ struct VulkanTexture : public HwTexture, VulkanResource {
     // and the identity swizzle.
     VkImageView getAttachmentView(VkImageSubresourceRange range);
 
-    // Gets or creates a cached VkImageView for a single subresource that can be used as a render
-    // target attachment when rendering with multiview.
-    VkImageView getMultiviewAttachmentView(VkImageSubresourceRange range);
-
     // This is a workaround for the first few frames where we're waiting for the texture to actually
     // be uploaded.  In that case, we bind the sampler to an empty texture, but the corresponding
     // imageView needs to be of the right type. Hence, we provide an option to indicate the

filament/backend/src/vulkan/caching/VulkanDescriptorSetManager.cpp

@@ -172,7 +172,7 @@ public:
         UTILS_UNUSED VkResult result = vkAllocateDescriptorSets(mDevice, &allocInfo, &vkSet);
         FILAMENT_CHECK_POSTCONDITION(result == VK_SUCCESS)
                 << "Failed to allocate descriptor set code=" << result << " size=" << mSize
-                << " capacity=" << mCapacity << " count=" << mUnusedCount;
+                << " capacity=" << mCapacity << " count=" << "%s";
         mSize++;
         return createSet(layout->bitmask, vkSet);
     }

filament/backend/src/vulkan/caching/VulkanPipelineLayoutCache.cpp

@@ -33,11 +33,11 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
 
     // build the push constant layout key
     uint32_t pushConstantRangeCount = program->getPushConstantRangeCount();
-    auto const& pushConstantRanges = program->getPushConstantRanges();    
+    auto const& pushCostantRanges = program->getPushConstantRanges();    
     if (pushConstantRangeCount > 0) {
         assert_invariant(pushConstantRangeCount <= Program::SHADER_TYPE_COUNT);
         for (uint8_t i = 0; i < pushConstantRangeCount; ++i) {
-            auto const& range = pushConstantRanges[i];
+            auto const& range = pushCostantRanges[i];
             auto& pushConstant = key.pushConstant[i];
             if (range.stageFlags &  VK_SHADER_STAGE_VERTEX_BIT) {
                 pushConstant.stage = static_cast<uint8_t>(ShaderStage::VERTEX);
@@ -52,8 +52,9 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
         }
     }
 
-    if (PipelineLayoutMap::iterator iter = mPipelineLayouts.find(key); iter != mPipelineLayouts.end()) {
-        PipelineLayoutCacheEntry& entry = iter.value();
+    auto iter = mPipelineLayouts.find(key);
+    if (iter != mPipelineLayouts.end()) {
+        PipelineLayoutCacheEntry& entry = mPipelineLayouts[key];
         entry.lastUsed = mTimestamp++;
         return entry.handle;
     }
@@ -64,7 +65,7 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
         .setLayoutCount = (uint32_t) descSetLayoutCount,
         .pSetLayouts = key.descSetLayouts.data(),
         .pushConstantRangeCount = pushConstantRangeCount,
-        .pPushConstantRanges = pushConstantRanges,
+        .pPushConstantRanges = pushCostantRanges,
     };
 
     VkPipelineLayout layout;

filament/backend/src/vulkan/platform/VulkanPlatform.cpp

@@ -95,7 +95,7 @@ void printDeviceInfo(VkInstance instance, VkPhysicalDevice device) {
                 .pNext = &driverProperties,
         };
         vkGetPhysicalDeviceProperties2(device, &physicalDeviceProperties2);
-        FVK_LOGI << "Vulkan device driver: " << driverProperties.driverName << " "
+        utils::slog.i << "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);
 
-    FVK_LOGI << "Selected physical device '" << deviceProperties.deviceName << "' from "
+    utils::slog.i << "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;
-    FVK_LOGI << "Sampleable depth formats: ";
+    utils::slog.i << "Sampleable depth formats: ";
     for (VkFormat format : ALL_VK_FORMATS) {
         VkFormatProperties props;
         vkGetPhysicalDeviceFormatProperties(device, format, &props);
         if ((props.optimalTilingFeatures & required) == required) {
-            FVK_LOGI << format << " ";
+            utils::slog.i << format << " ";
         }
     }
-    FVK_LOGI << utils::io::endl;
+    utils::slog.i << utils::io::endl;
 }
 #endif
 
@@ -198,7 +198,6 @@ 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
@@ -242,11 +241,11 @@ VkInstance createInstance(ExtensionSet const& requiredExts) {
         instanceCreateInfo.ppEnabledLayerNames = enabledLayers.data();
     } else {
 #if defined(__ANDROID__)
-        FVK_LOGD << "Validation layers are not available; did you set jniLibs in your "
-                 << "gradle file?" << utils::io::endl;
+        utils::slog.d << "Validation layers are not available; did you set jniLibs in your "
+                      << "gradle file?" << utils::io::endl;
 #else
-        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;
+        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;
 #endif // __ANDROID__
 
     }
@@ -335,7 +334,6 @@ 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,
@@ -343,24 +341,9 @@ VkDevice createLogicalDevice(VkPhysicalDevice physicalDevice,
             .mutableComparisonSamplers = VK_TRUE,
     };
     if (setContains(deviceExtensions, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)) {
-        portability.pNext = pNext;
-        pNext = &portability;
+        deviceCreateInfo.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 << ".";
 
@@ -435,8 +418,8 @@ inline int deviceTypeOrder(VkPhysicalDeviceType deviceType) {
         case VK_PHYSICAL_DEVICE_TYPE_OTHER:
             return 1;
         default:
-            FVK_LOGW << "deviceTypeOrder: Unexpected deviceType: " << deviceType
-                     << utils::io::endl;
+            utils::slog.w << "deviceTypeOrder: Unexpected deviceType: " << deviceType
+                          << utils::io::endl;
             return -1;
     }
 }
@@ -718,10 +701,6 @@ 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
@@ -737,7 +716,6 @@ 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
@@ -772,8 +750,8 @@ VulkanPlatform::SwapChainBundle VulkanPlatform::getSwapChainBundle(SwapChainPtr
     SWAPCHAIN_RET_FUNC(getSwapChainBundle, handle, )
 }
 
-VkResult VulkanPlatform::acquire(SwapChainPtr handle, ImageSyncData* outImageSyncData) {
-    SWAPCHAIN_RET_FUNC(acquire, handle, outImageSyncData)
+VkResult VulkanPlatform::acquire(SwapChainPtr handle, VkSemaphore clientSignal, uint32_t* index) {
+    SWAPCHAIN_RET_FUNC(acquire, handle, clientSignal, index)
 }
 
 VkResult VulkanPlatform::present(SwapChainPtr handle, uint32_t index,

filament/backend/src/vulkan/platform/VulkanPlatformSwapChainImpl.cpp

@@ -133,7 +133,6 @@ VulkanPlatformSurfaceSwapChain::VulkanPlatformSurfaceSwapChain(VulkanContext con
 VulkanPlatformSurfaceSwapChain::~VulkanPlatformSurfaceSwapChain() {
     vkDestroySwapchainKHR(mDevice, mSwapchain, VKALLOC);
     vkDestroySurfaceKHR(mInstance, mSurface, VKALLOC);
-    destroy();
 }
 
 VkResult VulkanPlatformSurfaceSwapChain::create() {
@@ -154,7 +153,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) {
-        FVK_LOGE << "Swap chain does not support " << desiredImageCount << " images."
+        utils::slog.e << "Swap chain does not support " << desiredImageCount << " images."
                       << utils::io::endl;
         desiredImageCount = caps.minImageCount;
     }
@@ -247,7 +246,7 @@ VkResult VulkanPlatformSurfaceSwapChain::create() {
             selectDepthFormat(mContext.getAttachmentDepthStencilFormats(), mHasStencil);
     mSwapChainBundle.depth = createImage(mSwapChainBundle.extent, mSwapChainBundle.depthFormat);
 
-    FVK_LOGI << "vkCreateSwapchain"
+    slog.i << "vkCreateSwapchain"
            << ": " << mSwapChainBundle.extent.width << "x" << mSwapChainBundle.extent.height << ", "
            << surfaceFormat.format << ", " << surfaceFormat.colorSpace << ", "
            << "swapchain-size=" << mSwapChainBundle.colors.size() << ", "
@@ -255,29 +254,19 @@ 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(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);
+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);
 
     // 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) {
-        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << io::endl;
+        slog.w << "Vulkan Driver: Suboptimal swap chain." << io::endl;
         mSuboptimal = true;
     }
     return result;
@@ -299,7 +288,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) {
-        FVK_LOGW << "Vulkan Driver: Suboptimal swap chain." << utils::io::endl;
+        utils::slog.w << "Vulkan Driver: Suboptimal swap chain." << utils::io::endl;
         mSuboptimal = true;
     }
     return result;
@@ -323,17 +312,6 @@ 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),
@@ -365,8 +343,8 @@ VkResult VulkanPlatformHeadlessSwapChain::present(uint32_t index, VkSemaphore fi
     return VK_SUCCESS;
 }
 
-VkResult VulkanPlatformHeadlessSwapChain::acquire(VulkanPlatform::ImageSyncData* outImageSyncData) {
-    outImageSyncData->imageIndex = mCurrentIndex;
+VkResult VulkanPlatformHeadlessSwapChain::acquire(VkSemaphore clientSignal, uint32_t* index) {
+    *index = mCurrentIndex;
     mCurrentIndex = (mCurrentIndex + 1) % HEADLESS_SWAPCHAIN_SIZE;
     return VK_SUCCESS;
 }

filament/backend/src/vulkan/platform/VulkanPlatformSwapChainImpl.h

@@ -42,7 +42,7 @@ struct VulkanPlatformSwapChainImpl : public Platform::SwapChain {
     ~VulkanPlatformSwapChainImpl();
 
     // Non-virtual override-able method
-    VkResult acquire(VulkanPlatform::ImageSyncData* outImageSyncData) {
+    VkResult acquire(VkSemaphore clientSignal, uint32_t* index) {
         PANIC_PRECONDITION("Should not be called");
         return VK_ERROR_UNKNOWN;
     }
@@ -86,7 +86,7 @@ struct VulkanPlatformSurfaceSwapChain : public VulkanPlatformSwapChainImpl {
     ~VulkanPlatformSurfaceSwapChain();
 
     // Non-virtual override
-    VkResult acquire(VulkanPlatform::ImageSyncData* outImageSyncData);
+    VkResult acquire(VkSemaphore clientSignal, uint32_t* index);
 
     // Non-virtual override
     VkResult present(uint32_t index, VkSemaphore finished);
@@ -97,13 +97,7 @@ 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;
@@ -112,8 +106,6 @@ 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;
@@ -129,7 +121,7 @@ struct VulkanPlatformHeadlessSwapChain : public VulkanPlatformSwapChainImpl {
     ~VulkanPlatformHeadlessSwapChain();
 
     // Non-virtual override
-    VkResult acquire(VulkanPlatform::ImageSyncData* outImageSyncData);
+    VkResult acquire(VkSemaphore clientSignal, uint32_t* index);
 
     // Non-virtual override
     VkResult present(uint32_t index, VkSemaphore finished);

filament/docs/SpirvDebugging.md

@@ -64,15 +64,14 @@ First determine the Filament material and variant that causes the problem.
 What we want is the "raw" GLSL version of the shader, before any optimizations / cross-compilation
 happens.
 
-We can use the `--save-raw-variants` debug flag in matc to export each GLSL
-shader to a file. For example:
+The easiest way I've found to do this is by adding a `std::cout` statement inside `MaterialBuilder`,
+right after `sg.createFragmentProgram` or `sg.createVertexProgram` is called. For example,
 
 ```
-matc --save-raw-variants --optimize-size --variant-filter fog,ssr,vsm,stereo \
-        -a all -p all -o mymaterial.filamat mymaterial.mat
+if (v.variant.key == 8u) { std::cout << shader << std::endl; }
 ```
 
-Files will be named like `mymaterial_0x05.frag` or `mymaterial_0x05.vert`.
+Then, I invoke `matc` and redirect stdout to a .frag or .vert file.
 
 Note that gltfio material "templates" first go through a build step. After building gltfio, the
 gltfio Filament materials are output to:

filament/include/filament/BufferObject.h

@@ -54,7 +54,7 @@ public:
     using BufferDescriptor = backend::BufferDescriptor;
     using BindingType = backend::BufferObjectBinding;
 
-    class Builder : public BuilderBase<BuilderDetails>, public BuilderNameMixin<Builder> {
+    class Builder : public BuilderBase<BuilderDetails> {
         friend struct BuilderDetails;
     public:
         Builder() noexcept;
@@ -78,21 +78,6 @@ public:
          */
         Builder& bindingType(BindingType bindingType) noexcept;
 
-        /**
-         * Associate an optional name with this BufferObject for debugging purposes.
-         *
-         * name will show in error messages and should be kept as short as possible. The name is
-         * truncated to a maximum of 128 characters.
-         *
-         * The name string is copied during this method so clients may free its memory after
-         * the function returns.
-         *
-         * @param name A string to identify this BufferObject
-         * @param len Length of name, should be less than or equal to 128
-         * @return This Builder, for chaining calls.
-         */
-        // Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept; // inherited
-
         /**
          * Creates the BufferObject and returns a pointer to it. After creation, the buffer
          * object is uninitialized. Use BufferObject::setBuffer() to initialize it.

filament/include/filament/Engine.h

@@ -298,24 +298,6 @@ 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.
@@ -350,12 +332,9 @@ public:
         uint32_t resourceAllocatorCacheSizeMB = 64;
 
         /*
-         * This value determines how many frames texture entries are kept for in the cache. This
-         * is a soft limit, meaning some texture older than this are allowed to stay in the cache.
-         * Typically only one texture is evicted per frame.
-         * The default is 1.
+         * This value determines for how many frames are texture entries kept in the cache.
          */
-        uint32_t resourceAllocatorCacheMaxAge = 1;
+        uint32_t resourceAllocatorCacheMaxAge = 2;
 
         /*
          * Disable backend handles use-after-free checks.
@@ -896,29 +875,6 @@ public:
     /** Tells whether an InstanceBuffer object is valid */
     bool isValid(const InstanceBuffer* UTILS_NULLABLE p) const;
 
-    /**
-     * Retrieve the count of each resource tracked by Engine.
-     * This is intended for debugging.
-     * @{
-     */
-    size_t getBufferObjectCount() const noexcept;
-    size_t getViewCount() const noexcept;
-    size_t getSceneCount() const noexcept;
-    size_t getSwapChainCount() const noexcept;
-    size_t getStreamCount() const noexcept;
-    size_t getIndexBufferCount() const noexcept;
-    size_t getSkinningBufferCount() const noexcept;
-    size_t getMorphTargetBufferCount() const noexcept;
-    size_t getInstanceBufferCount() const noexcept;
-    size_t getVertexBufferCount() const noexcept;
-    size_t getIndirectLightCount() const noexcept;
-    size_t getMaterialCount() const noexcept;
-    size_t getTextureCount() const noexcept;
-    size_t getSkyboxeCount() const noexcept;
-    size_t getColorGradingCount() const noexcept;
-    size_t getRenderTargetCount() const noexcept;
-    /**  @} */
-
     /**
      * Kicks the hardware thread (e.g. the OpenGL, Vulkan or Metal thread) and blocks until
      * all commands to this point are executed. Note that does guarantee that the
@@ -1065,21 +1021,6 @@ 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:

filament/include/filament/FilamentAPI.h

@@ -19,7 +19,6 @@
 
 #include <utils/compiler.h>
 #include <utils/PrivateImplementation.h>
-#include <utils/CString.h>
 
 #include <stddef.h>
 
@@ -55,22 +54,6 @@ public:
 template<typename T>
 using BuilderBase = utils::PrivateImplementation<T>;
 
-void builderMakeName(utils::CString& outName, const char* name, size_t len) noexcept;
-
-template <typename Builder>
-class UTILS_PUBLIC BuilderNameMixin {
-public:
-    Builder& name(const char* name, size_t len) noexcept {
-        builderMakeName(mName, name, len);
-        return static_cast<Builder&>(*this);
-    }
-
-    utils::CString const& getName() const noexcept { return mName; }
-
-private:
-    utils::CString mName;
-};
-
 } // namespace filament
 
 #endif // TNT_FILAMENT_FILAMENTAPI_H

filament/include/filament/IndexBuffer.h

@@ -59,7 +59,7 @@ public:
         UINT = uint8_t(backend::ElementType::UINT),      //!< 32-bit indices
     };
 
-    class Builder : public BuilderBase<BuilderDetails>, public BuilderNameMixin<Builder> {
+    class Builder : public BuilderBase<BuilderDetails> {
         friend struct BuilderDetails;
     public:
         Builder() noexcept;
@@ -83,21 +83,6 @@ public:
          */
         Builder& bufferType(IndexType indexType) noexcept;
 
-        /**
-         * Associate an optional name with this IndexBuffer for debugging purposes.
-         *
-         * name will show in error messages and should be kept as short as possible. The name is
-         * truncated to a maximum of 128 characters.
-         *
-         * The name string is copied during this method so clients may free its memory after
-         * the function returns.
-         *
-         * @param name A string to identify this IndexBuffer
-         * @param len Length of name, should be less than or equal to 128
-         * @return This Builder, for chaining calls.
-         */
-        // Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept; // inherited
-
         /**
          * Creates the IndexBuffer object and returns a pointer to it. After creation, the index
          * buffer is uninitialized. Use IndexBuffer::setBuffer() to initialize the IndexBuffer.

filament/include/filament/IndirectLight.h

@@ -158,8 +158,6 @@ 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.

filament/include/filament/InstanceBuffer.h

@@ -38,7 +38,7 @@ class UTILS_PUBLIC InstanceBuffer : public FilamentAPI {
     struct BuilderDetails;
 
 public:
-    class Builder : public BuilderBase<BuilderDetails>, public BuilderNameMixin<Builder> {
+    class Builder : public BuilderBase<BuilderDetails> {
         friend struct BuilderDetails;
 
     public:
@@ -70,21 +70,6 @@ public:
          */
         Builder& localTransforms(math::mat4f const* UTILS_NULLABLE localTransforms) noexcept;
 
-        /**
-         * Associate an optional name with this InstanceBuffer for debugging purposes.
-         *
-         * name will show in error messages and should be kept as short as possible. The name is
-         * truncated to a maximum of 128 characters.
-         *
-         * The name string is copied during this method so clients may free its memory after
-         * the function returns.
-         *
-         * @param name A string to identify this InstanceBuffer
-         * @param len Length of name, should be less than or equal to 128
-         * @return This Builder, for chaining calls.
-         */
-        // Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept; // inherited
-
         /**
          * Creates the InstanceBuffer object and returns a pointer to it.
          */

filament/include/filament/Material.h

@@ -140,18 +140,6 @@ 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.
          *

filament/include/filament/MaterialInstance.h

@@ -140,7 +140,6 @@ 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,
@@ -235,32 +234,6 @@ 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.
      *

filament/include/filament/MorphTargetBuffer.h

@@ -39,7 +39,7 @@ class UTILS_PUBLIC MorphTargetBuffer : public FilamentAPI {
     struct BuilderDetails;
 
 public:
-    class Builder : public BuilderBase<BuilderDetails>, public BuilderNameMixin<Builder> {
+    class Builder : public BuilderBase<BuilderDetails> {
         friend struct BuilderDetails;
     public:
         Builder() noexcept;
@@ -63,21 +63,6 @@ public:
          */
         Builder& count(size_t count) noexcept;
 
-        /**
-         * Associate an optional name with this MorphTargetBuffer for debugging purposes.
-         *
-         * name will show in error messages and should be kept as short as possible. The name is
-         * truncated to a maximum of 128 characters.
-         *
-         * The name string is copied during this method so clients may free its memory after
-         * the function returns.
-         *
-         * @param name A string to identify this MorphTargetBuffer
-         * @param len Length of name, should be less than or equal to 128
-         * @return This Builder, for chaining calls.
-         */
-        // Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept; // inherited
-
         /**
          * Creates the MorphTargetBuffer object and returns a pointer to it.
          *

filament/include/filament/RenderableManager.h

@@ -489,20 +489,43 @@ 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)
          */
-        RenderableManager::Builder& morphing(uint8_t level,
-                size_t primitiveIndex, size_t offset) noexcept;
+        Builder& morphing(uint8_t level, size_t primitiveIndex,
+                size_t offset, size_t count) noexcept;
 
 
         /**
@@ -763,13 +786,25 @@ public:
     /**
      * Associates a MorphTargetBuffer to the given primitive.
      */
-    void setMorphTargetBufferOffsetAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            size_t offset);
+    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());
+    }
 
     /**
-     * Get a MorphTargetBuffer to the given renderable or null if it doesn't exist.
+     * Get a MorphTargetBuffer to the given primitive or null if it doesn't exist.
      */
-    MorphTargetBuffer* UTILS_NULLABLE getMorphTargetBuffer(Instance instance) const noexcept;
+    MorphTargetBuffer* UTILS_NULLABLE getMorphTargetBufferAt(Instance instance,
+            uint8_t level, size_t primitiveIndex) const noexcept;
 
     /**
      * Gets the number of morphing in the given entity.

filament/include/filament/Renderer.h

@@ -22,11 +22,9 @@
 #include <filament/FilamentAPI.h>
 
 #include <utils/compiler.h>
-#include <utils/FixedCapacityVector.h>
 
 #include <math/vec4.h>
 
-#include <stddef.h>
 #include <stdint.h>
 
 namespace filament {
@@ -83,37 +81,6 @@ public:
         UTILS_DEPRECATED uint64_t vsyncOffsetNanos = 0;
     };
 
-    /**
-     * Timing information about a frame
-     * @see getFrameInfoHistory()
-     */
-    struct FrameInfo {
-        using time_point_ns = int64_t;
-        using duration_ns = int64_t;
-        uint32_t frameId;                   //!< monotonically increasing frame identifier
-        duration_ns frameTime;              //!< frame duration on the GPU in nanosecond [ns]
-        duration_ns denoisedFrameTime;      //!< denoised frame duration on the GPU in [ns]
-        time_point_ns beginFrame;           //!< Renderer::beginFrame() time since epoch [ns]
-        time_point_ns endFrame;             //!< Renderer::endFrame() time since epoch [ns]
-        time_point_ns backendBeginFrame;    //!< Backend thread time of frame start since epoch [ns]
-        time_point_ns backendEndFrame;      //!< Backend thread time of frame end since epoch [ns]
-    };
-
-    /**
-     * Retrieve an historic of frame timing information. The maximum frame history size is
-     * given by getMaxFrameHistorySize().
-     * @param historySize requested history size. The returned vector could be smaller.
-     * @return A vector of FrameInfo.
-     */
-    utils::FixedCapacityVector<Renderer::FrameInfo> getFrameInfoHistory(
-            size_t historySize = 1) const noexcept;
-
-    /**
-     * @return the maximum supported frame history size.
-     * @see getFrameInfoHistory()
-     */
-    size_t getMaxFrameHistorySize() const noexcept;
-
     /**
      * Use FrameRateOptions to set the desired frame rate and control how quickly the system
      * reacts to GPU load changes.
@@ -260,25 +227,6 @@ 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;
-
-    /**
-     * Call skipFrame when momentarily skipping frames, for instance if the content of the
-     * scene doesn't change.
-     *
-     * @param vsyncSteadyClockTimeNano
-     */
-    void skipFrame(uint64_t vsyncSteadyClockTimeNano = 0u);
-
     /**
      * Set-up a frame for this Renderer.
      *

filament/include/filament/SkinningBuffer.h

@@ -39,7 +39,7 @@ class UTILS_PUBLIC SkinningBuffer : public FilamentAPI {
     struct BuilderDetails;
 
 public:
-    class Builder : public BuilderBase<BuilderDetails>, public BuilderNameMixin<Builder> {
+    class Builder : public BuilderBase<BuilderDetails> {
         friend struct BuilderDetails;
     public:
         Builder() noexcept;
@@ -69,21 +69,6 @@ public:
          */
         Builder& initialize(bool initialize = true) noexcept;
 
-        /**
-         * Associate an optional name with this SkinningBuffer for debugging purposes.
-         *
-         * name will show in error messages and should be kept as short as possible. The name is
-         * truncated to a maximum of 128 characters.
-         *
-         * The name string is copied during this method so clients may free its memory after
-         * the function returns.
-         *
-         * @param name A string to identify this SkinningBuffer
-         * @param len Length of name, should be less than or equal to 128
-         * @return This Builder, for chaining calls.
-         */
-        // Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept; // inherited
-
         /**
          * Creates the SkinningBuffer object and returns a pointer to it.
          *

filament/include/filament/Stream.h

@@ -94,7 +94,7 @@ public:
      *
      * To create a NATIVE stream, call the <pre>stream</pre> method on the builder.
      */
-    class Builder : public BuilderBase<BuilderDetails>, public BuilderNameMixin<Builder> {
+    class Builder : public BuilderBase<BuilderDetails> {
         friend struct BuilderDetails;
     public:
         Builder() noexcept;
@@ -136,21 +136,6 @@ public:
          */
         Builder& height(uint32_t height) noexcept;
 
-        /**
-         * Associate an optional name with this Stream for debugging purposes.
-         *
-         * name will show in error messages and should be kept as short as possible. The name is
-         * truncated to a maximum of 128 characters.
-         *
-         * The name string is copied during this method so clients may free its memory after
-         * the function returns.
-         *
-         * @param name A string to identify this Stream
-         * @param len Length of name, should be less than or equal to 128
-         * @return This Builder, for chaining calls.
-         */
-        // Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept; // inherited
-
         /**
          * Creates the Stream object and returns a pointer to it.
          *

filament/include/filament/Texture.h

@@ -112,7 +112,7 @@ public:
 
 
     //! Use Builder to construct a Texture object instance
-    class Builder : public BuilderBase<BuilderDetails>, public BuilderNameMixin<Builder> {
+    class Builder : public BuilderBase<BuilderDetails> {
         friend struct BuilderDetails;
     public:
         Builder() noexcept;
@@ -202,21 +202,6 @@ public:
          */
         Builder& swizzle(Swizzle r, Swizzle g, Swizzle b, Swizzle a) noexcept;
 
-        /**
-         * Associate an optional name with this Texture for debugging purposes.
-         *
-         * name will show in error messages and should be kept as short as possible. The name is
-         * truncated to a maximum of 128 characters.
-         *
-         * The name string is copied during this method so clients may free its memory after
-         * the function returns.
-         *
-         * @param name A string to identify this Texture
-         * @param len Length of name, should be less than or equal to 128
-         * @return This Builder, for chaining calls.
-         */
-         // Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept; // inherited
-
         /**
          * Creates the Texture object and returns a pointer to it.
          *

filament/include/filament/VertexBuffer.h

@@ -61,7 +61,7 @@ public:
     using AttributeType = backend::ElementType;
     using BufferDescriptor = backend::BufferDescriptor;
 
-    class Builder : public BuilderBase<BuilderDetails>, public BuilderNameMixin<Builder> {
+    class Builder : public BuilderBase<BuilderDetails> {
         friend struct BuilderDetails;
     public:
         Builder() noexcept;
@@ -158,21 +158,6 @@ public:
          */
         Builder& advancedSkinning(bool enabled) noexcept;
 
-        /**
-         * Associate an optional name with this VertexBuffer for debugging purposes.
-         *
-         * name will show in error messages and should be kept as short as possible. The name is
-         * truncated to a maximum of 128 characters.
-         *
-         * The name string is copied during this method so clients may free its memory after
-         * the function returns.
-         *
-         * @param name A string to identify this VertexBuffer
-         * @param len Length of name, should be less than or equal to 128
-         * @return This Builder, for chaining calls.
-         */
-        // Builder& name(const char* UTILS_NONNULL name, size_t len) noexcept; // inherited
-
         /**
          * Creates the VertexBuffer object and returns a pointer to it.
          *

filament/include/filament/View.h

@@ -24,7 +24,6 @@
 
 #include <utils/compiler.h>
 #include <utils/Entity.h>
-#include <utils/FixedCapacityVector.h>
 
 #include <math/mathfwd.h>
 
@@ -41,7 +40,6 @@ class CallbackHandler;
 
 class Camera;
 class ColorGrading;
-class Engine;
 class MaterialInstance;
 class RenderTarget;
 class Scene;
@@ -728,7 +726,7 @@ public:
     void setDebugCamera(Camera* UTILS_NULLABLE camera) noexcept;
 
     //! debugging: returns a Camera from the point of view of *the* dominant directional light used for shadowing.
-    utils::FixedCapacityVector<Camera const*> getDirectionalShadowCameras() const noexcept;
+    Camera const* UTILS_NULLABLE getDirectionalShadowCamera() const noexcept;
 
 
     /** Result of a picking query */
@@ -880,17 +878,6 @@ public:
      */
     utils::Entity getFogEntity() const noexcept;
 
-
-    /**
-     * When certain temporal features are used (e.g.: TAA or Screen-space reflections), the view
-     * keeps a history of previous frame renders associated with the Renderer the view was last
-     * used with. When switching Renderer, it may be necessary to clear that history by calling
-     * this method. Similarly, if the whole content of the screen change, like when a cut-scene
-     * starts, clearing the history might be needed to avoid artifacts due to the previous frame
-     * being very different.
-     */
-    void clearFrameHistory(Engine& engine) noexcept;
-
     /**
      * List of available ambient occlusion techniques
      * @deprecated use AmbientOcclusionOptions::enabled instead

filament/src/Engine.cpp

@@ -16,8 +16,6 @@
 
 #include "details/Engine.h"
 
-#include "ResourceAllocator.h"
-
 #include "details/BufferObject.h"
 #include "details/Camera.h"
 #include "details/Fence.h"
@@ -41,8 +39,6 @@
 #include <utils/compiler.h>
 #include <utils/Panic.h>
 
-#include <chrono>
-
 #include <stddef.h>
 #include <stdint.h>
 
@@ -268,71 +264,6 @@ bool Engine::isValid(const InstanceBuffer* p) const {
     return downcast(this)->isValid(downcast(p));
 }
 
-size_t Engine::getBufferObjectCount() const noexcept {
-    return downcast(this)->getBufferObjectCount();
-}
-
-size_t Engine::getViewCount() const noexcept {
-    return downcast(this)->getViewCount();
-}
-
-size_t Engine::getSceneCount() const noexcept {
-    return downcast(this)->getSceneCount();
-}
-
-size_t Engine::getSwapChainCount() const noexcept {
-    return downcast(this)->getSwapChainCount();
-}
-
-size_t Engine::getStreamCount() const noexcept {
-    return downcast(this)->getStreamCount();
-}
-
-size_t Engine::getIndexBufferCount() const noexcept {
-    return downcast(this)->getIndexBufferCount();
-}
-
-size_t Engine::getSkinningBufferCount() const noexcept {
-    return downcast(this)->getSkinningBufferCount();
-}
-
-size_t Engine::getMorphTargetBufferCount() const noexcept {
-    return downcast(this)->getMorphTargetBufferCount();
-}
-
-size_t Engine::getInstanceBufferCount() const noexcept {
-    return downcast(this)->getInstanceBufferCount();
-}
-
-size_t Engine::getVertexBufferCount() const noexcept {
-    return downcast(this)->getVertexBufferCount();
-}
-
-size_t Engine::getIndirectLightCount() const noexcept {
-    return downcast(this)->getIndirectLightCount();
-}
-
-size_t Engine::getMaterialCount() const noexcept {
-    return downcast(this)->getMaterialCount();
-}
-
-size_t Engine::getTextureCount() const noexcept {
-    return downcast(this)->getTextureCount();
-}
-
-size_t Engine::getSkyboxeCount() const noexcept {
-    return downcast(this)->getSkyboxeCount();
-}
-
-size_t Engine::getColorGradingCount() const noexcept {
-    return downcast(this)->getColorGradingCount();
-}
-
-size_t Engine::getRenderTargetCount() const noexcept {
-    return downcast(this)->getRenderTargetCount();
-}
-
-
 void Engine::flushAndWait() {
     downcast(this)->flushAndWait();
 }
@@ -430,7 +361,7 @@ const Engine::Config& Engine::getConfig() const noexcept {
     return downcast(this)->getConfig();
 }
 
-bool Engine::isStereoSupported(StereoscopicType) const noexcept {
+bool Engine::isStereoSupported(StereoscopicType stereoscopicType) const noexcept {
     return downcast(this)->isStereoSupported();
 }
 
@@ -438,10 +369,6 @@ 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();

filament/src/FilamentBuilder.cpp

@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2024 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <filament/FilamentAPI.h>
-
-#include <algorithm>
-
-namespace filament {
-
-void builderMakeName(utils::CString& outName, const char* name, size_t len) noexcept {
-    if (!name) {
-        return;
-    }
-    size_t const length = std::min(len, size_t { 128u });
-    outName = utils::CString(name, length);
-}
-
-} // namespace filament

filament/src/FrameHistory.h

@@ -21,9 +21,6 @@
 #include <fg/FrameGraphTexture.h>
 
 #include <math/mat4.h>
-#include <math/vec2.h>
-
-#include <stdint.h>
 
 namespace filament {
 

filament/src/FrameInfo.cpp

@@ -16,34 +16,30 @@
 
 #include "FrameInfo.h"
 
-#include <filament/Renderer.h>
-
-#include <backend/DriverEnums.h>
-
-#include <utils/compiler.h>
-#include <utils/debug.h>
-#include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
-#include <utils/ostream.h>
 #include <utils/Systrace.h>
 
-#include <algorithm>
-#include <atomic>
-#include <chrono>
-#include <memory>
-#include <ratio>
+#include <math/scalar.h>
 
-#include <stdint.h>
-#include <stddef.h>
+#include <cmath>
 
 namespace filament {
 
 using namespace utils;
 using namespace backend;
 
+// this is to avoid a call to memmove
+template<class InputIterator, class OutputIterator>
+static inline
+void move_backward(InputIterator first, InputIterator last, OutputIterator result) {
+    while (first != last) {
+        *--result = *--last;
+    }
+}
+
 FrameInfoManager::FrameInfoManager(DriverApi& driver) noexcept {
     for (auto& query : mQueries) {
-        query.handle = driver.createTimerQuery();
+        query = driver.createTimerQuery();
     }
 }
 
@@ -51,155 +47,65 @@ FrameInfoManager::~FrameInfoManager() noexcept = default;
 
 void FrameInfoManager::terminate(DriverApi& driver) noexcept {
     for (auto& query : mQueries) {
-        driver.destroyTimerQuery(query.handle);
+        driver.destroyTimerQuery(query);
     }
 }
 
-void FrameInfoManager::beginFrame(DriverApi& driver, Config const& config, uint32_t frameId) noexcept {
-    auto& history = mFrameTimeHistory;
-    // don't exceed the capacity, drop the oldest entry
-    if (UTILS_LIKELY(history.size() == history.capacity())) {
-        history.pop_back();
-    }
-
-    // create a new entry
-    auto& front = history.emplace_front(frameId);
-
-    // store the current time
-    front.beginFrame = std::chrono::steady_clock::now();
-
-    // references are not invalidated by CircularQueue<>, so we can associate a reference to
-    // the slot we created to the timer query used to find the frame time.
-    mQueries[mIndex].pInfo = std::addressof(front);
-    // issue the timer query
-    driver.beginTimerQuery(mQueries[mIndex].handle);
-    // issue the custom backend command to get the backend time
-    driver.queueCommand([&front](){
-        front.backendBeginFrame = std::chrono::steady_clock::now();
-    });
-
-    // now is a good time to check the oldest active query
-    while (mLast != mIndex) {
-        uint64_t elapsed = 0;
-        TimerQueryResult const result = driver.getTimerQueryValue(mQueries[mLast].handle, &elapsed);
-        switch (result) {
-            case TimerQueryResult::NOT_READY:
-                // nothing to do
-                break;
-            case TimerQueryResult::ERROR:
-                mLast = (mLast + 1) % POOL_COUNT;
-                break;
-            case TimerQueryResult::AVAILABLE: {
-                SYSTRACE_CONTEXT();
-                SYSTRACE_VALUE32("FrameInfo::elapsed", uint32_t(elapsed));
-                // conversion to our duration happens here
-                pFront = mQueries[mLast].pInfo;
-                pFront->frameTime = std::chrono::duration<uint64_t, std::nano>(elapsed);
-                mLast = (mLast + 1) % POOL_COUNT;
-                denoiseFrameTime(history, config);
-                break;
-            }
-        }
-        if (result != TimerQueryResult::AVAILABLE) {
+void FrameInfoManager::beginFrame(DriverApi& driver,Config const& config, uint32_t) noexcept {
+    driver.beginTimerQuery(mQueries[mIndex]);
+    uint64_t elapsed = 0;
+    TimerQueryResult const result = driver.getTimerQueryValue(mQueries[mLast], &elapsed);
+    switch (result) {
+        case TimerQueryResult::NOT_READY:
+            // nothing to do
+            break;
+        case TimerQueryResult::ERROR:
+            mLast = (mLast + 1) % POOL_COUNT;
+            break;
+        case TimerQueryResult::AVAILABLE:
+            mLast = (mLast + 1) % POOL_COUNT;
+            // conversion to our duration happens here
+            mFrameTime = std::chrono::duration<uint64_t, std::nano>(elapsed);
             break;
-        }
-        // read the pending timer queries until we find one that's not ready
-    }
-
-    // keep this just for debugging
-    if constexpr (false) {
-        using namespace utils;
-        auto h = getFrameInfoHistory(1);
-        if (!h.empty()) {
-            slog.d << frameId << ": "
-                   << h[0].frameId << " (" << frameId - h[0].frameId << ")"
-                   << ", Dm=" << h[0].endFrame - h[0].beginFrame
-                   << ", L =" << h[0].backendBeginFrame - h[0].beginFrame
-                   << ", Db=" << h[0].backendEndFrame - h[0].backendBeginFrame
-                   << ", T =" << h[0].frameTime
-                   << io::endl;
-        }
     }
+    update(config, mFrameTime);
 }
 
 void FrameInfoManager::endFrame(DriverApi& driver) noexcept {
-    auto& front = mFrameTimeHistory.front();
-    // close the timer query
-    driver.endTimerQuery(mQueries[mIndex].handle);
-    // queue custom backend command to query the current time
-    driver.queueCommand([&front](){
-        // backend frame end-time
-        front.backendEndFrame = std::chrono::steady_clock::now();
-        // signal that the data is available
-        front.ready.store(true, std::memory_order_release);
-    });
-    // and finally acquire the time on the main thread
-    front.endFrame = std::chrono::steady_clock::now();
+    driver.endTimerQuery(mQueries[mIndex]);
     mIndex = (mIndex + 1) % POOL_COUNT;
 }
 
-void FrameInfoManager::denoiseFrameTime(FrameHistoryQueue& history, Config const& config) noexcept {
-    assert_invariant(!history.empty());
+void FrameInfoManager::update(Config const& config,
+        FrameInfoManager::duration lastFrameTime) noexcept {
+    // keep an history of frame times
+    auto& history = mFrameTimeHistory;
 
-    // find the first slot that has a valid frame duration
-    size_t first = history.size();
-    for (size_t i = 0, c = history.size(); i < c; ++i) {
-        if (history[i].frameTime != duration(0)) {
-            first = i;
-            break;
-        }
+    // this is like doing { pop_back(); push_front(); }
+    filament::move_backward(history.begin(), history.end() - 1, history.end());
+    history[0].frameTime = lastFrameTime;
+
+    mFrameTimeHistorySize = std::min(++mFrameTimeHistorySize, uint32_t(MAX_FRAMETIME_HISTORY));
+    if (UTILS_UNLIKELY(mFrameTimeHistorySize < 3)) {
+        // not enough history to do anything useful
+        history[0].valid = false;
+        return;
     }
-    assert_invariant(first != history.size());
 
-    // we need at least 3 valid frame time to calculate the median
-    if (history.size() >= first + 3) {
-        // apply a median filter to get a good representation of the frame time of the last
-        // N frames.
-        std::array<duration, MAX_FRAMETIME_HISTORY> median; // NOLINT -- it's initialized below
-        size_t const size = std::min({
-            history.size() - first,
-            median.size(),
-            size_t(config.historySize) });
+    // apply a median filter to get a good representation of the frame time of the last
+    // N frames.
+    std::array<duration, MAX_FRAMETIME_HISTORY> median; // NOLINT -- it's initialized below
+    size_t const size = std::min(mFrameTimeHistorySize,
+            std::min(config.historySize, (uint32_t)median.size()));
+    for (size_t i = 0; i < size; ++i) {
+        median[i] = history[i].frameTime;
+    }
+    std::sort(median.begin(), median.begin() + size);
+    duration const denoisedFrameTime = median[size / 2];
 
-        for (size_t i = 0; i < size; ++i) {
-            median[i] = history[first + i].frameTime;
-        }
-        std::sort(median.begin(), median.begin() + size);
-        duration const denoisedFrameTime = median[size / 2];
-
-        history[first].denoisedFrameTime = denoisedFrameTime;
-        history[first].valid = true;
-     }
+    history[0].denoisedFrameTime = denoisedFrameTime;
+    history[0].valid = true;
 }
 
-utils::FixedCapacityVector<Renderer::FrameInfo> FrameInfoManager::getFrameInfoHistory(
-        size_t historySize) const noexcept {
-    auto result = utils::FixedCapacityVector<Renderer::FrameInfo>::with_capacity(MAX_FRAMETIME_HISTORY);
-    auto const& history = mFrameTimeHistory;
-    size_t i = 0;
-    size_t const c = history.size();
-    for (; i < c; ++i) {
-        auto const& entry = history[i];
-        if (entry.ready.load(std::memory_order_acquire) && entry.valid) {
-            // once we found an entry ready,
-            // we know by construction that all following ones are too
-            break;
-        }
-    }
-    for (; i < c && historySize; ++i, --historySize) {
-        auto const& entry = history[i];
-        using namespace std::chrono;
-        result.push_back({
-                entry.frameId,
-                duration_cast<nanoseconds>(entry.frameTime).count(),
-                duration_cast<nanoseconds>(entry.denoisedFrameTime).count(),
-                duration_cast<nanoseconds>(entry.beginFrame.time_since_epoch()).count(),
-                duration_cast<nanoseconds>(entry.endFrame.time_since_epoch()).count(),
-                duration_cast<nanoseconds>(entry.backendBeginFrame.time_since_epoch()).count(),
-                duration_cast<nanoseconds>(entry.backendEndFrame.time_since_epoch()).count()
-        });
-    }
-    return result;
-}
 
 } // namespace filament

filament/src/FrameInfo.h

@@ -17,136 +17,30 @@
 #ifndef TNT_FILAMENT_FRAMEINFO_H
 #define TNT_FILAMENT_FRAMEINFO_H
 
-#include <filament/Renderer.h>
-
-#include <backend/Handle.h>
-
+#include "backend/Handle.h"
 #include <private/backend/DriverApi.h>
 
-#include <utils/compiler.h>
-#include <utils/debug.h>
-#include <utils/FixedCapacityVector.h>
-
 #include <array>
-#include <atomic>
 #include <chrono>
-#include <ratio>
-#include <type_traits>
 
 #include <stdint.h>
-#include <stddef.h>
 
 namespace filament {
 class FEngine;
 
-namespace details {
 struct FrameInfo {
     using duration = std::chrono::duration<float, std::milli>;
     duration frameTime{};            // frame period
     duration denoisedFrameTime{};    // frame period (median filter)
-    bool valid = false;              // true if the data of the structure is valid
-};
-} // namespace details
-
-struct FrameInfoImpl : public details::FrameInfo {
-    using clock = std::chrono::steady_clock;
-    using time_point = clock::time_point;
-    uint32_t const frameId;
-    time_point beginFrame;           // main thread beginFrame time
-    time_point endFrame;             // main thread endFrame time
-    time_point backendBeginFrame;    // backend thread beginFrame time (makeCurrent time)
-    time_point backendEndFrame;      // backend thread endFrame time (present time)
-    std::atomic_bool ready{};        // true once backend thread has populated its data
-    explicit FrameInfoImpl(uint32_t frameId) noexcept
-        : frameId(frameId) {
-    }
-};
-
-template<typename T, size_t CAPACITY>
-class CircularQueue {
-public:
-    using value_type = T;
-    using reference = value_type&;
-    using const_reference = value_type const&;
-
-    size_t capacity() const {
-        return CAPACITY;
-    }
-
-    size_t size() const {
-        return mSize;
-    }
-
-    bool empty() const noexcept {
-        return !size();
-    }
-
-    void pop_back() noexcept {
-        assert_invariant(!empty());
-        --mSize;
-        std::destroy_at(&mStorage[(mFront - mSize) % CAPACITY]);
-    }
-
-    void push_front(T const& v) noexcept {
-        assert_invariant(size() < CAPACITY);
-        mFront = advance(mFront);
-        new(&mStorage[mFront]) T(v);
-        ++mSize;
-    }
-
-    void push_front(T&& v) noexcept {
-        assert_invariant(size() < CAPACITY);
-        mFront = advance(mFront);
-        new(&mStorage[mFront]) T(std::move(v));
-        ++mSize;
-    }
-
-    template<typename ...Args>
-    T& emplace_front(Args&&... args) noexcept {
-        assert_invariant(size() < CAPACITY);
-        mFront = advance(mFront);
-        new(&mStorage[mFront]) T(std::forward<Args>(args)...);
-        ++mSize;
-        return front();
-    }
-
-    T& operator[](size_t pos) noexcept {
-        assert_invariant(pos < size());
-        size_t const index = (mFront + CAPACITY - pos) % CAPACITY;
-        return *std::launder(reinterpret_cast<T*>(&mStorage[index]));
-    }
-
-    T const& operator[](size_t pos) const noexcept {
-        return const_cast<CircularQueue&>(*this)[pos];
-    }
-
-    T const& front() const noexcept {
-        assert_invariant(!empty());
-        return operator[](0);
-    }
-
-    T& front() noexcept {
-        assert_invariant(!empty());
-        return operator[](0);
-    }
-
-private:
-    using Storage = std::aligned_storage_t<sizeof(T), alignof(T)>;
-    Storage mStorage[CAPACITY];
-    uint32_t mFront = 0;    // always index 0
-    uint32_t mSize = 0;
-    [[nodiscard]] inline uint32_t advance(uint32_t v) noexcept {
-        return (v + 1) % CAPACITY;
-    }
+    bool valid = false;
 };
 
 class FrameInfoManager {
     static constexpr size_t POOL_COUNT = 4;
-    static constexpr size_t MAX_FRAMETIME_HISTORY = 16u;
+    static constexpr size_t MAX_FRAMETIME_HISTORY = 31u;
 
 public:
-    using duration = FrameInfoImpl::duration;
-    using clock = FrameInfoImpl::clock;
+    using duration = FrameInfo::duration;
 
     struct Config {
         uint32_t historySize;
@@ -163,25 +57,23 @@ public:
     // call this immediately before "swap buffers"
     void endFrame(backend::DriverApi& driver) noexcept;
 
-    details::FrameInfo getLastFrameInfo() const noexcept {
-        // if pFront is not set yet, return FrameInfo(). But the `valid` field will be false in this case.
-        return pFront ? *pFront : details::FrameInfo{};
+    FrameInfo const& getLastFrameInfo() const noexcept {
+        return mFrameTimeHistory[0];
     }
 
-    utils::FixedCapacityVector<Renderer::FrameInfo> getFrameInfoHistory(size_t historySize) const noexcept;
+    duration getLastFrameTime() const noexcept {
+        return getLastFrameInfo().frameTime;
+    }
 
 private:
-    using FrameHistoryQueue = CircularQueue<FrameInfoImpl, MAX_FRAMETIME_HISTORY>;
-    static void denoiseFrameTime(FrameHistoryQueue& history, Config const& config) noexcept;
-    struct Query {
-        backend::Handle<backend::HwTimerQuery> handle{};
-        FrameInfoImpl* pInfo = nullptr;
-    };
-    std::array<Query, POOL_COUNT> mQueries;
-    uint32_t mIndex = 0;                // index of current query
-    uint32_t mLast = 0;                 // index of oldest query still active
-    FrameInfoImpl* pFront = nullptr;    // the most recent slot with a valid frame time
-    FrameHistoryQueue mFrameTimeHistory;
+    void update(Config const& config, duration lastFrameTime) noexcept;
+    backend::Handle<backend::HwTimerQuery> mQueries[POOL_COUNT];
+    duration mFrameTime{};
+    uint32_t mIndex = 0;
+    uint32_t mLast = 0;
+
+    std::array<FrameInfo, MAX_FRAMETIME_HISTORY> mFrameTimeHistory;
+    uint32_t mFrameTimeHistorySize = 0;
 };
 
 

filament/src/FrameSkipper.cpp

@@ -16,22 +16,16 @@
 
 #include "FrameSkipper.h"
 
-#include <backend/DriverEnums.h>
-
-#include <utils/compiler.h>
+#include <utils/Log.h>
 #include <utils/debug.h>
 
-#include <algorithm>
-
-#include <stddef.h>
-
 namespace filament {
 
 using namespace utils;
 using namespace backend;
 
 FrameSkipper::FrameSkipper(size_t latency) noexcept
-        : mLast(std::max(latency, MAX_FRAME_LATENCY) - 1) {
+        : mLast(latency - 1) {
     assert_invariant(latency <= MAX_FRAME_LATENCY);
 }
 
@@ -47,32 +41,31 @@ void FrameSkipper::terminate(DriverApi& driver) noexcept {
 
 bool FrameSkipper::beginFrame(DriverApi& driver) noexcept {
     auto& fences = mDelayedFences;
-    if (fences.front()) {
-        // Do we have a latency old fence?
-        auto status = driver.getFenceStatus(fences.front());
-        if (UTILS_UNLIKELY(status == FenceStatus::TIMEOUT_EXPIRED)) {
-            // The fence hasn't signaled yet, skip this frame
+    auto fence = fences.front();
+    if (fence) {
+        auto status = driver.getFenceStatus(fence);
+        if (status == FenceStatus::TIMEOUT_EXPIRED) {
+            // Sync not ready, skip frame
             return false;
         }
         assert_invariant(status == FenceStatus::CONDITION_SATISFIED);
+        driver.destroyFence(fence);
     }
+    // shift all fences down by 1
+    std::move(fences.begin() + 1, fences.end(), fences.begin());
+    fences.back() = {};
     return true;
 }
 
 void FrameSkipper::endFrame(DriverApi& driver) noexcept {
-    auto& fences = mDelayedFences;
-    size_t const last = mLast;
-
-    // pop the oldest fence and advance the other ones
-    if (fences.front()) {
-        driver.destroyFence(fences.front());
+    // If the user produced a new frame despite the fact that the previous one wasn't finished
+    // (i.e. FrameSkipper::beginFrame() returned false), we need to make sure to replace
+    // a fence that might be here already)
+    auto& fence = mDelayedFences[mLast];
+    if (fence) {
+        driver.destroyFence(fence);
     }
-    std::move(fences.begin() + 1, fences.end(), fences.begin());
-
-    // add a new fence to the end
-    assert_invariant(!fences[last]);
-
-    fences[last] = driver.createFence();
+    fence = driver.createFence();
 }
 
 } // namespace filament

filament/src/FrameSkipper.h

@@ -22,9 +22,6 @@
 
 #include <array>
 
-#include <stddef.h>
-#include <stdint.h>
-
 namespace filament {
 
 /*
@@ -63,7 +60,7 @@ public:
 private:
     using Container = std::array<backend::Handle<backend::HwFence>, MAX_FRAME_LATENCY>;
     mutable Container mDelayedFences{};
-    uint8_t const mLast;
+    size_t mLast;
 };
 
 } // namespace filament

filament/src/Froxelizer.cpp

@@ -26,7 +26,6 @@
 #include <filament/Viewport.h>
 
 #include <utils/BinaryTreeArray.h>
-#include <utils/Log.h>
 #include <utils/Systrace.h>
 #include <utils/debug.h>
 

filament/src/MaterialInstance.cpp

@@ -183,35 +183,6 @@ 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();
 }

filament/src/MaterialParser.cpp

@@ -354,12 +354,6 @@ bool MaterialParser::getSpecularAntiAliasingThreshold(float* value) const noexce
     return mImpl.getFromSimpleChunk(ChunkType::MaterialSpecularAntiAliasingThreshold, value);
 }
 
-bool MaterialParser::getStereoscopicType(backend::StereoscopicType* value) const noexcept {
-    static_assert(sizeof(StereoscopicType) == sizeof(uint8_t),
-            "StereoscopicType expected size is wrong");
-    return mImpl.getFromSimpleChunk(ChunkType::MaterialStereoscopicType, reinterpret_cast<uint8_t*>(value));
-}
-
 bool MaterialParser::getRequiredAttributes(AttributeBitset* value) const noexcept {
     uint32_t rawAttributes = 0;
     if (!mImpl.getFromSimpleChunk(ChunkType::MaterialRequiredAttributes, &rawAttributes)) {

filament/src/MaterialParser.h

@@ -122,7 +122,6 @@ public:
     bool hasSpecularAntiAliasing(bool* value) const noexcept;
     bool getSpecularAntiAliasingVariance(float* value) const noexcept;
     bool getSpecularAntiAliasingThreshold(float* value) const noexcept;
-    bool getStereoscopicType(backend::StereoscopicType*) const noexcept;
 
     bool getShader(filaflat::ShaderContent& shader, backend::ShaderModel shaderModel,
             Variant variant, backend::ShaderStage stage) noexcept;

filament/src/PostProcessManager.cpp

@@ -494,6 +494,7 @@ PostProcessManager::StructurePassOutput PostProcessManager::structure(FrameGraph
 
     struct StructureMipmapData {
         FrameGraphId<FrameGraphTexture> depth;
+        uint32_t rt[8];
     };
 
     fg.addPass<StructureMipmapData>("StructureMipmap",
@@ -504,7 +505,7 @@ PostProcessManager::StructurePassOutput PostProcessManager::structure(FrameGraph
                             .level = uint8_t(i)
                     });
                     out = builder.write(out, FrameGraphTexture::Usage::DEPTH_ATTACHMENT);
-                    builder.declareRenderPass("Structure mip target", {
+                    data.rt[i - 1] = builder.declareRenderPass("Structure mip target", {
                             .attachments = { .depth = out }
                     });
                 }
@@ -1964,8 +1965,8 @@ PostProcessManager::BloomPassOutput PostProcessManager::bloom(FrameGraph& fg,
         // - visible bloom size changes with dynamic resolution in non-homogenous mode
         // This allows us to use the 9 sample downsampling filter (instead of 13)
         // for at least 4 levels.
-        uint32_t width  = std::max(16u, uint32_t(std::floor(bloomWidth)));
-        uint32_t height = std::max(16u, uint32_t(std::floor(bloomHeight)));
+        uint32_t width  = std::max(1u, uint32_t(std::floor(bloomWidth)));
+        uint32_t height = std::max(1u, uint32_t(std::floor(bloomHeight)));
         width  &= ~((1 << 4) - 1);  // at least 4 levels
         height &= ~((1 << 4) - 1);
         bloomWidth  = float(width);
@@ -1977,8 +1978,6 @@ PostProcessManager::BloomPassOutput PostProcessManager::bloom(FrameGraph& fg,
     // we don't need to do the fireflies reduction if we have TAA (it already does it)
     bool fireflies = threshold && !taaOptions.enabled;
 
-    assert_invariant(bloomWidth && bloomHeight);
-
     while (2 * bloomWidth < float(desc.width) || 2 * bloomHeight < float(desc.height)) {
         if (inoutBloomOptions.quality == QualityLevel::LOW ||
             inoutBloomOptions.quality == QualityLevel::MEDIUM) {
@@ -2945,10 +2944,6 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::upscale(FrameGraph& fg, bool
                                     1.0f / outputDesc.height});
                     }
 
-                    if (blitterNames[index] == "blitLow") {
-                        mi->setParameter("levelOfDetail", 0.0f);
-                    }
-
                     mi->setParameter("viewport", float4{
                             (float)vp.left   / inputDesc.width,
                             (float)vp.bottom / inputDesc.height,
@@ -3007,8 +3002,9 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::blit(FrameGraph& fg, bool tr
         SamplerMagFilter filterMag,
         SamplerMinFilter filterMin) noexcept {
 
-    uint32_t const layer = fg.getSubResourceDescriptor(input).layer;
-    float const levelOfDetail = fg.getSubResourceDescriptor(input).level;
+    // TODO: add support for sub-resources
+    assert_invariant(fg.getSubResourceDescriptor(input).layer == 0);
+    assert_invariant(fg.getSubResourceDescriptor(input).level == 0);
 
     struct QuadBlitData {
         FrameGraphId<FrameGraphTexture> input;
@@ -3034,8 +3030,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::blit(FrameGraph& fg, bool tr
                 // --------------------------------------------------------------------------------
                 // set uniforms
 
-                PostProcessMaterial const& material =
-                        getPostProcessMaterial(layer ? "blitArray" : "blitLow");
+                PostProcessMaterial const& material = getPostProcessMaterial("blitLow");
                 auto* mi = material.getMaterialInstance(mEngine);
                 mi->setParameter("color", color, {
                         .filterMag = filterMag,
@@ -3047,10 +3042,6 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::blit(FrameGraph& fg, bool tr
                         float(vp.width)  / inputDesc.width,
                         float(vp.height) / inputDesc.height
                 });
-                mi->setParameter("levelOfDetail", levelOfDetail);
-                if (layer) {
-                    mi->setParameter("layerIndex", layer);
-                }
                 mi->commit(driver);
                 mi->use(driver);
 

filament/src/RenderPass.cpp

@@ -38,7 +38,6 @@
 #include <backend/PipelineState.h>
 
 #include "private/backend/CircularBuffer.h"
-#include "private/backend/CommandStream.h"
 
 #include <utils/compiler.h>
 #include <utils/debug.h>
@@ -118,11 +117,10 @@ RenderPass::RenderPass(FEngine& engine, RenderPassBuilder const& builder) noexce
     uint32_t const customCommandCount =
             builder.mCustomCommands.has_value() ? builder.mCustomCommands->size() : 0;
 
-    Command* const commandBegin = builder.mArena.alloc<Command>(commandCount + customCommandCount);
-    Command* commandEnd = commandBegin + (commandCount + customCommandCount);
-    assert_invariant(commandBegin);
+    Command* const curr = builder.mArena.alloc<Command>(commandCount + customCommandCount);
+    assert_invariant(curr);
 
-    if (UTILS_UNLIKELY(builder.mArena.getAllocator().isHeapAllocation(commandBegin))) {
+    if (UTILS_UNLIKELY(builder.mArena.getAllocator().isHeapAllocation(curr))) {
         static bool sLogOnce = true;
         if (UTILS_UNLIKELY(sLogOnce)) {
             sLogOnce = false;
@@ -131,7 +129,10 @@ RenderPass::RenderPass(FEngine& engine, RenderPassBuilder const& builder) noexce
         }
     }
 
-    appendCommands(engine, { commandBegin, commandCount },
+    mCommandBegin = curr;
+    mCommandEnd = curr + commandCount + customCommandCount;
+
+    appendCommands(engine, { curr, commandCount },
             builder.mUboHandle,
             builder.mVisibleRenderables,
             builder.mCommandTypeFlags,
@@ -142,36 +143,33 @@ RenderPass::RenderPass(FEngine& engine, RenderPassBuilder const& builder) noexce
             builder.mCameraForwardVector);
 
     if (builder.mCustomCommands.has_value()) {
-        Command* p = commandBegin + commandCount;
+        Command* p = curr + commandCount;
         for (auto [channel, passId, command, order, fn]: builder.mCustomCommands.value()) {
             appendCustomCommand(p++, channel, passId, command, order, fn);
         }
     }
 
     // sort commands once we're done adding commands
-    commandEnd = resize(builder.mArena,
-            RenderPass::sortCommands(commandBegin, commandEnd));
+    sortCommands(builder.mArena);
 
     if (engine.isAutomaticInstancingEnabled()) {
-        int32_t stereoscopicEyeCount = 1;
+        uint32_t stereoscopicEyeCount = 1;
         if (builder.mFlags & IS_INSTANCED_STEREOSCOPIC) {
             stereoscopicEyeCount *= engine.getConfig().stereoscopicEyeCount;
         }
-        commandEnd = resize(builder.mArena,
-                instanceify(engine, commandBegin, commandEnd, stereoscopicEyeCount));
+        instanceify(engine, builder.mArena, stereoscopicEyeCount);
     }
-
-    // these are `const` from this point on...
-    mCommandBegin = commandBegin;
-    mCommandEnd = commandEnd;
 }
 
 // this destructor is actually heavy because it inlines ~vector<>
-RenderPass::~RenderPass() noexcept = default;
+RenderPass::~RenderPass() noexcept {
+}
 
-RenderPass::Command* RenderPass::resize(Arena& arena, Command* const last) noexcept {
-    arena.rewind(last);
-    return last;
+void RenderPass::resize(Arena& arena, size_t count) noexcept {
+    if (mCommandBegin) {
+        mCommandEnd = mCommandBegin + count;
+        arena.rewind(mCommandEnd);
+    }
 }
 
 void RenderPass::appendCommands(FEngine& engine,
@@ -223,7 +221,7 @@ void RenderPass::appendCommands(FEngine& engine,
         work(vr.first, vr.size());
     } else {
         auto* jobCommandsParallel = jobs::parallel_for(js, nullptr, vr.first, (uint32_t)vr.size(),
-                std::cref(work), jobs::CountSplitter<JOBS_PARALLEL_FOR_COMMANDS_COUNT>());
+                std::cref(work), jobs::CountSplitter<JOBS_PARALLEL_FOR_COMMANDS_COUNT, 5>());
         js.runAndWait(jobCommandsParallel);
     }
 
@@ -262,19 +260,18 @@ void RenderPass::appendCustomCommand(Command* commands,
     commands->key = cmd;
 }
 
-RenderPass::Command* RenderPass::sortCommands(
-        Command* const begin, Command* const end) noexcept {
-    SYSTRACE_NAME("sort commands");
+void RenderPass::sortCommands(Arena& arena) noexcept {
+    SYSTRACE_NAME("sort and trim commands");
 
-    std::sort(begin, end);
+    std::sort(mCommandBegin, mCommandEnd);
 
     // find the last command
-    Command* const last = std::partition_point(begin, end,
+    Command const* const last = std::partition_point(mCommandBegin, mCommandEnd,
             [](Command const& c) {
                 return c.key != uint64_t(Pass::SENTINEL);
             });
 
-    return last;
+    resize(arena, uint32_t(last - mCommandBegin));
 }
 
 void RenderPass::execute(RenderPass const& pass,
@@ -287,9 +284,7 @@ void RenderPass::execute(RenderPass const& pass,
     driver.endRenderPass();
 }
 
-RenderPass::Command* RenderPass::instanceify(FEngine& engine,
-        Command* curr, Command* const last,
-        int32_t eyeCount) const noexcept {
+void RenderPass::instanceify(FEngine& engine, Arena& arena, int32_t eyeCount) noexcept {
     SYSTRACE_NAME("instanceify");
 
     // instanceify works by scanning the **sorted** command stream, looking for repeat draw
@@ -302,12 +297,14 @@ RenderPass::Command* RenderPass::instanceify(FEngine& engine,
 
     UTILS_UNUSED uint32_t drawCallsSavedCount = 0;
 
+    Command* curr = mCommandBegin;
+    Command* const last = mCommandEnd;
+
     Command* firstSentinel = nullptr;
     PerRenderableData const* uboData = nullptr;
     PerRenderableData* stagingBuffer = nullptr;
     uint32_t stagingBufferSize = 0;
     uint32_t instancedPrimitiveOffset = 0;
-    size_t const count = last - curr;
 
     // TODO: for the case of instancing we could actually use 128 instead of 64 instances
     constexpr size_t maxInstanceCount = CONFIG_MAX_INSTANCES;
@@ -346,6 +343,7 @@ RenderPass::Command* RenderPass::instanceify(FEngine& engine,
             if (UTILS_UNLIKELY(!stagingBuffer)) {
 
                 // create a temporary UBO for instancing
+                size_t const count = mCommandEnd - mCommandBegin;
                 mInstancedUboHandle = BufferObjectSharedHandle{
                         engine.getDriverApi().createBufferObject(
                                 count * sizeof(PerRenderableData) + sizeof(PerRenderableUib),
@@ -387,7 +385,7 @@ RenderPass::Command* RenderPass::instanceify(FEngine& engine,
 
     if (UTILS_UNLIKELY(firstSentinel)) {
         //slog.d << "auto-instancing, saving " << drawCallsSavedCount << " draw calls, out of "
-        //       << count << io::endl;
+        //       << mCommandEnd - mCommandBegin << io::endl;
 
         // we have instanced primitives
         DriverApi& driver = engine.getDriverApi();
@@ -403,15 +401,14 @@ RenderPass::Command* RenderPass::instanceify(FEngine& engine,
         stagingBuffer = nullptr;
 
         // remove all the canceled commands
-        auto lastCommand = std::remove_if(firstSentinel, last, [](auto const& command) {
+        auto lastCommand = std::remove_if(firstSentinel, mCommandEnd, [](auto const& command) {
             return command.key == uint64_t(Pass::SENTINEL);
         });
 
-        return lastCommand;
+        resize(arena, uint32_t(lastCommand - mCommandBegin));
     }
 
     assert_invariant(stagingBuffer == nullptr);
-    return last;
 }
 
 
@@ -610,7 +607,7 @@ RenderPass::Command* RenderPass::generateCommandsImpl(RenderPass::CommandTypeFla
         //   Here, objects close to the camera (but behind) will be drawn first.
         // An alternative that keeps the mathematical ordering is given here:
         //   distanceBits ^= ((int32_t(distanceBits) >> 31) | 0x80000000u);
-        float const distance = -(dot(soaWorldAABBCenter[i], cameraForward) - cameraPositionDotCameraForward);
+        float const distance = -dot(soaWorldAABBCenter[i], cameraForward) - cameraPositionDotCameraForward;
         uint32_t const distanceBits = reinterpret_cast<uint32_t const&>(distance);
 
         // calculate the per-primitive face winding order inversion
@@ -674,6 +671,7 @@ 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();
 
@@ -686,9 +684,8 @@ RenderPass::Command* RenderPass::generateCommandsImpl(RenderPass::CommandTypeFla
             cmd.info.indexOffset = primitive.getIndexOffset();
             cmd.info.indexCount = primitive.getIndexCount();
             cmd.info.type = primitive.getPrimitiveType();
-            cmd.info.morphTargetBuffer = morphing.morphTargetBuffer ?
-                    morphing.morphTargetBuffer->getHwHandle() : SamplerGroupHandle{};
-            cmd.info.morphingOffset = primitive.getMorphingBufferOffset();
+            cmd.info.morphTargetBuffer = morphTargets.buffer->getHwHandle();
+            cmd.info.morphingOffset = morphTargets.offset;
 
             if constexpr (isColorPass) {
                 RenderPass::setupColorCommand(cmd, renderableVariant, mi, inverseFrontFaces);
@@ -888,31 +885,14 @@ void RenderPass::Executor::execute(FEngine& engine,
 
         // Maximum space occupied in the CircularBuffer by a single `Command`. This must be
         // reevaluated when the inner loop below adds DriverApi commands or when we change the
-        // CommandStream protocol. Currently, the maximum is 320 bytes.
-        // The batch size is calculated by adding the size of all commands that can possibly be
-        // emitted per draw call:
-        constexpr size_t const maxCommandSizeInBytes =
-                sizeof(CustomCommand) +
-                sizeof(COMMAND_TYPE(scissor)) +
-                sizeof(COMMAND_TYPE(bindUniformBuffer)) +
-                sizeof(COMMAND_TYPE(bindSamplers)) +
-                sizeof(COMMAND_TYPE(bindBufferRange)) +
-                sizeof(COMMAND_TYPE(bindBufferRange)) +
-                sizeof(COMMAND_TYPE(bindSamplers)) +
-                sizeof(COMMAND_TYPE(bindSamplers)) +
-                sizeof(COMMAND_TYPE(bindUniformBuffer)) +
-                sizeof(COMMAND_TYPE(bindSamplers)) +
-                sizeof(COMMAND_TYPE(bindSamplers)) +
-                sizeof(COMMAND_TYPE(bindPipeline)) +
-                sizeof(COMMAND_TYPE(setPushConstant)) +
-                sizeof(COMMAND_TYPE(bindRenderPrimitive)) +
-                sizeof(COMMAND_TYPE(draw2));
-
+        // CommandStream protocol. Currently, the maximum is 240 bytes, and we use 256 to be on
+        // the safer side.
+        size_t const maxCommandSizeInBytes = 256;
 
         // Number of Commands that can be issued and guaranteed to fit in the current
         // CircularBuffer allocation. In practice, we'll have tons of headroom especially if
         // skinning and morphing aren't used. With a 2 MiB buffer (the default) a batch is
-        // 6553 commands (i.e. draw calls).
+        // 8192 commands (i.e. draw calls).
         size_t const batchCommandCount = capacity / maxCommandSizeInBytes;
         while(first != last) {
             Command const* const batchLast = std::min(first + batchCommandCount, last);

filament/src/RenderPass.h

@@ -408,19 +408,17 @@ private:
             uint8_t channel, Pass pass, CustomCommand custom, uint32_t order,
             Executor::CustomCommandFn command);
 
-    static Command* resize(Arena& arena, Command* const last) noexcept;
+    void resize(Arena& arena, size_t count) noexcept;
 
     // sorts commands then trims sentinels
-    static Command* sortCommands(
-            Command* begin, Command* end) noexcept;
+    void sortCommands(Arena& arena) noexcept;
 
     // instanceify commands then trims sentinels
-    RenderPass::Command* instanceify(FEngine& engine,
-            Command* begin, Command* end,
-            int32_t eyeCount) const noexcept;
+    void instanceify(FEngine& engine, Arena& arena, int32_t eyeCount) noexcept;
 
     // We choose the command count per job to minimize JobSystem overhead.
-    static constexpr size_t JOBS_PARALLEL_FOR_COMMANDS_COUNT = 128;
+    // On a Pixel 4, 2048 commands is about half a millisecond of processing.
+    static constexpr size_t JOBS_PARALLEL_FOR_COMMANDS_COUNT = 2048;
     static constexpr size_t JOBS_PARALLEL_FOR_COMMANDS_SIZE  =
             sizeof(Command) * JOBS_PARALLEL_FOR_COMMANDS_COUNT;
 
@@ -451,10 +449,10 @@ private:
 
     FScene::RenderableSoa const& mRenderableSoa;
     backend::Viewport const mScissorViewport;
-    Command const* /* const */ mCommandBegin = nullptr;   // Pointer to the first command
-    Command const* /* const */ mCommandEnd = nullptr;     // Pointer to one past the last command
+    Command* mCommandBegin = nullptr;   // Pointer to the first command
+    Command* mCommandEnd = nullptr;     // Pointer to one past the last command
     // a UBO for instanced primitives
-    mutable BufferObjectSharedHandle mInstancedUboHandle;
+    BufferObjectSharedHandle mInstancedUboHandle;
     // a vector for our custom commands
     using CustomCommandVector = std::vector<Executor::CustomCommandFn,
             utils::STLAllocator<Executor::CustomCommandFn, LinearAllocatorArena>>;