Testing ankerl containers

* improve parallel_for a bit

We get about 40% performance increase. The gain comes from not having
to copy the JobData structure each time we create a job, by using a
new emplaceJob() method, we can create the structure directly into
its destination.

* avoid calling wakeAll() when possible

wakeAll() is very expensive and not always needed when a job finishes
because there may not be anyone waiting on that job.

We now maintain a waiter count per job, and use that to determine if
we need to notify or not.

And now that the JobSystem overhead is lower, we can decrease the size
of the jobs, which improves the load balancing.

* mActiveJobs fixes

some comments claimed mActiveJobs needed to be modified before or after
accessing the WorkQueue; this couldn't be correct because there were no
guaranteed global ordering with the workQueue.

CMakeLists.txt

@@ -746,6 +746,7 @@ add_subdirectory(${EXTERNAL}/draco/tnt)
 add_subdirectory(${EXTERNAL}/jsmn/tnt)
 add_subdirectory(${EXTERNAL}/stb/tnt)
 add_subdirectory(${EXTERNAL}/getopt)
+add_subdirectory(${EXTERNAL}/unordered_dense)
 
 # Note that this has to be placed after mikktspace in order for combine_static_libs to work.
 add_subdirectory(${LIBRARIES}/geometry)

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.53.0'
+    implementation 'com.google.android.filament:filament-android:1.53.2'
 }
 ```
 
@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:
 
 ```shell
-pod 'Filament', '~> 1.53.0'
+pod 'Filament', '~> 1.53.2'
 ```
 
 ### Snapshots
@@ -176,6 +176,7 @@ steps:
   - [x] KHR_materials_unlit
   - [x] KHR_materials_variants
   - [x] KHR_materials_volume
+  - [x] KHR_materials_specular
   - [x] KHR_mesh_quantization
   - [x] KHR_texture_basisu
   - [x] KHR_texture_transform

RELEASE_NOTES.md

@@ -7,6 +7,13 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).
 
+## v1.53.3
+
+- Add drag and drop support for IBL files for desktop gltf_viewer.
+
+## v1.53.2
+
+
 ## v1.53.1
 
 

android/filament-android/CMakeLists.txt

@@ -128,7 +128,6 @@ target_include_directories(filament-jni PRIVATE
         ..
         ${FILAMENT_DIR}/include
         ../../filament/backend/include
-        ../../third_party/robin-map
         ../../libs/utils/include)
 
 # Force a relink when the version script is changed:

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

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

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

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

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

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

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

@@ -187,3 +187,10 @@ Java_com_google_android_filament_Renderer_nSetPresentationTime(JNIEnv *, jclass
     Renderer *renderer = (Renderer *) nativeRenderer;
     renderer->setPresentationTime(monotonicClockNanos);
 }
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Renderer_nSetVsyncTime(JNIEnv *, jclass,
+    jlong nativeRenderer, jlong steadyClockTimeNano) {
+    Renderer *renderer = (Renderer *) nativeRenderer;
+    renderer->setVsyncTime(steadyClockTimeNano);
+}

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

@@ -1292,7 +1292,6 @@ 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
      */
@@ -1300,6 +1299,13 @@ 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,6 +346,7 @@ public class Material {
     public static class Builder {
         private Buffer mBuffer;
         private int mSize;
+        private int mShBandCount = 0;
 
         /**
          * Specifies the material data. The material data is a binary blob produced by
@@ -361,6 +362,22 @@ public class Material {
             return this;
         }
 
+        /**
+         * Sets the quality of the indirect lights computations. This is only taken into account
+         * if this material is lit and in the surface domain. This setting will affect the
+         * IndirectLight computation if one is specified on the Scene and Spherical Harmonics
+         * are used for the irradiance.
+         *
+         * @param shBandCount Number of spherical harmonic bands. Must be 1, 2 or 3 (default).
+         * @return Reference to this Builder for chaining calls.
+         * @see IndirectLight
+         */
+        @NonNull
+        public Builder sphericalHarmonicsBandCount(@IntRange(from = 0) int shBandCount) {
+            mShBandCount = shBandCount;
+            return this;
+        }
+
         /**
          * Creates and returns the Material object.
          *
@@ -372,7 +389,8 @@ public class Material {
          */
         @NonNull
         public Material build(@NonNull Engine engine) {
-            long nativeMaterial = nBuilderBuild(engine.getNativeObject(), mBuffer, mSize);
+            long nativeMaterial = nBuilderBuild(engine.getNativeObject(),
+                mBuffer, mSize, mShBandCount);
             if (nativeMaterial == 0) throw new IllegalStateException("Couldn't create Material");
             return new Material(nativeMaterial);
         }
@@ -1023,7 +1041,7 @@ public class Material {
         mNativeObject = 0;
     }
 
-    private static native long nBuilderBuild(long nativeEngine, @NonNull Buffer buffer, int size);
+    private static native long nBuilderBuild(long nativeEngine, @NonNull Buffer buffer, int size, int shBandCount);
     private static native long nCreateInstance(long nativeMaterial);
     private static native long nCreateInstanceWithName(long nativeMaterial, @NonNull String name);
     private static native long nGetDefaultInstance(long nativeMaterial);

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 #setMorphTargetBufferAt
+         * @see #setMorphTargetBufferOffsetAt
          */
         @NonNull
         public MorphTargetBuffer build(@NonNull Engine engine) {

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

@@ -569,40 +569,13 @@ public class RenderableManager {
          *
          * @param level the level of detail (lod), only 0 can be specified
          * @param primitiveIndex zero-based index of the primitive, must be less than the count passed to Builder constructor
-         * @param morphTargetBuffer specifies the morph target buffer
          * @param offset specifies where in the morph target buffer to start reading (expressed as a number of vertices)
-         * @param count number of vertices in the morph target buffer to read, must equal the geometry's count (for triangles, this should be a multiple of 3)
          */
         @NonNull
         public Builder morphing(@IntRange(from = 0) int level,
                                 @IntRange(from = 0) int primitiveIndex,
-                                @IntRange(from = 0) int offset,
-                                @IntRange(from = 0) int count) {
-            nBuilderSetMorphTargetBufferAt(mNativeBuilder, level, primitiveIndex, 0, offset, count);
-            return this;
-        }
-
-        /** @deprecated */
-        @Deprecated
-        @NonNull
-        public Builder morphing(@IntRange(from = 0) int level,
-                                @IntRange(from = 0) int primitiveIndex,
-                                @NonNull MorphTargetBuffer morphTargetBuffer,
-                                @IntRange(from = 0) int offset,
-                                @IntRange(from = 0) int count) {
-            nBuilderSetMorphTargetBufferAt(mNativeBuilder, level, primitiveIndex,
-                    morphTargetBuffer.getNativeObject(), offset, count);
-            return this;
-        }
-
-        /** @deprecated */
-        @Deprecated
-        @NonNull
-        public Builder morphing(@IntRange(from = 0) int level,
-                                @IntRange(from = 0) int primitiveIndex,
-                                @NonNull MorphTargetBuffer morphTargetBuffer) {
-            nBuilderSetMorphTargetBufferAt(mNativeBuilder, level, primitiveIndex,
-                    morphTargetBuffer.getNativeObject(), 0, morphTargetBuffer.getVertexCount());
+                                @IntRange(from = 0) int offset) {
+            nBuilderSetMorphTargetBufferOffsetAt(mNativeBuilder, level, primitiveIndex, offset);
             return this;
         }
 
@@ -705,34 +678,11 @@ public class RenderableManager {
      *
      * @see Builder#morphing
      */
-    public void setMorphTargetBufferAt(@EntityInstance int i,
+    public void setMorphTargetBufferOffsetAt(@EntityInstance int i,
                                        @IntRange(from = 0) int level,
                                        @IntRange(from = 0) int primitiveIndex,
-                                       @IntRange(from = 0) int offset,
-                                       @IntRange(from = 0) int count) {
-        nSetMorphTargetBufferAt(mNativeObject, i, level, primitiveIndex, 0, offset, count);
-    }
-
-    /** @deprecated */
-    @Deprecated
-    public void setMorphTargetBufferAt(@EntityInstance int i,
-                                       @IntRange(from = 0) int level,
-                                       @IntRange(from = 0) int primitiveIndex,
-                                       @NonNull MorphTargetBuffer morphTargetBuffer,
-                                       @IntRange(from = 0) int offset,
-                                       @IntRange(from = 0) int count) {
-        nSetMorphTargetBufferAt(mNativeObject, i, level, primitiveIndex,
-                morphTargetBuffer.getNativeObject(), offset, count);
-    }
-
-    /** @deprecated */
-    @Deprecated
-    public void setMorphTargetBufferAt(@EntityInstance int i,
-                                       @IntRange(from = 0) int level,
-                                       @IntRange(from = 0) int primitiveIndex,
-                                       @NonNull MorphTargetBuffer morphTargetBuffer) {
-        nSetMorphTargetBufferAt(mNativeObject, i, level, primitiveIndex,
-                morphTargetBuffer.getNativeObject(), 0, morphTargetBuffer.getVertexCount());
+                                       @IntRange(from = 0) int offset) {
+        nSetMorphTargetBufferOffsetAt(mNativeObject, i, level, primitiveIndex, 0, offset);
     }
 
     /**
@@ -1033,7 +983,7 @@ public class RenderableManager {
     private static native void nBuilderSkinningBuffer(long nativeBuilder, long nativeSkinningBuffer, int boneCount, int offset);
     private static native void nBuilderMorphing(long nativeBuilder, int targetCount);
     private static native void nBuilderMorphingStandard(long nativeBuilder, long nativeMorphTargetBuffer);
-    private static native void nBuilderSetMorphTargetBufferAt(long nativeBuilder, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset, int count);
+    private static native void nBuilderSetMorphTargetBufferOffsetAt(long nativeBuilder, int level, int primitiveIndex, int offset);
     private static native void nBuilderEnableSkinningBuffers(long nativeBuilder, boolean enabled);
     private static native void nBuilderFog(long nativeBuilder, boolean enabled);
     private static native void nBuilderLightChannel(long nativeRenderableManager, int channel, boolean enable);
@@ -1043,7 +993,7 @@ public class RenderableManager {
     private static native int nSetBonesAsMatrices(long nativeObject, int i, Buffer matrices, int remaining, int boneCount, int offset);
     private static native int nSetBonesAsQuaternions(long nativeObject, int i, Buffer quaternions, int remaining, int boneCount, int offset);
     private static native void nSetMorphWeights(long nativeObject, int instance, float[] weights, int offset);
-    private static native void nSetMorphTargetBufferAt(long nativeObject, int i, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset, int count);
+    private static native void nSetMorphTargetBufferOffsetAt(long nativeObject, int i, int level, int primitiveIndex, long nativeMorphTargetBuffer, int offset);
     private static native int nGetMorphTargetCount(long nativeObject, int i);
     private static native void nSetAxisAlignedBoundingBox(long nativeRenderableManager, int i, float cx, float cy, float cz, float ex, float ey, float ez);
     private static native void nSetLayerMask(long nativeRenderableManager, int i, int select, int value);

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

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

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

@@ -125,6 +125,11 @@ 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,6 +274,17 @@ 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.
          *
@@ -483,6 +494,7 @@ 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.53.0
+VERSION_NAME=1.53.2
 
 POM_DESCRIPTION=Real-time physically based rendering engine for Android.
 

filament/backend/CMakeLists.txt

@@ -313,6 +313,7 @@ endif()
 
 target_link_libraries(${TARGET} PUBLIC math)
 target_link_libraries(${TARGET} PUBLIC utils)
+target_link_libraries(${TARGET} PRIVATE unordered_dense)
 
 # Android, iOS, and WebGL do not use bluegl.
 if(FILAMENT_SUPPORTS_OPENGL AND NOT IOS AND NOT ANDROID AND NOT WEBGL)

filament/backend/include/backend/Platform.h

@@ -75,6 +75,8 @@ public:
          */
         size_t textureUseAfterFreePoolSize = 0;
 
+        size_t metalUploadBufferSizeBytes = 512 * 1024;
+
         /**
          * Set to `true` to forcibly disable parallel shader compilation in the backend.
          * Currently only honored by the GL and Metal backends.

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

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

filament/backend/src/CircularBuffer.cpp

@@ -32,10 +32,11 @@
 #    define HAS_MMAP 0
 #endif
 
-#include <stdint.h>
 #include <stddef.h>
-#include <stdlib.h>
+#include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 using namespace utils;
 
@@ -81,6 +82,9 @@ 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);
@@ -101,7 +105,7 @@ void* CircularBuffer::alloc(size_t size) noexcept {
     if (UTILS_UNLIKELY(mAshmemFd < 0)) {
         // ashmem failed
         if (vaddr_guard != MAP_FAILED) {
-            munmap(vaddr_guard, size);
+            munmap(vaddr_guard, BLOCK_SIZE);
         }
 
         if (vaddr_shadow != MAP_FAILED) {
@@ -119,12 +123,11 @@ 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) <<
+        FILAMENT_CHECK_POSTCONDITION(data != MAP_FAILED) <<
                 "couldn't allocate " << (size * 2 / 1024) <<
                 " KiB of virtual address space for the command buffer";
 
-        slog.d << "WARNING: Using soft CircularBuffer (" << (size * 2 / 1024) << " KiB)"
-               << io::endl;
+        slog.w << "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/metal/MetalBuffer.h

@@ -204,6 +204,15 @@ public:
 
 private:
 
+    enum class UploadStrategy {
+        POOL,
+        BUMP_ALLOCATOR,
+    };
+
+    void uploadWithPoolBuffer(void* src, size_t size, size_t byteOffset) const;
+    void uploadWithBumpAllocator(void* src, size_t size, size_t byteOffset) const;
+
+    UploadStrategy mUploadStrategy;
     TrackedMetalBuffer mBuffer;
     size_t mBufferSize = 0;
     void* mCpuBuffer = nullptr;

filament/backend/src/metal/MetalBuffer.mm

@@ -27,7 +27,16 @@ MetalPlatform* TrackedMetalBuffer::platform = nullptr;
 MetalPlatform* ScopedAllocationTimer::platform = nullptr;
 
 MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType, BufferUsage usage,
-        size_t size, bool forceGpuBuffer) : mBufferSize(size), mContext(context) {
+        size_t size, bool forceGpuBuffer)
+    : mBufferSize(size), mContext(context) {
+    const MetalBumpAllocator& allocator = *mContext.bumpAllocator;
+    // VERTEX is also used for index buffers
+    if (allocator.getCapacity() > 0 && bindingType == BufferObjectBinding::VERTEX) {
+        mUploadStrategy = UploadStrategy::BUMP_ALLOCATOR;
+    } else {
+        mUploadStrategy = UploadStrategy::POOL;
+    }
+
     // If the buffer is less than 4K in size and is updated frequently, we don't use an explicit
     // buffer. Instead, we use immediate command encoder methods like setVertexBytes:length:atIndex:.
     // This won't work for SSBOs, since they are read/write.
@@ -61,34 +70,23 @@ void MetalBuffer::copyIntoBuffer(void* src, size_t size, size_t byteOffset) {
     FILAMENT_CHECK_PRECONDITION(size + byteOffset <= mBufferSize)
             << "Attempting to copy " << size << " bytes into a buffer of size " << mBufferSize
             << " at offset " << byteOffset;
+    // The copy blit requires that byteOffset be a multiple of 4.
+    FILAMENT_CHECK_PRECONDITION(!(byteOffset & 0x3)) << "byteOffset must be a multiple of 4";
 
-    // Either copy into the Metal buffer or into our cpu buffer.
+    // If we have a cpu buffer, we can directly copy into it.
     if (mCpuBuffer) {
         memcpy(static_cast<uint8_t*>(mCpuBuffer) + byteOffset, src, size);
         return;
     }
 
-    // Acquire a staging buffer to hold the contents of this update.
-    MetalBufferPool* bufferPool = mContext.bufferPool;
-    const MetalBufferPoolEntry* const staging = bufferPool->acquireBuffer(size);
-    memcpy(staging->buffer.get().contents, src, size);
-
-    // The blit below requires that byteOffset be a multiple of 4.
-    FILAMENT_CHECK_PRECONDITION(!(byteOffset & 0x3u)) << "byteOffset must be a multiple of 4";
-
-    // Encode a blit from the staging buffer into the private GPU buffer.
-    id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);
-    id<MTLBlitCommandEncoder> blitEncoder = [cmdBuffer blitCommandEncoder];
-    blitEncoder.label = @"Buffer upload blit";
-    [blitEncoder copyFromBuffer:staging->buffer.get()
-                   sourceOffset:0
-                       toBuffer:mBuffer.get()
-              destinationOffset:byteOffset
-                           size:size];
-    [blitEncoder endEncoding];
-    [cmdBuffer addCompletedHandler:^(id<MTLCommandBuffer> cb) {
-        bufferPool->releaseBuffer(staging);
-    }];
+    switch (mUploadStrategy) {
+        case UploadStrategy::BUMP_ALLOCATOR:
+            uploadWithBumpAllocator(src, size, byteOffset);
+            break;
+        case UploadStrategy::POOL:
+            uploadWithPoolBuffer(src, size, byteOffset);
+            break;
+    }
 }
 
 void MetalBuffer::copyIntoBufferUnsynchronized(void* src, size_t size, size_t byteOffset) {
@@ -199,5 +197,42 @@ void MetalBuffer::bindBuffers(id<MTLCommandBuffer> cmdBuffer, id<MTLCommandEncod
     }
 }
 
+void MetalBuffer::uploadWithPoolBuffer(void* src, size_t size, size_t byteOffset) const {
+    MetalBufferPool* bufferPool = mContext.bufferPool;
+    const MetalBufferPoolEntry* const staging = bufferPool->acquireBuffer(size);
+    memcpy(staging->buffer.get().contents, src, size);
+
+    // Encode a blit from the staging buffer into the private GPU buffer.
+    id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);
+    id<MTLBlitCommandEncoder> blitEncoder = [cmdBuffer blitCommandEncoder];
+    blitEncoder.label = @"Buffer upload blit - pool buffer";
+    [blitEncoder copyFromBuffer:staging->buffer.get()
+                   sourceOffset:0
+                       toBuffer:mBuffer.get()
+              destinationOffset:byteOffset
+                           size:size];
+    [blitEncoder endEncoding];
+    [cmdBuffer addCompletedHandler:^(id<MTLCommandBuffer> cb) {
+        bufferPool->releaseBuffer(staging);
+    }];
+}
+
+void MetalBuffer::uploadWithBumpAllocator(void* src, size_t size, size_t byteOffset) const {
+    MetalBumpAllocator& allocator = *mContext.bumpAllocator;
+    auto [buffer, offset] = allocator.allocateStagingArea(size);
+    memcpy(static_cast<char*>(buffer.contents) + offset, src, size);
+
+    // Encode a blit from the staging buffer into the private GPU buffer.
+    id<MTLCommandBuffer> cmdBuffer = getPendingCommandBuffer(&mContext);
+    id<MTLBlitCommandEncoder> blitEncoder = [cmdBuffer blitCommandEncoder];
+    blitEncoder.label = @"Buffer upload blit - bump allocator";
+    [blitEncoder copyFromBuffer:buffer
+                   sourceOffset:offset
+                       toBuffer:mBuffer.get()
+              destinationOffset:byteOffset
+                           size:size];
+    [blitEncoder endEncoding];
+}
+
 } // namespace backend
 } // namespace filament

filament/backend/src/metal/MetalBufferPool.h

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

filament/backend/src/metal/MetalBufferPool.mm

@@ -116,5 +116,39 @@ void MetalBufferPool::reset() noexcept {
     mFreeStages.clear();
 }
 
+MetalBumpAllocator::MetalBumpAllocator(id<MTLDevice> device, size_t capacity)
+    : mDevice(device), mCapacity(capacity) {
+    if (mCapacity > 0) {
+        mCurrentUploadBuffer = { [device newBufferWithLength:capacity options:MTLStorageModeShared],
+            TrackedMetalBuffer::Type::STAGING };
+    }
+}
+
+std::pair<id<MTLBuffer>, size_t> MetalBumpAllocator::allocateStagingArea(size_t size) {
+    if (size == 0) {
+        return { nil, 0 };
+    }
+    if (size > mCapacity) {
+        return { [mDevice newBufferWithLength:size options:MTLStorageModeShared], 0 };
+    }
+    assert_invariant(mCurrentUploadBuffer);
+
+    // Align the head to a 4-byte boundary.
+    mHead = (mHead + 3) & ~3;
+
+    if (UTILS_LIKELY(mHead + size <= mCapacity)) {
+        const size_t oldHead = mHead;
+        mHead += size;
+        return { mCurrentUploadBuffer.get(), oldHead };
+    }
+
+    // We're finished with the current allocation.
+    mCurrentUploadBuffer = { [mDevice newBufferWithLength:mCapacity options:MTLStorageModeShared],
+        TrackedMetalBuffer::Type::STAGING };
+    mHead = size;
+
+    return { mCurrentUploadBuffer.get(), 0 };
+}
+
 } // namespace backend
 } // namespace filament

filament/backend/src/metal/MetalContext.h

@@ -44,6 +44,7 @@ namespace backend {
 class MetalDriver;
 class MetalBlitter;
 class MetalBufferPool;
+class MetalBumpAllocator;
 class MetalRenderTarget;
 class MetalSamplerGroup;
 class MetalSwapChain;
@@ -141,6 +142,7 @@ struct MetalContext {
     utils::FixedCircularBuffer<Handle<HwTexture>> texturesToDestroy;
 
     MetalBufferPool* bufferPool;
+    MetalBumpAllocator* bumpAllocator;
 
     MetalSwapChain* currentDrawSwapChain = nil;
     MetalSwapChain* currentReadSwapChain = nil;

filament/backend/src/metal/MetalDriver.mm

@@ -171,6 +171,8 @@ MetalDriver::MetalDriver(MetalPlatform* platform, const Platform::DriverConfig&
     mContext->samplerStateCache.setDevice(mContext->device);
     mContext->argumentEncoderCache.setDevice(mContext->device);
     mContext->bufferPool = new MetalBufferPool(*mContext);
+    mContext->bumpAllocator =
+            new MetalBumpAllocator(mContext->device, driverConfig.metalUploadBufferSizeBytes);
     mContext->blitter = new MetalBlitter(*mContext);
 
     if (@available(iOS 12, *)) {
@@ -209,6 +211,7 @@ MetalDriver::~MetalDriver() noexcept {
     mContext->emptyTexture = nil;
     CFRelease(mContext->textureCache);
     delete mContext->bufferPool;
+    delete mContext->bumpAllocator;
     delete mContext->blitter;
     delete mContext->timerQueryImpl;
     delete mContext->shaderCompiler;

filament/backend/src/metal/MetalHandles.h

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

filament/backend/src/metal/MetalHandles.mm

@@ -73,6 +73,7 @@ MetalSwapChain::MetalSwapChain(MetalContext& context, CAMetalLayer* nativeWindow
     : context(context),
       depthStencilFormat(decideDepthStencilFormat(flags)),
       layer(nativeWindow),
+      layerDrawableMutex(std::make_shared<std::mutex>()),
       externalImage(context),
       type(SwapChainType::CAMETALLAYER) {
 
@@ -179,7 +180,7 @@ id<MTLTexture> MetalSwapChain::acquireDrawable() {
     // calling -nextDrawable, or when releasing the last known reference
     // to any CAMetalDrawable returned from a previous -nextDrawable.
     {
-        std::lock_guard<std::mutex> lock(layerDrawableMutex);
+        std::lock_guard<std::mutex> lock(*layerDrawableMutex);
         drawable = [layer nextDrawable];
     }
 
@@ -188,8 +189,10 @@ id<MTLTexture> MetalSwapChain::acquireDrawable() {
 }
 
 void MetalSwapChain::releaseDrawable() {
-    std::lock_guard<std::mutex> lock(layerDrawableMutex);
-    drawable = nil;
+    if (drawable) {
+        std::lock_guard<std::mutex> lock(*layerDrawableMutex);
+        drawable = nil;
+    }
 }
 
 id<MTLTexture> MetalSwapChain::acquireDepthTexture() {
@@ -265,7 +268,7 @@ public:
     PresentDrawableData& operator=(const PresentDrawableData&) = delete;
 
     static PresentDrawableData* create(id<CAMetalDrawable> drawable,
-            std::mutex* drawableMutex, MetalDriver* driver) {
+            std::shared_ptr<std::mutex> drawableMutex, MetalDriver* driver) {
         assert_invariant(drawableMutex);
         assert_invariant(driver);
         return new PresentDrawableData(drawable, drawableMutex, driver);
@@ -287,22 +290,22 @@ public:
     }
 
 private:
-    PresentDrawableData(id<CAMetalDrawable> drawable, std::mutex* drawableMutex,
+    PresentDrawableData(id<CAMetalDrawable> drawable, std::shared_ptr<std::mutex> drawableMutex,
             MetalDriver* driver)
         : mDrawable(drawable), mDrawableMutex(drawableMutex), mDriver(driver) {}
 
     static void cleanupAndDestroy(PresentDrawableData *that) {
-        {
+        if (that->mDrawable) {
             std::lock_guard<std::mutex> lock(*(that->mDrawableMutex));
             that->mDrawable = nil;
         }
-        that->mDrawableMutex = nullptr;
+        that->mDrawableMutex.reset();
         that->mDriver = nullptr;
         delete that;
     }
 
     id<CAMetalDrawable> mDrawable;
-    std::mutex* mDrawableMutex = nullptr;
+    std::shared_ptr<std::mutex> mDrawableMutex;
     MetalDriver* mDriver = nullptr;
 };
 
@@ -320,7 +323,7 @@ void MetalSwapChain::scheduleFrameScheduledCallback() {
 
     struct Callback {
         Callback(std::shared_ptr<FrameScheduledCallback> callback, id<CAMetalDrawable> drawable,
-                std::mutex* drawableMutex, MetalDriver* driver)
+                 std::shared_ptr<std::mutex> drawableMutex, MetalDriver* driver)
             : f(callback), data(PresentDrawableData::create(drawable, drawableMutex, driver)) {}
         std::shared_ptr<FrameScheduledCallback> f;
         // PresentDrawableData* is destroyed by maybePresentAndDestroyAsync() later.
@@ -337,7 +340,7 @@ void MetalSwapChain::scheduleFrameScheduledCallback() {
     // This callback pointer will be captured by the block. Even if the scheduled handler is never
     // called, the unique_ptr will still ensure we don't leak memory.
     __block auto callback = std::make_unique<Callback>(
-        frameScheduled.callback, drawable, &layerDrawableMutex, context.driver);
+        frameScheduled.callback, drawable, layerDrawableMutex, context.driver);
 
     backend::CallbackHandler* handler = frameScheduled.handler;
     MetalDriver* driver = context.driver;
@@ -553,8 +556,6 @@ 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:
@@ -569,8 +570,6 @@ 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];
@@ -583,8 +582,6 @@ 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
@@ -593,6 +590,12 @@ 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/opengl/OpenGLDriver.cpp

@@ -304,6 +304,13 @@ void OpenGLDriver::bindSampler(GLuint unit, GLuint sampler) noexcept {
 void OpenGLDriver::setPushConstant(backend::ShaderStage stage, uint8_t index,
         backend::PushConstantVariant value) {
     assert_invariant(stage == ShaderStage::VERTEX || stage == ShaderStage::FRAGMENT);
+
+#if FILAMENT_ENABLE_MATDBG
+    if (UTILS_UNLIKELY(!mValidProgram)) {
+        return;
+    }
+#endif
+
     utils::Slice<std::pair<GLint, ConstantType>> constants;
     if (stage == ShaderStage::VERTEX) {
         constants = mCurrentPushConstants->vertexConstants;
@@ -340,15 +347,11 @@ void OpenGLDriver::bindTexture(GLuint unit, GLTexture const* t) noexcept {
 }
 
 bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
-    if (UTILS_UNLIKELY(!p->isValid())) {
-        // If the program is not valid, we can't call use().
-        return false;
-    }
-
     // set-up textures and samplers in the proper TMUs (as specified in setSamplers)
-    p->use(this, mContext);
+    bool const success = p->use(this, mContext);
+    assert_invariant(success == p->isValid());
 
-    if (UTILS_UNLIKELY(mContext.isES2())) {
+    if (UTILS_UNLIKELY(mContext.isES2() && success)) {
         for (uint32_t i = 0; i < Program::UNIFORM_BINDING_COUNT; i++) {
             auto [id, buffer, age] = mContext.getEs2UniformBinding(i);
             if (buffer) {
@@ -359,7 +362,8 @@ bool OpenGLDriver::useProgram(OpenGLProgram* p) noexcept {
         // when mPlatform.isSRGBSwapChainSupported() is false (no need to check though).
         p->setRec709ColorSpace(mRec709OutputColorspace);
     }
-    return true;
+
+    return success;
 }
 
 
@@ -2332,9 +2336,9 @@ void OpenGLDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh,
     auto const* const pSamplers = (SamplerDescriptor const*)data.buffer;
     for (size_t i = 0, c = sb->textureUnitEntries.size(); i < c; i++) {
         GLuint samplerId = 0u;
-        const GLTexture* t = nullptr;
-        if (UTILS_LIKELY(pSamplers[i].t)) {
-            t = handle_cast<const GLTexture*>(pSamplers[i].t);
+        Handle<HwTexture> th = pSamplers[i].t;
+        if (UTILS_LIKELY(th)) {
+            GLTexture const* const t = handle_cast<const GLTexture*>(th);
             assert_invariant(t);
 
             SamplerParams params = pSamplers[i].s;
@@ -2390,7 +2394,7 @@ void OpenGLDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh,
             // which is not an error.
         }
 
-        sb->textureUnitEntries[i] = { t, samplerId };
+        sb->textureUnitEntries[i] = { th, samplerId };
     }
     scheduleDestroy(std::move(data));
 }

filament/backend/src/opengl/OpenGLDriver.h

@@ -126,7 +126,7 @@ public:
     struct GLSamplerGroup : public HwSamplerGroup {
         using HwSamplerGroup::HwSamplerGroup;
         struct Entry {
-            GLTexture const* texture = nullptr;
+            Handle<HwTexture> th;
             GLuint sampler = 0u;
         };
         utils::FixedCapacityVector<Entry> textureUnitEntries;
@@ -256,6 +256,11 @@ private:
         return mHandleAllocator.handle_cast<Dp, B>(handle);
     }
 
+    template<typename B>
+    bool is_valid(Handle<B>& handle) {
+        return mHandleAllocator.is_valid(handle);
+    }
+
     template<typename Dp, typename B>
     inline typename std::enable_if_t<
             std::is_pointer_v<Dp> &&

filament/backend/src/opengl/OpenGLProgram.cpp

@@ -20,21 +20,24 @@
 #include "OpenGLDriver.h"
 #include "ShaderCompilerService.h"
 
+#include <backend/DriverEnums.h>
 #include <backend/Program.h>
+#include <backend/Handle.h>
 
-#include <private/backend/BackendUtils.h>
-
-#include <utils/debug.h>
 #include <utils/compiler.h>
+#include <utils/debug.h>
+#include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
 #include <utils/Systrace.h>
 
+#include <algorithm>
 #include <array>
 #include <string_view>
 #include <utility>
 #include <new>
 
 #include <stddef.h>
+#include <stdint.h>
 
 namespace filament::backend {
 
@@ -241,8 +244,9 @@ void OpenGLProgram::updateSamplers(OpenGLDriver* const gld) const noexcept {
         assert_invariant(sb);
         if (!sb) continue; // should never happen, this would be a user error.
         for (uint8_t j = 0, m = sb->textureUnitEntries.size(); j < m; ++j, ++tmu) { // "<=" on purpose here
-            const GLTexture* const t = sb->textureUnitEntries[j].texture;
-            if (t) { // program may not use all samplers of sampler group
+            Handle<HwTexture> th = sb->textureUnitEntries[j].th;
+            if (th) { // program may not use all samplers of sampler group
+                GLTexture const* const t = gld->handle_cast<GLTexture const*>(th);
                 gld->bindTexture(tmu, t);
 #ifndef FILAMENT_SILENCE_NOT_SUPPORTED_BY_ES2
                 if (UTILS_LIKELY(!es2)) {

filament/backend/src/opengl/OpenGLProgram.h

@@ -53,11 +53,21 @@ public:
 
     bool isValid() const noexcept { return mToken || gl.program != 0; }
 
-    void use(OpenGLDriver* const gld, OpenGLContext& context) noexcept {
-        if (UTILS_UNLIKELY(!gl.program)) {
+    bool use(OpenGLDriver* const gld, OpenGLContext& context) noexcept {
+        // both non-null is impossible by construction
+        assert_invariant(!mToken || !gl.program);
+
+        if (UTILS_UNLIKELY(mToken && !gl.program)) {
+            // first time a program is used
             initialize(*gld);
         }
 
+        if (UTILS_UNLIKELY(!gl.program)) {
+            // compilation failed (token should be null)
+            assert_invariant(!mToken);
+            return false;
+        }
+
         context.useProgram(gl.program);
         if (UTILS_UNLIKELY(mUsedBindingsCount)) {
             // We rely on GL state tracking to avoid unnecessary glBindTexture / glBindSampler
@@ -74,6 +84,7 @@ public:
 
             updateSamplers(gld);
         }
+        return true;
     }
 
     // For ES2 only

filament/backend/src/opengl/ShaderCompilerService.cpp

@@ -359,7 +359,7 @@ ShaderCompilerService::program_token_t ShaderCompilerService::createProgram(
 GLuint ShaderCompilerService::getProgram(ShaderCompilerService::program_token_t& token) {
     GLuint const program = initialize(token);
     assert_invariant(token == nullptr);
-#ifndef FILAMENT_ENABLE_MATDBG
+#if !FILAMENT_ENABLE_MATDBG
     assert_invariant(program);
 #endif
     return program;
@@ -572,16 +572,23 @@ void ShaderCompilerService::compileShaders(OpenGLContext& context,
 
             // split shader source, so we can insert the specialization constants and the packing
             // functions
-            auto const [prolog, body] = splitShaderSource({ shader_src, shader_len });
+            auto [version, prolog, body] = splitShaderSource({ shader_src, shader_len });
 
-            const std::array<const char*, 4> sources = {
+            // enable ESSL 3.10 if available
+            if (context.isAtLeastGLES<3, 1>()) {
+                version = "#version 310 es\n";
+            }
+
+            const std::array<const char*, 5> sources = {
+                    version.data(),
                     prolog.data(),
                     specializationConstantString.c_str(),
                     packingFunctions.data(),
                     body.data()
             };
 
-            const std::array<GLint, 4> lengths = {
+            const std::array<GLint, 5> lengths = {
+                    (GLint)version.length(),
                     (GLint)prolog.length(),
                     (GLint)specializationConstantString.length(),
                     (GLint)packingFunctions.length(),
@@ -661,6 +668,7 @@ void ShaderCompilerService::process_OVR_multiview2(OpenGLContext& context,
 
 // Tragically, OpenGL 4.1 doesn't support unpackHalf2x16 (appeared in 4.2) and
 // macOS doesn't support GL_ARB_shading_language_packing
+// Also GLES3.0 didn't have the full set of packing/unpacking functions
 std::string_view ShaderCompilerService::process_ARB_shading_language_packing(OpenGLContext& context) noexcept {
     using namespace std::literals;
 #ifdef BACKEND_OPENGL_VERSION_GL
@@ -700,31 +708,102 @@ highp uint packHalf2x16(vec2 v) {
     highp uint y = fp32tou16(v.y);
     return (y << 16u) | x;
 }
+highp uint packUnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, 0.0, 1.0) * 255.0);
+    highp uint a = uint(v.x);
+    highp uint b = uint(v.y) <<  8;
+    highp uint c = uint(v.z) << 16;
+    highp uint d = uint(v.w) << 24;
+    return (a|b|c|d);
+}
+highp uint packSnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, -1.0, 1.0) * 127.0);
+    highp uint a = uint((int(v.x) & 0xff));
+    highp uint b = uint((int(v.y) & 0xff)) <<  8;
+    highp uint c = uint((int(v.z) & 0xff)) << 16;
+    highp uint d = uint((int(v.w) & 0xff)) << 24;
+    return (a|b|c|d);
+}
+mediump vec4 unpackUnorm4x8(highp uint v) {
+    return vec4(float((v & 0x000000ffu)      ),
+                float((v & 0x0000ff00u) >>  8),
+                float((v & 0x00ff0000u) >> 16),
+                float((v & 0xff000000u) >> 24)) / 255.0;
+}
+mediump vec4 unpackSnorm4x8(highp uint v) {
+    int a = int(((v       ) & 0xffu) << 24u) >> 24 ;
+    int b = int(((v >>  8u) & 0xffu) << 24u) >> 24 ;
+    int c = int(((v >> 16u) & 0xffu) << 24u) >> 24 ;
+    int d = int(((v >> 24u) & 0xffu) << 24u) >> 24 ;
+    return clamp(vec4(float(a), float(b), float(c), float(d)) / 127.0, -1.0, 1.0);
+}
 )"sv;
     }
 #endif // BACKEND_OPENGL_VERSION_GL
+
+#ifdef BACKEND_OPENGL_VERSION_GLES
+    if (!context.isES2() && !context.isAtLeastGLES<3, 1>()) {
+        return R"(
+
+highp uint packUnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, 0.0, 1.0) * 255.0);
+    highp uint a = uint(v.x);
+    highp uint b = uint(v.y) <<  8;
+    highp uint c = uint(v.z) << 16;
+    highp uint d = uint(v.w) << 24;
+    return (a|b|c|d);
+}
+highp uint packSnorm4x8(mediump vec4 v) {
+    v = round(clamp(v, -1.0, 1.0) * 127.0);
+    highp uint a = uint((int(v.x) & 0xff));
+    highp uint b = uint((int(v.y) & 0xff)) <<  8;
+    highp uint c = uint((int(v.z) & 0xff)) << 16;
+    highp uint d = uint((int(v.w) & 0xff)) << 24;
+    return (a|b|c|d);
+}
+mediump vec4 unpackUnorm4x8(highp uint v) {
+    return vec4(float((v & 0x000000ffu)      ),
+                float((v & 0x0000ff00u) >>  8),
+                float((v & 0x00ff0000u) >> 16),
+                float((v & 0xff000000u) >> 24)) / 255.0;
+}
+mediump vec4 unpackSnorm4x8(highp uint v) {
+    int a = int(((v       ) & 0xffu) << 24u) >> 24 ;
+    int b = int(((v >>  8u) & 0xffu) << 24u) >> 24 ;
+    int c = int(((v >> 16u) & 0xffu) << 24u) >> 24 ;
+    int d = int(((v >> 24u) & 0xffu) << 24u) >> 24 ;
+    return clamp(vec4(float(a), float(b), float(c), float(d)) / 127.0, -1.0, 1.0);
+}
+)"sv;
+    }
+#endif // BACKEND_OPENGL_VERSION_GLES
     return ""sv;
 }
 
-// split shader source code in two, the first section goes from the start to the line after the
-// last #extension, and the 2nd part goes from there to the end.
-std::array<std::string_view, 2> ShaderCompilerService::splitShaderSource(std::string_view source) noexcept {
-    auto start = source.find("#version");
-    assert_invariant(start != std::string_view::npos);
+// split shader source code in three:
+// - the version line
+// - extensions
+// - everything else
+std::array<std::string_view, 3> ShaderCompilerService::splitShaderSource(std::string_view source) noexcept {
+    auto version_start = source.find("#version");
+    assert_invariant(version_start != std::string_view::npos);
 
-    auto pos = source.rfind("\n#extension");
-    if (pos == std::string_view::npos) {
-        pos = start;
+    auto version_eol = source.find('\n', version_start) + 1;
+    assert_invariant(version_eol != std::string_view::npos);
+
+    auto prolog_start = version_eol;
+    auto prolog_eol = source.rfind("\n#extension"); // last #extension line
+    if (prolog_eol == std::string_view::npos) {
+        prolog_eol = prolog_start;
     } else {
-        ++pos;
+        prolog_eol = source.find('\n', prolog_eol + 1) + 1;
     }
+    auto body_start = prolog_eol;
 
-    auto eol = source.find('\n', pos) + 1;
-    assert_invariant(eol != std::string_view::npos);
-
-    std::string_view const version = source.substr(start, eol - start);
-    std::string_view const body = source.substr(version.length(), source.length() - version.length());
-    return { version, body };
+    std::string_view const version = source.substr(version_start, version_eol - version_start);
+    std::string_view const prolog = source.substr(prolog_start, prolog_eol - prolog_start);
+    std::string_view const body = source.substr(body_start, source.length() - body_start);
+    return { version, prolog, body };
 }
 
 /*

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, 2> splitShaderSource(std::string_view source) noexcept;
+    static std::array<std::string_view, 3> splitShaderSource(std::string_view source) noexcept;
 
     static GLuint linkProgram(OpenGLContext& context,
             std::array<GLuint, Program::SHADER_TYPE_COUNT> shaders,

filament/backend/src/vulkan/VulkanBuffer.cpp

@@ -28,6 +28,7 @@ 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)
@@ -80,6 +81,7 @@ 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,
@@ -93,6 +95,7 @@ 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,6 +42,7 @@ 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/VulkanDriver.cpp

@@ -986,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 (fl2.MAX_VERTEX_SAMPLER_COUNT < limits.maxPerStageDescriptorSamplers ||
-        fl2.MAX_FRAGMENT_SAMPLER_COUNT < limits.maxPerStageDescriptorSamplers) {
+    if (limits.maxPerStageDescriptorSamplers < fl2.MAX_VERTEX_SAMPLER_COUNT  ||
+        limits.maxPerStageDescriptorSamplers < fl2.MAX_FRAGMENT_SAMPLER_COUNT) {
         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 (fl3.MAX_VERTEX_SAMPLER_COUNT < limits.maxPerStageDescriptorSamplers ||
-        fl3.MAX_FRAGMENT_SAMPLER_COUNT < limits.maxPerStageDescriptorSamplers) {
+    if (limits.maxPerStageDescriptorSamplers < fl3.MAX_VERTEX_SAMPLER_COUNT||
+        limits.maxPerStageDescriptorSamplers < fl3.MAX_FRAGMENT_SAMPLER_COUNT) {
         return FeatureLevel::FEATURE_LEVEL_2;
     }
 

filament/backend/src/vulkan/VulkanPipelineCache.cpp

@@ -53,7 +53,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::getOrCreatePipelin
     // If a cached object exists, re-use it, otherwise create a new one.
     if (PipelineMap::iterator pipelineIter = mPipelines.find(mPipelineRequirements);
             pipelineIter != mPipelines.end()) {
-        auto& pipeline = pipelineIter.value();
+        auto& pipeline = pipelineIter->second;
         pipeline.lastUsed = mCurrentTime;
         return &pipeline;
     }
@@ -242,7 +242,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
         return nullptr;
     }
 
-    return &mPipelines.emplace(mPipelineRequirements, cacheEntry).first.value();
+    return &mPipelines.emplace(mPipelineRequirements, cacheEntry).first->second;
 }
 
 void VulkanPipelineCache::bindProgram(VulkanProgram* program) noexcept {
@@ -310,7 +310,7 @@ void VulkanPipelineCache::gc() noexcept {
     // Any pipeline older than FVK_MAX_COMMAND_BUFFERS can be safely destroyed.
    using ConstPipeIterator = decltype(mPipelines)::const_iterator;
    for (ConstPipeIterator iter = mPipelines.begin(); iter != mPipelines.end();) {
-       const PipelineCacheEntry& cacheEntry = iter.value();
+       const PipelineCacheEntry& cacheEntry = iter->second;
        if (cacheEntry.lastUsed + FVK_MAX_PIPELINE_AGE < mCurrentTime) {
            vkDestroyPipeline(mDevice, iter->second.handle, VKALLOC);
            iter = mPipelines.erase(iter);

filament/backend/src/vulkan/VulkanPipelineCache.h

@@ -33,11 +33,11 @@
 #include <utils/compiler.h>
 #include <utils/Hash.h>
 
+#include <ankerl/unordered_dense.h>
+
 #include <list>
-#include <tsl/robin_map.h>
 #include <type_traits>
 #include <vector>
-#include <unordered_map>
 
 namespace filament::backend {
 
@@ -238,7 +238,10 @@ private:
     // CACHE CONTAINERS
     // ----------------
 
-    using PipelineMap = tsl::robin_map<PipelineKey, PipelineCacheEntry,
+//    using PipelineMap = tsl::robin_map<PipelineKey, PipelineCacheEntry,
+//            PipelineHashFn, PipelineEqual>;
+
+    using PipelineMap = ankerl::unordered_dense::map<PipelineKey, PipelineCacheEntry,
             PipelineHashFn, PipelineEqual>;
 
 private:

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

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

@@ -23,6 +23,7 @@
 #include <utils/Hash.h>
 
 #include <tsl/robin_map.h>
+#include <ankerl/unordered_dense.h>
 
 namespace filament::backend {
 
@@ -73,7 +74,10 @@ private:
         }
     };
 
-    using PipelineLayoutMap = tsl::robin_map<PipelineLayoutKey, PipelineLayoutCacheEntry,
+//    using PipelineLayoutMap = tsl::robin_map<PipelineLayoutKey, PipelineLayoutCacheEntry,
+//            PipelineLayoutKeyHashFn, PipelineLayoutKeyEqual>;
+
+    using PipelineLayoutMap = ankerl::unordered_dense::map<PipelineLayoutKey, PipelineLayoutCacheEntry,
             PipelineLayoutKeyHashFn, PipelineLayoutKeyEqual>;
 
     VkDevice mDevice;

filament/docs/SpirvDebugging.md

@@ -64,14 +64,15 @@ 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.
 
-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,
+We can use the `--save-raw-variants` debug flag in matc to export each GLSL
+shader to a file. For example:
 
 ```
-if (v.variant.key == 8u) { std::cout << shader << std::endl; }
+matc --save-raw-variants --optimize-size --variant-filter fog,ssr,vsm,stereo \
+        -a all -p all -o mymaterial.filamat mymaterial.mat
 ```
 
-Then, I invoke `matc` and redirect stdout to a .frag or .vert file.
+Files will be named like `mymaterial_0x05.frag` or `mymaterial_0x05.vert`.
 
 Note that gltfio material "templates" first go through a build step. After building gltfio, the
 gltfio Filament materials are output to:

filament/include/filament/Engine.h

@@ -298,6 +298,24 @@ public:
          */
         size_t textureUseAfterFreePoolSize = 0;
 
+        /**
+         * When uploading vertex or index data, the Filament Metal backend copies data
+         * into a shared staging area before transferring it to the GPU. This setting controls
+         * the total size of the buffer used to perform these allocations.
+         *
+         * Higher values can improve performance when performing many uploads across a small
+         * number of frames.
+         *
+         * This buffer remains alive throughout the lifetime of the Engine, so this size adds to the
+         * memory footprint of the app and should be set as conservative as possible.
+         *
+         * A value of 0 disables the shared staging buffer entirely; uploads will acquire an
+         * individual buffer from a pool of shared buffers.
+         *
+         * Only respected by the Metal backend.
+         */
+        size_t metalUploadBufferSizeBytes = 512 * 1024;
+
         /**
          * Set to `true` to forcibly disable parallel shader compilation in the backend.
          * Currently only honored by the GL and Metal backends.
@@ -1021,6 +1039,21 @@ public:
     void resetBackendState() noexcept;
 #endif
 
+    /**
+     * Get the current time. This is a convenience function that simply returns the
+     * time in nanosecond since epoch of std::chrono::steady_clock.
+     * A possible implementation is:
+     *
+     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     *     return std::chrono::steady_clock::now().time_since_epoch().count();
+     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     *
+     * @return current time in nanosecond since epoch of std::chrono::steady_clock.
+     * @see Renderer::beginFrame()
+     */
+    static uint64_t getSteadyClockTimeNano() noexcept;
+
+
     DebugRegistry& getDebugRegistry() noexcept;
 
 protected:

filament/include/filament/IndirectLight.h

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

filament/include/filament/Material.h

@@ -140,6 +140,18 @@ public:
             return constant(name, strlen(name), value);
         }
 
+        /**
+         * Sets the quality of the indirect lights computations. This is only taken into account
+         * if this material is lit and in the surface domain. This setting will affect the
+         * IndirectLight computation if one is specified on the Scene and Spherical Harmonics
+         * are used for the irradiance.
+         *
+         * @param shBandCount Number of spherical harmonic bands. Must be 1, 2 or 3 (default).
+         * @return Reference to this Builder for chaining calls.
+         * @see IndirectLight
+         */
+        Builder& sphericalHarmonicsBandCount(size_t shBandCount) noexcept;
+
         /**
          * Creates the Material object and returns a pointer to it.
          *

filament/include/filament/RenderableManager.h

@@ -489,43 +489,20 @@ public:
          * For standard morphing, A MorphTargetBuffer must be provided.
          * Standard morphing supports up to \c CONFIG_MAX_MORPH_TARGET_COUNT morph targets.
          *
-         * For legacy morphing, the attached VertexBuffer must provide data in the
-         * appropriate VertexAttribute slots (\c MORPH_POSITION_0 etc). Legacy morphing only
-         * supports up to 4 morph targets and will be deprecated in the future. Legacy morphing must
-         * be enabled on the material definition: either via the legacyMorphing material attribute
-         * or by calling filamat::MaterialBuilder::useLegacyMorphing().
-         *
          * See also RenderableManager::setMorphWeights(), which can be called on a per-frame basis
          * to advance the animation.
          */
         Builder& morphing(MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer) noexcept;
 
-        /**
-         * @deprecated Use morphing(uint8_t level, size_t primitiveIndex, size_t offset, size_t count) instead
-         */
-        Builder& morphing(uint8_t level, size_t primitiveIndex,
-                MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer,
-                size_t offset, size_t count) noexcept;
-
-        /**
-         * @deprecated Use morphing(uint8_t level, size_t primitiveIndex, size_t offset, size_t count) instead
-         */
-        inline Builder& morphing(uint8_t level, size_t primitiveIndex,
-                MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer) noexcept {
-            return morphing(level, primitiveIndex, morphTargetBuffer, 0,
-                    morphTargetBuffer->getVertexCount());
-        }
-
         /**
          * Specifies the the range of the MorphTargetBuffer to use with this primitive.
          *
          * @param level the level of detail (lod), only 0 can be specified
          * @param primitiveIndex zero-based index of the primitive, must be less than the count passed to Builder constructor
          * @param offset specifies where in the morph target buffer to start reading (expressed as a number of vertices)
-         * @param count number of vertices in the morph target buffer to read, must equal the geometry's count (for triangles, this should be a multiple of 3)
          */
-        Builder& morphing(uint8_t level, size_t primitiveIndex,
-                size_t offset, size_t count) noexcept;
+        RenderableManager::Builder& morphing(uint8_t level,
+                size_t primitiveIndex, size_t offset) noexcept;
 
 
         /**
@@ -786,25 +763,13 @@ public:
     /**
      * Associates a MorphTargetBuffer to the given primitive.
      */
-    void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            size_t offset, size_t count);
-
-    /** @deprecated */
-    void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer, size_t offset, size_t count);
-
-    /** @deprecated */
-    inline void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            MorphTargetBuffer* UTILS_NONNULL morphTargetBuffer) {
-        setMorphTargetBufferAt(instance, level, primitiveIndex, morphTargetBuffer, 0,
-                morphTargetBuffer->getVertexCount());
-    }
+    void setMorphTargetBufferOffsetAt(Instance instance, uint8_t level, size_t primitiveIndex,
+            size_t offset);
 
     /**
-     * Get a MorphTargetBuffer to the given primitive or null if it doesn't exist.
+     * Get a MorphTargetBuffer to the given renderable or null if it doesn't exist.
      */
-    MorphTargetBuffer* UTILS_NULLABLE getMorphTargetBufferAt(Instance instance,
-            uint8_t level, size_t primitiveIndex) const noexcept;
+    MorphTargetBuffer* UTILS_NULLABLE getMorphTargetBuffer(Instance instance) const noexcept;
 
     /**
      * Gets the number of morphing in the given entity.

filament/include/filament/Renderer.h

@@ -22,9 +22,11 @@
 #include <filament/FilamentAPI.h>
 
 #include <utils/compiler.h>
+#include <utils/FixedCapacityVector.h>
 
 #include <math/vec4.h>
 
+#include <stddef.h>
 #include <stdint.h>
 
 namespace filament {
@@ -81,6 +83,37 @@ 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.
@@ -227,6 +260,17 @@ public:
     static constexpr CopyFrameFlag CLEAR = 0x4;
 
 
+    /**
+     * The use of this method is optional. It sets the VSYNC time expressed as the duration in
+     * nanosecond since epoch of std::chrono::steady_clock.
+     * If called, passing 0 to vsyncSteadyClockTimeNano in Renderer::BeginFrame will use this
+     * time instead.
+     * @param steadyClockTimeNano duration in nanosecond since epoch of std::chrono::steady_clock
+     * @see Engine::getSteadyClockTimeNano()
+     * @see Renderer::BeginFrame()
+     */
+    void setVsyncTime(uint64_t steadyClockTimeNano) noexcept;
+
     /**
      * Set-up a frame for this Renderer.
      *

filament/src/Engine.cpp

@@ -39,6 +39,8 @@
 #include <utils/compiler.h>
 #include <utils/Panic.h>
 
+#include <chrono>
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -361,7 +363,7 @@ const Engine::Config& Engine::getConfig() const noexcept {
     return downcast(this)->getConfig();
 }
 
-bool Engine::isStereoSupported(StereoscopicType stereoscopicType) const noexcept {
+bool Engine::isStereoSupported(StereoscopicType) const noexcept {
     return downcast(this)->isStereoSupported();
 }
 
@@ -369,6 +371,10 @@ size_t Engine::getMaxStereoscopicEyes() noexcept {
     return FEngine::getMaxStereoscopicEyes();
 }
 
+uint64_t Engine::getSteadyClockTimeNano() noexcept {
+    return std::chrono::steady_clock::now().time_since_epoch().count();
+}
+
 #if defined(__EMSCRIPTEN__)
 void Engine::resetBackendState() noexcept {
     downcast(this)->resetBackendState();

filament/src/FrameInfo.cpp

@@ -16,30 +16,33 @@
 
 #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/Systrace.h>
+#include <utils/ostream.h>
 
-#include <math/scalar.h>
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <ratio>
 
-#include <cmath>
+#include <stdint.h>
+#include <stddef.h>
 
 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 = driver.createTimerQuery();
+        query.handle = driver.createTimerQuery();
     }
 }
 
@@ -47,14 +50,36 @@ FrameInfoManager::~FrameInfoManager() noexcept = default;
 
 void FrameInfoManager::terminate(DriverApi& driver) noexcept {
     for (auto& query : mQueries) {
-        driver.destroyTimerQuery(query);
+        driver.destroyTimerQuery(query.handle);
     }
 }
 
-void FrameInfoManager::beginFrame(DriverApi& driver,Config const& config, uint32_t) noexcept {
-    driver.beginTimerQuery(mQueries[mIndex]);
+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
     uint64_t elapsed = 0;
-    TimerQueryResult const result = driver.getTimerQueryValue(mQueries[mLast], &elapsed);
+    TimerQueryResult const result = driver.getTimerQueryValue(mQueries[mLast].handle, &elapsed);
     switch (result) {
         case TimerQueryResult::NOT_READY:
             // nothing to do
@@ -63,49 +88,111 @@ void FrameInfoManager::beginFrame(DriverApi& driver,Config const& config, uint32
             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);
+            pFront = mQueries[mLast].pInfo;
+            pFront->frameTime = std::chrono::duration<uint64_t, std::nano>(elapsed);
+            mLast = (mLast + 1) % POOL_COUNT;
+            denoiseFrameTime(config);
             break;
     }
-    update(config, mFrameTime);
+
+
+    // 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;
+        }
+    }
 }
 
 void FrameInfoManager::endFrame(DriverApi& driver) noexcept {
-    driver.endTimerQuery(mQueries[mIndex]);
+    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();
     mIndex = (mIndex + 1) % POOL_COUNT;
 }
 
-void FrameInfoManager::update(Config const& config,
-        FrameInfoManager::duration lastFrameTime) noexcept {
-    // keep an history of frame times
+void FrameInfoManager::denoiseFrameTime(Config const& config) noexcept {
     auto& history = mFrameTimeHistory;
+    assert_invariant(!history.empty());
 
-    // 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;
+    // 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)) {
+            assert_invariant(std::addressof(history[i]) == pFront);
+            first = i;
+            break;
+        }
     }
+    assert_invariant(first != history.size());
 
-    // 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];
+    // 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) });
 
-    history[0].denoisedFrameTime = denoisedFrameTime;
-    history[0].valid = true;
+        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;
+     }
 }
 
+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,30 +17,136 @@
 #ifndef TNT_FILAMENT_FRAMEINFO_H
 #define TNT_FILAMENT_FRAMEINFO_H
 
-#include "backend/Handle.h"
+#include <filament/Renderer.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;
+    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;
+    }
 };
 
 class FrameInfoManager {
     static constexpr size_t POOL_COUNT = 4;
-    static constexpr size_t MAX_FRAMETIME_HISTORY = 31u;
+    static constexpr size_t MAX_FRAMETIME_HISTORY = 16u;
 
 public:
-    using duration = FrameInfo::duration;
+    using duration = FrameInfoImpl::duration;
+    using clock = FrameInfoImpl::clock;
 
     struct Config {
         uint32_t historySize;
@@ -57,23 +163,24 @@ public:
     // call this immediately before "swap buffers"
     void endFrame(backend::DriverApi& driver) noexcept;
 
-    FrameInfo const& getLastFrameInfo() const noexcept {
-        return mFrameTimeHistory[0];
+    details::FrameInfo const& getLastFrameInfo() const noexcept {
+        // if pFront is not set yet, return front() but in this case front().valid will be false
+        return pFront ? *pFront : mFrameTimeHistory.front();
     }
 
-    duration getLastFrameTime() const noexcept {
-        return getLastFrameInfo().frameTime;
-    }
+    utils::FixedCapacityVector<Renderer::FrameInfo> getFrameInfoHistory(size_t historySize) const noexcept;
 
 private:
-    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;
+    void denoiseFrameTime(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
+    CircularQueue<FrameInfoImpl, MAX_FRAMETIME_HISTORY> mFrameTimeHistory;
 };
 
 

filament/src/Froxelizer.cpp

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

filament/src/PostProcessManager.cpp

@@ -1965,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(1u, uint32_t(std::floor(bloomWidth)));
-        uint32_t height = std::max(1u, uint32_t(std::floor(bloomHeight)));
+        uint32_t width  = std::max(16u, uint32_t(std::floor(bloomWidth)));
+        uint32_t height = std::max(16u, uint32_t(std::floor(bloomHeight)));
         width  &= ~((1 << 4) - 1);  // at least 4 levels
         height &= ~((1 << 4) - 1);
         bloomWidth  = float(width);
@@ -1978,6 +1978,8 @@ 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) {

filament/src/RenderPass.cpp

@@ -38,6 +38,7 @@
 #include <backend/PipelineState.h>
 
 #include "private/backend/CircularBuffer.h"
+#include "private/backend/CommandStream.h"
 
 #include <utils/compiler.h>
 #include <utils/debug.h>
@@ -153,7 +154,7 @@ RenderPass::RenderPass(FEngine& engine, RenderPassBuilder const& builder) noexce
     sortCommands(builder.mArena);
 
     if (engine.isAutomaticInstancingEnabled()) {
-        uint32_t stereoscopicEyeCount = 1;
+        int32_t stereoscopicEyeCount = 1;
         if (builder.mFlags & IS_INSTANCED_STEREOSCOPIC) {
             stereoscopicEyeCount *= engine.getConfig().stereoscopicEyeCount;
         }
@@ -162,8 +163,7 @@ RenderPass::RenderPass(FEngine& engine, RenderPassBuilder const& builder) noexce
 }
 
 // this destructor is actually heavy because it inlines ~vector<>
-RenderPass::~RenderPass() noexcept {
-}
+RenderPass::~RenderPass() noexcept = default;
 
 void RenderPass::resize(Arena& arena, size_t count) noexcept {
     if (mCommandBegin) {
@@ -221,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, 5>());
+                std::cref(work), jobs::CountSplitter<JOBS_PARALLEL_FOR_COMMANDS_COUNT>());
         js.runAndWait(jobCommandsParallel);
     }
 
@@ -671,7 +671,6 @@ RenderPass::Command* RenderPass::generateCommandsImpl(RenderPass::CommandTypeFla
          */
         for (size_t pi = 0, c = primitives.size(); pi < c; ++pi) {
             auto const& primitive = primitives[pi];
-            auto const& morphTargets = morphing.targets[pi];
             FMaterialInstance const* const mi = primitive.getMaterialInstance();
             FMaterial const* const ma = mi->getMaterial();
 
@@ -684,8 +683,9 @@ RenderPass::Command* RenderPass::generateCommandsImpl(RenderPass::CommandTypeFla
             cmd.info.indexOffset = primitive.getIndexOffset();
             cmd.info.indexCount = primitive.getIndexCount();
             cmd.info.type = primitive.getPrimitiveType();
-            cmd.info.morphTargetBuffer = morphTargets.buffer->getHwHandle();
-            cmd.info.morphingOffset = morphTargets.offset;
+            cmd.info.morphTargetBuffer = morphing.morphTargetBuffer ?
+                    morphing.morphTargetBuffer->getHwHandle() : SamplerGroupHandle{};
+            cmd.info.morphingOffset = primitive.getMorphingBufferOffset();
 
             if constexpr (isColorPass) {
                 RenderPass::setupColorCommand(cmd, renderableVariant, mi, inverseFrontFaces);
@@ -885,14 +885,31 @@ 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 240 bytes, and we use 256 to be on
-        // the safer side.
-        size_t const maxCommandSizeInBytes = 256;
+        // 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));
+
 
         // 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
-        // 8192 commands (i.e. draw calls).
+        // 6553 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

@@ -417,8 +417,7 @@ private:
     void instanceify(FEngine& engine, Arena& arena, int32_t eyeCount) noexcept;
 
     // We choose the command count per job to minimize JobSystem overhead.
-    // 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_COUNT = 128;
     static constexpr size_t JOBS_PARALLEL_FOR_COMMANDS_SIZE  =
             sizeof(Command) * JOBS_PARALLEL_FOR_COMMANDS_COUNT;
 

filament/src/RenderPrimitive.h

@@ -56,6 +56,7 @@ public:
     backend::VertexBufferInfoHandle getVertexBufferInfoHandle() const { return mVertexBufferInfoHandle; }
     uint32_t getIndexOffset() const noexcept { return mIndexOffset; }
     uint32_t getIndexCount() const noexcept { return mIndexCount; }
+    uint32_t getMorphingBufferOffset() const noexcept { return mMorphingBufferOffset; }
 
     backend::PrimitiveType getPrimitiveType() const noexcept { return mPrimitiveType; }
     AttributeBitset getEnabledAttributes() const noexcept { return mEnabledAttributes; }
@@ -72,6 +73,10 @@ public:
         mGlobalBlendOrderEnabled = enabled;
     }
 
+    void setMorphingBufferOffset(uint32_t offset) noexcept {
+        mMorphingBufferOffset = offset;
+    }
+
 private:
     // These first fields are dereferences from PrimitiveInfo, keep them together
     struct {
@@ -80,6 +85,7 @@ private:
         backend::Handle<backend::HwVertexBufferInfo> mVertexBufferInfoHandle = {};
         uint32_t mIndexOffset = 0;
         uint32_t mIndexCount = 0;
+        uint32_t mMorphingBufferOffset = 0;
     };
 
     AttributeBitset mEnabledAttributes = {};

filament/src/RenderableManager.cpp

@@ -158,20 +158,14 @@ void RenderableManager::setMorphWeights(Instance instance, float const* weights,
     downcast(this)->setMorphWeights(instance, weights, count, offset);
 }
 
-void RenderableManager::setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-        MorphTargetBuffer* morphTargetBuffer, size_t offset, size_t count) {
-    downcast(this)->setMorphTargetBufferAt(instance, level, primitiveIndex,
-            downcast(morphTargetBuffer), offset, count);
+void RenderableManager::setMorphTargetBufferOffsetAt(Instance instance, uint8_t level,
+        size_t primitiveIndex,
+        size_t offset) {
+    downcast(this)->setMorphTargetBufferOffsetAt(instance, level, primitiveIndex, offset);
 }
 
-void RenderableManager::setMorphTargetBufferAt(
-        Instance instance, uint8_t level, size_t primitiveIndex, size_t offset, size_t count) {
-    downcast(this)->setMorphTargetBufferAt(instance, level, primitiveIndex, offset, count);
-}
-
-MorphTargetBuffer* RenderableManager::getMorphTargetBufferAt(Instance instance, uint8_t level,
-        size_t primitiveIndex) const noexcept {
-    return downcast(this)->getMorphTargetBufferAt(instance, level, primitiveIndex);
+MorphTargetBuffer* RenderableManager::getMorphTargetBuffer(Instance instance) const noexcept {
+    return downcast(this)->getMorphTargetBuffer(instance);
 }
 
 size_t RenderableManager::getMorphTargetCount(Instance instance) const noexcept {

filament/src/Renderer.cpp

@@ -14,11 +14,20 @@
  * limitations under the License.
  */
 
+#include <filament/Renderer.h>
+
 #include "details/Renderer.h"
 
 #include "details/Engine.h"
 #include "details/View.h"
 
+#include <utils/FixedCapacityVector.h>
+
+#include <utility>
+
+#include <stddef.h>
+#include <stdint.h>
+
 namespace filament {
 
 using namespace math;
@@ -89,4 +98,16 @@ void Renderer::renderStandaloneView(View const* view) {
     downcast(this)->renderStandaloneView(downcast(view));
 }
 
+void Renderer::setVsyncTime(uint64_t steadyClockTimeNano) noexcept {
+    downcast(this)->setVsyncTime(steadyClockTimeNano);
+}
+
+utils::FixedCapacityVector<Renderer::FrameInfo> Renderer::getFrameInfoHistory(size_t historySize) const noexcept {
+    return downcast(this)->getFrameInfoHistory(historySize);
+}
+
+size_t Renderer::getMaxFrameHistorySize() const noexcept {
+    return downcast(this)->getMaxFrameHistorySize();
+}
+
 } // namespace filament

filament/src/components/LightManager.cpp

@@ -20,12 +20,13 @@
 
 #include "details/Engine.h"
 
-#include <math/fast.h>
-#include <math/scalar.h>
-
-#include <utils/debug.h>
 #include <filament/LightManager.h>
 
+#include <utils/debug.h>
+#include <utils/Log.h>
+
+#include <math/fast.h>
+#include <math/scalar.h>
 
 using namespace filament::math;
 using namespace utils;

filament/src/components/RenderableManager.cpp

@@ -281,19 +281,13 @@ RenderableManager::Builder& RenderableManager::Builder::morphing(
     return *this;
 }
 
-RenderableManager::Builder& RenderableManager::Builder::morphing(
-        uint8_t level, size_t primitiveIndex, size_t offset, size_t count) noexcept {
-    return morphing(level, primitiveIndex, mImpl->mMorphTargetBuffer, offset, count);
-}
-
-RenderableManager::Builder& RenderableManager::Builder::morphing(uint8_t, size_t primitiveIndex,
-        MorphTargetBuffer* morphTargetBuffer, size_t offset, size_t count) noexcept {
-    std::vector<Entry>& entries = mImpl->mEntries;
+RenderableManager::Builder& RenderableManager::Builder::morphing(uint8_t level,
+        size_t primitiveIndex, size_t offset) noexcept {
+    // the last parameter "count" is unused, because it must be equal to the primitive's vertex count
+    std::vector<BuilderDetails::Entry>& entries = mImpl->mEntries;
     if (primitiveIndex < entries.size()) {
         auto& morphing = entries[primitiveIndex].morphing;
-        morphing.buffer = morphTargetBuffer;
-        morphing.offset = offset;
-        morphing.count = count;
+        morphing.offset = uint32_t(offset);
     }
     return *this;
 }
@@ -449,10 +443,10 @@ RenderableManager::Builder::Result RenderableManager::Builder::build(Engine& eng
             << ") instances when supplying transforms via an InstanceBuffer.";
 
     if (mImpl->mGeometryType == GeometryType::STATIC) {
-        FILAMENT_CHECK_PRECONDITION(mImpl->mSkinningBoneCount > 0)
+        FILAMENT_CHECK_PRECONDITION(mImpl->mSkinningBoneCount == 0)
                 << "Skinning can't be used with STATIC geometry";
 
-        FILAMENT_CHECK_PRECONDITION(mImpl->mMorphTargetCount > 0)
+        FILAMENT_CHECK_PRECONDITION(mImpl->mMorphTargetCount == 0)
                 << "Morphing can't be used with STATIC geometry";
     }
 
@@ -668,13 +662,6 @@ void FRenderableManager::create(
         if (morphTargetBuffer == nullptr) {
             morphTargetBuffer = mEngine.getDummyMorphTargetBuffer();
         }
-        MorphTargets* const morphTargets = new MorphTargets[entryCount];
-        std::generate_n(morphTargets, entryCount,
-                [morphTargetBuffer]() -> MorphTargets {
-                    return { morphTargetBuffer, 0, 0 };
-                });
-
-        mManager[ci].morphTargets = { morphTargets, size_type(entryCount) };
 
         // Always create skinning and morphing resources if one of them is enabled because
         // the shader always handles both. See Variant::SKINNING_OR_MORPHING.
@@ -700,13 +687,13 @@ void FRenderableManager::create(
                         backend::BufferUsage::DYNAMIC),
                 .count = targetCount };
 
-            for (size_t i = 0; i < entryCount; ++i) {
-                const auto& morphing = builder->mEntries[i].morphing;
-                if (!morphing.buffer) {
-                    continue;
+            Slice<FRenderPrimitive>& primitives = mManager[ci].primitives;
+            mManager[ci].morphTargetBuffer = morphTargetBuffer;
+            if (builder->mMorphTargetBuffer) {
+                for (size_t i = 0; i < entryCount; ++i) {
+                    const auto& morphing = builder->mEntries[i].morphing;
+                    primitives[i].setMorphingBufferOffset(morphing.offset);
                 }
-                morphTargets[i] = { downcast(morphing.buffer), (uint32_t)morphing.offset,
-                                    (uint32_t)morphing.count };
             }
             
             // When targetCount equal 0, boneCount>0 in this case, do an initialization for the
@@ -762,7 +749,6 @@ void FRenderableManager::destroyComponent(Instance ci) noexcept {
 
     // See create(RenderableManager::Builder&, Entity)
     destroyComponentPrimitives(mHwRenderPrimitiveFactory, driver, manager[ci].primitives);
-    destroyComponentMorphTargets(engine, manager[ci].morphTargets);
 
     // destroy the bones structures if any
     Bones const& bones = manager[ci].bones;
@@ -795,11 +781,6 @@ void FRenderableManager::destroyComponentPrimitives(
     delete[] primitives.data();
 }
 
-void FRenderableManager::destroyComponentMorphTargets(FEngine&,
-        utils::Slice<MorphTargets>& morphTargets) noexcept {
-    delete[] morphTargets.data();
-}
-
 void FRenderableManager::setMaterialInstanceAt(Instance instance, uint8_t level,
         size_t primitiveIndex, FMaterialInstance const* mi) {
     if (instance) {
@@ -968,42 +949,21 @@ void FRenderableManager::setMorphWeights(Instance instance, float const* weights
     }
 }
 
-void FRenderableManager::setMorphTargetBufferAt(Instance instance, uint8_t level,
-        size_t primitiveIndex, FMorphTargetBuffer* morphTargetBuffer, size_t offset, size_t count) {
+void FRenderableManager::setMorphTargetBufferOffsetAt(Instance instance, uint8_t level,
+        size_t primitiveIndex,
+        size_t offset) {
     if (instance) {
-        assert_invariant(morphTargetBuffer);
-
-        MorphWeights const& morphWeights = mManager[instance].morphWeights;
-        FILAMENT_CHECK_PRECONDITION(morphWeights.count == count)
-                << "Only " << morphWeights.count << " morph targets can be set (count=" << count
-                << ")";
-
-        Slice<MorphTargets>& morphTargets = getMorphTargets(instance, level);
-        if (primitiveIndex < morphTargets.size()) {
-            morphTargets[primitiveIndex] = { morphTargetBuffer, (uint32_t)offset,
-                                             (uint32_t)count };
+        assert_invariant(mManager[instance].morphTargetBuffer);
+        Slice<FRenderPrimitive>& primitives = mManager[instance].primitives;
+        if (primitiveIndex < primitives.size()) {
+            primitives[primitiveIndex].setMorphingBufferOffset(offset);
         }
     }
 }
 
-void FRenderableManager::setMorphTargetBufferAt(Instance instance, uint8_t level,
-        size_t primitiveIndex, size_t offset, size_t count) {
+MorphTargetBuffer* FRenderableManager::getMorphTargetBuffer(Instance instance) const noexcept {
     if (instance) {
-        Slice<MorphTargets>& morphTargets = getMorphTargets(instance, level);
-        if (primitiveIndex < morphTargets.size()) {
-            setMorphTargetBufferAt(instance, level,
-                    primitiveIndex, morphTargets[primitiveIndex].buffer, offset, count);
-        }
-    }
-}
-
-MorphTargetBuffer* FRenderableManager::getMorphTargetBufferAt(Instance instance, uint8_t level,
-        size_t primitiveIndex) const noexcept {
-    if (instance) {
-        const Slice<MorphTargets>& morphTargets = getMorphTargets(instance, level);
-        if (primitiveIndex < morphTargets.size()) {
-            return morphTargets[primitiveIndex].buffer;
-        }
+        return mManager[instance].morphTargetBuffer;
     }
     return nullptr;
 }

filament/src/components/RenderableManager.h

@@ -80,12 +80,6 @@ public:
 
     static_assert(sizeof(Visibility) == sizeof(uint16_t), "Visibility should be 16 bits");
 
-    struct MorphTargets {
-        FMorphTargetBuffer* buffer = nullptr;
-        uint32_t offset = 0;
-        uint32_t count = 0;
-    };
-
     explicit FRenderableManager(FEngine& engine) noexcept;
     ~FRenderableManager();
 
@@ -155,11 +149,9 @@ public:
 
     inline void setMorphing(Instance instance, bool enable);
     void setMorphWeights(Instance instance, float const* weights, size_t count, size_t offset);
-    void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            FMorphTargetBuffer* morphTargetBuffer, size_t offset, size_t count);
-    void setMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex,
-            size_t offset, size_t count);
-    MorphTargetBuffer* getMorphTargetBufferAt(Instance instance, uint8_t level, size_t primitiveIndex) const noexcept;
+    void setMorphTargetBufferOffsetAt(Instance instance, uint8_t level, size_t primitiveIndex,
+            size_t offset);
+    MorphTargetBuffer* getMorphTargetBuffer(Instance instance) const noexcept;
     size_t getMorphTargetCount(Instance instance) const noexcept;
 
     void setLightChannel(Instance instance, unsigned int channel, bool enable) noexcept;
@@ -189,7 +181,7 @@ public:
     struct MorphingBindingInfo {
         backend::Handle<backend::HwBufferObject> handle;
         uint32_t count;
-        MorphTargets const* targets; // Pointer to Slice<MorphTargets> at a renderable.
+        FMorphTargetBuffer const* morphTargetBuffer;
     };
     inline MorphingBindingInfo getMorphingBufferInfo(Instance instance) const noexcept;
 
@@ -218,16 +210,12 @@ public:
     AttributeBitset getEnabledAttributesAt(Instance instance, uint8_t level, size_t primitiveIndex) const noexcept;
     inline utils::Slice<FRenderPrimitive> const& getRenderPrimitives(Instance instance, uint8_t level) const noexcept;
     inline utils::Slice<FRenderPrimitive>& getRenderPrimitives(Instance instance, uint8_t level) noexcept;
-    inline utils::Slice<MorphTargets> const& getMorphTargets(Instance instance, uint8_t level) const noexcept;
-    inline utils::Slice<MorphTargets>& getMorphTargets(Instance instance, uint8_t level) noexcept;
 
 private:
     void destroyComponent(Instance ci) noexcept;
     static void destroyComponentPrimitives(
             HwRenderPrimitiveFactory& factory, backend::DriverApi& driver,
             utils::Slice<FRenderPrimitive>& primitives) noexcept;
-    static void destroyComponentMorphTargets(FEngine& engine,
-            utils::Slice<MorphTargets>& morphTargets) noexcept;
 
     struct Bones {
         backend::Handle<backend::HwBufferObject> handle;
@@ -254,7 +242,7 @@ private:
         VISIBILITY,             // user data
         PRIMITIVES,             // user data
         BONES,                  // filament data, UBO storing a pointer to the bones information
-        MORPH_TARGETS
+        MORPHTARGET_BUFFER      // morphtarget buffer for the component
     };
 
     using Base = utils::SingleInstanceComponentManager<
@@ -266,7 +254,7 @@ private:
             Visibility,                      // VISIBILITY
             utils::Slice<FRenderPrimitive>,  // PRIMITIVES
             Bones,                           // BONES
-            utils::Slice<MorphTargets>       // MORPH_TARGETS
+            FMorphTargetBuffer*              // MORPHTARGET_BUFFER
     >;
 
     struct Sim : public Base {
@@ -289,7 +277,7 @@ private:
                 Field<VISIBILITY>           visibility;
                 Field<PRIMITIVES>           primitives;
                 Field<BONES>                bones;
-                Field<MORPH_TARGETS>        morphTargets;
+                Field<MORPHTARGET_BUFFER>   morphTargetBuffer;
             };
         };
 
@@ -461,8 +449,8 @@ inline uint32_t FRenderableManager::getBoneCount(Instance instance) const noexce
 FRenderableManager::MorphingBindingInfo
 FRenderableManager::getMorphingBufferInfo(Instance instance) const noexcept {
     MorphWeights const& morphWeights = mManager[instance].morphWeights;
-    utils::Slice<MorphTargets> const& morphTargets = getMorphTargets(instance, 0);
-    return { morphWeights.handle, morphWeights.count, morphTargets.data() };
+    FMorphTargetBuffer const* const buffer = mManager[instance].morphTargetBuffer;
+    return { morphWeights.handle, morphWeights.count, buffer  };
 }
 
 FRenderableManager::InstancesInfo
@@ -480,16 +468,6 @@ utils::Slice<FRenderPrimitive>& FRenderableManager::getRenderPrimitives(
     return mManager[instance].primitives;
 }
 
-utils::Slice<FRenderableManager::MorphTargets> const& FRenderableManager::getMorphTargets(
-        Instance instance, UTILS_UNUSED uint8_t level) const noexcept {
-    return mManager[instance].morphTargets;
-}
-
-utils::Slice<FRenderableManager::MorphTargets>& FRenderableManager::getMorphTargets(
-        Instance instance, UTILS_UNUSED uint8_t level) noexcept {
-    return mManager[instance].morphTargets;
-}
-
 } // namespace filament
 
 #endif // TNT_FILAMENT_COMPONENTS_RENDERABLEMANAGER_H

filament/src/details/Engine.cpp

@@ -102,6 +102,7 @@ Engine* FEngine::create(Engine::Builder const& builder) {
         DriverConfig const driverConfig{
                 .handleArenaSize = instance->getRequestedDriverHandleArenaSize(),
                 .textureUseAfterFreePoolSize = instance->getConfig().textureUseAfterFreePoolSize,
+                .metalUploadBufferSizeBytes = instance->getConfig().metalUploadBufferSizeBytes,
                 .disableParallelShaderCompile = instance->getConfig().disableParallelShaderCompile,
                 .disableHandleUseAfterFreeCheck = instance->getConfig().disableHandleUseAfterFreeCheck,
                 .forceGLES2Context = instance->getConfig().forceGLES2Context,
@@ -678,6 +679,7 @@ int FEngine::loop() {
     DriverConfig const driverConfig {
             .handleArenaSize = getRequestedDriverHandleArenaSize(),
             .textureUseAfterFreePoolSize = mConfig.textureUseAfterFreePoolSize,
+            .metalUploadBufferSizeBytes = mConfig.metalUploadBufferSizeBytes,
             .disableParallelShaderCompile = mConfig.disableParallelShaderCompile,
             .disableHandleUseAfterFreeCheck = mConfig.disableHandleUseAfterFreeCheck,
             .forceGLES2Context = mConfig.forceGLES2Context,

filament/src/details/Material.cpp

@@ -119,6 +119,7 @@ struct Material::BuilderDetails {
     const void* mPayload = nullptr;
     size_t mSize = 0;
     bool mDefaultMaterial = false;
+    int32_t mShBandsCount = 3;
     std::unordered_map<
         utils::CString,
         std::variant<int32_t, float, bool>,
@@ -143,6 +144,11 @@ Material::Builder& Material::Builder::package(const void* payload, size_t size)
     return *this;
 }
 
+Material::Builder& Material::Builder::sphericalHarmonicsBandCount(size_t shBandCount) noexcept {
+    mImpl->mShBandsCount = math::clamp(shBandCount, size_t(1), size_t(3));
+    return *this;
+}
+
 template<typename T, typename>
 Material::Builder& Material::Builder::constant(const char* name, size_t nameLength, T value) {
     FILAMENT_CHECK_PRECONDITION(name != nullptr) << "name cannot be null";
@@ -897,6 +903,8 @@ void FMaterial::processSpecializationConstants(FEngine& engine, Material::Builde
     mSpecializationConstants.push_back({
             +ReservedSpecializationConstants::CONFIG_STEREO_EYE_COUNT,
             (int)engine.getConfig().stereoscopicEyeCount });
+    mSpecializationConstants.push_back({
+            +ReservedSpecializationConstants::CONFIG_SH_BANDS_COUNT, builder->mShBandsCount });
     if (UTILS_UNLIKELY(parser->getShaderLanguage() == ShaderLanguage::ESSL1)) {
         // The actual value of this spec-constant is set in the OpenGLDriver backend.
         mSpecializationConstants.push_back({

filament/src/details/MorphTargetBuffer.h

@@ -29,7 +29,8 @@
 
 #include <utils/Allocator.h>
 
-#include <vector>
+#include <stddef.h>
+#include <stdint.h>
 
 namespace filament {
 
@@ -59,16 +60,21 @@ public:
     inline size_t getVertexCount() const noexcept { return mVertexCount; }
     inline size_t getCount() const noexcept { return mCount; }
 
-private:
-    friend class FView;
-    friend class RenderPass;
+    backend::TextureHandle getPositionsHandle() const noexcept {
+        return mPbHandle;
+    }
 
+    backend::TextureHandle getTangentsHandle() const noexcept {
+        return mTbHandle;
+    }
+
+    inline backend::Handle<backend::HwSamplerGroup> getHwHandle() const noexcept { return mSbHandle; }
+
+private:
     void updateDataAt(backend::DriverApi& driver, backend::Handle <backend::HwTexture> handle,
             backend::PixelDataFormat format, backend::PixelDataType type, const char* out,
             size_t elementSize, size_t targetIndex, size_t count, size_t offset);
 
-    inline backend::Handle<backend::HwSamplerGroup> getHwHandle() const noexcept { return mSbHandle; }
-
     backend::Handle<backend::HwSamplerGroup> mSbHandle;
     backend::Handle<backend::HwTexture> mPbHandle;
     backend::Handle<backend::HwTexture> mTbHandle;

filament/src/details/Renderer.cpp

@@ -232,6 +232,10 @@ void FRenderer::setPresentationTime(int64_t monotonic_clock_ns) {
     driver.setPresentationTime(monotonic_clock_ns);
 }
 
+void FRenderer::setVsyncTime(uint64_t steadyClockTimeNano) noexcept {
+    mVsyncSteadyClockTimeNano = steadyClockTimeNano;
+}
+
 bool FRenderer::beginFrame(FSwapChain* swapChain, uint64_t vsyncSteadyClockTimeNano) {
     assert_invariant(swapChain);
 
@@ -252,6 +256,11 @@ bool FRenderer::beginFrame(FSwapChain* swapChain, uint64_t vsyncSteadyClockTimeN
     }
 #endif
 
+    if (!vsyncSteadyClockTimeNano) {
+        vsyncSteadyClockTimeNano = mVsyncSteadyClockTimeNano;
+        mVsyncSteadyClockTimeNano = 0;
+    }
+
     // get the timestamp as soon as possible
     using namespace std::chrono;
     const steady_clock::time_point now{ steady_clock::now() };
@@ -459,6 +468,9 @@ void FRenderer::renderStandaloneView(FView const* view) {
     FILAMENT_CHECK_PRECONDITION(view->getRenderTarget())
             << "View \"" << view->getName() << "\" must have a RenderTarget associated";
 
+    FILAMENT_CHECK_PRECONDITION(!mSwapChain)
+            << "renderStandaloneView() must be called outside of beginFrame() / endFrame()";
+
     if (UTILS_LIKELY(view->getScene())) {
         mPreviousRenderTargets.clear();
         mFrameId++;

filament/src/details/Renderer.h

@@ -29,9 +29,6 @@
 
 #include "backend/DriverApiForward.h"
 
-#include <fg/FrameGraphId.h>
-#include <fg/FrameGraphTexture.h>
-
 #include <filament/Renderer.h>
 #include <filament/Viewport.h>
 
@@ -40,9 +37,20 @@
 
 #include <utils/compiler.h>
 #include <utils/Allocator.h>
+#include <utils/FixedCapacityVector.h>
+
+#include <math/vec4.h>
 
 #include <tsl/robin_set.h>
 
+#include <algorithm>
+#include <chrono>
+#include <functional>
+#include <utility>
+
+#include <stddef.h>
+#include <stdint.h>
+
 namespace filament {
 
 namespace backend {
@@ -78,6 +86,8 @@ public:
 
     void setPresentationTime(int64_t monotonic_clock_ns);
 
+    void setVsyncTime(uint64_t steadyClockTimeNano) noexcept;
+
     // start a frame
     bool beginFrame(FSwapChain* swapChain, uint64_t vsyncSteadyClockTimeNano);
 
@@ -131,6 +141,14 @@ public:
         return mClearOptions;
     }
 
+    utils::FixedCapacityVector<Renderer::FrameInfo> getFrameInfoHistory(size_t historySize) const noexcept {
+        return mFrameInfoManager.getFrameInfoHistory(historySize);
+    }
+
+    size_t getMaxFrameHistorySize() const noexcept {
+        return MAX_FRAMETIME_HISTORY;
+    }
+
 private:
     friend class Renderer;
     using Command = RenderPass::Command;
@@ -187,6 +205,7 @@ private:
     backend::TargetBufferFlags mClearFlags{};
     tsl::robin_set<FRenderTarget*> mPreviousRenderTargets;
     std::function<void()> mBeginFrameInternal;
+    uint64_t mVsyncSteadyClockTimeNano = 0;
 };
 
 FILAMENT_DOWNCAST(Renderer)

filament/src/details/Scene.cpp

@@ -248,7 +248,7 @@ void FScene::prepare(utils::JobSystem& js,
 
     auto* renderableJob = jobs::parallel_for(js, rootJob,
             renderableInstances.data(), renderableInstances.size(),
-            std::cref(renderableWork), jobs::CountSplitter<128, 5>());
+            std::cref(renderableWork), jobs::CountSplitter<64>());
 
     auto* lightJob = jobs::parallel_for(js, rootJob,
             lightInstances.data(), lightInstances.size(),

filament/src/details/View.cpp

@@ -162,7 +162,7 @@ void FView::setDynamicLightingOptions(float zLightNear, float zLightFar) noexcep
 }
 
 float2 FView::updateScale(FEngine& engine,
-        FrameInfo const& info,
+        filament::details::FrameInfo const& info,
         Renderer::FrameRateOptions const& frameRateOptions,
         Renderer::DisplayInfo const& displayInfo) noexcept {
 

filament/src/details/View.h

@@ -283,7 +283,7 @@ public:
     }
 
     math::float2 updateScale(FEngine& engine,
-            FrameInfo const& info,
+            details::FrameInfo const& info,
             Renderer::FrameRateOptions const& frameRateOptions,
             Renderer::DisplayInfo const& displayInfo) noexcept;
 

ios/CocoaPods/Filament.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
   spec.name = "Filament"
-  spec.version = "1.53.0"
+  spec.version = "1.53.2"
   spec.license = { :type => "Apache 2.0", :file => "LICENSE" }
   spec.homepage = "https://google.github.io/filament"
   spec.authors = "Google LLC."
   spec.summary = "Filament is a real-time physically based rendering engine for Android, iOS, Windows, Linux, macOS, and WASM/WebGL."
   spec.platform = :ios, "11.0"
-  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.53.0/filament-v1.53.0-ios.tgz" }
+  spec.source = { :http => "https://github.com/google/filament/releases/download/v1.53.2/filament-v1.53.2-ios.tgz" }
 
   # Fix linking error with Xcode 12; we do not yet support the simulator on Apple silicon.
   spec.pod_target_xcconfig = {

libs/camutils/include/camutils/Manipulator.h

@@ -109,6 +109,7 @@ public:
         vec4 groundPlane;
         RayCallback raycastCallback;
         void* raycastUserdata;
+        bool panning = true;
     };
 
     struct Builder {
@@ -143,6 +144,8 @@ public:
         Builder& groundPlane(FLOAT a, FLOAT b, FLOAT c, FLOAT d);  //! Plane equation used as a raycast fallback
         Builder& raycastCallback(RayCallback cb, void* userdata);  //! Raycast function for accurate grab-and-pan
 
+        Builder& panning(bool enabled);  //! Sets whether panning is enabled
+
         /**
          * Creates a new camera manipulator, either ORBIT, MAP, or FREE_FLIGHT.
          *

libs/camutils/src/Manipulator.cpp

@@ -144,6 +144,14 @@ Manipulator<FLOAT>::Builder& Manipulator<FLOAT>::Builder::raycastCallback(RayCal
     return *this;
 }
 
+
+
+template <typename FLOAT> typename
+Manipulator<FLOAT>::Builder& Manipulator<FLOAT>::Builder::panning(bool enabled) {
+    details.panning = enabled;
+    return *this;
+}
+
 template <typename FLOAT>
 Manipulator<FLOAT>* Manipulator<FLOAT>::Builder::build(Mode mode) {
     switch (mode) {

libs/camutils/src/OrbitManipulator.h

@@ -69,7 +69,7 @@ public:
     }
 
     void grabBegin(int x, int y, bool strafe) override {
-        mGrabState = strafe ? PANNING : ORBITING;
+        mGrabState = strafe && Base::mProps.panning ? PANNING : ORBITING;
         mGrabPivot = mPivot;
         mGrabEye = Base::mEye;
         mGrabTarget = Base::mTarget;

libs/filabridge/include/filament/MaterialEnums.h

@@ -203,7 +203,7 @@ enum class ReflectionMode : uint8_t {
 // can't really use std::underlying_type<AttributeIndex>::type because the driver takes a uint32_t
 using AttributeBitset = utils::bitset32;
 
-static constexpr size_t MATERIAL_PROPERTIES_COUNT = 27;
+static constexpr size_t MATERIAL_PROPERTIES_COUNT = 29;
 enum class Property : uint8_t {
     BASE_COLOR,              //!< float4, all shading models
     ROUGHNESS,               //!< float,  lit shading models only
@@ -232,6 +232,8 @@ enum class Property : uint8_t {
     IOR,                     //!< float,  material's index of refraction
     MICRO_THICKNESS,         //!< float, thickness of the thin layer
     BENT_NORMAL,             //!< float3, all shading models only, except unlit
+    SPECULAR_FACTOR,         //!< float, lit shading models only, except subsurface and cloth
+    SPECULAR_COLOR_FACTOR,   //!< float3, lit shading models only, except subsurface and cloth
 
     // when adding new Properties, make sure to update MATERIAL_PROPERTIES_COUNT
 };

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

@@ -70,6 +70,7 @@ enum class ReservedSpecializationConstants : uint8_t {
     CONFIG_DEBUG_DIRECTIONAL_SHADOWMAP = 6,
     CONFIG_DEBUG_FROXEL_VISUALIZATION = 7,
     CONFIG_STEREO_EYE_COUNT = 8, // don't change (hardcoded in ShaderCompilerService.cpp)
+    CONFIG_SH_BANDS_COUNT = 9
 };
 
 enum class PushConstantIds : uint8_t  {

libs/filagui/src/ImGuiExtensions.cpp

@@ -119,7 +119,7 @@ static void PlotEx(ImGuiPlotType plot_type, const char* label, int series_count,
     const ImRect total_bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0));
     ImGui::ItemSize(total_bb, style.FramePadding.y);
     if (!ImGui::ItemAdd(total_bb, 0, &frame_bb)) return;
-    const bool hovered = ImGui::ItemHoverable(inner_bb, 0);
+    const bool hovered = ImGui::ItemHoverable(inner_bb, 0, ImGuiHoveredFlags_None);
 
     // Determine scale from values if not specified
     if (scale_min == FLT_MAX || scale_max == FLT_MAX) {

libs/filamat/include/filamat/MaterialBuilder.h

@@ -134,6 +134,7 @@ protected:
     TargetApi mTargetApi = (TargetApi) 0;
     Optimization mOptimization = Optimization::PERFORMANCE;
     bool mPrintShaders = false;
+    bool mSaveRawVariants = false;
     bool mGenerateDebugInfo = false;
     bool mIncludeEssl1 = true;
     utils::bitset32 mShaderModels;
@@ -586,6 +587,14 @@ public:
     //! If true, will output the generated GLSL shader code to stdout.
     MaterialBuilder& printShaders(bool printShaders) noexcept;
 
+    /**
+     * If true, this will write the raw generated GLSL for each variant to a text file in the
+     * current directory. The file will be named after the material name and the variant name. Its
+     * extension will be derived from the shader stage. For example, mymaterial_0x0e.frag,
+     * mymaterial_0x18.vert, etc.
+     */
+    MaterialBuilder& saveRawVariants(bool saveVariants) noexcept;
+
     //! If true, will include debugging information in generated SPIRV.
     MaterialBuilder& generateDebugInfo(bool generateDebugInfo) noexcept;
 

libs/filamat/src/Enums.cpp

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

libs/filamat/src/MaterialBuilder.cpp

@@ -57,7 +57,7 @@
 #include <atomic>
 #include <utility>
 #include <vector>
-
+#include <fstream>
 
 namespace filamat {
 
@@ -547,6 +547,11 @@ MaterialBuilder& MaterialBuilder::printShaders(bool printShaders) noexcept {
     return *this;
 }
 
+MaterialBuilder& MaterialBuilder::saveRawVariants(bool saveRawVariants) noexcept {
+    mSaveRawVariants = saveRawVariants;
+    return *this;
+}
+
 MaterialBuilder& MaterialBuilder::generateDebugInfo(bool generateDebugInfo) noexcept {
     mGenerateDebugInfo = generateDebugInfo;
     return *this;
@@ -918,6 +923,30 @@ bool MaterialBuilder::generateShaders(JobSystem& jobSystem, const std::vector<Va
                             shaderModel, targetApi, targetLanguage, featureLevel, info);
                 }
 
+                // Write the variant to a file.
+                if (mSaveRawVariants) {
+                    int variantKey = v.variant.key;
+                    auto getExtension = [](backend::ShaderStage stage) {
+                        switch (stage) {
+                            case backend::ShaderStage::VERTEX:
+                                return "vert";
+                            case backend::ShaderStage::FRAGMENT:
+                                return "frag";
+                            case backend::ShaderStage::COMPUTE:
+                                return "comp";
+                        }
+                    };
+                    char filename[256];
+                    snprintf(filename, sizeof(filename), "%s_0x%02x.%s", mMaterialName.c_str_safe(),
+                            variantKey, getExtension(v.stage));
+                    printf("Writing variant 0x%02x to %s\n", variantKey, filename);
+                    std::ofstream file(filename);
+                    if (file.is_open()) {
+                        file << shader;
+                        file.close();
+                    }
+                }
+
                 std::string* pGlsl = nullptr;
                 if (targetApiNeedsGlsl) {
                     pGlsl = &shader;

libs/filamat/src/shaders/CodeGenerator.cpp

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

libs/filamentapp/include/filamentapp/FilamentApp.h

@@ -104,6 +104,8 @@ public:
 
     size_t getSkippedFrameCount() const { return mSkippedFrames; }
 
+    void loadIBL(std::string_view path);
+
     FilamentApp(const FilamentApp& rhs) = delete;
     FilamentApp(FilamentApp&& rhs) = delete;
     FilamentApp& operator=(const FilamentApp& rhs) = delete;

libs/filamentapp/src/FilamentApp.cpp

@@ -174,11 +174,6 @@ void FilamentApp::run(const Config& config, SetupCallback setupCallback,
 
     loadDirt(config);
     loadIBL(config);
-    if (mIBL != nullptr) {
-        mIBL->getSkybox()->setLayerMask(0x7, 0x4);
-        mScene->setSkybox(mIBL->getSkybox());
-        mScene->setIndirectLight(mIBL->getIndirectLight());
-    }
 
     for (auto& view : window->mViews) {
         if (view.get() != window->mUiView) {
@@ -196,7 +191,7 @@ void FilamentApp::run(const Config& config, SetupCallback setupCallback,
             SDL_SysWMinfo wmInfo;
             SDL_VERSION(&wmInfo.version);
             SDL_GetWindowWMInfo(window->getSDLWindow(), &wmInfo);
-            io.ImeWindowHandle = wmInfo.info.win.window;
+            ImGui::GetMainViewport()->PlatformHandleRaw = wmInfo.info.win.window;
         #endif
         io.KeyMap[ImGuiKey_Tab] = SDL_SCANCODE_TAB;
         io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT;
@@ -519,31 +514,41 @@ const utils::Path& FilamentApp::getRootAssetsPath() {
     return root;
 }
 
-void FilamentApp::loadIBL(const Config& config) {
-    if (!config.iblDirectory.empty()) {
-        Path iblPath(config.iblDirectory);
+void FilamentApp::loadIBL(std::string_view path) {
+    Path iblPath(path);
+    if (!iblPath.exists()) {
+        std::cerr << "The specified IBL path does not exist: " << iblPath << std::endl;
+        return;
+    }
 
-        if (!iblPath.exists()) {
-            std::cerr << "The specified IBL path does not exist: " << iblPath << std::endl;
+    mIBL = std::make_unique<IBL>(*mEngine);
+
+    if (!iblPath.isDirectory()) {
+        if (!mIBL->loadFromEquirect(iblPath)) {
+            std::cerr << "Could not load the specified IBL: " << iblPath << std::endl;
+            mIBL.reset(nullptr);
             return;
         }
-
-        mIBL = std::make_unique<IBL>(*mEngine);
-
-        if (!iblPath.isDirectory()) {
-            if (!mIBL->loadFromEquirect(iblPath)) {
-                std::cerr << "Could not load the specified IBL: " << iblPath << std::endl;
-                mIBL.reset(nullptr);
-                return;
-            }
-        } else {
-            if (!mIBL->loadFromDirectory(iblPath)) {
-                std::cerr << "Could not load the specified IBL: " << iblPath << std::endl;
-                mIBL.reset(nullptr);
-                return;
-            }
+    } else {
+        if (!mIBL->loadFromDirectory(iblPath)) {
+            std::cerr << "Could not load the specified IBL: " << iblPath << std::endl;
+            mIBL.reset(nullptr);
+            return;
         }
     }
+
+    if (mIBL != nullptr) {
+        mIBL->getSkybox()->setLayerMask(0x7, 0x4);
+        mScene->setSkybox(mIBL->getSkybox());
+        mScene->setIndirectLight(mIBL->getIndirectLight());
+    }
+}
+
+void FilamentApp::loadIBL(const Config& config) {
+    if (config.iblDirectory.empty()) {
+        return;
+    }
+    loadIBL(config.iblDirectory);
 }
 
 void FilamentApp::loadDirt(const Config& config) {

libs/gltfio/CMakeLists.txt

@@ -147,6 +147,9 @@ build_ubershader(volume_opaque             volume          lit opaque)
 build_ubershader(volume_fade               volume          lit fade)
 build_ubershader(volume_masked             volume          lit masked)
 build_ubershader(sheen                     sheen           _ _)
+build_ubershader(specular_opaque           specular        lit opaque)
+build_ubershader(specular_fade             specular        lit fade)
+build_ubershader(specular_masked           specular        lit masked)
 
 add_custom_target(uberz_file DEPENDS ${UBERZ_OUTPUT_PATH})
 set_target_properties(uberz_file PROPERTIES FOLDER Libs)

libs/gltfio/include/gltfio/MaterialProvider.h

@@ -93,10 +93,17 @@ struct alignas(4) MaterialKey {
     bool hasSheen : 1;
     bool hasIOR : 1;
     bool hasVolume : 1;
-    uint8_t padding : 5;
+    bool hasSpecular : 1;
+    bool hasSpecularTexture : 1;
+    bool hasSpecularColorTexture : 1;
+    bool padding : 2;
+    // -- 32 bit boundary --
+    uint8_t specularTextureUV;
+    uint8_t specularColorTextureUV;
+    uint16_t padding2;
 };
 
-static_assert(sizeof(MaterialKey) == 16, "MaterialKey has unexpected size.");
+static_assert(sizeof(MaterialKey) == 20, "MaterialKey has unexpected size.");
 
 UTILS_WARNING_POP
 

libs/gltfio/materials/base.spec.in

@@ -30,3 +30,8 @@ TransmissionTexture = unsupported
 # Volume Features
 Volume = unsupported
 VolumeThicknessTexture = unsupported
+
+# Specular Features
+Specular = unsupported
+SpecularTexture = unsupported
+SpecularColorTexture = unsupported

libs/gltfio/materials/sheen.mat.in

@@ -55,7 +55,16 @@ material {
         { type : mat3, name : sheenRoughnessUvMatrix, precision: high },
 
         // Reflectance
-        { type : float, name : reflectance }
+        { type : float, name : reflectance },
+
+        // KHR_materials_specular
+        { type : float, name : specularStrength },
+        { type : float3, name : specularColorFactor },
+        { type : int, name : specularIndex },
+        { type : sampler2d, name : specularMap },
+        { type : mat3, name : specularUvMatrix, precision: high },
+        { type : int, name : specularColorIndex },
+        { type : mat3, name : specularColorUvMatrix, precision: high }
 
         ${CUSTOM_PARAMS}
     ],
@@ -136,6 +145,15 @@ fragment {
             material.emissive.rgb *= texture(materialParams_emissiveMap, uv).rgb;
         }
 
+        material.specularFactor = materialParams.specularStrength;
+        material.specularColorFactor = materialParams.specularColorFactor;
+
+        if (materialParams.specularIndex > -1) {
+            highp float2 uv = uvs[materialParams.specularIndex];
+            uv = (vec3(uv, 1.0) * materialParams.specularUvMatrix).xy;
+            material.specularFactor *= texture(materialParams_specularMap, uv).a;
+        }
+
         ${CUSTOM_FRAGMENT}
     }
 }

libs/gltfio/materials/sheen.spec.in

@@ -17,3 +17,8 @@ TextureTransforms=optional
 Sheen=optional
 SheenColorTexture=optional
 SheenRoughnessTexture=optional
+
+# KHR_material_specular Features
+Specular=optional
+SpecularTexture=optional
+SpecularColorTexture=unsupported

libs/gltfio/materials/specular.mat.in

@@ -0,0 +1,168 @@
+material {
+    name : specular_ubershader,
+    requires : [ uv0, uv1, color ],
+    shadingModel : lit,
+    blending : ${BLENDING},
+    doubleSided : ${DOUBLESIDED},
+    transparency : ${TRANSPARENCY},
+    flipUV : false,
+    specularAmbientOcclusion : simple,
+    specularAntiAliasing : true,
+    clearCoatIorChange : false,
+    reflections: screenspace,
+    parameters : [
+
+        // Base Color
+        { type : int, name : baseColorIndex },
+        { type : float4, name : baseColorFactor },
+        { type : sampler2d, name : baseColorMap },
+        { type : mat3, name : baseColorUvMatrix, precision: high },
+
+        // Metallic-Roughness Map
+        { type : int, name : metallicRoughnessIndex },
+        { type : float, name : metallicFactor },
+        { type : float, name : roughnessFactor },
+        { type : sampler2d, name : metallicRoughnessMap },
+        { type : mat3, name : metallicRoughnessUvMatrix, precision: high },
+
+        // Normal Map
+        { type : int, name : normalIndex },
+        { type : float, name : normalScale },
+        { type : sampler2d, name : normalMap },
+        { type : mat3, name : normalUvMatrix, precision: high },
+
+        // Ambient Occlusion
+        { type : int, name : aoIndex },
+        { type : float, name : aoStrength },
+        { type : sampler2d, name : occlusionMap },
+        { type : mat3, name : occlusionUvMatrix, precision: high },
+
+        // Emissive Map
+        { type : int, name : emissiveIndex },
+        { type : float3, name : emissiveFactor },
+        { type : float, name : emissiveStrength },
+        { type : sampler2d, name : emissiveMap },
+        { type : mat3, name : emissiveUvMatrix, precision: high },
+
+        // Clear coat, we drop texture support for clear coat due to 8 texture limits.
+        { type : float, name : clearCoatFactor },
+        { type : float, name : clearCoatRoughnessFactor },
+        { type : int, name : clearCoatIndex },
+        { type : sampler2d, name : clearCoatMap },
+        { type : mat3, name : clearCoatUvMatrix, precision: high },
+        { type : int, name : clearCoatRoughnessIndex },
+        { type : mat3, name : clearCoatRoughnessUvMatrix, precision: high },
+        { type : int, name : clearCoatNormalIndex },
+        { type : mat3, name : clearCoatNormalUvMatrix, precision: high },
+        { type : float, name : clearCoatNormalScale },
+
+        // KHR_materials_specular
+        { type : float, name : specularStrength },
+        { type : float3, name : specularColorFactor },
+        { type : int, name : specularIndex },
+        { type : sampler2d, name : specularMap },
+        { type : mat3, name : specularUvMatrix, precision: high },
+        { type : int, name : specularColorIndex },
+        { type : sampler2d, name : specularColorMap },
+        { type : mat3, name : specularColorUvMatrix, precision: high },
+
+        // IOR
+        { type : float, name : ior }
+
+        ${CUSTOM_PARAMS}
+    ],
+}
+
+vertex {
+void materialVertex(inout MaterialVertexInputs material) {
+    ${CUSTOM_VERTEX}
+}
+}
+
+fragment {
+void material(inout MaterialInputs material) {
+    highp float2 uvs[2];
+    uvs[0] = getUV0();
+    uvs[1] = getUV1();
+
+    if (materialParams.normalIndex > -1) {
+        highp float2 uv = uvs[materialParams.normalIndex];
+        uv = (vec3(uv, 1.0) * materialParams.normalUvMatrix).xy;
+        material.normal = texture(materialParams_normalMap, uv).xyz * 2.0 - 1.0;
+        material.normal.xy *= materialParams.normalScale;
+    }
+
+    prepareMaterial(material);
+    material.baseColor = materialParams.baseColorFactor;
+
+    if (materialParams.baseColorIndex > -1) {
+        highp float2 uv = uvs[materialParams.baseColorIndex];
+        uv = (vec3(uv, 1.0) * materialParams.baseColorUvMatrix).xy;
+        material.baseColor *= texture(materialParams_baseColorMap, uv);
+    }
+
+#if defined(BLEND_MODE_TRANSPARENT)
+    material.baseColor.rgb *= material.baseColor.a;
+#endif
+
+    material.baseColor *= getColor();
+
+    material.roughness = materialParams.roughnessFactor;
+    material.metallic = materialParams.metallicFactor;
+    material.ior = materialParams.ior;
+
+    material.emissive = vec4(materialParams.emissiveStrength *
+                             materialParams.emissiveFactor.rgb, 0.0);
+
+    // KHR_materials_clearcoat forbids clear coat from
+    // being applied in the specular/glossiness model
+    material.clearCoat = materialParams.clearCoatFactor;
+    material.clearCoatRoughness = materialParams.clearCoatRoughnessFactor;
+
+    if (materialParams.clearCoatIndex > -1) {
+        highp float2 uv = uvs[materialParams.clearCoatIndex];
+        uv = (vec3(uv, 1.0) * materialParams.clearCoatUvMatrix).xy;
+        material.clearCoat *= texture(materialParams_clearCoatMap, uv).r;
+    }
+
+    material.specularFactor = materialParams.specularStrength;
+    material.specularColorFactor = materialParams.specularColorFactor;
+
+    if (materialParams.specularIndex > -1) {
+        highp float2 uv = uvs[materialParams.specularIndex];
+        uv = (vec3(uv, 1.0) * materialParams.specularUvMatrix).xy;
+        material.specularFactor *= texture(materialParams_specularMap, uv).a;
+    }
+
+    if (materialParams.specularColorIndex > -1) {
+        highp float2 uv = uvs[materialParams.specularColorIndex];
+        uv = (vec3(uv, 1.0) * materialParams.specularColorUvMatrix).xy;
+        vec4 sc = texture(materialParams_specularColorMap, uv);
+        material.specularColorFactor.r *= sc.r;
+        material.specularColorFactor.g *= sc.g;
+        material.specularColorFactor.b *= sc.b;
+    }
+
+    if (materialParams.metallicRoughnessIndex > -1) {
+        highp float2 uv = uvs[materialParams.metallicRoughnessIndex];
+        uv = (vec3(uv, 1.0) * materialParams.metallicRoughnessUvMatrix).xy;
+        vec4 mr = texture(materialParams_metallicRoughnessMap, uv);
+        material.roughness *= mr.g;
+        material.metallic *= mr.b;
+    }
+
+    if (materialParams.aoIndex > -1) {
+        highp float2 uv = uvs[materialParams.aoIndex];
+        uv = (vec3(uv, 1.0) * materialParams.occlusionUvMatrix).xy;
+        float occlusion = texture(materialParams_occlusionMap, uv).r;
+        material.ambientOcclusion = 1.0 + materialParams.aoStrength * (occlusion - 1.0);
+    }
+    if (materialParams.emissiveIndex > -1) {
+        highp float2 uv = uvs[materialParams.emissiveIndex];
+        uv = (vec3(uv, 1.0) * materialParams.emissiveUvMatrix).xy;
+        material.emissive.rgb *= texture(materialParams_emissiveMap, uv).rgb;
+    }
+
+    ${CUSTOM_FRAGMENT}
+}
+}

libs/gltfio/materials/specular.spec.in

@@ -0,0 +1,35 @@
+ShadingModel=lit
+
+# Required Aspects
+BlendingMode = ${BLENDING}
+
+VertexColors = optional
+BaseColorTexture = optional
+NormalTexture = optional
+OcclusionTexture = optional
+EmissiveTexture = optional
+MetallicRoughnessTexture = optional
+TextureTransforms = optional
+
+# KHR_materials_specular Features
+Specular = optional
+SpecularTexture = optional
+SpecularColorTexture = optional
+
+# ClearCoat Features
+ClearCoat = optional
+ClearCoatTexture = optional
+
+# Sheen Features
+Sheen = unsupported
+SheenColorTexture = unsupported
+SheenRoughnessTexture = unsupported
+
+# Transmission and IOR Features
+Transmission = unsupported
+Ior = optional
+TransmissionTexture = unsupported
+
+# Volume Features
+Volume = unsupported
+VolumeThicknessTexture = unsupported

libs/gltfio/materials/transmission.mat.in

@@ -52,7 +52,18 @@ material {
         { type : mat3, name : transmissionUvMatrix, precision: high },
 
         // IOR
-        { type : float, name : ior }
+        { type : float, name : ior },
+
+        // KHR_materials_specular
+        { type : float, name : specularStrength },
+        { type : float3, name : specularColorFactor },
+        { type : int, name : specularIndex },
+        { type : sampler2d, name : specularMap },
+        { type : mat3, name : specularUvMatrix, precision: high },
+        { type : int, name : specularColorIndex },
+        { type : sampler2d, name : specularColorMap },
+        { type : mat3, name : specularColorUvMatrix, precision: high }
+
 
         ${CUSTOM_PARAMS}
     ],
@@ -126,6 +137,24 @@ fragment {
             material.emissive.rgb *= texture(materialParams_emissiveMap, uv).rgb;
         }
 
+        material.specularFactor = materialParams.specularStrength;
+        material.specularColorFactor = materialParams.specularColorFactor;
+
+        if (materialParams.specularIndex > -1) {
+            highp float2 uv = uvs[materialParams.specularIndex];
+            uv = (vec3(uv, 1.0) * materialParams.specularUvMatrix).xy;
+            material.specularFactor *= texture(materialParams_specularMap, uv).a;
+        }
+
+        if (materialParams.specularColorIndex > -1) {
+            highp float2 uv = uvs[materialParams.specularColorIndex];
+            uv = (vec3(uv, 1.0) * materialParams.specularColorUvMatrix).xy;
+            vec4 sc = texture(materialParams_specularColorMap, uv);
+            material.specularColorFactor.r *= sc.r;
+            material.specularColorFactor.g *= sc.g;
+            material.specularColorFactor.b *= sc.b;
+        }
+
         ${CUSTOM_FRAGMENT}
     }
 }

libs/gltfio/materials/transmission.spec.in

@@ -15,6 +15,11 @@ EmissiveTexture=optional
 MetallicRoughnessTexture=optional
 TextureTransforms=optional
 
+# KHR_materials_specular Features
+Specular=optional
+SpecularTexture=optional
+SpecularColorTexture=optional
+
 Transmission=optional
 Ior=optional
 TransmissionTexture=optional

libs/gltfio/materials/volume.mat.in

@@ -58,6 +58,15 @@ material {
         { type : sampler2d, name : volumeThicknessMap },
         { type : mat3, name : volumeThicknessUvMatrix, precision: high },
 
+        // KHR_materials_specular
+        { type : float, name : specularStrength },
+        { type : float3, name : specularColorFactor },
+        { type : int, name : specularIndex },
+        { type : sampler2d, name : specularMap },
+        { type : mat3, name : specularUvMatrix, precision: high },
+        { type : int, name : specularColorIndex },
+        { type : mat3, name : specularColorUvMatrix, precision: high },
+
         // IOR
         { type : float, name : ior }
 
@@ -142,6 +151,15 @@ fragment {
             material.emissive.rgb *= texture(materialParams_emissiveMap, uv).rgb;
         }
 
+        material.specularFactor = materialParams.specularStrength;
+        material.specularColorFactor = materialParams.specularColorFactor;
+
+        if (materialParams.specularIndex > -1) {
+            highp float2 uv = uvs[materialParams.specularIndex];
+            uv = (vec3(uv, 1.0) * materialParams.specularUvMatrix).xy;
+            material.specularFactor *= texture(materialParams_specularMap, uv).a;
+        }
+
         ${CUSTOM_FRAGMENT}
     }
 }

libs/gltfio/materials/volume.spec.in

@@ -26,3 +26,8 @@ TransmissionTexture=optional
 # Volume Features
 Volume=optional
 VolumeThicknessTexture=optional
+
+# KHR_materials_specular Features
+Specular=optional
+SpecularTexture=optional
+SpecularColorTexture=unsupported

libs/gltfio/src/AssetLoader.cpp

@@ -650,9 +650,6 @@ void FAssetLoader::createPrimitives(const cgltf_node* node, const char* name,
                     if (outputPrim.indices) {
                         fAsset->mIndexBuffers.push_back(outputPrim.indices);
                     }
-                    if (outputPrim.targets) {
-                        fAsset->mMorphTargetBuffers.push_back(outputPrim.targets);
-                    }
                 }
             } else {
                 // Create a Filament VertexBuffer and IndexBuffer for this prim if we haven't
@@ -695,11 +692,11 @@ void FAssetLoader::createRenderable(const cgltf_node* node, Entity entity, const
     // glTF spec says that all primitives must have the same number of morph targets.
     const cgltf_size numMorphTargets = inputPrim ? inputPrim->targets_count : 0;
     RenderableManager::Builder builder(primitiveCount);
-    builder.morphing(numMorphTargets);
 
     // For each prim, create a Filament VertexBuffer, IndexBuffer, and MaterialInstance.
     // The VertexBuffer and IndexBuffer objects are cached for possible re-use, but MaterialInstance
     // is not.
+    size_t morphingVertexCount = 0;
     for (cgltf_size index = 0; index < primitiveCount; ++index, ++outputPrim, ++inputPrim) {
         RenderableManager::PrimitiveType primType;
         if (!getPrimitiveType(inputPrim->type, &primType)) {
@@ -740,8 +737,78 @@ void FAssetLoader::createRenderable(const cgltf_node* node, Entity entity, const
         builder.geometry(index, primType, outputPrim->vertices, outputPrim->indices);
 
         if (numMorphTargets) {
-            assert_invariant(outputPrim->targets);
-            builder.morphing(0, index, outputPrim->targets);
+            outputPrim->morphTargetOffset = morphingVertexCount;    // FIXME: can I do that here?
+            builder.morphing(0, index, morphingVertexCount);
+            morphingVertexCount += outputPrim->vertices->getVertexCount();
+        }
+    }
+
+    if (numMorphTargets) {
+        MorphTargetBuffer* morphTargetBuffer = MorphTargetBuffer::Builder()
+                .count(numMorphTargets)
+                .vertexCount(morphingVertexCount)
+                .build(mEngine);
+
+        fAsset->mMorphTargetBuffers.push_back(morphTargetBuffer);
+
+        builder.morphing(morphTargetBuffer);
+
+        outputPrim = prims.data();
+        inputPrim = &mesh->primitives[0];
+        for (cgltf_size index = 0; index < primitiveCount; ++index, ++outputPrim, ++inputPrim) {
+            outputPrim->morphTargetBuffer = morphTargetBuffer;
+
+            UTILS_UNUSED_IN_RELEASE cgltf_accessor const* previous = nullptr;
+            for (int tindex = 0; tindex < numMorphTargets; ++tindex) {
+                const cgltf_morph_target& inTarget = inputPrim->targets[tindex];
+                for (cgltf_size aindex = 0; aindex < inTarget.attributes_count; ++aindex) {
+                    const cgltf_attribute& attribute = inTarget.attributes[aindex];
+                    const cgltf_accessor* accessor = attribute.data;
+                    const cgltf_attribute_type atype = attribute.type;
+                    if (atype == cgltf_attribute_type_position) {
+                        // All position attributes must have the same number of components.
+                        assert_invariant(!previous || previous->type == accessor->type);
+                        previous = accessor;
+
+                        assert_invariant(outputPrim->morphTargetBuffer);
+
+                        if (std::holds_alternative<FFilamentAsset::ResourceInfo>(
+                                fAsset->mResourceInfo)) {
+                            using BufferSlot = FFilamentAsset::ResourceInfo::BufferSlot;
+                            auto& slots = std::get<FFilamentAsset::ResourceInfo>(
+                                    fAsset->mResourceInfo).mBufferSlots;
+                            BufferSlot& slot = slots[outputPrim->slotIndices[tindex]];
+
+                            assert_invariant(!slot.vertexBuffer);
+                            assert_invariant(!slot.indexBuffer);
+
+                            slot.morphTargetBuffer = outputPrim->morphTargetBuffer;
+                            slot.morphTargetOffset = outputPrim->morphTargetOffset;
+                            slot.morphTargetCount = outputPrim->vertices->getVertexCount();
+                            slot.bufferIndex = tindex;
+                        }
+                        else if (std::holds_alternative<FFilamentAsset::ResourceInfoExtended>(
+                                fAsset->mResourceInfo))
+                        {
+                            using BufferSlot = FFilamentAsset::ResourceInfoExtended::BufferSlot;
+                            auto& slots = std::get<FFilamentAsset::ResourceInfoExtended>(
+                                    fAsset->mResourceInfo).slots;
+
+                            BufferSlot& slot = slots[outputPrim->slotIndices[tindex]];
+
+                            assert_invariant(slot.slot == tindex);
+                            assert_invariant(!slot.vertices);
+                            assert_invariant(!slot.indices);
+
+                            slot.target = outputPrim->morphTargetBuffer;
+                            slot.offset = outputPrim->morphTargetOffset;
+                            slot.count = outputPrim->vertices->getVertexCount();
+                        }
+
+                        break;
+                    }
+                }
+            }
         }
     }
 
@@ -753,7 +820,7 @@ void FAssetLoader::createRenderable(const cgltf_node* node, Entity entity, const
     nm.setMorphTargetNames(nm.getInstance(entity), std::move(morphTargetNames));
 
     if (node->skin) {
-       builder.skinning(node->skin->joints_count);
+        builder.skinning(node->skin->joints_count);
     }
 
     // Per the spec, glTF models must have valid mix / max annotations for position attributes.
@@ -825,7 +892,7 @@ bool FAssetLoader::createPrimitive(const cgltf_primitive& inPrim, const char* na
     // request from Google.
 
     // Create a little lambda that appends to the asset's vertex buffer slots.
-    auto slots = &std::get<FFilamentAsset::ResourceInfo>(fAsset->mResourceInfo).mBufferSlots;
+    auto* const slots = &std::get<FFilamentAsset::ResourceInfo>(fAsset->mResourceInfo).mBufferSlots;
     auto addBufferSlot = [slots](FFilamentAsset::ResourceInfo::BufferSlot entry) {
         slots->push_back(entry);
     };
@@ -1096,13 +1163,8 @@ bool FAssetLoader::createPrimitive(const cgltf_primitive& inPrim, const char* na
     }
 
     if (targetsCount > 0) {
-        MorphTargetBuffer* targets = MorphTargetBuffer::Builder()
-                .vertexCount(vertexCount)
-                .count(targetsCount)
-                .build(mEngine);
-        outPrim->targets = targets;
-        fAsset->mMorphTargetBuffers.push_back(targets);
         UTILS_UNUSED_IN_RELEASE cgltf_accessor const* previous = nullptr;
+        outPrim->slotIndices.resize(targetsCount);
         for (int tindex = 0; tindex < targetsCount; ++tindex) {
             const cgltf_morph_target& inTarget = inPrim.targets[tindex];
             for (cgltf_size aindex = 0; aindex < inTarget.attributes_count; ++aindex) {
@@ -1114,8 +1176,7 @@ bool FAssetLoader::createPrimitive(const cgltf_primitive& inPrim, const char* na
                     assert_invariant(!previous || previous->type == accessor->type);
                     previous = accessor;
                     BufferSlot slot = { accessor };
-                    slot.morphTargetBuffer = targets;
-                    slot.bufferIndex = tindex;
+                    outPrim->slotIndices[tindex] = slots->size();
                     addBufferSlot(slot);
                     break;
                 }
@@ -1222,6 +1283,7 @@ MaterialKey FAssetLoader::getMaterialKey(const cgltf_data* srcAsset,
     auto trConfig = inputMat->transmission;
     auto shConfig = inputMat->sheen;
     auto vlConfig = inputMat->volume;
+    auto spConfig = inputMat->specular;
     *baseColorTexture = mrConfig.base_color_texture;
     *metallicRoughnessTexture = mrConfig.metallic_roughness_texture;
 
@@ -1238,7 +1300,9 @@ MaterialKey FAssetLoader::getMaterialKey(const cgltf_data* srcAsset,
         ccConfig.clearcoat_normal_texture.has_transform ||
         shConfig.sheen_color_texture.has_transform ||
         shConfig.sheen_roughness_texture.has_transform ||
-        trConfig.transmission_texture.has_transform;
+        trConfig.transmission_texture.has_transform ||
+        spConfig.specular_color_texture.has_transform ||
+        spConfig.specular_texture.has_transform;
 
     MaterialKey matkey {
         .doubleSided = !!inputMat->double_sided,
@@ -1273,6 +1337,11 @@ MaterialKey FAssetLoader::getMaterialKey(const cgltf_data* srcAsset,
         .hasSheen = !!inputMat->has_sheen,
         .hasIOR = !!inputMat->has_ior,
         .hasVolume = !!inputMat->has_volume,
+        .hasSpecular = !!inputMat->has_specular,
+        .hasSpecularTexture = spConfig.specular_texture.texture != nullptr,
+        .hasSpecularColorTexture = spConfig.specular_color_texture.texture != nullptr,
+        .specularTextureUV = (uint8_t) spConfig.specular_texture.texcoord,
+        .specularColorTextureUV = (uint8_t) spConfig.specular_color_texture.texcoord,
     };
 
     if (inputMat->has_pbr_specular_glossiness) {
@@ -1361,6 +1430,7 @@ MaterialInstance* FAssetLoader::createMaterialInstance(const cgltf_material* inp
     auto trConfig = inputMat->transmission;
     auto shConfig = inputMat->sheen;
     auto vlConfig = inputMat->volume;
+    auto spConfig = inputMat->specular;
 
     // Check the material blending mode, not the cgltf blending mode, because the provider
     // might have selected an alternative blend mode (e.g. to support transmission).
@@ -1560,6 +1630,30 @@ MaterialInstance* FAssetLoader::createMaterialInstance(const cgltf_material* inp
                 inputMat->emissive_strength.emissive_strength : 1.0f);
     }
 
+    if (matkey.hasSpecular) {
+        const float* s = spConfig.specular_color_factor;
+        mi->setParameter("specularColorFactor", float3{s[0], s[1], s[2]});
+        mi->setParameter("specularStrength", spConfig.specular_factor);
+
+        if (matkey.hasSpecularColorTexture) {
+            fAsset->addTextureBinding(mi, "specularColorMap", spConfig.specular_color_texture.texture, sRGB);
+            if (matkey.hasTextureTransforms) {
+                const cgltf_texture_transform uvt = spConfig.specular_color_texture.transform;
+                auto uvmat = matrixFromUvTransform(uvt.offset, uvt.rotation, uvt.scale);
+                mi->setParameter("specularColorUvMatrix", uvmat);
+            }
+        }
+        if (matkey.hasSpecularTexture) {
+            bool sameTexture = spConfig.specular_color_texture.texture == spConfig.specular_texture.texture;
+            fAsset->addTextureBinding(mi, "specularMap", spConfig.specular_texture.texture, sameTexture ? sRGB : LINEAR);
+            if (matkey.hasTextureTransforms) {
+                const cgltf_texture_transform uvt = spConfig.specular_texture.transform;
+                auto uvmat = matrixFromUvTransform(uvt.offset, uvt.rotation, uvt.scale);
+                mi->setParameter("specularUvMatrix", uvmat);
+            }
+        }
+    }
+
     *cacheEntry = { mi, *uvmap };
     return mi;
 }

libs/gltfio/src/FFilamentAsset.h

@@ -96,7 +96,9 @@ struct Primitive {
     IndexBuffer* indices = nullptr;
     Aabb aabb; // object-space bounding box
     UvMap uvmap; // mapping from each glTF UV set to either UV0 or UV1 (8 bytes)
-    MorphTargetBuffer* targets = nullptr;
+    MorphTargetBuffer* morphTargetBuffer = nullptr;
+    uint32_t morphTargetOffset;
+    std::vector<int> slotIndices;
 };
 using MeshCache = utils::FixedCapacityVector<utils::FixedCapacityVector<Primitive>>;
 
@@ -329,6 +331,8 @@ struct FFilamentAsset : public FilamentAsset {
             VertexBuffer* vertexBuffer;
             IndexBuffer* indexBuffer;
             MorphTargetBuffer* morphTargetBuffer;
+            uint32_t morphTargetOffset;
+            uint32_t morphTargetCount;
         };
 
         std::vector<BufferSlot> mBufferSlots;
@@ -343,6 +347,8 @@ struct FFilamentAsset : public FilamentAsset {
             VertexBuffer* vertices = nullptr;
             IndexBuffer* indices = nullptr;
             MorphTargetBuffer* target = nullptr;
+            uint32_t offset = 0;
+            uint32_t count = 0;
             int slot = -1;
             size_t sizeInBytes = 0;
 

libs/gltfio/src/GltfEnums.h

@@ -131,6 +131,7 @@ inline bool getPrimitiveType(cgltf_primitive_type in,
         case cgltf_primitive_type_triangle_strip:
             *out = filament::RenderableManager::PrimitiveType::TRIANGLE_STRIP;
             return true;
+        case cgltf_primitive_type_invalid:
         case cgltf_primitive_type_line_loop:
         case cgltf_primitive_type_triangle_fan:
         case cgltf_primitive_type_max_enum:

libs/gltfio/src/JitShaderProvider.cpp

@@ -308,6 +308,35 @@ std::string shaderFromKey(const MaterialKey& config) {
                 material.ior = materialParams.ior;
             )SHADER";
         }
+
+        if (config.hasSpecular) {
+            shader += R"SHADER(
+                material.specularFactor = materialParams.specularStrength;
+                material.specularColorFactor = materialParams.specularColorFactor;
+            )SHADER";
+
+            if (config.hasSpecularTexture) {
+                shader += "highp float2 specularUV = ${specular};\n";
+                if (config.hasTextureTransforms) {
+                    shader += "specularUV = (vec3(specularUV, 1.0) * "
+                              "materialParams.specularUvMatrix).xy;\n";
+                }
+                shader += R"SHADER(
+                    material.specularFactor *= texture(materialParams_specularMap, specularUV).a;
+                )SHADER";
+            }
+
+            if (config.hasSpecularColorTexture) {
+                shader += "highp float2 specularColorUV = ${specularColor};\n";
+                if (config.hasTextureTransforms) {
+                    shader += "specularColorUV = (vec3(specularColorUV, 1.0) * "
+                              "materialParams.specularColorUvMatrix).xy;\n";
+                }
+                shader += R"SHADER(
+                    material.specularColorFactor *= texture(materialParams_specularColorMap, specularColorUV).rgb;
+                )SHADER";
+            }
+        }
     }
 
     shader += "}\n";
@@ -463,6 +492,26 @@ Material* createMaterial(Engine* engine, const MaterialKey& config, const UvMap&
         }
     }
 
+    // SPECULAR
+    if (config.hasSpecular) {
+        builder.parameter("specularStrength", MaterialBuilder::UniformType::FLOAT);
+        builder.parameter("specularColorFactor", MaterialBuilder::UniformType::FLOAT3);
+        if (config.hasSpecularTexture) {
+            builder.parameter("specularMap", MaterialBuilder::SamplerType::SAMPLER_2D);
+            if (config.hasTextureTransforms) {
+                builder.parameter("specularUvMatrix", MaterialBuilder::UniformType::MAT3,
+                                  MaterialBuilder::ParameterPrecision::HIGH);
+            }
+        }
+        if (config.hasSpecularColorTexture) {
+            builder.parameter("specularColorMap", MaterialBuilder::SamplerType::SAMPLER_2D);
+            if (config.hasTextureTransforms) {
+                builder.parameter("specularColorUvMatrix", MaterialBuilder::UniformType::MAT3,
+                                  MaterialBuilder::ParameterPrecision::HIGH);
+            }
+        }
+    }
+
     // BLENDING
     switch (config.alphaMode) {
         case AlphaMode::OPAQUE:

libs/gltfio/src/MaterialProvider.cpp

@@ -143,6 +143,21 @@ void constrainMaterial(MaterialKey* key, UvMap* uvmap) {
             retval[key->volumeThicknessUV] = (UvSet) index++;
         }
     }
+    if (key->hasSpecularTexture && retval[key->specularTextureUV] == UNUSED) {
+        if (index > MAX_INDEX) {
+            key->hasSpecularTexture = false;
+        } else {
+            retval[key->specularTextureUV] = (UvSet) index++;
+        }
+    }
+    if (key->hasSpecularColorTexture && retval[key->specularColorTextureUV] == UNUSED) {
+        if (index > MAX_INDEX) {
+            key->hasSpecularColorTexture = false;
+        } else {
+            retval[key->specularColorTextureUV] = (UvSet) index++;
+        }
+    }
+
     // NOTE: KHR_materials_clearcoat does not provide separate UVs, we'll assume UV0
     *uvmap = retval;
 }
@@ -167,6 +182,8 @@ void processShaderString(std::string* shader, const UvMap& uvmap, const Material
     const auto& sheenColorUV = uvstrings[uvmap[config.sheenColorUV]];
     const auto& sheenRoughnessUV = uvstrings[uvmap[config.sheenRoughnessUV]];
     const auto& volumeThicknessUV = uvstrings[uvmap[config.volumeThicknessUV]];
+    const auto& specularUV = uvstrings[uvmap[config.specularTextureUV]];
+    const auto& specularColorUV = uvstrings[uvmap[config.specularColorTextureUV]];
 
     replaceAll("${normal}", normalUV);
     replaceAll("${color}", baseColorUV);
@@ -180,6 +197,8 @@ void processShaderString(std::string* shader, const UvMap& uvmap, const Material
     replaceAll("${sheenColor}", sheenColorUV);
     replaceAll("${sheenRoughness}", sheenRoughnessUV);
     replaceAll("${volumeThickness}", volumeThicknessUV);
+    replaceAll("${specular}", specularUV);
+    replaceAll("${specularColor}", specularColorUV);
 }
 
 } // namespace filament::gltfio

libs/gltfio/src/ResourceLoader.cpp

@@ -293,10 +293,13 @@ inline void uploadBuffers(FFilamentAsset* asset, Engine& engine,
             cgltf_accessor_unpack_floats(accessor, floatsData, floatsCount);
             if (accessor->type == cgltf_type_vec3) {
                 slot.morphTargetBuffer->setPositionsAt(engine, slot.bufferIndex,
-                        (const float3*) floatsData, slot.morphTargetBuffer->getVertexCount());
+                        (const float3*) floatsData,
+                        slot.morphTargetCount,
+                        slot.morphTargetOffset);
             } else {
                 slot.morphTargetBuffer->setPositionsAt(engine, slot.bufferIndex,
-                        (const float4*) data, slot.morphTargetBuffer->getVertexCount());
+                        (const float4*) data, slot.morphTargetBuffer->getVertexCount(),
+                        slot.morphTargetOffset);
             }
             free(floatsData);
             continue;
@@ -304,11 +307,13 @@ inline void uploadBuffers(FFilamentAsset* asset, Engine& engine,
 
         if (accessor->type == cgltf_type_vec3) {
             slot.morphTargetBuffer->setPositionsAt(engine, slot.bufferIndex, (const float3*) data,
-                    slot.morphTargetBuffer->getVertexCount());
+                    slot.morphTargetCount,
+                    slot.morphTargetOffset);
         } else {
             assert_invariant(accessor->type == cgltf_type_vec4);
             slot.morphTargetBuffer->setPositionsAt(engine, slot.bufferIndex, (const float4*) data,
-                    slot.morphTargetBuffer->getVertexCount());
+                    slot.morphTargetCount,
+                    slot.morphTargetOffset);
         }
     }
 }
@@ -694,7 +699,7 @@ void ResourceLoader::Impl::computeTangents(FFilamentAsset* asset) {
         }
         auto iter = baseTangents.find(vb);
         if (iter != baseTangents.end()) {
-            jobParams.emplace_back(Params {{ prim }, {vb, nullptr, iter->second }});
+            jobParams.emplace_back(Params {{ prim }, {vb, nullptr, 0, iter->second }});
         }
     }
 
@@ -707,7 +712,8 @@ void ResourceLoader::Impl::computeTangents(FFilamentAsset* asset) {
         }
         for (cgltf_size pindex = 0, pcount = mesh.primitives_count; pindex < pcount; ++pindex) {
             const cgltf_primitive& prim = mesh.primitives[pindex];
-            MorphTargetBuffer* tb = prims[pindex].targets;
+            MorphTargetBuffer* const tb = prims[pindex].morphTargetBuffer;
+            uint32_t const morphTargetOffset = prims[pindex].morphTargetOffset;
             for (cgltf_size tindex = 0, tcount = prim.targets_count; tindex < tcount; ++tindex) {
                 const cgltf_morph_target& target = prim.targets[tindex];
                 bool hasNormals = false;
@@ -719,13 +725,13 @@ void ResourceLoader::Impl::computeTangents(FFilamentAsset* asset) {
                     }
                     hasNormals = true;
                     jobParams.emplace_back(Params { { &prim, (int) tindex },
-                                                    { nullptr, tb, (uint8_t) pindex } });
+                                                    { nullptr, tb, morphTargetOffset, (uint8_t) pindex } });
                     break;
                 }
                 // Generate flat normals if necessary.
                 if (!hasNormals && prim.material && !prim.material->unlit) {
                     jobParams.emplace_back(Params { { &prim, (int) tindex },
-                                                    { nullptr, tb, (uint8_t) pindex } });
+                                                    { nullptr, tb, morphTargetOffset, (uint8_t) pindex } });
                 }
             }
         }
@@ -752,7 +758,7 @@ void ResourceLoader::Impl::computeTangents(FFilamentAsset* asset) {
         } else {
             assert_invariant(params.context.tb);
             params.context.tb->setTangentsAt(*mEngine, params.in.morphTargetIndex,
-                    params.out.results, params.out.vertexCount);
+                    params.out.results, params.out.vertexCount, params.context.offset);
             free(params.out.results);
         }
     }

libs/gltfio/src/TangentsJob.h

@@ -47,6 +47,7 @@ struct TangentsJob {
     struct Context {
         VertexBuffer* const vb;
         MorphTargetBuffer* const tb;
+        uint32_t const offset;
         const uint8_t slot;
     };
 

libs/gltfio/src/UbershaderProvider.cpp

@@ -63,6 +63,42 @@ static void prepareConfig(MaterialKey* config, const char* label) {
         config->hasSheen = false;
         config->hasIOR = false;
     }
+
+    if (config->useSpecularGlossiness && config->hasSpecular) {
+        slog.w << "SpecularGlossiness and specular are not supported together in ubershader mode,"
+                  " removing specularGlossiness (" << label << ")." << io::endl;
+
+        config->useSpecularGlossiness = false;
+    }
+
+    if (config->unlit && config->hasSpecular) {
+        slog.w << "Unlit and specular are not supported together in ubershader mode,"
+                  " removing unlit (" << label << ")." << io::endl;
+
+        config->unlit = false;
+    }
+
+    // Also due to sampler overload, clearcoat with specular, we can only support with specular map.
+    if ((config->hasClearCoatNormalTexture || config->hasClearCoatRoughnessTexture) && config->hasSpecular) {
+        slog.w << "Specular can only work with clearcoat that does not use clear coat normal or clear coat roughness map,"
+                  " removing clear coat normal and roughness (" << label << ")." << io::endl;
+        config->hasClearCoatNormalTexture = false;
+        config->hasClearCoatRoughnessTexture = false;
+    }
+
+    // Also due to sampler overload, sheen with specular, we can only support without specular color texture.
+    if (config->hasSpecularColorTexture && config->hasSheen) {
+        slog.w << "Sheen can only work with specular that does not use specular color map,"
+                  " removing specular color (" << label << ")." << io::endl;
+        config->hasSpecularColorTexture = false;
+    }
+
+    // Also due to sampler overload, volume with specular, we can only support without specular color texture.
+    if (config->hasSpecularColorTexture && config->hasVolume) {
+        slog.w << "Volume can only work with specular that does not use specular color map,"
+                  "removing specular color (" << label << ")." << io::endl;
+        config->hasSpecularColorTexture = false;
+    }
 }
 
 class UbershaderProvider : public MaterialProvider {
@@ -155,6 +191,9 @@ Material* UbershaderProvider::getMaterial(const MaterialKey& config) const {
     requirements.features["SheenColorTexture"] = config.hasSheenColorTexture;
     requirements.features["SheenRoughnessTexture"] = config.hasSheenRoughnessTexture;
     requirements.features["VolumeThicknessTexture"] = config.hasVolumeThicknessTexture;
+    requirements.features["Specular"] = config.hasSpecular;
+    requirements.features["SpecularTexture"] = config.hasSpecularTexture;
+    requirements.features["SpecularColorTexture"] = config.hasSpecularColorTexture;
 
     if (Material* mat = mMaterials.getMaterial(requirements); mat != nullptr) {
         return mat;
@@ -250,6 +289,14 @@ MaterialInstance* UbershaderProvider::createMaterialInstance(MaterialKey* config
             mi->setParameter("transmissionIndex",
                     getUvIndex(config->transmissionUV, config->hasTransmissionTexture));
         }
+        if (config->hasSpecular) {
+            mi->setParameter("specularUvMatrix", identity);
+            mi->setParameter("specularIndex",
+                    getUvIndex(config->specularTextureUV, config->hasSpecularTexture));
+            mi->setParameter("specularColorUvMatrix", identity);
+            mi->setParameter("specularColorIndex",
+                    getUvIndex(config->specularColorTextureUV, config->hasSpecularColorTexture));
+        }
     }
 
     TextureSampler sampler;
@@ -300,6 +347,14 @@ MaterialInstance* UbershaderProvider::createMaterialInstance(MaterialKey* config
         mi->setParameter("reflectance", 0.5f);
     }
 
+    if (needsTexture("SpecularTexture")) {
+        mi->setParameter("specularMap", mDummyTexture, sampler);
+    }
+
+    if (needsTexture("SpecularColorTexture")) {
+        mi->setParameter("specularColorMap", mDummyTexture, sampler);
+    }
+
     return mi;
 }