Quick change to hello triangle to comply with WebGPU requirements on alignment. Long term it would check for which backend is in use

This reverts commit b94c802076.

README.md

@@ -31,7 +31,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.android.filament:filament-android:1.60.1'
+    implementation 'com.google.android.filament:filament-android:1.60.0'
 }
 ```
 
@@ -51,7 +51,7 @@ Here are all the libraries available in the group `com.google.android.filament`:
 iOS projects can use CocoaPods to install the latest release:
 
 ```shell
-pod 'Filament', '~> 1.60.1'
+pod 'Filament', '~> 1.60.0'
 ```
 
 ## Documentation

RELEASE_NOTES.md

@@ -7,12 +7,6 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).
 
-## v1.61.0
-
-- materials: sampler now export their type in the material binary [⚠️ **New Material Version**]
-- samples/texturedquad.cpp now has CLI to select backend api
-- samples/hellopbr.cpp CLI now allows for selecting webgpu
-
 ## v1.60.1
 
 

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

@@ -1801,22 +1801,6 @@ public class View {
      * @see setAmbientOcclusionOptions()
      */
     public static class AmbientOcclusionOptions {
-        public enum AmbientOcclusionType {
-            /**
-             * use Scalable Ambient Occlusion
-             */
-            SAO,
-            /**
-             * use Ground Truth-Based Ambient Occlusion
-             */
-            GTAO,
-        }
-
-        /**
-         * Type of ambient occlusion algorithm.
-         */
-        @NonNull
-        public AmbientOcclusionOptions.AmbientOcclusionType aoType = AmbientOcclusionOptions.AmbientOcclusionType.SAO;
         /**
          * Ambient Occlusion radius in meters, between 0 and ~10.
          */
@@ -1826,8 +1810,7 @@ public class View {
          */
         public float power = 1.0f;
         /**
-         * Self-occlusion bias in meters. Use to avoid self-occlusion.
-         * Between 0 and a few mm. No effect when aoType set to GTAO
+         * Self-occlusion bias in meters. Use to avoid self-occlusion. Between 0 and a few mm.
          */
         public float bias = 0.0005f;
         /**
@@ -1843,12 +1826,12 @@ public class View {
          */
         public float bilateralThreshold = 0.05f;
         /**
-         * affects # of samples used for AO and params for filtering
+         * affects # of samples used for AO.
          */
         @NonNull
         public QualityLevel quality = QualityLevel.LOW;
         /**
-         * affects AO smoothness. Recommend setting to HIGH when aoType set to GTAO.
+         * affects AO smoothness
          */
         @NonNull
         public QualityLevel lowPassFilter = QualityLevel.MEDIUM;
@@ -1866,7 +1849,7 @@ public class View {
          */
         public boolean bentNormals = false;
         /**
-         * min angle in radian to consider. No effect when aoType set to GTAO.
+         * min angle in radian to consider
          */
         public float minHorizonAngleRad = 0.0f;
         /**
@@ -1921,19 +1904,6 @@ public class View {
          */
         public boolean ssctEnabled = false;
 
-        /**
-         * Ground Truth-base Ambient Occlusion (GTAO) options
-         */
-        public int gtaoSampleSliceCount = 4;
-        /**
-         * Ground Truth-base Ambient Occlusion (GTAO) options
-         */
-        public int gtaoSampleStepsPerSlice = 3;
-        /**
-         * Ground Truth-base Ambient Occlusion (GTAO) options
-         */
-        public float gtaoThicknessHeuristic = 0.004f;
-
     }
 
     /**

android/gradle.properties

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

filament/CMakeLists.txt

@@ -262,8 +262,6 @@ set(MATERIAL_SRCS
         src/materials/ssao/mipmapDepth.mat
         src/materials/ssao/sao.mat
         src/materials/ssao/saoBentNormals.mat
-        src/materials/ssao/gtao.mat
-        src/materials/ssao/gtaoBentNormals.mat
         src/materials/vsmMipmap.mat
 )
 
@@ -320,6 +318,8 @@ endif()
 # Definitions
 # ==================================================================================================
 
+# "2" corresponds to SYSTRACE_TAG_FILEMENT (See: utils/Systrace.h)
+add_definitions(-DSYSTRACE_TAG=2)
 add_definitions(-DFILAMENT_DFG_LUT_SIZE=${DFG_LUT_SIZE})
 add_definitions(
     -DFILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB=${FILAMENT_PER_RENDER_PASS_ARENA_SIZE_IN_MB}
@@ -463,28 +463,6 @@ add_custom_command(
         APPEND
 )
 
-add_custom_command(
-        OUTPUT "${MATERIAL_DIR}/gtao.filamat"
-        DEPENDS src/materials/ssao/ssaoUtils.fs
-        DEPENDS src/materials/ssao/ssct.fs
-        DEPENDS src/materials/utils/depthUtils.fs
-        DEPENDS src/materials/utils/geometry.fs
-        DEPENDS src/materials/ssao/gtaoImpl.fs
-        DEPENDS src/materials/ssao/ssctImpl.fs
-        APPEND
-)
-
-add_custom_command(
-        OUTPUT "${MATERIAL_DIR}/gtaoBentNormals.filamat"
-        DEPENDS src/materials/ssao/ssaoUtils.fs
-        DEPENDS src/materials/ssao/ssct.fs
-        DEPENDS src/materials/utils/depthUtils.fs
-        DEPENDS src/materials/utils/geometry.fs
-        DEPENDS src/materials/ssao/gtaoImpl.fs
-        DEPENDS src/materials/ssao/ssctImpl.fs
-        APPEND
-)
-
 add_custom_command(
         OUTPUT "${MATERIAL_DIR}/bilateralBlur.filamat"
         DEPENDS src/materials/ssao/ssaoUtils.fs

filament/backend/CMakeLists.txt

@@ -290,6 +290,12 @@ if (ANDROID)
     list(APPEND SRCS src/BackendUtilsAndroid.cpp)
 endif()
 
+# ==================================================================================================
+# Definitions
+# ==================================================================================================
+# "2" corresponds to SYSTRACE_TAG_FILEMENT (See: utils/Systrace.h)
+add_definitions(-DSYSTRACE_TAG=2 )
+
 # ==================================================================================================
 # Includes & target definition
 # ==================================================================================================

filament/backend/include/backend/DriverEnums.h

@@ -36,7 +36,6 @@
 #include <array>
 #include <type_traits>
 #include <variant>
-#include <string_view>
 
 #include <stddef.h>
 #include <stdint.h>
@@ -163,7 +162,7 @@ enum class TimerQueryResult : int8_t {
     AVAILABLE = 1,  // result is available
 };
 
-constexpr std::string_view to_string(Backend const backend) noexcept {
+static constexpr const char* backendToString(Backend backend) {
     switch (backend) {
         case Backend::NOOP:
             return "Noop";
@@ -175,10 +174,9 @@ constexpr std::string_view to_string(Backend const backend) noexcept {
             return "Metal";
         case Backend::WEBGPU:
             return "WebGPU";
-        case Backend::DEFAULT:
-            return "Default";
+        default:
+            return "Unknown";
     }
-    return "Unknown";
 }
 
 /**
@@ -195,7 +193,7 @@ enum class ShaderLanguage {
     WGSL = 5,
 };
 
-constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) noexcept {
+static constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) {
     switch (shaderLanguage) {
         case ShaderLanguage::ESSL1:
             return "ESSL 1.0";
@@ -210,7 +208,6 @@ constexpr const char* shaderLanguageToString(ShaderLanguage shaderLanguage) noex
         case ShaderLanguage::WGSL:
             return "WGSL";
     }
-    return "UNKNOWN";
 }
 
 enum class ShaderStage : uint8_t {
@@ -228,7 +225,7 @@ enum class ShaderStageFlags : uint8_t {
     ALL_SHADER_STAGE_FLAGS = VERTEX | FRAGMENT | COMPUTE
 };
 
-constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept {
+static inline constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept {
     switch (type) {
         case ShaderStage::VERTEX:
             return bool(uint8_t(flags) & uint8_t(ShaderStageFlags::VERTEX));
@@ -239,239 +236,14 @@ constexpr bool hasShaderType(ShaderStageFlags flags, ShaderStage type) noexcept
     }
 }
 
-enum class TextureType : uint8_t {
-    FLOAT,
-    INT,
-    UINT,
-    DEPTH,
-    STENCIL,
-    DEPTH_STENCIL
+enum class DescriptorType : uint8_t {
+    UNIFORM_BUFFER,
+    SHADER_STORAGE_BUFFER,
+    SAMPLER,
+    INPUT_ATTACHMENT,
+    SAMPLER_EXTERNAL
 };
 
-constexpr std::string_view to_string(TextureType type) noexcept {
-    switch (type) {
-        case TextureType::FLOAT:            return "FLOAT";
-        case TextureType::INT:              return "INT";
-        case TextureType::UINT:             return "UINT";
-        case TextureType::DEPTH:            return "DEPTH";
-        case TextureType::STENCIL:          return "STENCIL";
-        case TextureType::DEPTH_STENCIL:    return "DEPTH_STENCIL";
-    }
-    return "UNKNOWN";
-}
-
- enum class DescriptorType : uint8_t {
-     SAMPLER_2D_FLOAT,
-     SAMPLER_2D_INT,
-     SAMPLER_2D_UINT,
-     SAMPLER_2D_DEPTH,
-
-     SAMPLER_2D_ARRAY_FLOAT,
-     SAMPLER_2D_ARRAY_INT,
-     SAMPLER_2D_ARRAY_UINT,
-     SAMPLER_2D_ARRAY_DEPTH,
-
-     SAMPLER_CUBE_FLOAT,
-     SAMPLER_CUBE_INT,
-     SAMPLER_CUBE_UINT,
-     SAMPLER_CUBE_DEPTH,
-
-     SAMPLER_CUBE_ARRAY_FLOAT,
-     SAMPLER_CUBE_ARRAY_INT,
-     SAMPLER_CUBE_ARRAY_UINT,
-     SAMPLER_CUBE_ARRAY_DEPTH,
-
-     SAMPLER_3D_FLOAT,
-     SAMPLER_3D_INT,
-     SAMPLER_3D_UINT,
-
-     SAMPLER_2D_MS_FLOAT,
-     SAMPLER_2D_MS_INT,
-     SAMPLER_2D_MS_UINT,
-
-     SAMPLER_2D_MS_ARRAY_FLOAT,
-     SAMPLER_2D_MS_ARRAY_INT,
-     SAMPLER_2D_MS_ARRAY_UINT,
-
-     SAMPLER_EXTERNAL,
-     UNIFORM_BUFFER,
-     SHADER_STORAGE_BUFFER,
-     INPUT_ATTACHMENT,
- };
-
-constexpr bool isDepthDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_DEPTH:
-        case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-        case DescriptorType::SAMPLER_CUBE_DEPTH:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isFloatDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_FLOAT:
-        case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_CUBE_FLOAT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_3D_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isIntDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_INT:
-        case DescriptorType::SAMPLER_2D_ARRAY_INT:
-        case DescriptorType::SAMPLER_CUBE_INT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-        case DescriptorType::SAMPLER_3D_INT:
-        case DescriptorType::SAMPLER_2D_MS_INT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isUnsignedIntDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_UINT:
-        case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-        case DescriptorType::SAMPLER_CUBE_UINT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-        case DescriptorType::SAMPLER_3D_UINT:
-        case DescriptorType::SAMPLER_2D_MS_UINT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool is3dTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_3D_FLOAT:
-        case DescriptorType::SAMPLER_3D_INT:
-        case DescriptorType::SAMPLER_3D_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool is2dTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_FLOAT:
-        case DescriptorType::SAMPLER_2D_INT:
-        case DescriptorType::SAMPLER_2D_UINT:
-        case DescriptorType::SAMPLER_2D_DEPTH:
-        case DescriptorType::SAMPLER_2D_MS_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_INT:
-        case DescriptorType::SAMPLER_2D_MS_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool is2dArrayTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_2D_ARRAY_INT:
-        case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-        case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isCubeTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_CUBE_FLOAT:
-        case DescriptorType::SAMPLER_CUBE_INT:
-        case DescriptorType::SAMPLER_CUBE_UINT:
-        case DescriptorType::SAMPLER_CUBE_DEPTH:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isCubeArrayTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-        case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr bool isMultiSampledTypeDescriptor(DescriptorType const type) noexcept {
-    switch (type) {
-        case DescriptorType::SAMPLER_2D_MS_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_INT:
-        case DescriptorType::SAMPLER_2D_MS_UINT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-        case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
-            return true;
-        default: ;
-    }
-    return false;
-}
-
-constexpr std::string_view to_string(DescriptorType type) noexcept {
-    #define DESCRIPTOR_TYPE_CASE(TYPE)  case DescriptorType::TYPE: return #TYPE;
-    switch (type) {
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_DEPTH)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_ARRAY_DEPTH)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_DEPTH)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_CUBE_ARRAY_DEPTH)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_3D_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_3D_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_3D_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_ARRAY_FLOAT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_ARRAY_INT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_2D_MS_ARRAY_UINT)
-        DESCRIPTOR_TYPE_CASE(SAMPLER_EXTERNAL)
-        DESCRIPTOR_TYPE_CASE(UNIFORM_BUFFER)
-        DESCRIPTOR_TYPE_CASE(SHADER_STORAGE_BUFFER)
-        DESCRIPTOR_TYPE_CASE(INPUT_ATTACHMENT)
-    }
-    return "UNKNOWN";
-    #undef DESCRIPTOR_TYPE_CASE
-}
-
 enum class DescriptorFlags : uint8_t {
     NONE = 0x00,
     DYNAMIC_OFFSET = 0x01
@@ -482,13 +254,6 @@ using descriptor_set_t = uint8_t;
 using descriptor_binding_t = uint8_t;
 
 struct DescriptorSetLayoutBinding {
-    static bool isSampler(DescriptorType type) noexcept {
-        return int(type) <= int(DescriptorType::SAMPLER_EXTERNAL);
-    }
-    static bool isBuffer(DescriptorType type) noexcept {
-        return type == DescriptorType::UNIFORM_BUFFER ||
-               type == DescriptorType::SHADER_STORAGE_BUFFER;
-    }
     DescriptorType type;
     ShaderStageFlags stageFlags;
     descriptor_binding_t binding;
@@ -499,7 +264,7 @@ struct DescriptorSetLayoutBinding {
     //  no uninitialized padding bytes.
     //    uint8_t externalSamplerDataIndex = EXTERNAL_SAMPLER_DATA_INDEX_UNUSED;
 
-    friend bool operator==(DescriptorSetLayoutBinding const& lhs,
+    friend inline bool operator==(DescriptorSetLayoutBinding const& lhs,
             DescriptorSetLayoutBinding const& rhs) noexcept {
         return lhs.type == rhs.type &&
                lhs.flags == rhs.flags &&
@@ -532,7 +297,7 @@ enum class TargetBufferFlags : uint32_t {
     ALL = COLOR_ALL | DEPTH | STENCIL       //!< Color, depth and stencil buffer selected.
 };
 
-constexpr TargetBufferFlags getTargetBufferFlagsAt(size_t index) noexcept {
+inline constexpr TargetBufferFlags getTargetBufferFlagsAt(size_t index) noexcept {
     if (index == 0u) return TargetBufferFlags::COLOR0;
     if (index == 1u) return TargetBufferFlags::COLOR1;
     if (index == 2u) return TargetBufferFlags::COLOR2;
@@ -689,24 +454,6 @@ enum class SamplerType : uint8_t {
     SAMPLER_CUBEMAP_ARRAY,  //!< Cube map array texture (feature level 2)
 };
 
-constexpr std::string_view to_string(SamplerType const type) noexcept {
-    switch (type) {
-        case SamplerType::SAMPLER_2D:
-            return "SAMPLER_2D";
-        case SamplerType::SAMPLER_2D_ARRAY:
-            return "SAMPLER_2D_ARRAY";
-        case SamplerType::SAMPLER_CUBEMAP:
-            return "SAMPLER_CUBEMAP";
-        case SamplerType::SAMPLER_EXTERNAL:
-            return "SAMPLER_EXTERNAL";
-        case SamplerType::SAMPLER_3D:
-            return "SAMPLER_3D";
-        case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            return "SAMPLER_CUBEMAP_ARRAY";
-    }
-    return "Unknown";
-}
-
 //! Subpass type
 enum class SubpassType : uint8_t {
     SUBPASS_INPUT
@@ -720,20 +467,6 @@ enum class SamplerFormat : uint8_t {
     SHADOW = 3      //!< shadow sampler (PCF)
 };
 
-constexpr std::string_view to_string(SamplerFormat const format) noexcept {
-    switch (format) {
-        case SamplerFormat::INT:
-            return "INT";
-        case SamplerFormat::UINT:
-            return "UINT";
-        case SamplerFormat::FLOAT:
-            return "FLOAT";
-        case SamplerFormat::SHADOW:
-            return "SHADOW";
-    }
-    return "Unknown";
-}
-
 /**
  * Supported element types
  */
@@ -773,15 +506,6 @@ enum class BufferObjectBinding : uint8_t {
     SHADER_STORAGE
 };
 
-constexpr std::string_view to_string(BufferObjectBinding type) noexcept {
-    switch (type) {
-        case BufferObjectBinding::VERTEX:           return "VERTEX";
-        case BufferObjectBinding::UNIFORM:          return "UNIFORM";
-        case BufferObjectBinding::SHADER_STORAGE:   return "SHADER_STORAGE";
-    }
-    return "UNKNOWN";
-}
-
 //! Face culling Mode
 enum class CullingMode : uint8_t {
     NONE,               //!< No culling, front and back faces are visible
@@ -1043,8 +767,6 @@ enum class TextureFormat : uint16_t {
     SRGB_ALPHA_BPTC_UNORM,  // BC7 sRGB
 };
 
-TextureType getTextureType(TextureFormat format) noexcept;
-
 //! Bitmask describing the intended Texture Usage
 enum class TextureUsage : uint16_t {
     NONE                = 0x0000,
@@ -1072,7 +794,7 @@ enum class TextureSwizzle : uint8_t {
 };
 
 //! returns whether this format a depth format
-constexpr bool isDepthFormat(TextureFormat format) noexcept {
+static constexpr bool isDepthFormat(TextureFormat format) noexcept {
     switch (format) {
         case TextureFormat::DEPTH32F:
         case TextureFormat::DEPTH24:
@@ -1085,7 +807,7 @@ constexpr bool isDepthFormat(TextureFormat format) noexcept {
     }
 }
 
-constexpr bool isStencilFormat(TextureFormat format) noexcept {
+static constexpr bool isStencilFormat(TextureFormat format) noexcept {
     switch (format) {
         case TextureFormat::STENCIL8:
         case TextureFormat::DEPTH24_STENCIL8:
@@ -1096,7 +818,7 @@ constexpr bool isStencilFormat(TextureFormat format) noexcept {
     }
 }
 
-constexpr bool isColorFormat(TextureFormat format) noexcept {
+inline constexpr bool isColorFormat(TextureFormat format) noexcept {
     switch (format) {
         // Standard color formats
         case TextureFormat::R8:
@@ -1123,7 +845,7 @@ constexpr bool isColorFormat(TextureFormat format) noexcept {
     return false;
 }
 
-constexpr bool isUnsignedIntFormat(TextureFormat format) {
+static constexpr bool isUnsignedIntFormat(TextureFormat format) {
     switch (format) {
         case TextureFormat::R8UI:
         case TextureFormat::R16UI:
@@ -1144,7 +866,7 @@ constexpr bool isUnsignedIntFormat(TextureFormat format) {
     }
 }
 
-constexpr bool isSignedIntFormat(TextureFormat format) {
+static constexpr bool isSignedIntFormat(TextureFormat format) {
     switch (format) {
         case TextureFormat::R8I:
         case TextureFormat::R16I:
@@ -1166,35 +888,35 @@ constexpr bool isSignedIntFormat(TextureFormat format) {
 }
 
 //! returns whether this format is a compressed format
-constexpr bool isCompressedFormat(TextureFormat format) noexcept {
+static constexpr bool isCompressedFormat(TextureFormat format) noexcept {
     return format >= TextureFormat::EAC_R11;
 }
 
 //! returns whether this format is an ETC2 compressed format
-constexpr bool isETC2Compression(TextureFormat format) noexcept {
+static constexpr bool isETC2Compression(TextureFormat format) noexcept {
     return format >= TextureFormat::EAC_R11 && format <= TextureFormat::ETC2_EAC_SRGBA8;
 }
 
 //! returns whether this format is an S3TC compressed format
-constexpr bool isS3TCCompression(TextureFormat format) noexcept {
+static constexpr bool isS3TCCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::DXT1_RGB && format <= TextureFormat::DXT5_SRGBA;
 }
 
-constexpr bool isS3TCSRGBCompression(TextureFormat format) noexcept {
+static constexpr bool isS3TCSRGBCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::DXT1_SRGB && format <= TextureFormat::DXT5_SRGBA;
 }
 
 //! returns whether this format is an RGTC compressed format
-constexpr bool isRGTCCompression(TextureFormat format) noexcept {
+static constexpr bool isRGTCCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::RED_RGTC1 && format <= TextureFormat::SIGNED_RED_GREEN_RGTC2;
 }
 
 //! returns whether this format is an BPTC compressed format
-constexpr bool isBPTCCompression(TextureFormat format) noexcept {
+static constexpr bool isBPTCCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::RGB_BPTC_SIGNED_FLOAT && format <= TextureFormat::SRGB_ALPHA_BPTC_UNORM;
 }
 
-constexpr bool isASTCCompression(TextureFormat format) noexcept {
+static constexpr bool isASTCCompression(TextureFormat format) noexcept {
     return format >= TextureFormat::RGBA_ASTC_4x4 && format <= TextureFormat::SRGB8_ALPHA8_ASTC_12x12;
 }
 
@@ -1315,23 +1037,19 @@ struct SamplerParams {             // NOLINT
             assert_invariant(lhs.padding2 == 0);
             auto* pLhs = reinterpret_cast<uint32_t const*>(reinterpret_cast<char const*>(&lhs));
             auto* pRhs = reinterpret_cast<uint32_t const*>(reinterpret_cast<char const*>(&rhs));
-            return *pLhs < *pRhs;
+            return *pLhs == *pRhs;
         }
     };
 
-    bool isFiltered() const noexcept {
-        return filterMag != SamplerMagFilter::NEAREST || filterMin != SamplerMinFilter::NEAREST;
-    }
-
 private:
-    friend bool operator == (SamplerParams lhs, SamplerParams rhs) noexcept {
-        return EqualTo{}(lhs, rhs);
+    friend inline bool operator == (SamplerParams lhs, SamplerParams rhs) noexcept {
+        return SamplerParams::EqualTo{}(lhs, rhs);
     }
-    friend bool operator != (SamplerParams lhs, SamplerParams rhs) noexcept {
-        return  !EqualTo{}(lhs, rhs);
+    friend inline bool operator != (SamplerParams lhs, SamplerParams rhs) noexcept {
+        return  !SamplerParams::EqualTo{}(lhs, rhs);
     }
-    friend bool operator < (SamplerParams lhs, SamplerParams rhs) noexcept {
-        return LessThan{}(lhs, rhs);
+    friend inline bool operator < (SamplerParams lhs, SamplerParams rhs) noexcept {
+        return SamplerParams::LessThan{}(lhs, rhs);
     }
 };
 
@@ -1381,15 +1099,15 @@ struct SamplerYcbcrConversion {// NOLINT
     };
 
 private:
-    friend bool operator == (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+    friend inline bool operator == (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
             noexcept {
         return SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
     }
-    friend bool operator != (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+    friend inline bool operator != (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
             noexcept {
         return  !SamplerYcbcrConversion::EqualTo{}(lhs, rhs);
     }
-    friend bool operator < (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
+    friend inline bool operator < (SamplerYcbcrConversion lhs, SamplerYcbcrConversion rhs)
             noexcept {
         return SamplerYcbcrConversion::LessThan{}(lhs, rhs);
     }

filament/backend/include/backend/PixelBufferDescriptor.h

@@ -204,15 +204,23 @@ public:
                 }, new T(std::forward<T>(functor))
         };
     }
+
+    // --------------------------------------------------------------------------------------------
+
     /**
-     * Computes the size in bytes for a pixel of given dimensions and format
+     * Computes the size in bytes needed to fit an image of given dimensions and format
      *
      * @param format    Format of the image pixels
      * @param type      Type of the image pixels
-     * @return The size of the specified pixel in bytes
+     * @param stride    Stride of a row in pixels
+     * @param height    Height of the image in rows
+     * @param alignment Alignment in bytes of pixel rows
+     * @return The buffer size needed to fit this image in bytes
      */
+    static constexpr size_t computeDataSize(PixelDataFormat format, PixelDataType type,
+            size_t stride, size_t height, size_t alignment) noexcept {
+        assert_invariant(alignment);
 
-    static constexpr size_t computePixelSize(PixelDataFormat format, PixelDataType type) noexcept {
         if (type == PixelDataType::COMPRESSED) {
             return 0;
         }
@@ -234,7 +242,7 @@ public:
             case PixelDataFormat::RGB_INTEGER:
                 n = 3;
                 break;
-            case PixelDataFormat::UNUSED:// shouldn't happen (used to be rgbm)
+            case PixelDataFormat::UNUSED: // shouldn't happen (used to be rgbm)
             case PixelDataFormat::RGBA:
             case PixelDataFormat::RGBA_INTEGER:
                 n = 4;
@@ -243,7 +251,7 @@ public:
 
         size_t bpp = n;
         switch (type) {
-            case PixelDataType::COMPRESSED:// Impossible -- to squash the IDE warnings
+            case PixelDataType::COMPRESSED: // Impossible -- to squash the IDE warnings
             case PixelDataType::UBYTE:
             case PixelDataType::BYTE:
                 // nothing to do
@@ -274,35 +282,16 @@ public:
                 bpp = 2;
                 break;
         }
-        return bpp;
-    }
 
-    // --------------------------------------------------------------------------------------------
-
-    /**
-     * Computes the size in bytes needed to fit an image of given dimensions and format
-     *
-     * @param format    Format of the image pixels
-     * @param type      Type of the image pixels
-     * @param stride    Stride of a row in pixels
-     * @param height    Height of the image in rows
-     * @param alignment Alignment in bytes of pixel rows
-     * @return The buffer size needed to fit this image in bytes
-     */
-    static constexpr size_t computeDataSize(PixelDataFormat format, PixelDataType type,
-            size_t stride, size_t height, size_t alignment) noexcept {
-        assert_invariant(alignment);
-
-        size_t bpp = computePixelSize(format, type);
         size_t const bpr = bpp * stride;
         size_t const bprAligned = (bpr + (alignment - 1)) & (~alignment + 1);
         return bprAligned * height;
     }
 
     //! left coordinate in pixels
-    uint32_t left = 0;
+    uint32_t left   = 0;
     //! top coordinate in pixels
-    uint32_t top = 0;
+    uint32_t top    = 0;
     union {
         struct {
             //! stride in pixels

filament/backend/src/BackendUtils.cpp

@@ -18,8 +18,6 @@
 
 #include "DataReshaper.h"
 
-#include <backend/DriverEnums.h>
-
 #include <utils/CString.h>
 
 #include <string_view>
@@ -225,143 +223,6 @@ size_t getFormatSize(TextureFormat format) noexcept {
     }
 }
 
-TextureType getTextureType(TextureFormat const format) noexcept {
-    switch (format) {
-        case TextureFormat::UNUSED:
-            // should not happen
-            return TextureType::FLOAT;
-
-        case TextureFormat::R8:
-        case TextureFormat::R16F:
-        case TextureFormat::RG8:
-        case TextureFormat::RGB565:
-        case TextureFormat::RGB5_A1:
-        case TextureFormat::RGBA4:
-        case TextureFormat::R32F:
-        case TextureFormat::RGB8:
-        case TextureFormat::SRGB8:
-        case TextureFormat::RG16F:
-        case TextureFormat::R11F_G11F_B10F:
-        case TextureFormat::RGB9_E5:
-        case TextureFormat::RGBA8:
-        case TextureFormat::SRGB8_A8:
-        case TextureFormat::RGB10_A2:
-        case TextureFormat::RGB16F:
-        case TextureFormat::RG32F:
-        case TextureFormat::RGBA16F:
-        case TextureFormat::RGB32F:
-        case TextureFormat::RGBA32F:
-            return TextureType::FLOAT;
-
-        case TextureFormat::R8_SNORM:
-        case TextureFormat::RG8_SNORM:
-        case TextureFormat::RGB8_SNORM:
-        case TextureFormat::RGBA8_SNORM:
-            // SNORM are treated as float
-            return TextureType::FLOAT;
-
-        case TextureFormat::R8UI:
-        case TextureFormat::R16UI:
-        case TextureFormat::RG8UI:
-        case TextureFormat::RGB8UI:
-        case TextureFormat::R32UI:
-        case TextureFormat::RG16UI:
-        case TextureFormat::RGBA8UI:
-        case TextureFormat::RGB16UI:
-        case TextureFormat::RG32UI:
-        case TextureFormat::RGBA16UI:
-        case TextureFormat::RGB32UI:
-        case TextureFormat::RGBA32UI:
-            return TextureType::UINT;
-
-        case TextureFormat::R8I:
-        case TextureFormat::R16I:
-        case TextureFormat::RG8I:
-        case TextureFormat::RGB8I:
-        case TextureFormat::R32I:
-        case TextureFormat::RG16I:
-        case TextureFormat::RGBA8I:
-        case TextureFormat::RGB16I:
-        case TextureFormat::RG32I:
-        case TextureFormat::RGBA16I:
-        case TextureFormat::RGB32I:
-        case TextureFormat::RGBA32I:
-            return TextureType::INT;
-
-        case TextureFormat::DEPTH16:
-        case TextureFormat::DEPTH24:
-        case TextureFormat::DEPTH32F:
-            return TextureType::DEPTH;
-
-        case TextureFormat::STENCIL8:
-            return TextureType::STENCIL;
-
-        case TextureFormat::DEPTH24_STENCIL8:
-        case TextureFormat::DEPTH32F_STENCIL8:
-            return TextureType::DEPTH_STENCIL;
-
-        // Compressed formats ---------------------------------------------------------------------
-
-        case TextureFormat::EAC_RG11:
-        case TextureFormat::EAC_RG11_SIGNED:
-        case TextureFormat::ETC2_EAC_RGBA8:
-        case TextureFormat::ETC2_EAC_SRGBA8:
-        case TextureFormat::EAC_R11:
-        case TextureFormat::EAC_R11_SIGNED:
-        case TextureFormat::ETC2_RGB8:
-        case TextureFormat::ETC2_SRGB8:
-        case TextureFormat::ETC2_RGB8_A1:
-        case TextureFormat::ETC2_SRGB8_A1:
-        case TextureFormat::DXT1_RGB:
-        case TextureFormat::DXT1_RGBA:
-        case TextureFormat::DXT1_SRGB:
-        case TextureFormat::DXT1_SRGBA:
-        case TextureFormat::DXT3_RGBA:
-        case TextureFormat::DXT3_SRGBA:
-        case TextureFormat::DXT5_RGBA:
-        case TextureFormat::DXT5_SRGBA:
-        case TextureFormat::RED_RGTC1:
-        case TextureFormat::SIGNED_RED_RGTC1:
-        case TextureFormat::RED_GREEN_RGTC2:
-        case TextureFormat::SIGNED_RED_GREEN_RGTC2:
-        case TextureFormat::RGB_BPTC_SIGNED_FLOAT:
-        case TextureFormat::RGB_BPTC_UNSIGNED_FLOAT:
-        case TextureFormat::RGBA_BPTC_UNORM:
-        case TextureFormat::SRGB_ALPHA_BPTC_UNORM:
-        case TextureFormat::RGBA_ASTC_4x4:
-        case TextureFormat::RGBA_ASTC_5x4:
-        case TextureFormat::RGBA_ASTC_5x5:
-        case TextureFormat::RGBA_ASTC_6x5:
-        case TextureFormat::RGBA_ASTC_6x6:
-        case TextureFormat::RGBA_ASTC_8x5:
-        case TextureFormat::RGBA_ASTC_8x6:
-        case TextureFormat::RGBA_ASTC_8x8:
-        case TextureFormat::RGBA_ASTC_10x5:
-        case TextureFormat::RGBA_ASTC_10x6:
-        case TextureFormat::RGBA_ASTC_10x8:
-        case TextureFormat::RGBA_ASTC_10x10:
-        case TextureFormat::RGBA_ASTC_12x10:
-        case TextureFormat::RGBA_ASTC_12x12:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_4x4:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_5x4:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_5x5:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_6x5:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_6x6:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_8x5:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_8x6:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_8x8:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_10x5:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_10x6:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_10x8:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_10x10:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_12x10:
-        case TextureFormat::SRGB8_ALPHA8_ASTC_12x12:
-            return TextureType::FLOAT;
-    }
-
-    return TextureType::FLOAT;
-}
-
 size_t getFormatComponentCount(TextureFormat format) noexcept {
     switch (format) {
         case TextureFormat::R8:

filament/backend/src/CommandBufferQueue.cpp

@@ -18,13 +18,12 @@
 #include "private/backend/CircularBuffer.h"
 #include "private/backend/CommandStream.h"
 
-#include <private/utils/Tracing.h>
-
 #include <utils/compiler.h>
 #include <utils/Log.h>
 #include <utils/Mutex.h>
 #include <utils/ostream.h>
 #include <utils/Panic.h>
+#include <utils/Systrace.h>
 #include <utils/debug.h>
 
 #include <algorithm>
@@ -80,7 +79,7 @@ bool CommandBufferQueue::isExitRequested() const {
 
 
 void CommandBufferQueue::flush() noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     CircularBuffer& circularBuffer = mCircularBuffer;
     if (circularBuffer.empty()) {
@@ -130,7 +129,7 @@ void CommandBufferQueue::flush() noexcept {
         mHighWatermark = std::max(mHighWatermark, totalUsed);
 #endif
 
-        FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "waiting: CircularBuffer::flush()");
+        SYSTRACE_NAME("waiting: CircularBuffer::flush()");
 
         FILAMENT_CHECK_POSTCONDITION(!mPaused) <<
                 "CommandStream is full, but since the rendering thread is paused, "

filament/backend/src/CommandStream.cpp

@@ -16,8 +16,6 @@
 
 #include "private/backend/CommandStream.h"
 
-#include <private/utils/Tracing.h>
-
 #if DEBUG_COMMAND_STREAM
 #include <utils/CallStack.h>
 #endif
@@ -26,6 +24,7 @@
 #include <utils/Log.h>
 #include <utils/ostream.h>
 #include <utils/Profiler.h>
+#include <utils/Systrace.h>
 
 #include <cstddef>
 #include <functional>
@@ -80,13 +79,12 @@ CommandStream::CommandStream(Driver& driver, CircularBuffer& buffer) noexcept
 }
 
 void CommandStream::execute(void* buffer) {
-    // NOTE: we can't use FILAMENT_TRACING_CALL() or similar here because, execute() below, also
+    // NOTE: we can't use SYSTRACE_CALL() or similar here because, execute() below, also
     // uses systrace BEGIN/END and the END is not guaranteed to be happening in this scope.
 
     Profiler profiler;
 
-
-    if constexpr (FILAMENT_TRACING_ENABLED) {
+    if (SYSTRACE_TAG) {
         if (UTILS_UNLIKELY(mUsePerformanceCounter)) {
             // we want to remove all this when tracing is completely disabled
             profiler.resetEvents(Profiler::EV_CPU_CYCLES  | Profiler::EV_BPU_MISSES);
@@ -102,17 +100,17 @@ void CommandStream::execute(void* buffer) {
         }
     });
 
-    if constexpr (FILAMENT_TRACING_ENABLED) {
+    if (SYSTRACE_TAG) {
         if (UTILS_UNLIKELY(mUsePerformanceCounter)) {
             // we want to remove all this when tracing is completely disabled
             profiler.stop();
             UTILS_UNUSED Profiler::Counters const counters = profiler.readCounters();
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (I)", counters.getInstructions());
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (C)", counters.getCpuCycles());
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (CPI x10)", counters.getCPI() * 10);
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (BPU miss)", counters.getBranchMisses());
-            FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "GLThread (I / BPU miss)",
+            SYSTRACE_CONTEXT();
+            SYSTRACE_VALUE32("GLThread (I)", counters.getInstructions());
+            SYSTRACE_VALUE32("GLThread (C)", counters.getCpuCycles());
+            SYSTRACE_VALUE32("GLThread (CPI x10)", counters.getCPI() * 10);
+            SYSTRACE_VALUE32("GLThread (BPU miss)", counters.getBranchMisses());
+            SYSTRACE_VALUE32("GLThread (I / BPU miss)",
                     counters.getInstructions() / counters.getBranchMisses());
         }
     }

filament/backend/src/CommandStreamDispatcher.h

@@ -20,9 +20,8 @@
 #include "private/backend/Driver.h"
 #include "private/backend/CommandStream.h"
 
-#include <private/utils/Tracing.h>
-
 #include <utils/compiler.h>
+#include <utils/Systrace.h>
 
 #include <utility>
 
@@ -39,7 +38,7 @@
 #if DEBUG_LEVEL == DEBUG_LEVEL_NONE
 #   define SYSTRACE()
 #elif DEBUG_LEVEL == DEBUG_LEVEL_SYSTRACE
-#   define SYSTRACE() FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+#   define SYSTRACE() SYSTRACE_CALL();
 #else
 #   error "invalid debug level"
 #endif

filament/backend/src/CompilerThreadPool.cpp

@@ -16,7 +16,7 @@
 
 #include "CompilerThreadPool.h"
 
-#include <private/utils/Tracing.h>
+#include <utils/Systrace.h>
 
 #include <memory>
 
@@ -41,7 +41,7 @@ void CompilerThreadPool::init(uint32_t threadCount,
 
     for (size_t i = 0; i < threadCount; i++) {
         mCompilerThreads.emplace_back([this, setup, cleanup]() {
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+            SYSTRACE_CONTEXT();
 
             (*setup)();
 
@@ -54,7 +54,7 @@ void CompilerThreadPool::init(uint32_t threadCount,
                                     [](auto&& q) { return q.empty(); }));
                 });
 
-                FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "CompilerThreadPool Jobs",
+                SYSTRACE_VALUE32("CompilerThreadPool Jobs",
                         mQueues[0].size() + mQueues[1].size());
 
                 if (UTILS_LIKELY(!mExitRequested)) {

filament/backend/src/Driver.cpp

@@ -23,12 +23,11 @@
 #include <backend/BufferDescriptor.h>
 #include <backend/DriverEnums.h>
 
-#include <private/utils/Tracing.h>
-
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/Log.h>
 #include <utils/ostream.h>
+#include <utils/Systrace.h>
 
 #include <math/half.h>
 #include <math/vec2.h>
@@ -152,31 +151,30 @@ void DriverBase::debugCommandBegin(CommandStream* cmds, bool synchronous, const
             utils::slog.d << methodName << utils::io::endl;
         }
         if constexpr (bool(FILAMENT_DEBUG_COMMANDS & FILAMENT_DEBUG_COMMANDS_SYSTRACE)) {
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, methodName);
+            SYSTRACE_CONTEXT();
+            SYSTRACE_NAME_BEGIN(methodName);
 
             if (!synchronous) {
                 cmds->queueCommand([=]() {
-                    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-                    FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, methodName);
+                    SYSTRACE_CONTEXT();
+                    SYSTRACE_NAME_BEGIN(methodName);
                 });
             }
         }
     }
 }
 
-void DriverBase::debugCommandEnd(CommandStream* cmds, bool synchronous,
-        const char* methodName) noexcept {
+void DriverBase::debugCommandEnd(CommandStream* cmds, bool synchronous, const char* methodName) noexcept {
     if constexpr (bool(FILAMENT_DEBUG_COMMANDS > FILAMENT_DEBUG_COMMANDS_NONE)) {
         if constexpr (bool(FILAMENT_DEBUG_COMMANDS & FILAMENT_DEBUG_COMMANDS_SYSTRACE)) {
             if (!synchronous) {
                 cmds->queueCommand([]() {
-                    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-                    FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
+                    SYSTRACE_CONTEXT();
+                    SYSTRACE_NAME_END();
                 });
             }
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
+            SYSTRACE_CONTEXT();
+            SYSTRACE_NAME_END();
         }
     }
 }

filament/backend/src/PlatformFactory.cpp

@@ -16,8 +16,7 @@
 
 #include <private/backend/PlatformFactory.h>
 
-#include <private/utils/Tracing.h>
-
+#include <utils/Systrace.h>
 #include <utils/debug.h>
 
 // We need to keep this up top for the linux (X11) name collisions.
@@ -86,7 +85,7 @@ namespace filament::backend {
 // responsible for destroying it. Initialization of the backend API is deferred until
 // createDriver(). The passed-in backend hint is replaced with the resolved backend.
 Platform* PlatformFactory::create(Backend* backend) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
     assert_invariant(backend);
 
 #if defined(__ANDROID__)

filament/backend/src/SystraceProfile.h

@@ -17,7 +17,7 @@
 #ifndef TNT_FILAMENT_BACKEND_SYSTRACEPROFILE_H
 #define TNT_FILAMENT_BACKEND_SYSTRACEPROFILE_H
 
-#include <private/utils/Tracing.h>
+#include <utils/Systrace.h>
 
 #define PROFILE_SCOPE(marker)       SYSTRACE_NAME(marker)
 

filament/backend/src/metal/MetalDriver.mm

@@ -672,8 +672,22 @@ void MetalDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {
     // nothing to do, timer query was constructed in createTimerQueryS
 }
 
-UTILS_UNUSED
-static const char* toString(ShaderStageFlags flags) {
+const char* toString(DescriptorType type) {
+    switch (type) {
+        case DescriptorType::UNIFORM_BUFFER:
+            return "UNIFORM_BUFFER";
+        case DescriptorType::SHADER_STORAGE_BUFFER:
+            return "SHADER_STORAGE_BUFFER";
+        case DescriptorType::SAMPLER:
+            return "SAMPLER";
+        case DescriptorType::INPUT_ATTACHMENT:
+            return "INPUT_ATTACHMENT";
+        case DescriptorType::SAMPLER_EXTERNAL:
+            return "SAMPLER_EXTERNAL";
+    }
+}
+
+const char* toString(ShaderStageFlags flags) {
     std::vector<const char*> stages;
     if (any(flags & ShaderStageFlags::VERTEX)) {
         stages.push_back("VERTEX");

filament/backend/src/metal/MetalHandles.mm

@@ -1356,31 +1356,7 @@ id<MTLArgumentEncoder> MetalDescriptorSetLayout::getArgumentEncoderSlow(id<MTLDe
                 [arguments addObject:bufferArgument];
                 break;
             }
-            case DescriptorType::SAMPLER_2D_FLOAT:
-            case DescriptorType::SAMPLER_2D_INT:
-            case DescriptorType::SAMPLER_2D_UINT:
-            case DescriptorType::SAMPLER_2D_DEPTH:
-            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_INT:
-            case DescriptorType::SAMPLER_CUBE_UINT:
-            case DescriptorType::SAMPLER_CUBE_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_3D_FLOAT:
-            case DescriptorType::SAMPLER_3D_INT:
-            case DescriptorType::SAMPLER_3D_UINT:
-            case DescriptorType::SAMPLER_2D_MS_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_INT:
-            case DescriptorType::SAMPLER_2D_MS_UINT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+            case DescriptorType::SAMPLER:
             case DescriptorType::SAMPLER_EXTERNAL: {
                 MTLArgumentDescriptor* textureArgument = [MTLArgumentDescriptor argumentDescriptor];
                 textureArgument.index = binding.binding * 2;
@@ -1502,31 +1478,7 @@ id<MTLBuffer> MetalDescriptorSet::finalizeAndGetBuffer(MetalDriver* driver, Shad
                            atIndex:binding.binding * 2];
                 break;
             }
-            case DescriptorType::SAMPLER_2D_FLOAT:
-            case DescriptorType::SAMPLER_2D_INT:
-            case DescriptorType::SAMPLER_2D_UINT:
-            case DescriptorType::SAMPLER_2D_DEPTH:
-            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_INT:
-            case DescriptorType::SAMPLER_CUBE_UINT:
-            case DescriptorType::SAMPLER_CUBE_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_3D_FLOAT:
-            case DescriptorType::SAMPLER_3D_INT:
-            case DescriptorType::SAMPLER_3D_UINT:
-            case DescriptorType::SAMPLER_2D_MS_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_INT:
-            case DescriptorType::SAMPLER_2D_MS_UINT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+            case DescriptorType::SAMPLER:
             case DescriptorType::SAMPLER_EXTERNAL: {
                 auto found = textures.find(binding.binding);
                 if (found == textures.end()) {

filament/backend/src/opengl/BindingMap.h

@@ -69,8 +69,9 @@ public:
         assert_invariant(set < MAX_DESCRIPTOR_SET_COUNT);
         assert_invariant(binding < MAX_DESCRIPTOR_COUNT);
         assert_invariant(entry.binding < 128); // we reserve 1 bit for the type right now
-        mStorage[set][binding] = { uint8_t(entry.binding),
-                                   DescriptorSetLayoutBinding::isSampler(entry.type) };
+        mStorage[set][binding] = { (uint8_t)entry.binding,
+                                   entry.type == DescriptorType::SAMPLER ||
+                                   entry.type == DescriptorType::SAMPLER_EXTERNAL };
         mActiveDescriptors[set].set(binding);
     }
 

filament/backend/src/opengl/GLDescriptorSet.cpp

@@ -95,32 +95,7 @@ GLDescriptorSet::GLDescriptorSet(OpenGLContext& gl, DescriptorSetLayoutHandle ds
                 }
                 break;
             }
-
-            case DescriptorType::SAMPLER_2D_FLOAT:
-            case DescriptorType::SAMPLER_2D_INT:
-            case DescriptorType::SAMPLER_2D_UINT:
-            case DescriptorType::SAMPLER_2D_DEPTH:
-            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_INT:
-            case DescriptorType::SAMPLER_CUBE_UINT:
-            case DescriptorType::SAMPLER_CUBE_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_3D_FLOAT:
-            case DescriptorType::SAMPLER_3D_INT:
-            case DescriptorType::SAMPLER_3D_UINT:
-            case DescriptorType::SAMPLER_2D_MS_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_INT:
-            case DescriptorType::SAMPLER_2D_MS_UINT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+            case DescriptorType::SAMPLER:
             case DescriptorType::SAMPLER_EXTERNAL:
                 if (UTILS_UNLIKELY(gl.isES2())) {
                     desc.emplace<SamplerGLES2>();

filament/backend/src/opengl/OpenGLBlobCache.cpp

@@ -21,7 +21,7 @@
 #include <backend/Platform.h>
 #include <backend/Program.h>
 
-#include <private/utils/Tracing.h>
+#include <utils/Systrace.h>
 
 namespace filament::backend {
 
@@ -36,7 +36,7 @@ OpenGLBlobCache::OpenGLBlobCache(OpenGLContext& gl) noexcept
 
 GLuint OpenGLBlobCache::retrieve(BlobCacheKey* outKey, Platform& platform,
         Program const& program) const noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
     if (!mCachingSupported || !platform.hasRetrieveBlobFunc()) {
         // the key is never updated in that case
         return 0;
@@ -68,7 +68,7 @@ GLuint OpenGLBlobCache::retrieve(BlobCacheKey* outKey, Platform& platform,
         programId = glCreateProgram();
 
         { // scope for systrace
-            FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glProgramBinary");
+            SYSTRACE_NAME("glProgramBinary");
             glProgramBinary(programId, blob->format, blob->data, programBinarySize);
         }
 
@@ -90,7 +90,7 @@ GLuint OpenGLBlobCache::retrieve(BlobCacheKey* outKey, Platform& platform,
 
 void OpenGLBlobCache::insert(Platform& platform,
         BlobCacheKey const& key, GLuint program) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
     if (!mCachingSupported || !platform.hasInsertBlobFunc()) {
         // the key is never updated in that case
         return;
@@ -100,7 +100,7 @@ void OpenGLBlobCache::insert(Platform& platform,
     GLenum format;
     GLint programBinarySize = 0;
     { // scope for systrace
-        FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glGetProgramiv");
+        SYSTRACE_NAME("glGetProgramiv");
         glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &programBinarySize);
     }
     if (programBinarySize) {
@@ -108,7 +108,7 @@ void OpenGLBlobCache::insert(Platform& platform,
         std::unique_ptr<Blob, decltype(&::free)> blob{ (Blob*)malloc(size), &::free };
         if (UTILS_LIKELY(blob)) {
             { // scope for systrace
-                FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glGetProgramBinary");
+                SYSTRACE_NAME("glGetProgramBinary");
                 glGetProgramBinary(program, programBinarySize,
                         &programBinarySize, &format, blob->data);
             }

filament/backend/src/opengl/OpenGLDriver.cpp

@@ -44,8 +44,6 @@
 #include "private/backend/Dispatcher.h"
 #include "private/backend/DriverApi.h"
 
-#include <private/utils/Tracing.h>
-
 #include <type_traits>
 #include <utils/BitmaskEnum.h>
 #include <utils/FixedCapacityVector.h>
@@ -53,6 +51,7 @@
 #include <utils/Invocable.h>
 #include <utils/Log.h>
 #include <utils/Panic.h>
+#include <utils/Systrace.h>
 #include <utils/Slice.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
@@ -99,13 +98,13 @@
 
 #define DEBUG_GROUP_MARKER_NONE       0x00    // no debug marker
 #define DEBUG_GROUP_MARKER_OPENGL     0x01    // markers in the gl command queue (req. driver support)
-#define DEBUG_GROUP_MARKER_BACKEND    0x02    // markers on the backend side (perfetto)
+#define DEBUG_GROUP_MARKER_BACKEND    0x02    // markers on the backend side (systrace)
 #define DEBUG_GROUP_MARKER_ALL        0xFF    // all markers
 
 #define DEBUG_MARKER_NONE             0x00    // no debug marker
 #define DEBUG_MARKER_OPENGL           0x01    // markers in the gl command queue (req. driver support)
-#define DEBUG_MARKER_BACKEND          0x02    // markers on the backend side (perfetto)
-#define DEBUG_MARKER_PROFILE          0x04    // profiling on the backend side (perfetto)
+#define DEBUG_MARKER_BACKEND          0x02    // markers on the backend side (systrace)
+#define DEBUG_MARKER_PROFILE          0x04    // profiling on the backend side (systrace)
 #define DEBUG_MARKER_ALL              (0xFF & ~DEBUG_MARKER_PROFILE) // all markers
 
 // set to the desired debug marker level (for user markers [default: All])
@@ -249,8 +248,8 @@ OpenGLDriver::DebugMarker::DebugMarker(OpenGLDriver& driver, const char* string)
 #endif
 
 #if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, string);
+    SYSTRACE_CONTEXT();
+    SYSTRACE_NAME_BEGIN(string);
 #endif
 #endif
 }
@@ -266,8 +265,8 @@ OpenGLDriver::DebugMarker::~DebugMarker() noexcept {
 #endif
 
 #if DEBUG_MARKER_LEVEL & DEBUG_MARKER_BACKEND
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CONTEXT();
+    SYSTRACE_NAME_END();
 #endif
 #endif
 }
@@ -3349,8 +3348,8 @@ void OpenGLDriver::pushGroupMarker(char const* string) {
 #endif
 
 #if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_BACKEND
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, string);
+    SYSTRACE_CONTEXT();
+    SYSTRACE_NAME_BEGIN(string);
 #endif
 #endif
 }
@@ -3366,8 +3365,8 @@ void OpenGLDriver::popGroupMarker(int) {
 #endif
 
 #if DEBUG_GROUP_MARKER_LEVEL & DEBUG_GROUP_MARKER_BACKEND
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CONTEXT();
+    SYSTRACE_NAME_END();
 #endif
 #endif
 }
@@ -3686,7 +3685,7 @@ void OpenGLDriver::endFrame(UTILS_UNUSED uint32_t frameId) {
     gl.depthFunc(GL_LESS);
     gl.disable(GL_SCISSOR_TEST);
 #endif
-    //FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "glFinish");
+    //SYSTRACE_NAME("glFinish");
     //glFinish();
     mPlatform.endFrame(frameId);
     insertEventMarker("endFrame");

filament/backend/src/opengl/OpenGLProgram.cpp

@@ -25,13 +25,12 @@
 #include <backend/Program.h>
 #include <backend/Handle.h>
 
-#include <private/utils/Tracing.h>
-
 #include <utils/BitmaskEnum.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>
@@ -97,7 +96,8 @@ OpenGLProgram::~OpenGLProgram() noexcept {
 }
 
 void OpenGLProgram::initialize(OpenGLDriver& gld) {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+
+    SYSTRACE_CALL();
 
     assert_invariant(gl.program == 0);
     assert_invariant(mToken);
@@ -122,7 +122,8 @@ void OpenGLProgram::initialize(OpenGLDriver& gld) {
  */
 void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint program,
         LazyInitializationData& lazyInitializationData) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+
+    SYSTRACE_CALL();
 
     // from the pipeline layout we compute a mapping from {set, binding} to {binding}
     // for both buffers and textures
@@ -174,31 +175,7 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
                     }
                     break;
                 }
-                case DescriptorType::SAMPLER_2D_FLOAT:
-                case DescriptorType::SAMPLER_2D_INT:
-                case DescriptorType::SAMPLER_2D_UINT:
-                case DescriptorType::SAMPLER_2D_DEPTH:
-                case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-                case DescriptorType::SAMPLER_2D_ARRAY_INT:
-                case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-                case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-                case DescriptorType::SAMPLER_CUBE_FLOAT:
-                case DescriptorType::SAMPLER_CUBE_INT:
-                case DescriptorType::SAMPLER_CUBE_UINT:
-                case DescriptorType::SAMPLER_CUBE_DEPTH:
-                case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-                case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-                case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-                case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-                case DescriptorType::SAMPLER_3D_FLOAT:
-                case DescriptorType::SAMPLER_3D_INT:
-                case DescriptorType::SAMPLER_3D_UINT:
-                case DescriptorType::SAMPLER_2D_MS_FLOAT:
-                case DescriptorType::SAMPLER_2D_MS_INT:
-                case DescriptorType::SAMPLER_2D_MS_UINT:
-                case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-                case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-                case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT:
+                case DescriptorType::SAMPLER:
                 case DescriptorType::SAMPLER_EXTERNAL: {
                     if (!entry.name.empty()) {
                         GLint const loc = glGetUniformLocation(program, entry.name.c_str());

filament/backend/src/opengl/OpenGLTimerQuery.cpp

@@ -23,13 +23,12 @@
 #include <backend/platforms/OpenGLPlatform.h>
 #include <backend/DriverEnums.h>
 
-#include <private/utils/Tracing.h>
-
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/JobSystem.h>
 #include <utils/Log.h>
 #include <utils/Mutex.h>
+#include <utils/Systrace.h>
 
 #include <atomic>
 #include <memory>
@@ -241,8 +240,8 @@ void TimerQueryFenceFactory::beginTimeElapsedQuery(GLTimerQuery* tq) {
         if (state) {
             platform.waitFence(fence, FENCE_WAIT_FOR_EVER);
             state->then = clock::now().time_since_epoch().count();
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_ASYNC_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, "OpenGLTimerQueryFence", intptr_t(state.get()));
+            SYSTRACE_CONTEXT();
+            SYSTRACE_ASYNC_BEGIN("OpenGLTimerQueryFence", intptr_t(state.get()));
         }
         platform.destroyFence(fence);
     });
@@ -258,8 +257,8 @@ void TimerQueryFenceFactory::endTimeElapsedQuery(OpenGLDriver&, GLTimerQuery* tq
             platform.waitFence(fence, FENCE_WAIT_FOR_EVER);
             int64_t const now = clock::now().time_since_epoch().count();
             state->elapsed.store(now - state->then, std::memory_order_relaxed);
-            FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-            FILAMENT_TRACING_ASYNC_END(FILAMENT_TRACING_CATEGORY_FILAMENT, "OpenGLTimerQueryFence", intptr_t(state.get()));
+            SYSTRACE_CONTEXT();
+            SYSTRACE_ASYNC_END("OpenGLTimerQueryFence", intptr_t(state.get()));
         }
         platform.destroyFence(fence);
     });

filament/backend/src/opengl/ShaderCompilerService.cpp

@@ -28,8 +28,6 @@
 #include <backend/DriverEnums.h>
 #include <backend/Program.h>
 
-#include <private/utils/Tracing.h>
-
 #include <utils/compiler.h>
 #include <utils/CString.h>
 #include <utils/debug.h>
@@ -38,6 +36,7 @@
 #include <utils/Log.h>
 #include <utils/ostream.h>
 #include <utils/Panic.h>
+#include <utils/Systrace.h>
 
 #include <algorithm>
 #include <array>
@@ -368,7 +367,7 @@ void ShaderCompilerService::notifyWhenAllProgramsAreReady(
 
 GLuint ShaderCompilerService::initialize(program_token_t& token) {
 
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     assert_invariant(token);// This function should be called when the token is still alive.
 
@@ -455,8 +454,8 @@ void ShaderCompilerService::runAtNextTick(CompilerPriorityQueue priority,
             });
     ops.emplace(pos, priority, token, std::move(job));
 
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "ShaderCompilerService Jobs", mRunAtNextTickOps.size());
+    SYSTRACE_CONTEXT();
+    SYSTRACE_VALUE32("ShaderCompilerService Jobs", mRunAtNextTickOps.size());
 }
 
 bool ShaderCompilerService::cancelTickOp(program_token_t const& token) noexcept {
@@ -469,8 +468,8 @@ bool ShaderCompilerService::cancelTickOp(program_token_t const& token) noexcept
         ops.erase(pos);
         return true;
     }
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "ShaderCompilerService Jobs", ops.size());
+    SYSTRACE_CONTEXT();
+    SYSTRACE_VALUE32("ShaderCompilerService Jobs", ops.size());
     return false;
 }
 
@@ -486,15 +485,15 @@ void ShaderCompilerService::executeTickOps() noexcept {
             ++it;
         }
     }
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "ShaderCompilerService Jobs", ops.size());
+    SYSTRACE_CONTEXT();
+    SYSTRACE_VALUE32("ShaderCompilerService Jobs", ops.size());
 }
 
 /* static */ void ShaderCompilerService::compileShaders(OpenGLContext& context,
         Program::ShaderSource shadersSource,
         FixedCapacityVector<Program::SpecializationConstant> const& specializationConstants,
         bool multiview, program_token_t const& token) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     auto const appendSpecConstantString = +[](std::string& s, Program::SpecializationConstant const& sc) {
         s += "#define SPIRV_CROSS_CONSTANT_ID_" + std::to_string(sc.id) + ' ';
@@ -617,7 +616,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 }
 
 /* static */ void ShaderCompilerService::checkCompileStatus(program_token_t const& token) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     UTILS_NOUNROLL
     for (size_t i = 0; i < Program::SHADER_TYPE_COUNT; i++) {
@@ -640,7 +639,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 
 /* static */ void ShaderCompilerService::linkProgram(OpenGLContext const& context,
         program_token_t const& token) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     // Shader compilation should be completed by now. Check the status and log errors on failure.
     checkCompileStatus(token);
@@ -676,7 +675,7 @@ void ShaderCompilerService::executeTickOps() noexcept {
 
 /* static */ bool ShaderCompilerService::checkLinkStatusAndCleanupShaders(
         program_token_t const& token) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
     assert_invariant(token->gl.program);
 
     bool linked = true;

filament/backend/src/opengl/platforms/PlatformEGLAndroid.cpp

@@ -255,7 +255,6 @@ Platform::ExternalImageHandle PlatformEGLAndroid::createExternalImage(AHardwareB
         p->height = hardwareBufferDescription.height;
         p->width = hardwareBufferDescription.width;
         auto textureFormat = mapToFilamentFormat(hardwareBufferDescription.format, sRGB);
-        p->format = textureFormat;
         p->usage = mapToFilamentUsage(hardwareBufferDescription.usage, textureFormat);
         return ExternalImageHandle{ p };
     }

filament/backend/src/vulkan/VulkanBuffer.cpp

@@ -28,7 +28,7 @@ VulkanBuffer::VulkanBuffer(VmaAllocator allocator, VulkanStagePool& stagePool,
     : mAllocator(allocator),
       mStagePool(stagePool),
       mUsage(usage),
-      mUpdatedOffset(0),
+	  mUpdatedOffset(0),
       mUpdatedBytes(0) {
     // for now make sure that only 1 bit is set in usage
     // (because loadFromCpu() assumes that somewhat)
@@ -56,12 +56,11 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
     vmaMapMemory(mAllocator, stage->memory, &mapped);
     memcpy(mapped, cpuData, numBytes);
     vmaUnmapMemory(mAllocator, stage->memory);
-    vmaFlushAllocation(mAllocator, stage->memory, 0, numBytes);
+    vmaFlushAllocation(mAllocator, stage->memory, byteOffset, numBytes);
 
     // If there was a previous update, then we need to make sure the following write is properly
     // synced with the previous read.
-    if (mUpdatedBytes > 0 &&
-            (byteOffset >= mUpdatedOffset && byteOffset <= (mUpdatedOffset + mUpdatedBytes))) {
+    if (mUpdatedBytes > 0) {
         VkAccessFlags srcAccess = 0;
         VkPipelineStageFlags srcStage = 0;
         if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
@@ -75,28 +74,28 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
             srcStage = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
         }
 
-        VkBufferMemoryBarrier barrier = {
+        VkBufferMemoryBarrier barrier{
             .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
             .srcAccessMask = srcAccess,
             .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
             .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
             .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
             .buffer = mGpuBuffer,
-            .offset = byteOffset,
-            .size = numBytes,
+			.offset = mUpdatedOffset,
+            .size = mUpdatedBytes,
         };
         vkCmdPipelineBarrier(cmdbuf, srcStage, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1,
                 &barrier, 0, nullptr);
     }
 
-    VkBufferCopy region = {
-        .srcOffset = 0,
-        .dstOffset = byteOffset,
-        .size = numBytes,
+    VkBufferCopy region {
+            .srcOffset = 0,
+            .dstOffset = byteOffset,
+            .size = numBytes,
     };
     vkCmdCopyBuffer(cmdbuf, stage->buffer, mGpuBuffer, 1, &region);
 
-    mUpdatedOffset = byteOffset;
+	mUpdatedOffset = byteOffset;
     mUpdatedBytes = numBytes;
 
     // Firstly, ensure that the copy finishes before the next draw call.
@@ -113,21 +112,21 @@ void VulkanBuffer::loadFromCpu(VkCommandBuffer cmdbuf, const void* cpuData, uint
         dstAccessMask |= VK_ACCESS_INDEX_READ_BIT;
         dstStageMask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
     } else if (mUsage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
-        dstAccessMask |= VK_ACCESS_SHADER_READ_BIT;
-        dstStageMask |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+        dstAccessMask |= VK_ACCESS_UNIFORM_READ_BIT;
+        dstStageMask |=
+                (VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
     } else if (mUsage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) {
         // TODO: implement me
     }
 
-    VkBufferMemoryBarrier barrier = {
+    VkBufferMemoryBarrier barrier{
         .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
         .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
         .dstAccessMask = dstAccessMask,
         .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .buffer = mGpuBuffer,
-        .offset = byteOffset,
-        .size = numBytes,
+        .size = VK_WHOLE_SIZE,
     };
 
     vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_TRANSFER_BIT, dstStageMask, 0, 0, nullptr, 1,

filament/backend/src/vulkan/VulkanConstants.h

@@ -151,13 +151,13 @@ static_assert(FVK_ENABLED(FVK_DEBUG_VALIDATION));
 
 #elif FVK_ENABLED(FVK_DEBUG_SYSTRACE)
 
-    #include <private/utils/Tracing.h>
-
-    #define FVK_SYSTRACE_CONTEXT()      FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT)
-    #define FVK_SYSTRACE_START(marker)  FILAMENT_TRACING_NAME_BEGIN(FILAMENT_TRACING_CATEGORY_FILAMENT, marker)
-    #define FVK_SYSTRACE_END()          FILAMENT_TRACING_NAME_END(FILAMENT_TRACING_CATEGORY_FILAMENT)
-    #define FVK_SYSTRACE_SCOPE()        FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT)
-    #define FVK_PROFILE_MARKER(marker)  FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT)
+    #include <utils/Systrace.h>
+    
+    #define FVK_SYSTRACE_CONTEXT()      SYSTRACE_CONTEXT()
+    #define FVK_SYSTRACE_START(marker)  SYSTRACE_NAME_BEGIN(marker)
+    #define FVK_SYSTRACE_END()          SYSTRACE_NAME_END()
+    #define FVK_SYSTRACE_SCOPE()        SYSTRACE_NAME(__func__)
+    #define FVK_PROFILE_MARKER(marker)  FVK_SYSTRACE_SCOPE()
 
 #else
     #define FVK_SYSTRACE_CONTEXT()

filament/backend/src/vulkan/VulkanDescriptorSetCache.cpp

@@ -358,11 +358,12 @@ void VulkanDescriptorSetCache::updateSamplerImpl(VkDescriptorSet vkset, uint8_t
         range.levelCount = 1;
         range.layerCount = 1;
     }
-    VkDescriptorImageInfo info = {
+    VkDescriptorImageInfo info{
         .sampler = sampler,
         .imageView = texture->getView(range),
-        .imageLayout = fvkutils::getVkLayout(texture->getSamplerLayout()),
+        .imageLayout = fvkutils::getVkLayout(texture->getDefaultLayout()),
     };
+
     VkWriteDescriptorSet descriptorWrite = {
         .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
         .pNext = nullptr,

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -622,7 +622,7 @@ void VulkanDriver::createTextureExternalImage2R(Handle<HwTexture> th, backend::S
     auto& commands = mCommands.get();
     // Unlike uploaded textures or swapchains, we need to explicit transition this
     // texture into the read layout.
-    texture->transitionLayout(&commands, texture->getPrimaryViewRange(), VulkanLayout::FRAG_READ);
+    texture->transitionLayout(&commands, texture->getPrimaryViewRange(), VulkanLayout::READ_ONLY);
 
     if (imgData.external.valid()) {
         mExternalImageManager.addExternallySampledTexture(texture, externalImage);

filament/backend/src/vulkan/VulkanHandles.cpp

@@ -93,32 +93,7 @@ BitmaskGroup fromBackendLayout(DescriptorSetLayout const& layout) {
             case DescriptorType::SAMPLER_EXTERNAL:
                 fromStageFlags(binding.stageFlags, binding.binding, mask.externalSampler);
                 UTILS_FALLTHROUGH;
-
-            case DescriptorType::SAMPLER_2D_FLOAT:
-            case DescriptorType::SAMPLER_2D_INT:
-            case DescriptorType::SAMPLER_2D_UINT:
-            case DescriptorType::SAMPLER_2D_DEPTH:
-            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_INT:
-            case DescriptorType::SAMPLER_CUBE_UINT:
-            case DescriptorType::SAMPLER_CUBE_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_3D_FLOAT:
-            case DescriptorType::SAMPLER_3D_INT:
-            case DescriptorType::SAMPLER_3D_UINT:
-            case DescriptorType::SAMPLER_2D_MS_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_INT:
-            case DescriptorType::SAMPLER_2D_MS_UINT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT: {
+            case DescriptorType::SAMPLER: {
                 fromStageFlags(binding.stageFlags, binding.binding, mask.sampler);
                 break;
             }
@@ -520,8 +495,7 @@ void VulkanRenderTarget::emitBarriersEndRenderPass(VulkanCommandBuffer& commands
             }
         } else {
             texture->setLayout(range, VulkanFboCache::FINAL_COLOR_ATTACHMENT_LAYOUT);
-            if (texture->isSampleable() &&
-                    !texture->transitionLayout(&commands, range, VulkanLayout::FRAG_READ)) {
+            if (!texture->transitionLayout(&commands, range, VulkanLayout::READ_WRITE)) {
                 texture->attachmentToSamplerBarrier(&commands, range);
             }
         }

filament/backend/src/vulkan/VulkanReadPixels.cpp

@@ -234,7 +234,6 @@ void VulkanReadPixels::run(fvkmemory::resource_ptr<VulkanRenderTarget> srcTarget
 
     VulkanAttachment const srcAttachment = srcTarget->getColor0();
     VkImageSubresourceRange const srcRange = srcAttachment.getSubresourceRange();
-    VulkanLayout const srcLayout = srcAttachment.getLayout();
     srcTexture->transitionLayout(cmdbuffer, srcRange, VulkanLayout::TRANSFER_SRC);
 
     VkImageCopy const imageCopyRegion = {
@@ -271,7 +270,7 @@ void VulkanReadPixels::run(fvkmemory::resource_ptr<VulkanRenderTarget> srcTarget
             fvkutils::getVkLayout(VulkanLayout::TRANSFER_DST), 1, &imageCopyRegion);
 
     // Restore the source image layout.
-    srcTexture->transitionLayout(cmdbuffer, srcRange, srcLayout);
+    srcTexture->transitionLayout(cmdbuffer, srcRange, srcTexture->getDefaultLayout());
 
     vkEndCommandBuffer(cmdbuffer);
 

filament/backend/src/vulkan/VulkanStagePool.cpp

@@ -125,7 +125,7 @@ VulkanStageImage const* VulkanStagePool::acquireImage(PixelDataFormat format, Pi
     fvkutils::transitionLayout(cmdbuffer, {
             .image = image->image,
             .oldLayout = VulkanLayout::UNDEFINED,
-            .newLayout = VulkanLayout::STAGING, // (= VK_IMAGE_LAYOUT_GENERAL)
+            .newLayout = VulkanLayout::READ_WRITE, // (= VK_IMAGE_LAYOUT_GENERAL)
             .subresources = { aspectFlags, 0, 1, 0, 1 },
         });
     return image;

filament/backend/src/vulkan/VulkanTexture.cpp

@@ -125,7 +125,7 @@ inline VulkanLayout getDefaultLayoutImpl(TextureUsage usage) {
         return VulkanLayout::COLOR_ATTACHMENT;
     }
     // Finally, the layout for an immutable texture is optimal read-only.
-    return VulkanLayout::FRAG_READ;
+    return VulkanLayout::READ_ONLY;
 }
 
 inline VulkanLayout getDefaultLayoutImpl(VkImageUsageFlags vkusage) {
@@ -187,7 +187,7 @@ VkImageUsageFlags getUsage(VulkanContext const& context, uint8_t samples,
             VkFormatProperties props;
             vkGetPhysicalDeviceFormatProperties(physicalDevice, vkFormat, &props);
             if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
-                FVK_LOGW << "Texture usage is SAMPLEABLE but format " << vkFormat << " is not "
+                FVK_LOGW << "Texture usage is SAMPLEABLE but format " << mState->mVkFormat << " is not "
                         "sampleable with optimal tiling." << utils::io::endl;
             }
         }
@@ -691,7 +691,6 @@ bool VulkanTexture::transitionLayout(VkCommandBuffer cmdbuf, VkImageSubresourceR
                  << " is skipped because of no change in layout" << utils::io::endl;
 #endif
     }
-
     return hasTransitions;
 }
 
@@ -701,15 +700,16 @@ void VulkanTexture::samplerToAttachmentBarrier(VulkanCommandBuffer* commands,
     VkImageLayout const layout =
             fvkutils::getVkLayout(getLayout(range.baseArrayLayer, range.baseMipLevel));
     VkImageMemoryBarrier barrier = {
-        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-        .srcAccessMask = VK_ACCESS_SHADER_READ_BIT,
-        .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        .oldLayout = layout,
-        .newLayout = layout,
-        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .image = mState->mTextureImage,
-        .subresourceRange = range,
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+            .srcAccessMask = VK_ACCESS_SHADER_READ_BIT,
+            .dstAccessMask =
+                    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+            .oldLayout = layout,
+            .newLayout = layout,
+            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .image = mState->mTextureImage,
+            .subresourceRange = range,
     };
     vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
             VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
@@ -723,15 +723,15 @@ void VulkanTexture::attachmentToSamplerBarrier(VulkanCommandBuffer* commands,
     VkImageLayout const layout
             = fvkutils::getVkLayout(getLayout(range.baseArrayLayer, range.baseMipLevel));
     VkImageMemoryBarrier barrier = {
-        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-        .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-        .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
-        .oldLayout = layout,
-        .newLayout = layout,
-        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .image = mState->mTextureImage,
-        .subresourceRange = range,
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+            .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
+            .oldLayout = layout,
+            .newLayout = layout,
+            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+            .image = mState->mTextureImage,
+            .subresourceRange = range,
     };
     vkCmdPipelineBarrier(cmdbuf, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
             VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);

filament/backend/src/vulkan/VulkanTexture.h

@@ -145,14 +145,8 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
 
     VkImageSubresourceRange const& getPrimaryViewRange() const { return mPrimaryViewRange; }
 
-    VulkanLayout getSamplerLayout() const {
-        if (!isSampleable()) {
-            return VulkanLayout::UNDEFINED;
-        }
-        if (mState->mUsage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
-            return VulkanLayout::DEPTH_SAMPLER;
-        }
-        return VulkanLayout::FRAG_READ;
+    VulkanLayout getPrimaryImageLayout() const {
+        return getLayout(mPrimaryViewRange.baseArrayLayer, mPrimaryViewRange.baseMipLevel);
     }
 
     // Returns the layout for the intended use of this texture (and not the expected layout at the
@@ -186,10 +180,6 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
         return mState->mUsage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
     }
 
-    bool isSampleable() const {
-        return mState->mUsage & VK_IMAGE_USAGE_SAMPLED_BIT;
-    }
-
     bool getIsProtected() const {
         return mState->mIsProtected;
     }

filament/backend/src/vulkan/utils/Image.cpp

@@ -42,22 +42,20 @@ getVkTransition(const VulkanLayoutTransition& transition) {
             srcStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
             break;
         case VulkanLayout::COLOR_ATTACHMENT:
-            srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+            srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
+                            VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
                             VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-            srcStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+                       VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
             break;
-        case VulkanLayout::STAGING:
+        case VulkanLayout::READ_WRITE:
             srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
             srcStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
             break;
-        case VulkanLayout::FRAG_READ:
+        case VulkanLayout::READ_ONLY:
             srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
             srcStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
             break;
-        case VulkanLayout::VERT_READ:
-            srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
-            srcStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
-            break;
         case VulkanLayout::TRANSFER_SRC:
             srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
             srcStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
@@ -71,7 +69,7 @@ getVkTransition(const VulkanLayoutTransition& transition) {
             srcStage = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
             break;
         case VulkanLayout::DEPTH_SAMPLER:
-            srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
+            srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
             srcStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
             break;
         case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:
@@ -86,21 +84,19 @@ getVkTransition(const VulkanLayoutTransition& transition) {
 
     switch (transition.newLayout) {
         case VulkanLayout::COLOR_ATTACHMENT:
-            dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
+            dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT
+                            | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
                             | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-            dstStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+            dstStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
+                       | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
             break;
-        case VulkanLayout::STAGING:
+        case VulkanLayout::READ_WRITE:
             dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
             dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
             break;
-        case VulkanLayout::FRAG_READ:
+        case VulkanLayout::READ_ONLY:
             dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-            dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-            break;
-        case VulkanLayout::VERT_READ:
-            dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-            dstStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+            dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
             break;
         case VulkanLayout::TRANSFER_SRC:
             dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
@@ -116,8 +112,10 @@ getVkTransition(const VulkanLayoutTransition& transition) {
             dstStage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
             break;
         case VulkanLayout::DEPTH_SAMPLER:
-            dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-            dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+            dstAccessMask =
+                    VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+            dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+                       VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
             break;
         case VulkanLayout::PRESENT:
         case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:
@@ -140,6 +138,7 @@ bool transitionLayout(VkCommandBuffer cmdbuffer,
     }
     auto [srcAccessMask, dstAccessMask, srcStage, dstStage, oldLayout, newLayout]
             = getVkTransition(transition);
+
     if (oldLayout == newLayout) {
         return false;
     }
@@ -156,7 +155,7 @@ bool transitionLayout(VkCommandBuffer cmdbuffer,
             .image = transition.image,
             .subresourceRange = transition.subresources,
     };
-   vkCmdPipelineBarrier(cmdbuffer, srcStage, dstStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);
+    vkCmdPipelineBarrier(cmdbuffer, srcStage, dstStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);
     return true;
 }
 
@@ -265,9 +264,8 @@ utils::io::ostream& operator<<(utils::io::ostream& out,
         const filament::backend::VulkanLayout& layout) {
     switch (layout) {
         CASE(UNDEFINED)
-        CASE(FRAG_READ)
-        CASE(VERT_READ)
-        CASE(STAGING)
+        CASE(READ_ONLY)
+        CASE(READ_WRITE)
         CASE(TRANSFER_SRC)
         CASE(TRANSFER_DST)
         CASE(DEPTH_ATTACHMENT)

filament/backend/src/vulkan/utils/Image.h

@@ -32,11 +32,9 @@ enum class VulkanLayout : uint8_t {
     // any transition.
     UNDEFINED,
     // Fragment/vertex shader accessible layout for reading and writing.
-    STAGING,
-    // Fragment shader accessible layout for reading only.
-    FRAG_READ,
-    // Vertex shader accessible layout for reading only.
-    VERT_READ,
+    READ_WRITE,
+    // Fragment/vertex shader accessible layout for reading only.
+    READ_ONLY,
     // For the source of a copy operation.
     TRANSFER_SRC,
     // For the destination of a copy operation.
@@ -67,10 +65,9 @@ constexpr inline VkImageLayout getVkLayout(VulkanLayout layout) {
     switch (layout) {
         case VulkanLayout::UNDEFINED:
             return VK_IMAGE_LAYOUT_UNDEFINED;
-        case VulkanLayout::STAGING:
+        case VulkanLayout::READ_WRITE:
             return VK_IMAGE_LAYOUT_GENERAL;
-        case VulkanLayout::FRAG_READ:
-        case VulkanLayout::VERT_READ:
+        case VulkanLayout::READ_ONLY:
             return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
         case VulkanLayout::TRANSFER_SRC:
             return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
@@ -83,8 +80,9 @@ constexpr inline VkImageLayout getVkLayout(VulkanLayout layout) {
         case VulkanLayout::PRESENT:
             return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
         // Filament sometimes samples from one miplevel while writing to another level in the
-        // same texture (e.g. bloom does this). So, keep it simple and use GENERAL for all
-        // color-attachable textures.
+        // same texture (e.g. bloom does this). Moreover we'd like to avoid lots of expensive
+        // layout transitions. So, keep it simple and use GENERAL for all color-attachable
+        // textures.
         case VulkanLayout::COLOR_ATTACHMENT:
             return VK_IMAGE_LAYOUT_GENERAL;
         case VulkanLayout::COLOR_ATTACHMENT_RESOLVE:

filament/backend/src/webgpu/WebGPUDriver.cpp

@@ -26,7 +26,7 @@
 #include <backend/DriverEnums.h>
 #include <backend/Handle.h>
 #include <backend/TargetBufferInfo.h>
-#include <private/backend/BackendUtils.h>
+
 #include <math/mat3.h>
 #include <utils/CString.h>
 #include <utils/Panic.h>
@@ -39,7 +39,6 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <memory>
 #include <sstream>
 #include <string_view>
 #include <utility>
@@ -235,9 +234,6 @@ WebGPUDriver::WebGPUDriver(WebGPUPlatform& platform, const Platform::DriverConfi
     printAdapterDetails(mAdapter);
 #endif
     mDevice = mPlatform.requestDevice(mAdapter);
-    wgpu::Limits supportedLimits{};
-    mDevice.GetLimits(&supportedLimits);
-    mMinUniformBufferOffsetAlignment = supportedLimits.minUniformBufferOffsetAlignment;
 #if FWGPU_ENABLED(FWGPU_PRINT_SYSTEM)
     printDeviceDetails(mDevice);
 #endif
@@ -354,17 +350,6 @@ void WebGPUDriver::destroyProgram(Handle<HwProgram> ph) {
 }
 
 void WebGPUDriver::destroyRenderTarget(Handle<HwRenderTarget> rth) {
-    if (rth) {
-        WGPURenderTarget* rt = handleCast<WGPURenderTarget>(rth);
-        if (rt == mDefaultRenderTarget) {
-            mDefaultRenderTarget = nullptr;
-        }
-        // WGPURenderTarget destructor is trivial.
-        // The HwTexture handles stored within WGPURenderTarget (via MRT, TargetBufferInfo)
-        // are not owned by WGPURenderTarget, so they are not destroyed here.
-        // They are destroyed via WebGPUDriver::destroyTexture.
-        destructHandle<WGPURenderTarget>(rth);
-    }
 }
 
 void WebGPUDriver::destroySwapChain(Handle<HwSwapChain> sch) {
@@ -483,10 +468,11 @@ void WebGPUDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow,
     mSwapChain = constructHandle<WebGPUSwapChain>(sch, std::move(surface), surfaceSize, mAdapter,
             mDevice, flags);
     assert_invariant(mSwapChain);
-
-    FWGPU_LOGW << "WebGPU support is highly experimental, in development, and tested for only a "
-                  "small set of simple samples (e.g. hellotriangle and texturedquad), thus issues "
-                  "are likely to be encountered at this stage."
+    WebGPUDescriptorSet::initializeDummyResourcesIfNotAlready(mDevice,
+            mSwapChain->getColorFormat());
+    FWGPU_LOGW << "WebGPU support is still essentially a no-op at this point in development (only "
+                  "background components have been instantiated/selected, such as surface/screen, "
+                  "graphics device/GPU, etc.), thus nothing is being drawn to the screen."
                << utils::io::endl;
 #if !FWGPU_ENABLED(FWGPU_PRINT_SYSTEM) && !defined(NDEBUG)
     FWGPU_LOGI << "If the FILAMENT_BACKEND_DEBUG_FLAG variable were set with the " << utils::io::hex
@@ -582,6 +568,7 @@ void WebGPUDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph, Handle<
 void WebGPUDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
     constructHandle<WGPUProgram>(ph, mDevice, program);
 }
+
 void WebGPUDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {
     assert_invariant(!mDefaultRenderTarget);
     mDefaultRenderTarget = constructHandle<WGPURenderTarget>(rth);
@@ -590,21 +577,7 @@ void WebGPUDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {
 
 void WebGPUDriver::createRenderTargetR(Handle<HwRenderTarget> rth, TargetBufferFlags targets,
         uint32_t width, uint32_t height, uint8_t samples, uint8_t layerCount, MRT color,
-        TargetBufferInfo depth, TargetBufferInfo stencil) {
-    // The `targets` flags indicate which of the `color`, `depth`, `stencil` TargetBufferInfo
-    // are actually active for this render target.
-    // We'll pass all TargetBufferInfo to WGPURenderTarget; it will use them if their handles are valid.
-
-    // Ensure that textures intended for use as attachments were created with
-    // wgpu::TextureUsage::RenderAttachment. This check should ideally be in createTextureR
-    // or validated here if possible.
-
-    // The `layerCount` parameter might be for creating array textures that this RT targets.
-    // Individual attachments (color[i].layer, depth.layer, stencil.layer) specify which layer
-    // of an array texture to bind. For now, we assume textures are pre-configured.
-
-    constructHandle<WGPURenderTarget>(rth, width, height, samples, color, depth, stencil);
-}
+        TargetBufferInfo depth, TargetBufferInfo stencil) {}
 
 void WebGPUDriver::createFenceR(Handle<HwFence> fh, int) {}
 
@@ -748,20 +721,17 @@ size_t WebGPUDriver::getMaxArrayTextureLayers() {
 
 void WebGPUDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor&& p,
         uint32_t byteOffset) {
-    handleCast<WGPUIndexBuffer>(ibh)->updateGPUBuffer(p, byteOffset, mQueue);
-    scheduleDestroy(std::move(p));
+    updateGPUBuffer(handleCast<WGPUIndexBuffer>(ibh), std::move(p), byteOffset);
 }
 
 void WebGPUDriver::updateBufferObject(Handle<HwBufferObject> ibh, BufferDescriptor&& p,
         uint32_t byteOffset) {
-    handleCast<WGPUBufferObject>(ibh)->updateGPUBuffer(p, byteOffset, mQueue);
-    scheduleDestroy(std::move(p));
+    updateGPUBuffer(handleCast<WGPUBufferObject>(ibh), std::move(p), byteOffset);
 }
 
 void WebGPUDriver::updateBufferObjectUnsynchronized(Handle<HwBufferObject> ibh,
         BufferDescriptor&& p, uint32_t byteOffset) {
-    handleCast<WGPUBufferObject>(ibh)->updateGPUBuffer(p, byteOffset, mQueue);
-    scheduleDestroy(std::move(p));
+    updateGPUBuffer(handleCast<WGPUBufferObject>(ibh), std::move(p), byteOffset);
 }
 
 void WebGPUDriver::resetBufferObject(Handle<HwBufferObject> boh) {
@@ -773,76 +743,15 @@ void WebGPUDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh, uint32_t in
     auto* vertexBuffer = handleCast<WGPUVertexBuffer>(vbh);
     auto* bufferObject = handleCast<WGPUBufferObject>(boh);
     assert_invariant(index < vertexBuffer->buffers.size());
-    assert_invariant(bufferObject->getBuffer().GetUsage() & wgpu::BufferUsage::Vertex);
-    vertexBuffer->buffers[index] = bufferObject->getBuffer();
+    assert_invariant(bufferObject->buffer.GetUsage() & wgpu::BufferUsage::Vertex);
+    vertexBuffer->buffers[index] = bufferObject->buffer;
 }
 
-void WebGPUDriver::update3DImage(Handle<HwTexture> th, uint32_t level, uint32_t xoffset,
-        uint32_t yoffset, uint32_t zoffset, uint32_t width, uint32_t height, uint32_t depth,
-        PixelBufferDescriptor&& p) {
-    PixelBufferDescriptor* data = &p;
-    PixelBufferDescriptor reshapedData;
-    if (reshape(p, reshapedData)) {
-        data = &reshapedData;
-    }
-    auto texture = handleCast<WGPUTexture>(th);
-
-    // TODO: Writing to a depth texture is illegal and errors. I'm not sure why Filament is trying
-    // to do so, but early returning is working?
-    if(texture->getAspect() == wgpu::TextureAspect::DepthOnly){
-        scheduleDestroy(std::move(p));
-        return;
-    }
-    size_t blockWidth = texture->getBlockWidth();
-    size_t blockHeight = texture->getBlockHeight();
-    // WebGPU specification requires that for compressed textures, the x and y offsets
-    // must be a multiple of the compressed texture format's block width and height.
-    // See: https://www.w3.org/TR/webgpu/#abstract-opdef-validating-gputexelcopytextureinfo
-    if (blockWidth > 1 || blockHeight > 1) {
-        FILAMENT_CHECK_PRECONDITION(xoffset % blockWidth == 0)
-                << "xoffset must be aligned to blockwidth, but offset is " << blockWidth
-                << "and offset is " << xoffset;
-        FILAMENT_CHECK_PRECONDITION(yoffset % blockHeight == 0)
-                << "yoffset must be aligned to blockHeight, but offset is " << blockHeight
-                << "and offset is " << yoffset;
-    }
-
-    auto copyInfo = wgpu::TexelCopyTextureInfo{ .texture = texture->getTexture(),
-        .mipLevel = level,
-        .origin = { .x = xoffset, .y = yoffset, .z = zoffset },
-        .aspect = texture->getAspect() };
-    uint32_t bytesPerRow = static_cast<uint32_t>(
-            PixelBufferDescriptor::computePixelSize(data->format, data->type) * width);
-    auto extent = wgpu::Extent3D{ .width = width, .height = height, .depthOrArrayLayers = depth };
-
-    const uint8_t* dataBuff = static_cast<const uint8_t*>(data->buffer);
-    size_t dataSize = data->size;
-    std::unique_ptr<uint8_t[]> paddedBuffer;
-
-    if (bytesPerRow % 256 != 0) {
-        uint32_t padding = 256 - (bytesPerRow % 256);
-        uint32_t paddedBytesPerRow = bytesPerRow + padding;
-
-        size_t paddedBufferSize = static_cast<size_t>(paddedBytesPerRow) * height * depth;
-        paddedBuffer = std::make_unique<uint8_t[]>(paddedBufferSize);
-        uint8_t* dest = paddedBuffer.get();
-
-        for (uint32_t z = 0; z < depth; ++z) {
-            for (uint32_t y = 0; y < height; ++y) {
-                std::memcpy(dest, dataBuff, bytesPerRow);
-                dest += paddedBytesPerRow;
-                dataBuff += bytesPerRow;
-            }
-        }
-        dataBuff = paddedBuffer.get();
-        dataSize = paddedBufferSize;
-        bytesPerRow = paddedBytesPerRow;
-    }
-
-    auto layout = wgpu::TexelCopyBufferLayout{ .bytesPerRow = bytesPerRow, .rowsPerImage = height };
-
-    mQueue.WriteTexture(&copyInfo, dataBuff, dataSize, &layout, &extent);
-    scheduleDestroy(std::move(p));
+void WebGPUDriver::update3DImage(Handle<HwTexture> th,
+        uint32_t level, uint32_t xoffset, uint32_t yoffset, uint32_t zoffset,
+        uint32_t width, uint32_t height, uint32_t depth,
+        PixelBufferDescriptor&& data) {
+    scheduleDestroy(std::move(data));
 }
 
 void WebGPUDriver::setupExternalImage(void* image) {
@@ -869,74 +778,56 @@ void WebGPUDriver::compilePrograms(CompilerPriorityQueue priority,
 
 void WebGPUDriver::beginRenderPass(Handle<HwRenderTarget> rth, RenderPassParams const& params) {
     assert_invariant(mCommandEncoder);
+
     auto* renderTarget = handleCast<WGPURenderTarget>(rth);
-
-    wgpu::RenderPassDescriptor renderPassDescriptor{};
-    wgpu::TextureView defaultColorView = nullptr;
-    wgpu::TextureView defaultDepthStencilView = nullptr;
-
-    std::array<wgpu::TextureView, MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT> customColorViews{};
-    uint32_t customColorViewCount = 0;
-    wgpu::TextureView customDepthView = nullptr;
-    wgpu::TextureView customStencilView = nullptr;
-
-    if (renderTarget->isDefaultRenderTarget()) {
-        assert_invariant(mSwapChain && mTextureView);
-        defaultColorView = mTextureView;
-        defaultDepthStencilView = mSwapChain->getDepthTextureView();
+    // if (renderTarget == mDefaultRenderTarget) {
+    //     FWGPU_LOGW << "Default render target"
+    //                << utils::io::endl;
+    // } else {
+    //     FWGPU_LOGW << "Non Default render target"
+    //                << utils::io::endl;
+    // }
+    wgpu::RenderPassDescriptor renderPassDescriptor2;
+    wgpu::RenderPassDepthStencilAttachment depthStencilAttachment{
+        .view = mSwapChain->getDepthTextureView(),
+        .depthLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH),
+        .depthStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH),
+        .depthClearValue = static_cast<float>(params.clearDepth),
+        .depthReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0,
+        .stencilLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL),
+        .stencilStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL),
+        .stencilClearValue = params.clearStencil,
+        .stencilReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0
+    };
+    renderTarget->setUpRenderPassAttachments(renderPassDescriptor2, mTextureView, params);
+    renderPassDescriptor2.depthStencilAttachment = &depthStencilAttachment;
+    // TODO: Remove this code once WebGPU pipeline is implemented
+    static float red = 1.0f;
+    if (red - 0.01 > 0) {
+        red -= 0.01;
     } else {
-        // Resolve views for custom render target
-        const auto& colorInfos = renderTarget->getColorAttachmentInfos();
-        for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; ++i) {
-            if (colorInfos[i].handle) {
-                auto* hwTexture = handleCast<WGPUTexture>(colorInfos[i].handle);
-                if (hwTexture) {
-                    // TODO: Consider colorInfos[i].level and colorInfos[i].layer for view creation
-                    // if WGPUTexture::getTexView() isn't sufficient or needs parameters.
-                    customColorViews[customColorViewCount++] = hwTexture->getTexView();
-                }
-            }
-        }
-
-        const auto& depthInfo = renderTarget->getDepthAttachmentInfo();
-        if (depthInfo.handle) {
-            auto* hwTexture = handleCast<WGPUTexture>(depthInfo.handle);
-            if (hwTexture) {
-                customDepthView = hwTexture->getTexView();
-            }
-        }
-
-        const auto& stencilInfo = renderTarget->getStencilAttachmentInfo();
-        if (stencilInfo.handle) {
-            // If depth and stencil use the same texture handle, this will re-cast but that's fine.
-            auto* hwTexture = handleCast<WGPUTexture>(stencilInfo.handle);
-            if (hwTexture) {
-                customStencilView = hwTexture->getTexView();
-            }
-        }
+        red = 1.0f;
     }
+    assert_invariant(mTextureView);
+    wgpu::RenderPassColorAttachment renderPassColorAttachment = {
+        .view = mTextureView,
+        // TODO: remove this code once WebGPU Pipeline is implemented with render targets, pipeline and buffers.
+        .depthSlice = wgpu::kDepthSliceUndefined,
+        .loadOp = wgpu::LoadOp::Clear,
+        .storeOp = wgpu::StoreOp::Store,
+        .clearValue = wgpu::Color{red, 0 , 0 , 1},
+    };
 
-    renderTarget->setUpRenderPassAttachments(renderPassDescriptor,
-            params,
-            defaultColorView,
-            defaultDepthStencilView,
-            customColorViews.data(),
-            customColorViewCount,
-            customDepthView,
-            customStencilView);
+    wgpu::RenderPassDescriptor renderPassDescriptor = {
+        .colorAttachmentCount = 1,
+        .colorAttachments = &renderPassColorAttachment,
+        .depthStencilAttachment = nullptr,
+        .timestampWrites = nullptr,
+    };
 
-    mRenderPassEncoder = mCommandEncoder.BeginRenderPass(&renderPassDescriptor);
-    // Ensure viewport dimensions are positive
-    uint32_t viewportWidth = params.viewport.width > 0 ? params.viewport.width : 1;
-    uint32_t viewportHeight = params.viewport.height > 0 ? params.viewport.height : 1;
-
-    mRenderPassEncoder.SetViewport(
-            static_cast<float>(params.viewport.left),
-            static_cast<float>(params.viewport.bottom),
-            static_cast<float>(viewportWidth),
-            static_cast<float>(viewportHeight),
-            params.depthRange.near,
-            params.depthRange.far);
+    mRenderPassEncoder = mCommandEncoder.BeginRenderPass(&renderPassDescriptor2);
+    mRenderPassEncoder.SetViewport(params.viewport.left, params.viewport.bottom,
+            params.viewport.width, params.viewport.height, params.depthRange.near, params.depthRange.far);
 }
 
 void WebGPUDriver::endRenderPass(int /* dummy */) {
@@ -1029,20 +920,10 @@ void WebGPUDriver::bindPipeline(PipelineState const& pipelineState) {
     // VulkanPipelineCache to handle this, may be missing nuance
     static auto pipleineStateHasher = utils::hash::MurmurHashFn<filament::backend::PipelineState>();
     auto hash = pipleineStateHasher(pipelineState);
-    if(mPipelineMap.find(hash) != mPipelineMap.end()) {
+    if(mPipelineMap.find(hash) != mPipelineMap.end()){
         mRenderPassEncoder.SetPipeline(mPipelineMap[hash]);
         return;
     }
-    for (size_t index = 0; index < MAX_DESCRIPTOR_SET_COUNT; ++index) {
-        auto& entry = currentDescriptorSets[index];
-        if (entry.bg != nullptr) {
-            mRenderPassEncoder.SetBindGroup(index, entry.bg, entry.dynamicOffsetCount,
-                    entry.offsets.data());
-            entry.bg = nullptr;
-            entry.dynamicOffsetCount = 0;
-            entry.offsets.clear();
-        }
-    }
     const auto* program = handleCast<WGPUProgram>(pipelineState.program);
     assert_invariant(program);
     assert_invariant(program->computeShaderModule == nullptr &&
@@ -1085,28 +966,28 @@ void WebGPUDriver::bindPipeline(PipelineState const& pipelineState) {
 
 void WebGPUDriver::bindRenderPrimitive(Handle<HwRenderPrimitive> rph) {
     auto* renderPrimitive = handleCast<WGPURenderPrimitive>(rph);
-    auto* vbi = handleCast<WGPUVertexBufferInfo>(renderPrimitive->vertexBuffer->vbih);
 
-    // Loop over the WebGPU vertex buffer slots defined by the VertexBufferInfo.
-    // For each WebGPU slot, find the corresponding Filament buffer that supplies the data.
-    for (uint32_t webGPUSlot = 0; webGPUSlot < vbi->getWebGPULayoutCount(); ++webGPUSlot) {
-        uint8_t filamentBufferIndex = vbi->getFilamentBufferIndexForSlot(webGPUSlot);
-
-        // Ensure the Filament buffer index is valid for the vertexBuffer's internal storage.
-        // This check assumes renderPrimitive->vertexBuffer->buffers is sized by the
-        // original Filament buffer count.
-        assert_invariant(filamentBufferIndex < renderPrimitive->vertexBuffer->buffers.size());
-
-        mRenderPassEncoder.SetVertexBuffer(webGPUSlot,
-                renderPrimitive->vertexBuffer->buffers[filamentBufferIndex]);
+    // This *must* match the WGPUVertexBufferInfo that was bound in bindPipeline(). But we want
+    // to allow to call this before bindPipeline(), so the validation can only happen in draw()
+    auto vbi = handleCast<WGPUVertexBufferInfo>(renderPrimitive->vertexBuffer->vbih);
+    assert_invariant(
+            vbi->getVertexBufferLayoutSize() == renderPrimitive->vertexBuffer->buffers.size());
+    for (uint32_t i = 0; i < vbi->getVertexBufferLayoutSize(); i++) {
+        mRenderPassEncoder.SetVertexBuffer(i, renderPrimitive->vertexBuffer->buffers[i]);
     }
 
-    mRenderPassEncoder.SetIndexBuffer(renderPrimitive->indexBuffer->getBuffer(),
+    mRenderPassEncoder.SetIndexBuffer(renderPrimitive->indexBuffer->buffer,
             renderPrimitive->indexBuffer->indexFormat);
 }
 
 void WebGPUDriver::draw2(uint32_t indexOffset, uint32_t indexCount, uint32_t instanceCount) {
-    mRenderPassEncoder.DrawIndexed(indexCount, instanceCount, indexOffset, 0, 0);
+    // Calling DrawIndexed with "firstInstance = 0" results in a NON spinning triangle
+    //    mRenderPassEncoder.DrawIndexed(indexCount, instanceCount, indexOffset, 0, 0);
+    // Calling DrawIndexed with "firstInstance = 1" results in a spinning triangle
+    mRenderPassEncoder.DrawIndexed(indexCount, instanceCount, indexOffset, 0, 1);
+    // Calling Draw with "firstInstance = 0" results in a NON spinning triangle
+    // Calling Draw with "firstInstance = 1" results in a spinning triangle
+    //    mRenderPassEncoder.Draw(indexCount, instanceCount, 0, 1);
 }
 
 void WebGPUDriver::draw(PipelineState, Handle<HwRenderPrimitive>, uint32_t indexOffset,
@@ -1137,11 +1018,8 @@ void WebGPUDriver::updateDescriptorSetBuffer(Handle<HwDescriptorSet> dsh,
     auto buffer = handleCast<WGPUBufferObject>(boh);
     if (!bindGroup->getIsLocked()) {
         // TODO making assumptions that size and offset mean the same thing here.
-        FILAMENT_CHECK_PRECONDITION(offset % mMinUniformBufferOffsetAlignment == 0)
-                << "Binding offset must be multiple of " << mMinUniformBufferOffsetAlignment
-                << "But requested offset is " << offset;
         wgpu::BindGroupEntry entry{ .binding = static_cast<uint32_t>(binding * 2),
-            .buffer = buffer->getBuffer(),
+            .buffer = buffer->buffer,
             .offset = offset,
             .size = size };
         bindGroup->addEntry(entry.binding, std::move(entry));
@@ -1172,109 +1050,116 @@ void WebGPUDriver::bindDescriptorSet(Handle<HwDescriptorSet> dsh,
         backend::descriptor_set_t setIndex, backend::DescriptorSetOffsetArray&& offsets) {
     const auto bindGroup = handleCast<WebGPUDescriptorSet>(dsh);
     const auto wbg = bindGroup->lockAndReturn(mDevice);
+    assert_invariant(mRenderPassEncoder);
+    // TODO is this how we should be getting the dynamic offsets?
+    //      should we add offsets for unused entries or is the input already have them?
+    //      this implementation assumes unused entries are not provided, and adds dummy values.
+    //      The count also includes unused entities, as not doing so produces errors
     const size_t dynamicOffsetCount = bindGroup->countEntitiesWithDynamicOffsets();
-
-    if(mRenderPassEncoder){
-        mRenderPassEncoder.SetBindGroup(setIndex, wbg, dynamicOffsetCount, offsets.data());
-    }
-    currentDescriptorSets[setIndex] = {wbg, dynamicOffsetCount, std::move(offsets)};
+    uint32_t const* const dynamicOffsetsWithUnused = bindGroup->setDynamicOffsets(offsets.data());
+    mRenderPassEncoder.SetBindGroup(setIndex, wbg, dynamicOffsetCount, dynamicOffsetsWithUnused);
 }
 
 void WebGPUDriver::setDebugTag(HandleBase::HandleId handleId, utils::CString tag) {
 }
 wgpu::Sampler WebGPUDriver::makeSampler(SamplerParams const& params) {
-    wgpu::SamplerDescriptor desc{};
+    wgpu::SamplerDescriptor desc;
 
     desc.label = "TODO";
     desc.addressModeU = fWrapModeToWAddressMode(params.wrapS);
     desc.addressModeV = fWrapModeToWAddressMode(params.wrapR);
     desc.addressModeW = fWrapModeToWAddressMode(params.wrapT);
-    if (params.compareMode == SamplerCompareMode::COMPARE_TO_TEXTURE) {
-        switch (params.filterMag) {
-            case SamplerMagFilter::NEAREST: {
-                desc.magFilter = wgpu::FilterMode::Nearest;
-                break;
-            }
-            case SamplerMagFilter::LINEAR: {
-                desc.magFilter = wgpu::FilterMode::Linear;
-                break;
-            }
+    switch (params.filterMag) {
+        case SamplerMagFilter::NEAREST: {
+            desc.magFilter = wgpu::FilterMode::Nearest;
+            break;
         }
-        switch (params.filterMin) {
-            case SamplerMinFilter::NEAREST: {
-                desc.minFilter = wgpu::FilterMode::Nearest;
-                desc.mipmapFilter = wgpu::MipmapFilterMode::Undefined;
-                break;
-            }
-            case SamplerMinFilter::LINEAR: {
-                desc.minFilter = wgpu::FilterMode::Linear;
-                desc.mipmapFilter = wgpu::MipmapFilterMode::Undefined;
-                break;
-            }
-            case SamplerMinFilter::NEAREST_MIPMAP_NEAREST: {
-                desc.minFilter = wgpu::FilterMode::Nearest;
-                desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
-                break;
-            }
-            case SamplerMinFilter::LINEAR_MIPMAP_NEAREST: {
-                desc.minFilter = wgpu::FilterMode::Linear;
-                desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
-
-                break;
-            }
-            case SamplerMinFilter::NEAREST_MIPMAP_LINEAR: {
-                desc.minFilter = wgpu::FilterMode::Nearest;
-                desc.mipmapFilter = wgpu::MipmapFilterMode::Linear;
-
-                break;
-            }
-            case SamplerMinFilter::LINEAR_MIPMAP_LINEAR: {
-                desc.minFilter = wgpu::FilterMode::Linear;
-                desc.mipmapFilter = wgpu::MipmapFilterMode::Linear;
-                break;
-            }
+        case SamplerMagFilter::LINEAR: {
+            desc.magFilter = wgpu::FilterMode::Linear;
+            break;
         }
-        switch (params.compareFunc) {
-            case SamplerCompareFunc::LE: {
-                desc.compare = wgpu::CompareFunction::LessEqual;
-                break;
-            }
-            case SamplerCompareFunc::GE: {
-                desc.compare = wgpu::CompareFunction::GreaterEqual;
-                break;
-            }
-            case SamplerCompareFunc::L: {
-                desc.compare = wgpu::CompareFunction::Less;
-                break;
-            }
-            case SamplerCompareFunc::G: {
-                desc.compare = wgpu::CompareFunction::Greater;
-                break;
-            }
-            case SamplerCompareFunc::E: {
-                desc.compare = wgpu::CompareFunction::Equal;
-                break;
-            }
-            case SamplerCompareFunc::NE: {
-                desc.compare = wgpu::CompareFunction::NotEqual;
-                break;
-            }
-            case SamplerCompareFunc::A: {
-                desc.compare = wgpu::CompareFunction::Always;
-                break;
-            }
-            case SamplerCompareFunc::N: {
-                desc.compare = wgpu::CompareFunction::Never;
-                break;
-            }
+    }
+    switch (params.filterMin) {
+        case SamplerMinFilter::NEAREST: {
+            desc.minFilter = wgpu::FilterMode::Nearest;
+            // Metal Driver uses an explicit not-mipmapped value webgpu lacks. Nearest should
+            // suffice
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+            break;
+        }
+        case SamplerMinFilter::LINEAR: {
+            desc.minFilter = wgpu::FilterMode::Linear;
+            // Metal Driver uses an explicit not-mipmapped value webgpu lacks. Nearest should
+            // suffice
+
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+            break;
+        }
+        case SamplerMinFilter::NEAREST_MIPMAP_NEAREST: {
+            desc.minFilter = wgpu::FilterMode::Nearest;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+            break;
+        }
+        case SamplerMinFilter::LINEAR_MIPMAP_NEAREST: {
+            desc.minFilter = wgpu::FilterMode::Linear;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Nearest;
+
+            break;
+        }
+        case SamplerMinFilter::NEAREST_MIPMAP_LINEAR: {
+            desc.minFilter = wgpu::FilterMode::Nearest;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Linear;
+
+            break;
+        }
+        case SamplerMinFilter::LINEAR_MIPMAP_LINEAR: {
+            desc.minFilter = wgpu::FilterMode::Linear;
+            desc.mipmapFilter = wgpu::MipmapFilterMode::Linear;
+            break;
+        }
+    }
+    switch (params.compareFunc) {
+        case SamplerCompareFunc::LE: {
+            desc.compare = wgpu::CompareFunction::LessEqual;
+            break;
+        }
+        case SamplerCompareFunc::GE: {
+            desc.compare = wgpu::CompareFunction::GreaterEqual;
+            break;
+        }
+        case SamplerCompareFunc::L: {
+            desc.compare = wgpu::CompareFunction::Less;
+            break;
+        }
+        case SamplerCompareFunc::G: {
+            desc.compare = wgpu::CompareFunction::Greater;
+            break;
+        }
+        case SamplerCompareFunc::E: {
+            desc.compare = wgpu::CompareFunction::Equal;
+            break;
+        }
+        case SamplerCompareFunc::NE: {
+            desc.compare = wgpu::CompareFunction::NotEqual;
+            break;
+        }
+        case SamplerCompareFunc::A: {
+            desc.compare = wgpu::CompareFunction::Always;
+            break;
+        }
+        case SamplerCompareFunc::N: {
+            desc.compare = wgpu::CompareFunction::Never;
+            break;
         }
     }
 
     desc.maxAnisotropy = 1u << params.anisotropyLog2;
 
-    // Unused: WGPU lodMinClamp/lodMaxClamp unnecessary
 
-    return mDevice.CreateSampler(&desc);
+    // Unused: Filament's compareMode, WGPU lodMinClamp/lodMaxClamp
+
+    //TODO Once we can properly map to descriptorsetlayout use the sampler.
+    return mDevice.CreateSampler(/*&desc*/);
 }
 wgpu::AddressMode WebGPUDriver::fWrapModeToWAddressMode(const SamplerWrapMode& fWrapMode) {
     switch (fWrapMode) {
@@ -1294,4 +1179,5 @@ wgpu::AddressMode WebGPUDriver::fWrapModeToWAddressMode(const SamplerWrapMode& f
     return wgpu::AddressMode::Undefined;
 }
 
+
 } // namespace filament

filament/backend/src/webgpu/WebGPUDriver.h

@@ -58,13 +58,32 @@ private:
     [[nodiscard]] ShaderLanguage getShaderLanguage() const noexcept final;
     [[nodiscard]] wgpu::Sampler makeSampler(SamplerParams const& params);
     [[nodiscard]] static wgpu::AddressMode fWrapModeToWAddressMode(const filament::backend::SamplerWrapMode& fUsage);
+    template<typename GPUBufferObject>
+    void updateGPUBuffer(GPUBufferObject* gpuBufferObject, BufferDescriptor&& bufferDescriptor,
+            uint32_t byteOffset) {
+        FILAMENT_CHECK_PRECONDITION(bufferDescriptor.buffer)
+                << "copyIntoBuffer called with a null buffer";
+        FILAMENT_CHECK_PRECONDITION(
+                bufferDescriptor.size + byteOffset <= gpuBufferObject->buffer.GetSize())
+                << "Attempting to copy " << bufferDescriptor.size << " bytes into a buffer of size "
+                << gpuBufferObject->buffer.GetSize() << " at offset " << byteOffset;
+
+        // TODO: All buffer objects are created with CopyDst usage.
+        // This may have some performance implications. That should be investigated later.
+        assert_invariant(gpuBufferObject->buffer.GetUsage() & wgpu::BufferUsage::CopyDst);
+
+        // WriteBuffer is an async call. But cpu buffer data is already written to the staging
+        // buffer on return from the WriteBuffer.
+        mQueue.WriteBuffer(gpuBufferObject->buffer, byteOffset, bufferDescriptor.buffer,
+                bufferDescriptor.size);
+        scheduleDestroy(std::move(bufferDescriptor));
+    }
 
     // the platform (e.g. OS) specific aspects of the WebGPU backend are strictly only
     // handled in the WebGPUPlatform
     WebGPUPlatform& mPlatform;
     wgpu::Adapter mAdapter = nullptr;
     wgpu::Device mDevice = nullptr;
-    uint32_t mMinUniformBufferOffsetAlignment;
     wgpu::Queue mQueue = nullptr;
     void* mNativeWindow = nullptr;
     WebGPUSwapChain* mSwapChain = nullptr;
@@ -72,12 +91,6 @@ private:
     wgpu::CommandEncoder mCommandEncoder = nullptr;
     wgpu::TextureView mTextureView = nullptr;
     wgpu::RenderPassEncoder mRenderPassEncoder = nullptr;
-    struct bgInfo{
-        wgpu::BindGroup bg;
-        size_t dynamicOffsetCount;
-        backend::DescriptorSetOffsetArray offsets;
-    };
-    std::array<bgInfo, MAX_DESCRIPTOR_SET_COUNT> currentDescriptorSets = {};
     wgpu::CommandBuffer mCommandBuffer = nullptr;
     WGPURenderTarget* mDefaultRenderTarget = nullptr;
 

filament/backend/src/webgpu/WebGPUHandles.cpp

@@ -20,12 +20,11 @@
 
 #include <utils/BitmaskEnum.h>
 #include <utils/Panic.h>
-#include <private/backend/BackendUtils.h>
+
 #include <webgpu/webgpu_cpp.h>
 
 #include <algorithm>
 #include <cstdint>
-#include <map>
 #include <utility>
 #include <vector>
 
@@ -42,6 +41,15 @@ constexpr wgpu::BufferUsage getBufferObjectUsage(
     }
 }
 
+wgpu::Buffer createBuffer(wgpu::Device const& device, wgpu::BufferUsage usage, uint32_t size,
+        char const* label) {
+    wgpu::BufferDescriptor descriptor{ .label = label,
+        .usage = usage,
+        .size = size,
+        .mappedAtCreation = false };
+    return device.CreateBuffer(&descriptor);
+}
+
 wgpu::VertexFormat getVertexFormat(filament::backend::ElementType type, bool normalized, bool integer) {
     using ElementType = filament::backend::ElementType;
     using VertexFormat = wgpu::VertexFormat;
@@ -69,7 +77,7 @@ wgpu::VertexFormat getVertexFormat(filament::backend::ElementType type, bool nor
             case ElementType::BYTE4: return VertexFormat::Snorm8x4;
             case ElementType::UBYTE4: return VertexFormat::Unorm8x4;
             case ElementType::SHORT4: return VertexFormat::Snorm16x4;
-            case ElementType::USHORT4: return VertexFormat::Unorm16x4;
+            case ElementType::USHORT4: return VertexFormat::Unorm8x4;
             default:
                 FILAMENT_CHECK_POSTCONDITION(false) << "Normalized format does not exist.";
                 return VertexFormat::Float32x3;
@@ -127,7 +135,7 @@ wgpu::StringView getUserTextureLabel(filament::backend::SamplerType target) {
         case SamplerType::SAMPLER_3D:
             return "a_3D_user_texture";
         case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            return "a_cube_map_array_user_texture";
+            return "a_cube_mape_array_user_texture";
     }
 }
 
@@ -146,7 +154,7 @@ wgpu::StringView getUserTextureViewLabel(filament::backend::SamplerType target)
         case SamplerType::SAMPLER_3D:
             return "a_3D_user_texture_view";
         case SamplerType::SAMPLER_CUBEMAP_ARRAY:
-            return "a_cube_map_array_user_texture_view";
+            return "a_cube_mape_array_user_texture_view";
     }
 }
 
@@ -154,129 +162,51 @@ wgpu::StringView getUserTextureViewLabel(filament::backend::SamplerType target)
 
 namespace filament::backend {
 
-void WGPUBufferBase::createBuffer(const wgpu::Device& device, wgpu::BufferUsage usage,
-        uint32_t size, const char* label) {
-    // Write size must be divisible by 4. If the whole buffer is written to as is common, so must
-    // the buffer size.
-    size += (4 - (size % 4)) % 4;
-    wgpu::BufferDescriptor descriptor{ .label = label,
-        .usage = usage,
-        .size = size,
-        .mappedAtCreation = false };
-    buffer = device.CreateBuffer(&descriptor);
-}
-
-void WGPUBufferBase::updateGPUBuffer(BufferDescriptor& bufferDescriptor, uint32_t byteOffset,
-        wgpu::Queue queue) {
-    FILAMENT_CHECK_PRECONDITION(bufferDescriptor.buffer)
-            << "copyIntoBuffer called with a null buffer";
-    FILAMENT_CHECK_PRECONDITION(bufferDescriptor.size + byteOffset <= buffer.GetSize())
-            << "Attempting to copy " << bufferDescriptor.size << " bytes into a buffer of size "
-            << buffer.GetSize() << " at offset " << byteOffset;
-    FILAMENT_CHECK_PRECONDITION(byteOffset % 4 == 0)
-            << "Byte offset must be a multiple of 4 but is " << byteOffset;
-
-    // TODO: All buffer objects are created with CopyDst usage.
-    // This may have some performance implications. That should be investigated later.
-    assert_invariant(buffer.GetUsage() & wgpu::BufferUsage::CopyDst);
-
-    size_t remainder = bufferDescriptor.size % 4;
-
-    // WriteBuffer is an async call. But cpu buffer data is already written to the staging
-    // buffer on return from the WriteBuffer.
-    auto legalSize = bufferDescriptor.size - remainder;
-    queue.WriteBuffer(buffer, byteOffset, bufferDescriptor.buffer, legalSize);
-    if (remainder != 0) {
-        const uint8_t* remainderStart =
-                static_cast<const uint8_t*>(bufferDescriptor.buffer) + legalSize;
-        memcpy(mRemainderChunk.data(), remainderStart, remainder);
-        // Pad the remainder with zeros to ensure deterministic behavior, though GPU shouldn't
-        // access this
-        std::memset(mRemainderChunk.data() + remainder, 0, 4 - remainder);
-
-        queue.WriteBuffer(buffer, byteOffset + legalSize, &mRemainderChunk, 4);
-    }
-}
-
 WGPUVertexBufferInfo::WGPUVertexBufferInfo(uint8_t bufferCount, uint8_t attributeCount,
         AttributeArray const& attributes)
-    : HwVertexBufferInfo(bufferCount, attributeCount) { // Base class constructor
-
+    : HwVertexBufferInfo(bufferCount, attributeCount),
+      mVertexBufferLayout(bufferCount),
+      mAttributes(bufferCount) {
     assert_invariant(attributeCount > 0);
-    // bufferCount is Filament's buffer count. The number of WebGPU slots might differ.
-
-    struct LayoutKey {
-        uint8_t filamentBufferIndex;
-        uint16_t stride;
-        bool operator<(const LayoutKey& other) const {
-            if (filamentBufferIndex != other.filamentBufferIndex) {
-                return filamentBufferIndex < other.filamentBufferIndex;
-            }
-            return stride < other.stride;
-        }
-    };
-    std::map<LayoutKey, uint32_t> layoutKeyToWebGPUSlot;
-    uint32_t nextWebGPUSlot = 0;
-
+    assert_invariant(bufferCount > 0);
     for (uint32_t attribIndex = 0; attribIndex < attributes.size(); attribIndex++) {
         Attribute const& attrib = attributes[attribIndex];
-        // Ignore attributes not bound to any vertex buffer.
+        // Ignore the attributes which are not bind to vertex buffers.
         if (attrib.buffer == Attribute::BUFFER_UNUSED) {
             continue;
         }
 
-        assert_invariant(attrib.buffer < bufferCount); // Ensure Filament buffer index is valid
-
-        LayoutKey key = {attrib.buffer, attrib.stride};
-        uint32_t currentWebGPUSlot;
-
-        auto it = layoutKeyToWebGPUSlot.find(key);
-        if (it == layoutKeyToWebGPUSlot.end()) {
-            currentWebGPUSlot = nextWebGPUSlot++;
-            layoutKeyToWebGPUSlot[key] = currentWebGPUSlot;
-
-            mActualWebGPULayouts.emplace_back();
-            mActualWebGPULayouts.back().arrayStride = attrib.stride;
-            mActualWebGPULayouts.back().stepMode = wgpu::VertexStepMode::Vertex;
-            // .attributes and .attributeCount will be set later
-
-            mSlotMappings.emplace_back(SlotMapping{attrib.buffer});
-            mActualWebGPUAttributes.emplace_back(); // Add a new vector for this slot's attributes
-        } else {
-            currentWebGPUSlot = it->second;
-            // Sanity check: if we found an existing slot for this key, its stride should match.
-            assert_invariant(mActualWebGPULayouts[currentWebGPUSlot].arrayStride == attrib.stride);
-        }
-
+        assert_invariant(attrib.buffer < bufferCount);
         bool const isInteger = attrib.flags & Attribute::FLAG_INTEGER_TARGET;
         bool const isNormalized = attrib.flags & Attribute::FLAG_NORMALIZED;
         wgpu::VertexFormat vertexFormat = getVertexFormat(attrib.type, isNormalized, isInteger);
 
-        mActualWebGPUAttributes[currentWebGPUSlot].push_back({
+        // Attributes are sequential per buffer
+        mAttributes[attrib.buffer].push_back({
             .format = vertexFormat,
             .offset = attrib.offset,
-            .shaderLocation = attribIndex, // Use original attribIndex as shaderLocation
+            .shaderLocation = attribIndex,
         });
+
+        mVertexBufferLayout[attrib.buffer].stepMode = wgpu::VertexStepMode::Vertex;
+        if (mVertexBufferLayout[attrib.buffer].arrayStride == 0) {
+            mVertexBufferLayout[attrib.buffer].arrayStride = attrib.stride;
+        } else {
+            assert_invariant(mVertexBufferLayout[attrib.buffer].arrayStride == attrib.stride);
+        }
     }
 
-    // Finalize attribute pointers and counts in mActualWebGPULayouts
-    for (uint32_t slot = 0; slot < mActualWebGPULayouts.size(); ++slot) {
-        if (!mActualWebGPUAttributes[slot].empty()) {
-            mActualWebGPULayouts[slot].attributeCount = mActualWebGPUAttributes[slot].size();
-            mActualWebGPULayouts[slot].attributes = mActualWebGPUAttributes[slot].data();
-        } else {
-            mActualWebGPULayouts[slot].attributeCount = 0;
-            mActualWebGPULayouts[slot].attributes = nullptr;
-        }
+    for (uint32_t bufferIndex = 0; bufferIndex < bufferCount; bufferIndex++) {
+        mVertexBufferLayout[bufferIndex].attributeCount = mAttributes[bufferIndex].size();
+        mVertexBufferLayout[bufferIndex].attributes = mAttributes[bufferIndex].data();
     }
 }
 
 WGPUIndexBuffer::WGPUIndexBuffer(wgpu::Device const& device, uint8_t elementSize,
         uint32_t indexCount)
-    : indexFormat(elementSize == 2 ? wgpu::IndexFormat::Uint16 : wgpu::IndexFormat::Uint32) {
-    createBuffer(device, wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Index,
-            elementSize * indexCount, "index_buffer");
-}
+    : buffer(createBuffer(device, wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Index,
+              elementSize * indexCount, "index_buffer")),
+      indexFormat(elementSize == 2 ? wgpu::IndexFormat::Uint16 : wgpu::IndexFormat::Uint32) {}
 
 
 WGPUVertexBuffer::WGPUVertexBuffer(wgpu::Device const& device, uint32_t vertexCount,
@@ -287,10 +217,10 @@ WGPUVertexBuffer::WGPUVertexBuffer(wgpu::Device const& device, uint32_t vertexCo
 
 WGPUBufferObject::WGPUBufferObject(wgpu::Device const& device, BufferObjectBinding bindingType,
         uint32_t byteCount)
-    : HwBufferObject(byteCount) {
-    createBuffer(device, wgpu::BufferUsage::CopyDst | getBufferObjectUsage(bindingType), byteCount,
-            "buffer_object");
-}
+    : HwBufferObject(byteCount),
+      buffer(createBuffer(device, wgpu::BufferUsage::CopyDst | getBufferObjectUsage(bindingType),
+              byteCount, "buffer_object")),
+      bufferObjectBinding(bindingType) {}
 
 wgpu::ShaderStage WebGPUDescriptorSetLayout::filamentStageToWGPUStage(ShaderStageFlags fFlags) {
     wgpu::ShaderStage retStages = wgpu::ShaderStage::None;
@@ -325,7 +255,8 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&
 
     unsigned int samplerCount =
             std::count_if(layout.bindings.begin(), layout.bindings.end(), [](auto& fEntry) {
-                return DescriptorSetLayoutBinding::isSampler(fEntry.type);
+                return fEntry.type == DescriptorType::SAMPLER ||
+                       fEntry.type == DescriptorType::SAMPLER_EXTERNAL;
             });
 
 
@@ -341,44 +272,26 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&
         entryInfo.binding = wEntry.binding;
 
         switch (fEntry.type) {
-            case DescriptorType::SAMPLER_2D_FLOAT:
-            case DescriptorType::SAMPLER_2D_INT:
-            case DescriptorType::SAMPLER_2D_UINT:
-            case DescriptorType::SAMPLER_2D_DEPTH:
-            case DescriptorType::SAMPLER_2D_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_ARRAY_UINT:
-            case DescriptorType::SAMPLER_2D_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_INT:
-            case DescriptorType::SAMPLER_CUBE_UINT:
-            case DescriptorType::SAMPLER_CUBE_DEPTH:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_INT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_UINT:
-            case DescriptorType::SAMPLER_CUBE_ARRAY_DEPTH:
-            case DescriptorType::SAMPLER_3D_FLOAT:
-            case DescriptorType::SAMPLER_3D_INT:
-            case DescriptorType::SAMPLER_3D_UINT:
-            case DescriptorType::SAMPLER_2D_MS_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_INT:
-            case DescriptorType::SAMPLER_2D_MS_UINT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_FLOAT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_INT:
-            case DescriptorType::SAMPLER_2D_MS_ARRAY_UINT: {
+            case DescriptorType::SAMPLER_EXTERNAL:
+            case DescriptorType::SAMPLER: {
                 auto& samplerEntry = wEntries.emplace_back();
                 auto& samplerEntryInfo = mBindGroupEntries.emplace_back();
                 samplerEntry.binding = fEntry.binding * 2 + 1;
                 samplerEntryInfo.binding = samplerEntry.binding;
+                samplerEntryInfo.type = WebGPUDescriptorSetLayout::BindGroupEntryType::SAMPLER;
                 samplerEntry.visibility = wEntry.visibility;
-                wEntry.texture.multisampled = isMultiSampledTypeDescriptor(fEntry.type);
-                // TODO: Set once we have the filtering values
-                if (isDepthDescriptor(fEntry.type)) {
-                    samplerEntry.sampler.type = wgpu::SamplerBindingType::Comparison;
+                // We are simply hoping that undefined and defaults suffices here.
+                samplerEntry.sampler.type = wgpu::SamplerBindingType::NonFiltering; // Example default
+                wEntry.texture.sampleType = wgpu::TextureSampleType::Float;      // Example default
+                // TODO: FIX! THIS IS HACK FOR HELLO-TRIANGLE!
+                if (baseLabel.find("Skybox") != std::string::npos ||
+                        (baseLabel == "Filament Default Material_perView" && wEntry.binding == 22)) {
+                    wEntry.texture.viewDimension = wgpu::TextureViewDimension::Cube;
                 } else {
-                    samplerEntry.sampler.type =
-                            wgpu::SamplerBindingType::NonFiltering;
+                    wEntry.texture.viewDimension =
+                            wgpu::TextureViewDimension::e2D;// Example default
                 }
+                entryInfo.type = WebGPUDescriptorSetLayout::BindGroupEntryType::TEXTURE_VIEW;
                 break;
             }
             case DescriptorType::UNIFORM_BUFFER: {
@@ -389,6 +302,7 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&
                 // TODO: Ideally we fill minBindingSize
                 break;
             }
+
             case DescriptorType::INPUT_ATTACHMENT: {
                 PANIC_POSTCONDITION("Input Attachment is not supported");
                 break;
@@ -397,48 +311,6 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&
                 PANIC_POSTCONDITION("Shader storage is not supported");
                 break;
             }
-            case DescriptorType::SAMPLER_EXTERNAL: {
-                PANIC_POSTCONDITION("External Sampler is not supported");
-                break;
-            }
-        }
-        if (isDepthDescriptor(fEntry.type))
-        {
-            wEntry.texture.sampleType = wgpu::TextureSampleType::Depth;
-        }
-        else if (isFloatDescriptor(fEntry.type))
-        {
-            // TODO: Set once we have the filtering values
-            wEntry.texture.sampleType = wgpu::TextureSampleType::UnfilterableFloat;
-        }
-        else if (isIntDescriptor(fEntry.type))
-        {
-            wEntry.texture.sampleType = wgpu::TextureSampleType::Sint;
-        }
-        else if (isUnsignedIntDescriptor(fEntry.type))
-        {
-            wEntry.texture.sampleType = wgpu::TextureSampleType::Uint;
-        }
-
-        if (is3dTypeDescriptor(fEntry.type))
-        {
-            wEntry.texture.viewDimension = wgpu::TextureViewDimension::e3D;
-        }
-        else if (is2dTypeDescriptor(fEntry.type))
-        {
-            wEntry.texture.viewDimension = wgpu::TextureViewDimension::e2D;
-        }
-        else if (is2dArrayTypeDescriptor(fEntry.type))
-        {
-            wEntry.texture.viewDimension = wgpu::TextureViewDimension::e2DArray;
-        }
-        else if (isCubeTypeDescriptor(fEntry.type))
-        {
-            wEntry.texture.viewDimension = wgpu::TextureViewDimension::Cube;
-        }
-        else if (isCubeArrayTypeDescriptor(fEntry.type))
-        {
-            wEntry.texture.viewDimension = wgpu::TextureViewDimension::CubeArray;
         }
         // fEntry.count is unused currently
     }
@@ -453,26 +325,114 @@ WebGPUDescriptorSetLayout::WebGPUDescriptorSetLayout(DescriptorSetLayout const&
 
 WebGPUDescriptorSetLayout::~WebGPUDescriptorSetLayout() {}
 
+wgpu::Buffer WebGPUDescriptorSet::sDummyUniformBuffer = nullptr;
+wgpu::Texture WebGPUDescriptorSet::sDummyTexture = nullptr;
+wgpu::TextureView WebGPUDescriptorSet::sDummyTextureView = nullptr;
+wgpu::Sampler WebGPUDescriptorSet::sDummySampler = nullptr;
+
+void WebGPUDescriptorSet::initializeDummyResourcesIfNotAlready(wgpu::Device const& device,
+        wgpu::TextureFormat aColorFormat) {
+    if (!sDummyUniformBuffer) {
+        wgpu::BufferDescriptor bufferDescriptor{
+            .label = "dummy_uniform_not_to_be_used",
+            .usage = wgpu::BufferUsage::Uniform,
+            .size = 4
+        };
+        sDummyUniformBuffer = device.CreateBuffer(&bufferDescriptor);
+        FILAMENT_CHECK_POSTCONDITION(sDummyUniformBuffer)
+                << "Failed to create dummy uniform buffer?";
+    }
+    if (!sDummyTexture || !sDummyTextureView) {
+        wgpu::TextureDescriptor textureDescriptor{
+            .label = "dummy_texture_not_to_be_used",
+            .usage = wgpu::TextureUsage::TextureBinding,
+            .dimension = wgpu::TextureDimension::e2D,
+            .size = wgpu::Extent3D{ .width = 4, .height = 4, .depthOrArrayLayers = 1 },
+            .format = aColorFormat,
+        };
+        if (!sDummyTexture) {
+            sDummyTexture = device.CreateTexture(&textureDescriptor);
+            FILAMENT_CHECK_POSTCONDITION(sDummyUniformBuffer) << "Failed to create dummy texture?";
+        }
+        if (!sDummyTextureView) {
+            wgpu::TextureViewDescriptor textureViewDescriptor{
+                .label = "dummy_texture_view_not_to_be_used"
+            };
+            sDummyTextureView = sDummyTexture.CreateView(&textureViewDescriptor);
+            FILAMENT_CHECK_POSTCONDITION(sDummyUniformBuffer)
+                    << "Failed to create dummy texture view?";
+        }
+    }
+    if (!sDummySampler) {
+        wgpu::SamplerDescriptor samplerDescriptor{
+            .label = "dummy_sampler_not_to_be_used"
+        };
+        sDummySampler = device.CreateSampler(&samplerDescriptor);
+        FILAMENT_CHECK_POSTCONDITION(sDummyUniformBuffer) << "Failed to create dummy sampler?";
+    }
+}
+
+std::vector<wgpu::BindGroupEntry> WebGPUDescriptorSet::createDummyEntriesSortedByBinding(
+        std::vector<filament::backend::WebGPUDescriptorSetLayout::BindGroupEntryInfo> const&
+                bindGroupEntries) {
+    assert_invariant(WebGPUDescriptorSet::sDummyUniformBuffer &&
+                     "Dummy uniform buffer must have been created before "
+                     "creating dummy bind group entries.");
+    assert_invariant(
+            WebGPUDescriptorSet::sDummyTexture &&
+            "Dummy texture must have been created before creating dummy bind group entries.");
+    assert_invariant(
+            WebGPUDescriptorSet::sDummyTextureView &&
+            "Dummy texture view must have been created before creating dummy bind group entries.");
+    assert_invariant(
+            WebGPUDescriptorSet::sDummySampler &&
+            "Dummy sampler must have been created before creating dummy bind group entries.");
+    using filament::backend::WebGPUDescriptorSetLayout;
+    std::vector<wgpu::BindGroupEntry> entries;
+    entries.reserve(bindGroupEntries.size());
+    for (auto const& entryInfo: bindGroupEntries) {
+        auto& entry = entries.emplace_back();
+        entry.binding = entryInfo.binding;
+        switch (entryInfo.type) {
+            case WebGPUDescriptorSetLayout::BindGroupEntryType::UNIFORM_BUFFER:
+                entry.buffer = WebGPUDescriptorSet::sDummyUniformBuffer;
+                break;
+            case WebGPUDescriptorSetLayout::BindGroupEntryType::TEXTURE_VIEW:
+                entry.textureView = WebGPUDescriptorSet::sDummyTextureView;
+                break;
+            case WebGPUDescriptorSetLayout::BindGroupEntryType::SAMPLER:
+                entry.sampler = WebGPUDescriptorSet::sDummySampler;
+                break;
+        }
+    }
+    std::sort(entries.begin(), entries.end(),
+            [](wgpu::BindGroupEntry const& a, wgpu::BindGroupEntry const& b) {
+                return a.binding < b.binding;
+            });
+    return entries;
+}
+
 WebGPUDescriptorSet::WebGPUDescriptorSet(wgpu::BindGroupLayout const& layout,
         std::vector<WebGPUDescriptorSetLayout::BindGroupEntryInfo> const& bindGroupEntries)
     : mLayout(layout),
-      mEntriesWithDynamicOffsetsCount(std::count_if(bindGroupEntries.begin(),
-              bindGroupEntries.end(), [](auto const& entry) { return entry.hasDynamicOffset; })) {
-
-    mEntries.resize(bindGroupEntries.size());
-    for (size_t i = 0; i < bindGroupEntries.size(); ++i) {
-        mEntries[i].binding = bindGroupEntries[i].binding;
-    }
+      mEntriesSortedByBinding(createDummyEntriesSortedByBinding(bindGroupEntries)) {
     // Establish the size of entries based on the layout. This should be reliable and efficient.
     assert_invariant(INVALID_INDEX > mEntryIndexByBinding.size());
     for (size_t i = 0; i < mEntryIndexByBinding.size(); i++) {
         mEntryIndexByBinding[i] = INVALID_INDEX;
     }
-    for (size_t index = 0; index < mEntries.size(); index++) {
-        wgpu::BindGroupEntry const& entry = mEntries[index];
+    for (size_t index = 0; index < mEntriesSortedByBinding.size(); index++) {
+        wgpu::BindGroupEntry const& entry = mEntriesSortedByBinding[index];
         assert_invariant(entry.binding < mEntryIndexByBinding.size());
         mEntryIndexByBinding[entry.binding] = static_cast<uint8_t>(index);
     }
+    for (auto const& entry : bindGroupEntries) {
+        if (entry.hasDynamicOffset) {
+            assert_invariant(entry.binding < mEntriesByBindingWithDynamicOffsets.size());
+            mEntriesByBindingWithDynamicOffsets[entry.binding] = true;
+        }
+    }
+    mDynamicOffsets.reserve(mEntriesSortedByBinding.size());
 }
 
 WebGPUDescriptorSet::~WebGPUDescriptorSet() {
@@ -487,15 +447,15 @@ wgpu::BindGroup WebGPUDescriptorSet::lockAndReturn(const wgpu::Device& device) {
     // TODO label? Should we just copy layout label?
     wgpu::BindGroupDescriptor desc{
         .layout = mLayout,
-        .entryCount = mEntries.size(),
-        .entries = mEntries.data()
+        .entryCount = mEntriesSortedByBinding.size(),
+        .entries = mEntriesSortedByBinding.data()
     };
     mBindGroup = device.CreateBindGroup(&desc);
     FILAMENT_CHECK_POSTCONDITION(mBindGroup) << "Failed to create bind group?";
     // once we have created the bind group itself we should no longer need any other state
     mLayout = nullptr;
-    mEntries.clear();
-    mEntries.shrink_to_fit();
+    mEntriesSortedByBinding.clear();
+    mEntriesSortedByBinding.shrink_to_fit();
     return mBindGroup;
 }
 
@@ -513,14 +473,34 @@ void WebGPUDescriptorSet::addEntry(unsigned int index, wgpu::BindGroupEntry&& en
             << index;
     uint8_t entryIndex = mEntryIndexByBinding[index];
     FILAMENT_CHECK_POSTCONDITION(
-            entryIndex != INVALID_INDEX && entryIndex < mEntries.size())
+            entryIndex != INVALID_INDEX && entryIndex < mEntriesSortedByBinding.size())
             << "Invalid binding " << index;
     entry.binding = index;
-    mEntries[entryIndex] = std::move(entry);
+    mEntriesSortedByBinding[entryIndex] = std::move(entry);
+    mEntriesByBindingAdded[index] = true;
+}
+
+uint32_t const* WebGPUDescriptorSet::setDynamicOffsets(uint32_t const* offsets) {
+    // mDynamicOffsets already reserves enough memory for the number of entries in the set
+    mDynamicOffsets.clear();
+    // this implementation copies the offsets to mDynamicOffsets, but also adds values for
+    // unused entries TODO: is this necessary?
+    size_t inputIndex = 0;
+    size_t outputIndex = 0;
+    for (auto const& entry : mEntriesSortedByBinding) {
+        if (mEntriesByBindingWithDynamicOffsets[entry.binding]) {
+            if (mEntriesByBindingAdded[entry.binding]) {
+                mDynamicOffsets[outputIndex++] = offsets[inputIndex++];
+            } else {
+                mDynamicOffsets[outputIndex++] = 0; // dummy offset, as it was never added
+            }
+        }
+    }
+    return mDynamicOffsets.data();
 }
 
 size_t WebGPUDescriptorSet::countEntitiesWithDynamicOffsets() const {
-    return mEntriesWithDynamicOffsetsCount;
+    return mEntriesByBindingWithDynamicOffsets.count();
 }
 
 WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat format, uint8_t samples,
@@ -537,8 +517,6 @@ WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat forma
     mUsage = fToWGPUTextureUsage(usage);
     mFormat = fToWGPUTextureFormat(format);
     mAspect = fToWGPUTextureViewAspect(usage, format);
-    mBlockWidth = filament::backend::getBlockWidth(format);
-    mBlockHeight = filament::backend::getBlockHeight(format);
     wgpu::TextureDescriptor textureDescriptor{
         .label = getUserTextureLabel(target),
         .usage = mUsage,
@@ -585,10 +563,6 @@ WGPUTexture::WGPUTexture(SamplerType target, uint8_t levels, TextureFormat forma
 
 WGPUTexture::WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept {
     mTexture = src->mTexture;
-    mAspect = src->mAspect;
-    mBlockWidth = src->mBlockWidth;
-    mBlockHeight = src->mBlockHeight;
-
     mTexView = makeTextureView(baseLevel, levelCount, target);
 }
 
@@ -958,147 +932,58 @@ wgpu::TextureView WGPUTexture::makeTextureView(const uint8_t& baseLevel, const u
     return textureView;
 }
 
-WGPURenderTarget::WGPURenderTarget(uint32_t width, uint32_t height, uint8_t samples,
-        const MRT& colorAttachmentsMRT,
-        const Attachment& depthAttachmentInfo,
-        const Attachment& stencilAttachmentInfo)
-    : HwRenderTarget(width, height),
-      defaultRenderTarget(false),
-      samples(samples),
-      mColorAttachments(colorAttachmentsMRT),
-      mDepthAttachment(depthAttachmentInfo),
-      mStencilAttachment(stencilAttachmentInfo) {
-    mColorAttachmentDescriptors.reserve(MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
-}
+WGPURenderTarget::Attachment WGPURenderTarget::getDrawColorAttachment(size_t index) {
+    assert_invariant( index < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT);
+    auto result = color[index];
+    if (index == 0 && defaultRenderTarget) {
 
-// Static helper to map MRT index to TargetBufferFlags
-TargetBufferFlags WGPURenderTarget::getTargetBufferFlagsAt(int mrtIndex) {
-    if (mrtIndex < 0 || mrtIndex >= MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT) {
-        return TargetBufferFlags::NONE;
     }
-    // This mapping assumes TargetBufferFlags::COLOR_0, COLOR_1 etc. are contiguous
-    return static_cast<TargetBufferFlags>(
-            static_cast<uint32_t>(TargetBufferFlags::COLOR0) << mrtIndex);
+
+    return result;
 }
 
-// Corrected getLoadOperation
 wgpu::LoadOp WGPURenderTarget::getLoadOperation(RenderPassParams const& params,
-                                                TargetBufferFlags bufferToOperateOn) {
-    if (any(params.flags.clear & bufferToOperateOn)) {
+                                             TargetBufferFlags buffer) {
+    auto clearFlags = params.flags.clear;
+    auto discardStartFlags = params.flags.discardStart;
+    if (any(clearFlags & buffer)) {
+        return wgpu::LoadOp::Clear;
+    } else if (any(discardStartFlags & buffer)) {
         return wgpu::LoadOp::Clear;
-    }
-    if (any(params.flags.discardStart & bufferToOperateOn)) {
-        return wgpu::LoadOp::Clear; // Or wgpu::LoadOp::Undefined if clear is not desired on discard
     }
     return wgpu::LoadOp::Load;
 }
 
-// Corrected getStoreOperation
 wgpu::StoreOp WGPURenderTarget::getStoreOperation(RenderPassParams const& params,
-                                                  TargetBufferFlags bufferToOperateOn) {
-    if (any(params.flags.discardEnd & bufferToOperateOn)) {
+                                               TargetBufferFlags buffer) {
+    const auto discardEndFlags = params.flags.discardEnd;
+    if (any(discardEndFlags & buffer)) {
         return wgpu::StoreOp::Discard;
     }
     return wgpu::StoreOp::Store;
 }
-
-void WGPURenderTarget::setUpRenderPassAttachments(
-        wgpu::RenderPassDescriptor& descriptor,
-        RenderPassParams const& params,
-        wgpu::TextureView const& defaultColorTextureView,
-        wgpu::TextureView const& defaultDepthStencilTextureView,
-        wgpu::TextureView const* customColorTextureViews,
-        uint32_t customColorTextureViewCount,
-        wgpu::TextureView const& customDepthTextureView,
-        wgpu::TextureView const& customStencilTextureView) {
-    mColorAttachmentDescriptors.clear();
-    mHasDepthStencilAttachment = false;
-
-    if (defaultRenderTarget) {
-        assert_invariant(defaultColorTextureView);
-        wgpu::RenderPassColorAttachment colorAttDesc{};
-        colorAttDesc.view = defaultColorTextureView;
-        colorAttDesc.resolveTarget = nullptr;
-        colorAttDesc.loadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::COLOR0);
-        colorAttDesc.storeOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::COLOR0);
-        colorAttDesc.clearValue = {params.clearColor.r, params.clearColor.g,
-                                   params.clearColor.b, params.clearColor.a};
-        mColorAttachmentDescriptors.push_back(colorAttDesc);
-
-        if (defaultDepthStencilTextureView) {
-            mDepthStencilAttachmentDescriptor = {
-                .view = defaultDepthStencilTextureView,
-                .depthLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH),
-                .depthStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH),
-                .depthClearValue = static_cast<float>(params.clearDepth),
-                .depthReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0,
-                .stencilLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL),
-                .stencilStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL),
-                .stencilClearValue = params.clearStencil,
-                .stencilReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0,
-            };
-            mHasDepthStencilAttachment = true;
-        }
-    } else { // Custom Render Target
-        for (uint32_t i = 0; i < customColorTextureViewCount; ++i) {
-            if (customColorTextureViews[i]) {
-                wgpu::RenderPassColorAttachment colorAttDesc{};
-                colorAttDesc.view = customColorTextureViews[i];
-                colorAttDesc.resolveTarget = nullptr; // TODO: MSAA resolve for custom RT
-                colorAttDesc.loadOp = WGPURenderTarget::getLoadOperation(params, getTargetBufferFlagsAt(i));
-                colorAttDesc.storeOp = WGPURenderTarget::getStoreOperation(params, getTargetBufferFlagsAt(i));
-                colorAttDesc.clearValue = {params.clearColor.r, params.clearColor.g,
-                                           params.clearColor.b, params.clearColor.a};
-                mColorAttachmentDescriptors.push_back(colorAttDesc);
-            }
-        }
-
-        wgpu::TextureView combinedDsView = customDepthTextureView ? customDepthTextureView : customStencilTextureView;
-
-        if (combinedDsView) {
-            mDepthStencilAttachmentDescriptor = {};
-            mDepthStencilAttachmentDescriptor.view = combinedDsView;
-
-            if (customDepthTextureView) {
-                mDepthStencilAttachmentDescriptor.depthLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::DEPTH);
-                mDepthStencilAttachmentDescriptor.depthStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::DEPTH);
-                mDepthStencilAttachmentDescriptor.depthClearValue = static_cast<float>(params.clearDepth);
-                mDepthStencilAttachmentDescriptor.depthReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_DEPTH) > 0;
-            } else {
-                mDepthStencilAttachmentDescriptor.depthLoadOp = wgpu::LoadOp::Undefined;
-                mDepthStencilAttachmentDescriptor.depthStoreOp = wgpu::StoreOp::Undefined;
-                mDepthStencilAttachmentDescriptor.depthReadOnly = true;
-            }
-
-            if (customStencilTextureView) {
-                mDepthStencilAttachmentDescriptor.stencilLoadOp = WGPURenderTarget::getLoadOperation(params, TargetBufferFlags::STENCIL);
-                mDepthStencilAttachmentDescriptor.stencilStoreOp = WGPURenderTarget::getStoreOperation(params, TargetBufferFlags::STENCIL);
-                mDepthStencilAttachmentDescriptor.stencilClearValue = params.clearStencil;
-                mDepthStencilAttachmentDescriptor.stencilReadOnly = (params.readOnlyDepthStencil & RenderPassParams::READONLY_STENCIL) > 0;
-            } else {
-                mDepthStencilAttachmentDescriptor.stencilLoadOp = wgpu::LoadOp::Undefined;
-                mDepthStencilAttachmentDescriptor.stencilStoreOp = wgpu::StoreOp::Undefined;
-                mDepthStencilAttachmentDescriptor.stencilReadOnly = true;
-            }
-            mHasDepthStencilAttachment = true;
-        }
+void WGPURenderTarget::setUpRenderPassAttachments(wgpu::RenderPassDescriptor& descriptor,
+        wgpu::TextureView const& textureView, RenderPassParams const& params) {
+    // auto discardFlags = params.flags.discardEnd;
+    // (void) discardFlags;
+    // std::vector<wgpu::RenderPassColorAttachment> colorAttachments;
+    colorAttachments.clear();
+    for (size_t i = 0; i < 1/*MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT*/; i++) {
+        // auto attachment = getDrawColorAttachment(i);
+        // if (attachment) {
+            wgpu::RenderPassColorAttachment colorAttachment;
+            colorAttachment.view = textureView;
+            colorAttachment.loadOp  = getLoadOperation(params, getTargetBufferFlagsAt(i));
+            colorAttachment.storeOp = getStoreOperation(params, getTargetBufferFlagsAt(i));
+            colorAttachment.clearValue = { params.clearColor.r, params.clearColor.g, params.clearColor.b, params.clearColor.a };
+            colorAttachments.emplace_back(colorAttachment);
+        // }
     }
-
-    descriptor.colorAttachmentCount = mColorAttachmentDescriptors.size();
-    descriptor.colorAttachments = mColorAttachmentDescriptors.data();
-    descriptor.depthStencilAttachment = mHasDepthStencilAttachment ? &mDepthStencilAttachmentDescriptor : nullptr;
-    // descriptor.sampleCount was removed from the core spec. If your webgpu.h still has it,
-    // and your Dawn version expects it, you might need to set it here based on this->samples.
-    // e.g., descriptor.sampleCount = this->samples;
+    descriptor.colorAttachments = colorAttachments.data();
+    descriptor.colorAttachmentCount = colorAttachments.size();
+    descriptor.depthStencilAttachment = nullptr;
+    descriptor.timestampWrites = nullptr;
 }
 
-math::uint2 WGPURenderTarget::getAttachmentSize() const noexcept {
-    if (!defaultRenderTarget) {
-        return {width, height};
-    }
-    // For default RT, size is dynamic and usually obtained from the swapchain.
-    // The caller (WebGPUDriver::beginRenderPass) should know the current swapchain size.
-    return {0,0};
-}
 
 }// namespace filament::backend

filament/backend/src/webgpu/WebGPUHandles.h

@@ -28,6 +28,7 @@
 #include <webgpu/webgpu_cpp.h>
 
 #include <array>
+#include <bitset>
 #include <cstdint>
 #include <vector>
 
@@ -43,6 +44,7 @@ public:
     std::vector<wgpu::ConstantEntry> constants;
 };
 
+struct WGPUBufferObject;
 
 // VertexBufferInfo contains layout info for Vertex Buffer based on WebGPU structs. In WebGPU each
 // VertexBufferLayout is associated with a single vertex buffer. So number of mVertexBufferLayout
@@ -52,40 +54,30 @@ class WGPUVertexBufferInfo : public HwVertexBufferInfo {
 public:
     WGPUVertexBufferInfo(uint8_t bufferCount, uint8_t attributeCount,
             AttributeArray const& attributes);
-
-    // Returns the WebGPU native vertex buffer layouts
-    inline wgpu::VertexBufferLayout const* getWebGPULayouts() const {
-        return mActualWebGPULayouts.data();
+    inline  wgpu::VertexBufferLayout const* getVertexBufferLayout() const {
+        return mVertexBufferLayout.data();
     }
 
-    // Returns the count of WebGPU native vertex buffer layouts
-    inline uint32_t getWebGPULayoutCount() const {
-        return mActualWebGPULayouts.size();
+    inline uint32_t getVertexBufferLayoutSize() const {
+        return mVertexBufferLayout.size();
     }
 
-    // Returns the Filament buffer index for a given WebGPU layout slot
-    inline uint8_t getFilamentBufferIndexForSlot(uint32_t webgpuSlotIndex) const {
-        assert_invariant(webgpuSlotIndex < mSlotMappings.size());
-        return mSlotMappings[webgpuSlotIndex].filamentBufferIndex;
+    inline wgpu::VertexAttribute const* getVertexAttributeForIndex(uint32_t index) const {
+        assert_invariant(index < mAttributes.size());
+        return mAttributes[index].data();
+    }
+
+    inline uint32_t getVertexAttributeSize(uint32_t index) const {
+        assert_invariant(index < mAttributes.size());
+        return mAttributes[index].size();
     }
 
 private:
-    // Stores the final WebGPU vertex buffer layouts
-    std::vector<wgpu::VertexBufferLayout> mActualWebGPULayouts;
-    // Stores attributes per WebGPU layout, parallel to mActualWebGPULayouts.
-    // Each wgpu::VertexBufferLayout in mActualWebGPULayouts will point to its attributes here.
-    std::vector<std::vector<wgpu::VertexAttribute>> mActualWebGPUAttributes;
-
-    struct SlotMapping {
-        uint8_t filamentBufferIndex; // Original Filament buffer index for this WebGPU slot
-    };
-    // Maps a WebGPU slot index to its original Filament buffer index
-    std::vector<SlotMapping> mSlotMappings;
-
-    // Remove or comment out old members if they were similarly named:
-    // std::vector<wgpu::VertexBufferLayout> mVertexBufferLayout {}; // OLD
-    // std::vector<std::vector<wgpu::VertexAttribute>> mAttributes {}; // OLD
+    // TODO: can we do better in terms on heap management.
+    std::vector<wgpu::VertexBufferLayout> mVertexBufferLayout{};
+    std::vector<std::vector<wgpu::VertexAttribute>> mAttributes{};
 };
+
 struct WGPUVertexBuffer : public HwVertexBuffer {
     WGPUVertexBuffer(wgpu::Device const &device, uint32_t vertexCount, uint32_t bufferCount,
                      Handle<HwVertexBufferInfo> vbih);
@@ -94,37 +86,33 @@ struct WGPUVertexBuffer : public HwVertexBuffer {
     utils::FixedCapacityVector<wgpu::Buffer> buffers;
 };
 
-class WGPUBufferBase {
-public:
-    void createBuffer(wgpu::Device const& device, wgpu::BufferUsage usage, uint32_t size,
-            char const* label);
-    void updateGPUBuffer(BufferDescriptor& bufferDescriptor, uint32_t byteOffset,
-            wgpu::Queue queue);
-    const wgpu::Buffer& getBuffer() const { return buffer; }
-protected:
-    wgpu::Buffer buffer;
-private:
-    // 4 bytes to hold any extra chunk we need.
-    std::array<uint8_t,4> mRemainderChunk;
-};
-
-class WGPUIndexBuffer : public HwIndexBuffer, public WGPUBufferBase {
-public:
+struct WGPUIndexBuffer : public HwIndexBuffer {
     WGPUIndexBuffer(wgpu::Device const &device, uint8_t elementSize,
                     uint32_t indexCount);
+
+    wgpu::Buffer buffer;
     wgpu::IndexFormat indexFormat;
 };
 
-class WGPUBufferObject : public HwBufferObject, public WGPUBufferBase {
-public:
+struct WGPUBufferObject : HwBufferObject {
     WGPUBufferObject(wgpu::Device const &device, BufferObjectBinding bindingType, uint32_t byteCount);
+
+    wgpu::Buffer buffer = nullptr;
+    const BufferObjectBinding bufferObjectBinding;
 };
 
 class WebGPUDescriptorSetLayout final : public HwDescriptorSetLayout {
 public:
 
+    enum class BindGroupEntryType : uint8_t {
+        UNIFORM_BUFFER,
+        TEXTURE_VIEW,
+        SAMPLER
+    };
+
     struct BindGroupEntryInfo final {
         uint8_t binding = 0;
+        BindGroupEntryType type = BindGroupEntryType::UNIFORM_BUFFER;
         bool hasDynamicOffset = false;
     };
 
@@ -137,7 +125,7 @@ public:
 
 private:
     // TODO: If this is useful elsewhere, remove it from this class
-    // Convert Filament Shader Stage Flags bitmask to webgpu equivalent
+    // Convert Filament Shader Stage Flags bitmask to webgpu equivilant
     static wgpu::ShaderStage filamentStageToWGPUStage(ShaderStageFlags fFlags);
     std::vector<BindGroupEntryInfo> mBindGroupEntries;
     wgpu::BindGroupLayout mLayout;
@@ -145,6 +133,8 @@ private:
 
 class WebGPUDescriptorSet final : public HwDescriptorSet {
 public:
+    static void initializeDummyResourcesIfNotAlready(wgpu::Device const&,
+            wgpu::TextureFormat aColorFormat);
 
     WebGPUDescriptorSet(wgpu::BindGroupLayout const& layout,
             std::vector<WebGPUDescriptorSetLayout::BindGroupEntryInfo> const& bindGroupEntries);
@@ -152,15 +142,30 @@ public:
 
     wgpu::BindGroup lockAndReturn(wgpu::Device const&);
     void addEntry(unsigned int index, wgpu::BindGroupEntry&& entry);
+    [[nodiscard]] uint32_t const* setDynamicOffsets(uint32_t const* offsets);
     [[nodiscard]] bool getIsLocked() const { return mBindGroup != nullptr; }
     [[nodiscard]] size_t countEntitiesWithDynamicOffsets() const;
 
 private:
+    static wgpu::Buffer sDummyUniformBuffer;
+    static wgpu::Texture sDummyTexture;
+    static wgpu::TextureView sDummyTextureView;
+    static wgpu::Sampler sDummySampler;
+
+    static std::vector<wgpu::BindGroupEntry> createDummyEntriesSortedByBinding(
+            std::vector<filament::backend::WebGPUDescriptorSetLayout::BindGroupEntryInfo> const&);
+
+    // TODO: Consider storing what we used to make the layout. However we need to essentially
+    // Recreate some of the info (Sampler in slot X with the actual sampler) so letting Dawn confirm
+    // there isn't a mismatch may be easiest.
+    // Also storing the wgpu ObjectBase takes care of ownership challenges in theory
     wgpu::BindGroupLayout mLayout = nullptr;
     static constexpr uint8_t INVALID_INDEX = MAX_DESCRIPTOR_COUNT + 1;
     std::array<uint8_t, MAX_DESCRIPTOR_COUNT> mEntryIndexByBinding{};
-    std::vector<wgpu::BindGroupEntry> mEntries;
-    const size_t mEntriesWithDynamicOffsetsCount;
+    std::vector<wgpu::BindGroupEntry> mEntriesSortedByBinding;
+    std::bitset<MAX_DESCRIPTOR_COUNT> mEntriesByBindingWithDynamicOffsets{};
+    std::bitset<MAX_DESCRIPTOR_COUNT> mEntriesByBindingAdded{};
+    std::vector<uint32_t> mDynamicOffsets;
     wgpu::BindGroup mBindGroup = nullptr;
 };
 
@@ -171,9 +176,6 @@ public:
             wgpu::Device const& device) noexcept;
 
     WGPUTexture(WGPUTexture* src, uint8_t baseLevel, uint8_t levelCount) noexcept;
-    wgpu::TextureAspect getAspect() const { return mAspect; }
-    size_t getBlockWidth() const { return mBlockWidth; }
-    size_t getBlockHeight() const { return mBlockHeight; }
 
     [[nodiscard]] const wgpu::Texture& getTexture() const { return mTexture; }
     [[nodiscard]] const wgpu::TextureView& getTexView() const { return mTexView; }
@@ -197,8 +199,6 @@ private:
     uint32_t mArrayLayerCount = 1;
     wgpu::TextureView mTexView = nullptr;
     wgpu::TextureUsage fToWGPUTextureUsage(filament::backend::TextureUsage const& fUsage);
-    size_t mBlockWidth;
-    size_t mBlockHeight;
 };
 
 struct WGPURenderPrimitive : public HwRenderPrimitive {
@@ -207,66 +207,57 @@ struct WGPURenderPrimitive : public HwRenderPrimitive {
     WGPUIndexBuffer* indexBuffer = nullptr;
 };
 
-
-
 class WGPURenderTarget : public HwRenderTarget {
 public:
-    using Attachment = TargetBufferInfo; // Using TargetBufferInfo directly for attachments
+    class Attachment {
+    public:
+        friend class WGPURenderTarget;
+
+        Attachment() = default;
+        Attachment(WGPUTexture* gpuTexture, uint8_t level = 0, uint16_t layer = 0)
+            : level(level),
+              layer(layer),
+              texture(gpuTexture->getTexture()),
+              mWGPUTexture(gpuTexture) {}
+        operator bool() const {
+            return mWGPUTexture != nullptr;
+        }
+
+        uint8_t level = 0;
+        uint16_t layer = 0;
+
+    private:
+        wgpu::Texture texture = nullptr;
+        WGPUTexture* mWGPUTexture = nullptr;
+    };
 
     WGPURenderTarget(uint32_t width, uint32_t height, uint8_t samples,
-            const MRT& colorAttachments,
-            const Attachment& depthAttachment,
-            const Attachment& stencilAttachment);
-
-    // Default constructor for the default render target
+            Attachment colorAttachments[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT]);
     WGPURenderTarget()
         : HwRenderTarget(0, 0),
-          defaultRenderTarget(true),
-          samples(1) {}
+          defaultRenderTarget(true) {}
 
-    // Updated signature: takes resolved views for custom RTs, and default views for default RT
-    void setUpRenderPassAttachments(
-            wgpu::RenderPassDescriptor& descriptor,
-            RenderPassParams const& params,
-            // For default render target:
-            wgpu::TextureView const& defaultColorTextureView,
-            wgpu::TextureView const& defaultDepthStencilTextureView,
-            // For custom render targets:
-            wgpu::TextureView const* customColorTextureViews, // Array of views
-            uint32_t customColorTextureViewCount,
-            wgpu::TextureView const& customDepthTextureView,
-            wgpu::TextureView const& customStencilTextureView);
+    void setUpRenderPassAttachments(wgpu::RenderPassDescriptor& descriptor,
+            wgpu::TextureView const& textureView, RenderPassParams const& params);
 
-
-    math::uint2 getAttachmentSize() const noexcept;
+    math::uint2 getAttachmentSize() noexcept;
 
     bool isDefaultRenderTarget() const { return defaultRenderTarget; }
     uint8_t getSamples() const { return samples; }
 
-    // Accessors for the driver to get stored attachment info
-    const MRT& getColorAttachmentInfos() const { return mColorAttachments; }
-    const Attachment& getDepthAttachmentInfo() const { return mDepthAttachment; }
-    const Attachment& getStencilAttachmentInfo() const { return mStencilAttachment; }
+    Attachment getDrawColorAttachment(size_t index);
+    Attachment getReadColorAttachment(size_t index);
 
-    // Static helpers for load/store operations
     static wgpu::LoadOp getLoadOperation(const RenderPassParams& params, TargetBufferFlags buffer);
     static wgpu::StoreOp getStoreOperation(const RenderPassParams& params, TargetBufferFlags buffer);
-
 private:
-    // Helper to map MRT index to TargetBufferFlags
-    static TargetBufferFlags getTargetBufferFlagsAt(int mrtIndex);
-
     bool defaultRenderTarget = false;
     uint8_t samples = 1;
 
-    MRT mColorAttachments{};
-    Attachment mDepthAttachment{};
-    Attachment mStencilAttachment{};
-
-    // Cached descriptors for the render pass
-    std::vector<wgpu::RenderPassColorAttachment> mColorAttachmentDescriptors;
-    wgpu::RenderPassDepthStencilAttachment mDepthStencilAttachmentDescriptor{};
-    bool mHasDepthStencilAttachment = false;
+    Attachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT] = {};
+    math::uint2 attachmentSize = {};
+    std::vector<wgpu::RenderPassColorAttachment> colorAttachments{};
 };
+
 }// namespace filament::backend
 #endif// TNT_FILAMENT_BACKEND_WEBGPUHANDLES_H

filament/backend/src/webgpu/WebGPUPipelineCreation.cpp

@@ -191,8 +191,8 @@ wgpu::RenderPipeline createWebGPURenderPipeline(wgpu::Device const& device,
             .entryPoint = "main",
             .constantCount = program.constants.size(),
             .constants = program.constants.data(),
-            .bufferCount = vertexBufferInfo.getWebGPULayoutCount(),
-            .buffers = vertexBufferInfo.getWebGPULayouts()
+            .bufferCount = vertexBufferInfo.getVertexBufferLayoutSize(),
+            .buffers = vertexBufferInfo.getVertexBufferLayout()
         },
         .primitive = {
             .topology = toWebGPU(primitiveType),

filament/backend/src/webgpu/WebGPUSwapChain.cpp

@@ -320,14 +320,11 @@ wgpu::TextureView WebGPUSwapChain::getCurrentSurfaceTextureView(
     if (surfaceTexture.status != wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal) {
         return nullptr;
     }
-
-    mCurrentSurfaceTexture = nullptr;
-    mCurrentSurfaceTexture = surfaceTexture.texture;
     // Create a view for this surface texture
     // TODO: review these initiliazations as webgpu pipeline gets mature
     wgpu::TextureViewDescriptor textureViewDescriptor = {
         .label = "surface_texture_view",
-        .format = mCurrentSurfaceTexture.GetFormat(),
+        .format = surfaceTexture.texture.GetFormat(),
         .dimension = wgpu::TextureViewDimension::e2D,
         .baseMipLevel = 0,
         .mipLevelCount = 1,
@@ -340,7 +337,6 @@ wgpu::TextureView WebGPUSwapChain::getCurrentSurfaceTextureView(
 void WebGPUSwapChain::present() {
     assert_invariant(mSurface);
     mSurface.Present();
-    mCurrentSurfaceTexture = nullptr;
 }
 
 }// namespace filament::backend

filament/backend/src/webgpu/WebGPUSwapChain.h

@@ -52,8 +52,6 @@ private:
     wgpu::TextureFormat mDepthFormat = wgpu::TextureFormat::Undefined;
     wgpu::Texture mDepthTexture = nullptr;
     wgpu::TextureView mDepthTextureView = nullptr;
-    wgpu::Texture mCurrentSurfaceTexture = nullptr; // To hold the texture from getCurrentTexture()
-
 };
 
 } // namespace filament::backend

filament/backend/test/BackendTest.cpp

@@ -32,7 +32,6 @@ static constexpr size_t CONFIG_COMMAND_BUFFERS_SIZE     = 3 * CONFIG_MIN_COMMAND
 
 using namespace filament;
 using namespace filament::backend;
-using namespace filament::math;
 
 #ifndef FILAMENT_IOS
 #include <imageio/ImageEncoder.h>
@@ -107,35 +106,16 @@ Handle<HwSwapChain> BackendTest::createSwapChain() {
     return getDriverApi().createSwapChain(view.ptr, 0);
 }
 
-PipelineState BackendTest::getColorWritePipelineState() {
-    PipelineState result;
-    result.rasterState.colorWrite = true;
-    result.rasterState.depthWrite = false;
-    result.rasterState.depthFunc = RasterState::DepthFunc::A;
-    return result;
+void BackendTest::fullViewport(RenderPassParams& params) {
+    fullViewport(params.viewport);
 }
 
-filament::backend::Viewport BackendTest::getFullViewport() const {
-   const NativeView& view = getNativeView();
-   return Viewport {
-       .left = 0,
-       .bottom = 0,
-       .width = static_cast<uint32_t>(view.width),
-       .height = static_cast<uint32_t>(view.height)
-   };
-}
-
-filament::backend::RenderPassParams BackendTest::getClearColorRenderPass(float4 color) {
-    RenderPassParams params = {};
-    params.flags.clear = TargetBufferFlags::COLOR;
-    params.flags.discardStart = TargetBufferFlags::ALL;
-    params.flags.discardEnd = TargetBufferFlags::NONE;
-    params.clearColor = color;
-    return params;
-}
-
-filament::backend::RenderPassParams BackendTest::getNoClearRenderPass() {
-    return RenderPassParams{};
+void BackendTest::fullViewport(Viewport& viewport) {
+    const NativeView& view = getNativeView();
+    viewport.left = 0;
+    viewport.bottom = 0;
+    viewport.width = view.width;
+    viewport.height = view.height;
 }
 
 void BackendTest::renderTriangle(
@@ -143,9 +123,14 @@ void BackendTest::renderTriangle(
         Handle<filament::backend::HwRenderTarget> renderTarget,
         Handle<filament::backend::HwSwapChain> swapChain,
         Handle<filament::backend::HwProgram> program) {
-    RenderPassParams params = getClearColorRenderPass();
-    params.viewport.width = 512;
+    RenderPassParams params = {};
+    fullViewport(params);
+    params.flags.clear = TargetBufferFlags::COLOR;
+    params.clearColor = {0.f, 0.f, 1.f, 1.f};
+    params.flags.discardStart = TargetBufferFlags::ALL;
+    params.flags.discardEnd = TargetBufferFlags::NONE;
     params.viewport.height = 512;
+    params.viewport.width = 512;
     renderTriangle(pipelineLayout, renderTarget, swapChain, program, params);
 }
 

filament/backend/test/BackendTest.h

@@ -52,14 +52,9 @@ protected:
 
     filament::backend::Handle<filament::backend::HwSwapChain> createSwapChain();
 
-    static filament::backend::PipelineState getColorWritePipelineState();
-
-    // Gets the full back buffer's viewport
-    filament::backend::Viewport getFullViewport() const;
-    // If color is unset this defaults to using opaque cyan
-    static filament::backend::RenderPassParams getClearColorRenderPass(
-            filament::math::float4 color = filament::math::float4(0, 1, 1, 1));
-    static filament::backend::RenderPassParams getNoClearRenderPass();
+    // Helper methods to set the viewport to the full extent of the swap chain.
+    static void fullViewport(filament::backend::RenderPassParams& params);
+    static void fullViewport(filament::backend::Viewport& viewport);
 
     void renderTriangle(
             filament::backend::PipelineLayout const& pipelineLayout,

filament/backend/test/Shader.cpp

@@ -56,35 +56,26 @@ Shader::Shader(DriverApi& api, Cleanup& cleanup, ShaderConfig config) : mCleanup
     mProgram = cleanup.add(api.createProgram(std::move(prog)));
 
     if (!kLayouts.empty()) {
-        mDescriptorSetLayout = cleanup.add(
-                api.createDescriptorSetLayout(DescriptorSetLayout{ .bindings = kLayouts }));
+        mDescriptorSetLayout =
+                cleanup.add(api.createDescriptorSetLayout(DescriptorSetLayout{ .bindings = kLayouts }));
     }
 }
 
-DescriptorSetHandle Shader::createDescriptorSet(DriverApi& api) const {
+filament::backend::DescriptorSetHandle Shader::createDescriptorSet(DriverApi& api) const {
     return mCleanup.add(api.createDescriptorSet(mDescriptorSetLayout));
 }
 
-ProgramHandle Shader::getProgram() const {
+filament::backend::ProgramHandle Shader::getProgram() const {
     assert(mProgram);
     EXPECT_THAT(mProgram, ::testing::IsTrue())
                         << "Shader program accessed despite being null.";
     return mProgram;
 }
 
-DescriptorSetLayoutHandle Shader::getDescriptorSetLayout() const {
+filament::backend::DescriptorSetLayoutHandle Shader::getDescriptorSetLayout() const {
     EXPECT_THAT(mDescriptorSetLayout, ::testing::IsTrue())
             << "Shader descriptor set layout accessed despite being null.";
     return mDescriptorSetLayout;
 }
 
-void Shader::addProgramToPipelineState(PipelineState& state) const {
-    state.program = getProgram();
-    // In case another shader was set first, clear the set layout and then set this shader's values.
-    state.pipelineLayout.setLayout = PipelineLayout::SetLayout();
-    if (mDescriptorSetLayout) {
-        state.pipelineLayout.setLayout[0] = { getDescriptorSetLayout() };
-    }
-}
-
 } // namespace test

filament/backend/test/Shader.h

@@ -90,8 +90,6 @@ public:
     filament::backend::ProgramHandle getProgram() const;
     filament::backend::DescriptorSetLayoutHandle getDescriptorSetLayout() const;
 
-    void addProgramToPipelineState(filament::backend::PipelineState& state) const;
-
     filament::backend::DescriptorSetHandle createDescriptorSet(
             filament::backend::DriverApi& api) const;
 

filament/backend/test/ShaderGenerator.cpp

@@ -118,7 +118,7 @@ ShaderGenerator::Blob ShaderGenerator::transpileShader(ShaderStage stage, std::s
     } else if (backend == Backend::VULKAN) {
         shader.insert(pos, "#define TARGET_VULKAN_ENVIRONMENT\n");
     } else if (backend == Backend::WEBGPU) {
-        shader.insert(pos, "#define TARGET_WEBGPU_ENVIRONMENT\n");
+        shader.insert(pos, "#define TARGET_VULKAN_ENVIRONMENT\n");
     }
 
     const char* shaderCString = shader.c_str();
@@ -186,16 +186,4 @@ Program ShaderGenerator::getProgram(filament::backend::DriverApi&) noexcept {
     return program;
 }
 
-Program ShaderGenerator::getProgramWithPushConstants(filament::backend::DriverApi&,
-        std::array<PushConstants, filament::backend::Program::SHADER_TYPE_COUNT> constants) {
-    Program program;
-    program.shaderLanguage(mShaderLanguage);
-    program.shader(ShaderStage::VERTEX, mVertexBlob.data(), mVertexBlob.size());
-    program.shader(ShaderStage::FRAGMENT, mFragmentBlob.data(), mFragmentBlob.size());
-    for (auto const stage : {ShaderStage::VERTEX, ShaderStage::FRAGMENT }) {
-        program.pushConstants(stage, constants[uint8_t(stage)]);
-    }
-    return program;
-}
-
 } // namespace test

filament/backend/test/ShaderGenerator.h

@@ -48,10 +48,6 @@ public:
 
     filament::backend::Program getProgram(filament::backend::DriverApi&) noexcept;
 
-    using PushConstants = utils::FixedCapacityVector<filament::backend::Program::PushConstant>;
-    filament::backend::Program getProgramWithPushConstants(filament::backend::DriverApi&,
-            std::array<PushConstants, filament::backend::Program::SHADER_TYPE_COUNT> constants);
-
 private:
     using ShaderStage = filament::backend::ShaderStage;
 

filament/backend/test/SharedShaders.cpp

@@ -184,7 +184,7 @@ std::vector<UniformConfig> GetUniformConfig(ShaderUniformType type) {
                     "backend_test", "test_tex", 0,
                     SamplerType::SAMPLER_2D, SamplerFormat::FLOAT, Precision::HIGH, false };
             return {{
-                            "test_tex", DescriptorType::SAMPLER_2D_FLOAT, samplerInfo
+                            "test_tex", DescriptorType::SAMPLER, samplerInfo
                     }};
         }
         default:

filament/backend/test/TrianglePrimitive.h

@@ -55,8 +55,6 @@ public:
     void updateIndices(const index_type* indices) noexcept;
     void updateIndices(const index_type* indices, int count, int offset) noexcept;
 
-    VertexInfoHandle getVertexBufferInfo() const { return mVertexBufferInfo; }
-
 private:
 
     size_t mVertexCount = 3;

filament/backend/test/move_actual_images_to_expected.py

@@ -151,6 +151,3 @@ if __name__ == "__main__":
             results.show_images(file_prefix)
     else:
         results.batch_move(args.batch)
-    print("--------------------------------------------------------")
-    print("REMEMBER TO RESYNC CMAKE AND UPDATE HASHES IN TEST FILES")
-    print("--------------------------------------------------------")

filament/backend/test/test_Blit.cpp

@@ -302,13 +302,22 @@ TEST_F(BlitTest, ColorResolve) {
             {{ dstColorTexture }}, {}, {}));
 
     // Prep for rendering.
-    PipelineState state = getColorWritePipelineState();
-    shader.addProgramToPipelineState(state);
-
-    RenderPassParams params = getClearColorRenderPass();
+    RenderPassParams params = {};
+    params.flags.clear = TargetBufferFlags::COLOR;
+    params.flags.discardStart = TargetBufferFlags::ALL;
+    params.flags.discardEnd = TargetBufferFlags::NONE;
+    params.clearColor = float4(1, 1, 0, 1);
     params.viewport.width = kSrcTexWidth;
     params.viewport.height = kSrcTexHeight;
 
+    PipelineState state = {};
+    state.program = shader.getProgram();
+    state.pipelineLayout.setLayout[0] = { shader.getDescriptorSetLayout() };
+    state.rasterState.colorWrite = true;
+    state.rasterState.depthWrite = false;
+    state.rasterState.depthFunc = RasterState::DepthFunc::A;
+    state.rasterState.culling = CullingMode::NONE;
+
     auto ubuffer = mCleanup.add(api.createBufferObject(sizeof(SimpleMaterialParams),
             BufferObjectBinding::UNIFORM, BufferUsage::STATIC));
     // Draw red triangle into srcRenderTarget.
@@ -319,6 +328,7 @@ TEST_F(BlitTest, ColorResolve) {
     });
     shader.bindUniform<SimpleMaterialParams>(api, ubuffer);
 
+    // FIXME: on Metal this triangle is not drawn. Can't understand why.
     {
         RenderFrame frame(api);
         api.beginRenderPass(srcRenderTarget, params);
@@ -333,7 +343,7 @@ TEST_F(BlitTest, ColorResolve) {
             SamplerMagFilter::NEAREST);
 
     EXPECT_IMAGE(dstRenderTarget, getExpectations(),
-            ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorResolve", 531759687));
+            ScreenshotParams(kDstTexWidth, kDstTexHeight, "ColorResolve", 0xebfac2ef));
 }
 
 TEST_F(BlitTest, Blit2DTextureArray) {

filament/backend/test/test_BufferUpdates.cpp

@@ -76,11 +76,20 @@ TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
         // buffer. Only the first 3 vertices will be used.
         TrianglePrimitive triangle(api, largeBuffers);
 
-        PipelineState state = getColorWritePipelineState();
-        shader.addProgramToPipelineState(state);
+        RenderPassParams params = {};
+        fullViewport(params);
+        params.flags.clear = TargetBufferFlags::COLOR;
+        params.clearColor = { 0.f, 1.f, 0.f, 1.f };
+        params.flags.discardStart = TargetBufferFlags::ALL;
+        params.flags.discardEnd = TargetBufferFlags::NONE;
 
-        RenderPassParams params = getClearColorRenderPass();
-        params.viewport = getFullViewport();
+        PipelineState state;
+        state.program = shader.getProgram();
+        state.pipelineLayout.setLayout[0] = { shader.getDescriptorSetLayout() };
+        state.rasterState.colorWrite = true;
+        state.rasterState.depthWrite = false;
+        state.rasterState.depthFunc = RasterState::DepthFunc::A;
+        state.rasterState.culling = CullingMode::NONE;
 
         // Create a uniform buffer.
         // We use STATIC here, even though the buffer is updated, to force the Metal backend to use
@@ -153,9 +162,6 @@ TEST_F(BufferUpdatesTest, VertexBufferUpdate) {
 TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
     NONFATAL_FAIL_IF(SkipEnvironment(OperatingSystem::APPLE, Backend::VULKAN),
             "All values including alpha are written as 0, see b/417254943");
-    constexpr int kTexWidth = 512;
-    constexpr int kTexHeight = 512;
-
     auto& api = getDriverApi();
     Cleanup cleanup(api);
 
@@ -176,9 +182,9 @@ TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
 
     // Create a render target.
     auto colorTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
-            TextureFormat::RGBA8, 1, kTexWidth, kTexHeight, 1, TextureUsage::COLOR_ATTACHMENT));
+            TextureFormat::RGBA8, 1, 512, 512, 1, TextureUsage::COLOR_ATTACHMENT));
     auto renderTarget = cleanup.add(api.createRenderTarget(
-            TargetBufferFlags::COLOR0, kTexWidth, kTexHeight, 1, 0, {{ colorTexture }}, {}, {}));
+            TargetBufferFlags::COLOR0, 512, 512, 1, 0, {{ colorTexture }}, {}, {}));
 
     // Upload uniforms for the first triangle.
     // Upload the uniform, but with an offset to accommodate the padding in the shader's
@@ -189,9 +195,13 @@ TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
             .offset = { 0.0f, 0.0f, 0.0f, 0.0f }
     });
 
-    RenderPassParams params = getClearColorRenderPass();
-    params.viewport.height = kTexWidth;
-    params.viewport.width = kTexHeight;
+    RenderPassParams params = {};
+    params.flags.clear = TargetBufferFlags::COLOR;
+    params.clearColor = { 0.f, 0.f, 1.f, 1.f };
+    params.flags.discardStart = TargetBufferFlags::ALL;
+    params.flags.discardEnd = TargetBufferFlags::NONE;
+    params.viewport.height = 512;
+    params.viewport.width = 512;
     renderTriangle({ { shader.getDescriptorSetLayout() } }, renderTarget, swapChain,
             shader.getProgram(), params);
 
@@ -216,7 +226,7 @@ TEST_F(BufferUpdatesTest, BufferObjectUpdateWithOffset) {
 
 
     EXPECT_IMAGE(renderTarget, getExpectations(),
-            ScreenshotParams(kTexWidth, kTexHeight, "BufferObjectUpdateWithOffset", 2320747245));
+            ScreenshotParams(512, 512, "BufferObjectUpdateWithOffset", 91322442));
 
     api.flush();
     api.commit(swapChain);

filament/backend/test/test_FeedbackLoops.cpp

@@ -120,7 +120,7 @@ TEST_F(BackendTest, FeedbackLoops) {
         Shader shader = Shader(api, cleanup, ShaderConfig {
             .vertexShader = fullscreenVs,
             .fragmentShader = fullscreenFs,
-            .uniforms = {{"test_tex", DescriptorType::SAMPLER_2D_FLOAT, samplerInfo}, {"Params"}}
+            .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}, {"Params"}}
         });
 
         TrianglePrimitive const triangle(getDriverApi());
@@ -161,10 +161,15 @@ TEST_F(BackendTest, FeedbackLoops) {
         for (int frame = 0; frame < kNumFrames; frame++) {
 
             // Prep for rendering.
-            PipelineState state = getColorWritePipelineState();
-            shader.addProgramToPipelineState(state);
-
-            RenderPassParams params = getNoClearRenderPass();
+            RenderPassParams params = {};
+            params.flags.clear = TargetBufferFlags::NONE;
+            params.flags.discardEnd = TargetBufferFlags::NONE;
+            PipelineState state;
+            state.rasterState.colorWrite = true;
+            state.rasterState.depthWrite = false;
+            state.rasterState.depthFunc = RasterState::DepthFunc::A;
+            state.program = shader.getProgram();
+            state.pipelineLayout.setLayout[0] = { shader.getDescriptorSetLayout() };
 
             api.makeCurrent(swapChain, swapChain);
             api.beginFrame(0, 0, 0);

filament/backend/test/test_LoadImage.cpp

@@ -52,7 +52,7 @@ layout(location = 0, set = 0) uniform {samplerType} test_tex;
 void main() {
     vec2 fbsize = vec2(512);
     vec2 uv = gl_FragCoord.xy / fbsize;
-#if defined(TARGET_METAL_ENVIRONMENT) || defined(TARGET_VULKAN_ENVIRONMENT) || defined(TARGET_WEBGPU_ENVIRONMENT)
+#if defined(TARGET_METAL_ENVIRONMENT) || defined(TARGET_VULKAN_ENVIRONMENT)
     uv.y = 1.0 - uv.y;
 #endif
     fragColor = vec4(texture(test_tex, uv).rgb, 1.0f);
@@ -73,7 +73,7 @@ float getLayer(in sampler2DArray s) { return 2.0f; }
 void main() {
     vec2 fbsize = vec2(512);
     vec2 uv = gl_FragCoord.xy / fbsize;
-#if defined(TARGET_METAL_ENVIRONMENT) || defined(TARGET_VULKAN_ENVIRONMENT) || defined(TARGET_WEBGPU_ENVIRONMENT)
+#if defined(TARGET_METAL_ENVIRONMENT) || defined(TARGET_VULKAN_ENVIRONMENT)
     uv.y = 1.0 - uv.y;
 #endif
     fragColor = vec4(texture(test_tex, vec3(uv, getLayer(test_tex))).rgb, 1.0f);
@@ -91,7 +91,7 @@ layout(location = 0, set = 0) uniform sampler2D test_tex;
 void main() {
     vec2 fbsize = vec2(512);
     vec2 uv = gl_FragCoord.xy / fbsize;
-#if defined(TARGET_METAL_ENVIRONMENT) || defined(TARGET_VULKAN_ENVIRONMENT) || defined(TARGET_WEBGPU_ENVIRONMENT)
+#if defined(TARGET_METAL_ENVIRONMENT) || defined(TARGET_VULKAN_ENVIRONMENT)
     uv.y = 1.0 - uv.y;
 #endif
     fragColor = vec4(textureLod(test_tex, uv, 1.0f).rgb, 1.0f);
@@ -215,7 +215,7 @@ TEST_F(LoadImageTest, UpdateImage2D) {
     FAIL_IF(Backend::VULKAN, "Multiple test cases crash, see b/417481434");
 
     // All of these test cases should result in the same rendered image, and thus the same hash.
-    static const uint32_t expectedHash = 1875922935;
+    static const uint32_t expectedHash = 3644679986;
 
     struct TestCase {
         const char* name;
@@ -308,7 +308,7 @@ TEST_F(LoadImageTest, UpdateImage2D) {
         Shader shader(api, cleanup, ShaderConfig{
            .vertexShader = mVertexShader,
            .fragmentShader= fragment,
-           .uniforms = {{"test_tex", DescriptorType::SAMPLER_2D_FLOAT, samplerInfo}}
+           .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}}
         });
 
         // Create a Texture.
@@ -372,7 +372,7 @@ TEST_F(LoadImageTest, UpdateImageSRGB) {
             getSamplerTypeName(textureFormat), fragmentTemplate);
     Shader shader(api, cleanup, ShaderConfig{
         .vertexShader = mVertexShader, .fragmentShader = fragment, .uniforms = {{
-            "test_tex", DescriptorType::SAMPLER_2D_FLOAT, samplerInfo
+            "test_tex", DescriptorType::SAMPLER, samplerInfo
     }}});
 
     // Create a texture.
@@ -417,7 +417,7 @@ TEST_F(LoadImageTest, UpdateImageSRGB) {
             defaultRenderTarget, swapChain, shader.getProgram());
 
     EXPECT_IMAGE(defaultRenderTarget, getExpectations(),
-            ScreenshotParams(512, 512, "UpdateImageSRGB", 3300305265));
+            ScreenshotParams(512, 512, "UpdateImageSRGB", 359858623));
 
     api.commit(swapChain);
     api.endFrame(0);
@@ -447,7 +447,7 @@ TEST_F(LoadImageTest, UpdateImageMipLevel) {
     Shader shader(api, cleanup, ShaderConfig {
         .vertexShader = mVertexShader,
         .fragmentShader = fragment,
-        .uniforms = {{"test_tex", DescriptorType::SAMPLER_2D_FLOAT, samplerInfo}}
+        .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}}
     });
 
     // Create a texture with 3 mip levels.
@@ -476,7 +476,7 @@ TEST_F(LoadImageTest, UpdateImageMipLevel) {
             defaultRenderTarget, swapChain, shader.getProgram());
 
     EXPECT_IMAGE(defaultRenderTarget, getExpectations(),
-            ScreenshotParams(512, 512, "UpdateImageMipLevel", 1875922935));
+            ScreenshotParams(512, 512, "UpdateImageMipLevel", 3644679986));
 
     api.commit(swapChain);
     api.endFrame(0);
@@ -511,7 +511,7 @@ TEST_F(LoadImageTest, UpdateImage3D) {
     Shader shader(api, cleanup, ShaderConfig {
         .vertexShader = mVertexShader,
         .fragmentShader = fragment,
-        .uniforms = {{"test_tex", DescriptorType::SAMPLER_2D_ARRAY_FLOAT, samplerInfo}}
+        .uniforms = {{"test_tex", DescriptorType::SAMPLER, samplerInfo}}
     });
 
     // Create a texture.
@@ -550,7 +550,7 @@ TEST_F(LoadImageTest, UpdateImage3D) {
                 defaultRenderTarget, swapChain, shader.getProgram());
 
         EXPECT_IMAGE(defaultRenderTarget, getExpectations(),
-                ScreenshotParams(512, 512, "UpdateImage3D", 1875922935));
+                ScreenshotParams(512, 512, "UpdateImage3D", 3644679986));
     }
 
     api.stopCapture();

filament/backend/test/test_MRT.cpp

@@ -102,11 +102,19 @@ TEST_F(BackendTest, MRT) {
                 {},                                        // depth
                 {}));                                       // stencil
 
-        PipelineState state = getColorWritePipelineState();
-        shader.addProgramToPipelineState(state);
+        RenderPassParams params = {};
+        fullViewport(params);
+        params.flags.clear = TargetBufferFlags::COLOR;
+        params.clearColor = {0.f, 1.f, 0.f, 1.f};
+        params.flags.discardStart = TargetBufferFlags::ALL;
+        params.flags.discardEnd = TargetBufferFlags::NONE;
 
-        RenderPassParams params = getClearColorRenderPass();
-        params.viewport = getFullViewport();
+        PipelineState state;
+        state.program = shader.getProgram();
+        state.rasterState.colorWrite = true;
+        state.rasterState.depthWrite = false;
+        state.rasterState.depthFunc = RasterState::DepthFunc::A;
+        state.rasterState.culling = CullingMode::NONE;
 
         api.startCapture(0);
 

filament/backend/test/test_MipLevels.cpp

@@ -82,7 +82,7 @@ TEST_F(BackendTest, TextureViewLod) {
            .vertexShader = vertexShader,
            .fragmentShader = fragmentTexturedLod,
            .uniforms = {{
-               "backend_test_sib_tex", DescriptorType::SAMPLER_2D_FLOAT, samplerInfo
+               "backend_test_sib_tex", DescriptorType::SAMPLER, samplerInfo
            }}
         });
 
@@ -138,25 +138,37 @@ TEST_F(BackendTest, TextureViewLod) {
                 TargetBufferFlags::COLOR, 32, 32, 1, 0,
                 {texture, 2 /* level */, 0 /* layer */}, {}, {}));
         {
-            PipelineState state = getColorWritePipelineState();
-            whiteShader.addProgramToPipelineState(state);
-
-            RenderPassParams params = getNoClearRenderPass();
-            params.viewport = getFullViewport();
-
+            RenderPassParams params = {};
+            fullViewport(params);
+            params.flags.clear = TargetBufferFlags::NONE;
+            params.flags.discardStart = TargetBufferFlags::NONE;
+            params.flags.discardEnd = TargetBufferFlags::NONE;
+            PipelineState ps = {};
+            ps.program = whiteShader.getProgram();
+            ps.rasterState.colorWrite = true;
+            ps.rasterState.depthWrite = false;
             api.beginRenderPass(renderTarget, params);
-            api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
+            api.draw(ps, triangle.getRenderPrimitive(), 0, 3, 1);
             api.endRenderPass();
         }
 
         backend::Handle<HwRenderTarget> defaultRenderTarget =
                 cleanup.add(api.createDefaultRenderTarget(0));
 
-        PipelineState state = getColorWritePipelineState();
-        texturedShader.addProgramToPipelineState(state);
+        RenderPassParams params = {};
+        fullViewport(params);
+        params.flags.clear = TargetBufferFlags::COLOR;
+        params.clearColor = {0.f, 0.f, 0.5f, 1.f};
+        params.flags.discardStart = TargetBufferFlags::ALL;
+        params.flags.discardEnd = TargetBufferFlags::NONE;
 
-        RenderPassParams params = getClearColorRenderPass();
-        params.viewport = getFullViewport();
+        PipelineState state;
+        state.program = texturedShader.getProgram();
+        state.pipelineLayout.setLayout = { texturedShader.getDescriptorSetLayout() };
+        state.rasterState.colorWrite = true;
+        state.rasterState.depthWrite = false;
+        state.rasterState.depthFunc = SamplerCompareFunc::A;
+        state.rasterState.culling = CullingMode::NONE;
 
         DescriptorSetHandle descriptorSet13 = texturedShader.createDescriptorSet(api);
         api.updateDescriptorSetTexture(descriptorSet13, 0, texture13, {

filament/backend/test/test_MissingRequiredAttributes.cpp

@@ -79,11 +79,19 @@ TEST_F(BackendTest, MissingRequiredAttributes) {
 
         TrianglePrimitive triangle(api);
 
-        PipelineState state = getColorWritePipelineState();
-        shader.addProgramToPipelineState(state);
+        RenderPassParams params = {};
+        fullViewport(params);
+        params.flags.clear = TargetBufferFlags::COLOR;
+        params.clearColor = { 0.f, 1.f, 0.f, 1.f };
+        params.flags.discardStart = TargetBufferFlags::ALL;
+        params.flags.discardEnd = TargetBufferFlags::NONE;
 
-        RenderPassParams params = getClearColorRenderPass();
-        params.viewport = getFullViewport();
+        PipelineState state;
+        state.program = shader.getProgram();
+        state.rasterState.colorWrite = true;
+        state.rasterState.depthWrite = false;
+        state.rasterState.depthFunc = RasterState::DepthFunc::A;
+        state.rasterState.culling = CullingMode::NONE;
 
         api.startCapture(0);
 

filament/backend/test/test_PushConstants.cpp

@@ -21,16 +21,11 @@
 #include "ShaderGenerator.h"
 #include "Skip.h"
 #include "TrianglePrimitive.h"
-#include "backend/DriverEnums.h"
-#include "backend/Handle.h"
 
 #include <utils/Hash.h>
 
 namespace test {
 
-static ShaderGenerator::PushConstants gVertConstants;
-static ShaderGenerator::PushConstants gFragConstants;
-
 using namespace filament;
 using namespace filament::backend;
 
@@ -84,29 +79,10 @@ void main() {
     fragColor = vec4(pushConstants.red, pushConstants.green, pushConstants.blue, 1.0);
 })";
 
-void initPushConstants() {
-    // TODO: move this initialization to a more appropriate place.
-    gVertConstants.clear();
-    gFragConstants.clear();
-
-    gVertConstants.reserve(4);
-    gVertConstants.resize(4);
-    gVertConstants[pushConstantIndex.TRIANGLE_HIDE] = {"hideTriangle", backend::ConstantType::BOOL};
-    gVertConstants[pushConstantIndex.TRIANGLE_SCALE] = {"triangleScale", backend::ConstantType::FLOAT};
-    gVertConstants[pushConstantIndex.TRIANGLE_OFFSET_X] = {"triangleOffsetX", backend::ConstantType::FLOAT};
-    gVertConstants[pushConstantIndex.TRIANGLE_OFFSET_Y] = {"triangleOffsetY", backend::ConstantType::FLOAT};
-
-    gFragConstants.reserve(4);
-    gFragConstants.resize(4);
-    gFragConstants[pushConstantIndex.RED] = {"red", backend::ConstantType::FLOAT};
-    gFragConstants[pushConstantIndex.GREEN] = {"green", backend::ConstantType::FLOAT};
-    gFragConstants[pushConstantIndex.BLUE] = {"blue", backend::ConstantType::FLOAT};
-}
-
 TEST_F(BackendTest, PushConstants) {
     SKIP_IF(Backend::OPENGL, "Push constants not supported on OpenGL");
-
-    initPushConstants();
+    FAIL_IF(Backend::VULKAN,
+            "Crashing due to no program set when setting push constants, see b/417477740");
 
     auto& api = getDriverApi();
 
@@ -122,20 +98,22 @@ TEST_F(BackendTest, PushConstants) {
 
         // Create a program.
         ShaderGenerator shaderGen(triangleVs, triangleFs, sBackend, sIsMobilePlatform);
-        Program p =
-                shaderGen.getProgramWithPushConstants(api, { gVertConstants, gFragConstants, {} });
+        Program p = shaderGen.getProgram(api);
         ProgramHandle program = cleanup.add(api.createProgram(std::move(p)));
 
         Handle<HwRenderTarget> renderTarget = cleanup.add(api.createDefaultRenderTarget());
 
         TrianglePrimitive triangle(api);
 
-        RenderPassParams params = getClearColorRenderPass();
-        params.viewport = getFullViewport();
+        RenderPassParams params = {};
+        params.flags.clear = TargetBufferFlags::COLOR0;
+        params.viewport = { 0, 0, 512, 512 };
+        params.clearColor = math::float4(0.0f, 0.0f, 1.0f, 1.0f);
+        params.flags.discardStart = TargetBufferFlags::ALL;
+        params.flags.discardEnd = TargetBufferFlags::NONE;
 
         PipelineState ps = {};
         ps.program = program;
-        ps.vertexBufferInfo = triangle.getVertexBufferInfo();
         ps.rasterState.colorWrite = true;
         ps.rasterState.depthWrite = false;
 
@@ -143,8 +121,6 @@ TEST_F(BackendTest, PushConstants) {
         api.beginFrame(0, 0, 0);
 
         api.beginRenderPass(renderTarget, params);
-        api.bindPipeline(ps);
-        api.bindRenderPrimitive(triangle.getRenderPrimitive());
 
         // Set the push constants to scale the triangle in half
         api.setPushConstant(ShaderStage::VERTEX, pushConstantIndex.TRIANGLE_HIDE, false);
@@ -154,7 +130,7 @@ TEST_F(BackendTest, PushConstants) {
         api.setPushConstant(ShaderStage::FRAGMENT, pushConstantIndex.RED, 0.25f);
         api.setPushConstant(ShaderStage::FRAGMENT, pushConstantIndex.GREEN, 0.5f);
         api.setPushConstant(ShaderStage::FRAGMENT, pushConstantIndex.BLUE, 1.0f);
-        api.draw2(0, 3, 1);
+        api.draw(ps, triangle.getRenderPrimitive(), 0, 3, 1);
 
         // Draw another triangle, transposed to the upper-right.
         api.setPushConstant(ShaderStage::VERTEX, pushConstantIndex.TRIANGLE_OFFSET_X, 0.5f);
@@ -164,7 +140,7 @@ TEST_F(BackendTest, PushConstants) {
         api.setPushConstant(ShaderStage::FRAGMENT, pushConstantIndex.GREEN, 0.5f);
         api.setPushConstant(ShaderStage::FRAGMENT, pushConstantIndex.BLUE, 0.25f);
 
-        api.draw2(0, 3, 1);
+        api.draw(ps, triangle.getRenderPrimitive(), 0, 3, 1);
 
         // Draw a final triangle, transposed to the lower-left.
         api.setPushConstant(ShaderStage::VERTEX, pushConstantIndex.TRIANGLE_OFFSET_X, -0.5f);
@@ -174,13 +150,12 @@ TEST_F(BackendTest, PushConstants) {
         api.setPushConstant(ShaderStage::FRAGMENT, pushConstantIndex.GREEN, 0.25f);
         api.setPushConstant(ShaderStage::FRAGMENT, pushConstantIndex.BLUE, 1.00f);
 
-        api.draw2(0, 3, 1);
+        api.draw(ps, triangle.getRenderPrimitive(), 0, 3, 1);
 
         api.endRenderPass();
 
         EXPECT_IMAGE(renderTarget, getExpectations(),
-                ScreenshotParams(params.viewport.width, params.viewport.height, "pushConstants",
-                        3575588741));
+                ScreenshotParams(512, 512, "pushConstants", 1957275826));
 
         api.commit(swapChain);
         api.endFrame(0);

filament/backend/test/test_ReadPixels.cpp

@@ -279,9 +279,14 @@ TEST_F(ReadPixelsTest, ReadPixels) {
 
         TrianglePrimitive const triangle(api);
 
-        RenderPassParams params = getClearColorRenderPass(math::float4(0, 0, 1, 1));
-        params.viewport.width = t.getRenderTargetSize();
+        RenderPassParams params = {};
+        fullViewport(params);
+        params.flags.clear = TargetBufferFlags::COLOR;
+        params.clearColor = { 0.f, 0.f, 1.f, 1.f };
+        params.flags.discardStart = TargetBufferFlags::ALL;
+        params.flags.discardEnd = TargetBufferFlags::NONE;
         params.viewport.height = t.getRenderTargetSize();
+        params.viewport.width = t.getRenderTargetSize();
 
         api.makeCurrent(swapChain, swapChain);
         api.beginFrame(0, 0, 0);
@@ -289,12 +294,15 @@ TEST_F(ReadPixelsTest, ReadPixels) {
         // Render a white triangle over blue.
         api.beginRenderPass(renderTarget, params);
 
-        PipelineState state = getColorWritePipelineState();
+        PipelineState state;
+        state.program = floatShader.getProgram();
         if (isUnsignedIntFormat(t.textureFormat)) {
-            uintShader.addProgramToPipelineState(state);
-        } else {
-            floatShader.addProgramToPipelineState(state);
+            state.program = uintShader.getProgram();
         }
+        state.rasterState.colorWrite = true;
+        state.rasterState.depthWrite = false;
+        state.rasterState.depthFunc = RasterState::DepthFunc::A;
+        state.rasterState.culling = CullingMode::NONE;
         api.draw(state, triangle.getRenderPrimitive(), 0, 3, 1);
 
         api.endRenderPass();
@@ -392,15 +400,24 @@ TEST_F(ReadPixelsTest, ReadPixelsPerformance) {
 
     TrianglePrimitive triangle(api);
 
-    PipelineState state = getColorWritePipelineState();
-    shader.addProgramToPipelineState(state);
-
-    RenderPassParams params = getClearColorRenderPass(math::float4(0, 0, 1, 1));
-    params.viewport.width = renderTargetSize;
+    RenderPassParams params = {};
+    fullViewport(params);
+    params.flags.clear = TargetBufferFlags::COLOR;
+    params.clearColor = { 0.f, 0.f, 1.f, 1.f };
+    params.flags.discardStart = TargetBufferFlags::ALL;
+    params.flags.discardEnd = TargetBufferFlags::NONE;
     params.viewport.height = renderTargetSize;
+    params.viewport.width = renderTargetSize;
 
     void* buffer = calloc(1, renderTargetSize * renderTargetSize * 4);
 
+    PipelineState state;
+    state.program = shader.getProgram();
+    state.rasterState.colorWrite = true;
+    state.rasterState.depthWrite = false;
+    state.rasterState.depthFunc = RasterState::DepthFunc::A;
+    state.rasterState.culling = CullingMode::NONE;
+
     for (int iteration = 0; iteration < iterationCount; ++iteration) {
         readPixelsFinished = false;
 

filament/backend/test/test_RenderExternalImage.cpp

@@ -73,11 +73,20 @@ TEST_F(BackendTest, RenderExternalImageWithoutSet) {
             1,                                  // depth
             usage));                             // usage
 
-    PipelineState state = getColorWritePipelineState();
-    shader.addProgramToPipelineState(state);
+    RenderPassParams params = {};
+    fullViewport(params);
+    params.flags.clear = TargetBufferFlags::COLOR;
+    params.clearColor = { 0.f, 1.f, 0.f, 1.f };
+    params.flags.discardStart = TargetBufferFlags::ALL;
+    params.flags.discardEnd = TargetBufferFlags::NONE;
 
-    RenderPassParams params = getClearColorRenderPass();
-    params.viewport = getFullViewport();
+    PipelineState state;
+    state.program = shader.getProgram();
+    state.pipelineLayout.setLayout[0] = { shader.getDescriptorSetLayout() };
+    state.rasterState.colorWrite = true;
+    state.rasterState.depthWrite = false;
+    state.rasterState.depthFunc = RasterState::DepthFunc::A;
+    state.rasterState.culling = CullingMode::NONE;
 
     DescriptorSetHandle descriptorSet = shader.createDescriptorSet(api);
 
@@ -170,11 +179,20 @@ TEST_F(BackendTest, RenderExternalImage) {
     // We're now free to release the buffer.
     CVBufferRelease(pixBuffer);
 
-    PipelineState state = getColorWritePipelineState();
-    shader.addProgramToPipelineState(state);
+    RenderPassParams params = {};
+    fullViewport(params);
+    params.flags.clear = TargetBufferFlags::COLOR;
+    params.clearColor = { 0.f, 1.f, 0.f, 1.f };
+    params.flags.discardStart = TargetBufferFlags::ALL;
+    params.flags.discardEnd = TargetBufferFlags::NONE;
 
-    RenderPassParams params = getClearColorRenderPass();
-    params.viewport = getFullViewport();
+    PipelineState state;
+    state.program = shader.getProgram();
+    state.pipelineLayout.setLayout[0] = { shader.getDescriptorSetLayout() };
+    state.rasterState.colorWrite = true;
+    state.rasterState.depthWrite = false;
+    state.rasterState.depthFunc = RasterState::DepthFunc::A;
+    state.rasterState.culling = CullingMode::NONE;
 
     api.startCapture(0);
     api.makeCurrent(swapChain, swapChain);
@@ -192,7 +210,7 @@ TEST_F(BackendTest, RenderExternalImage) {
     api.commit(swapChain);
     api.endFrame(0);
     EXPECT_IMAGE(defaultRenderTarget, getExpectations(),
-            ScreenshotParams(512, 512, "RenderExternalImage", 1206264951));
+            ScreenshotParams(512, 512, "RenderExternalImage", 267229901));
 
     api.stopCapture(0);
     api.finish();

filament/backend/test/test_Scissor.cpp

@@ -80,8 +80,8 @@ TEST_F(BackendTest, ScissorViewportRegion) {
         });
 
         // Create source color and depth textures.
-        Handle<HwTexture> srcTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D,
-                kNumLevels, kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
+        Handle<HwTexture> srcTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, kNumLevels,
+                kSrcTexFormat, 1, kSrcTexWidth, kSrcTexHeight, 1,
                 TextureUsage::SAMPLEABLE | TextureUsage::COLOR_ATTACHMENT));
         Handle<HwTexture> depthTexture = cleanup.add(api.createTexture(SamplerType::SAMPLER_2D, 1,
                 TextureFormat::DEPTH16, 1, 512, 512, 1,
@@ -104,21 +104,27 @@ TEST_F(BackendTest, ScissorViewportRegion) {
         // We purposely set the render target width and height to smaller than the texture, to check
         // that this case is handled correctly.
         Handle<HwRenderTarget> srcRenderTarget = cleanup.add(api.createRenderTarget(
-                TargetBufferFlags::COLOR | TargetBufferFlags::DEPTH, kSrcRtHeight, kSrcRtHeight, 1,
-                0, { srcTexture, kSrcLevel, 0 }, { depthTexture, 0, 0 }, {}));
+                TargetBufferFlags::COLOR | TargetBufferFlags::DEPTH, kSrcRtHeight, kSrcRtHeight, 1, 0,
+                {srcTexture, kSrcLevel, 0}, {depthTexture, 0, 0}, {}));
 
-        Handle<HwRenderTarget> fullRenderTarget = cleanup.add(
-                api.createRenderTarget(TargetBufferFlags::COLOR, kSrcTexHeight >> kSrcLevel,
-                        kSrcTexWidth >> kSrcLevel, 1, 0, {srcTexture, kSrcLevel, 0}, {}, {}));
+        Handle<HwRenderTarget> fullRenderTarget = cleanup.add(api.createRenderTarget(TargetBufferFlags::COLOR,
+                kSrcTexHeight >> kSrcLevel, kSrcTexWidth >> kSrcLevel, 1, 0,
+                {srcTexture, kSrcLevel, 0}, {}, {}));
 
         TrianglePrimitive triangle(api);
 
         // Render a white triangle over blue.
-        RenderPassParams params = getClearColorRenderPass();
+        RenderPassParams params = {};
+        params.flags.clear = TargetBufferFlags::COLOR0;
         params.viewport = srcRect;
+        params.clearColor = math::float4(0.0f, 0.0f, 1.0f, 1.0f);
+        params.flags.discardStart = TargetBufferFlags::ALL;
+        params.flags.discardEnd = TargetBufferFlags::NONE;
 
-        PipelineState ps = getColorWritePipelineState();
-        shader.addProgramToPipelineState(ps);
+        PipelineState ps = {};
+        ps.program = shader.getProgram();
+        ps.rasterState.colorWrite = true;
+        ps.rasterState.depthWrite = false;
 
         api.makeCurrent(swapChain, swapChain);
         api.beginFrame(0, 0, 0);
@@ -129,7 +135,7 @@ TEST_F(BackendTest, ScissorViewportRegion) {
         api.endRenderPass();
 
         EXPECT_IMAGE(fullRenderTarget, getExpectations(),
-                ScreenshotParams(kSrcTexWidth >> 1, kSrcTexHeight >> 1, "scissor", 15842520));
+                ScreenshotParams(kSrcTexWidth >> 1, kSrcTexHeight >> 1, "scissor", 0xAB3D1C53));
 
         api.commit(swapChain);
         api.endFrame(0);
@@ -190,11 +196,17 @@ TEST_F(BackendTest, ScissorViewportEdgeCases) {
         TrianglePrimitive triangle(api);
 
         // Render a white triangle over blue.
-        RenderPassParams params = getClearColorRenderPass();
+        RenderPassParams params = {};
+        params.flags.clear = TargetBufferFlags::COLOR0;
         params.viewport = bottomLeftViewport;
+        params.clearColor = math::float4(0.0f, 0.0f, 1.0f, 1.0f);
+        params.flags.discardStart = TargetBufferFlags::ALL;
+        params.flags.discardEnd = TargetBufferFlags::NONE;
 
-        PipelineState ps = getColorWritePipelineState();
-        shader.addProgramToPipelineState(ps);
+        PipelineState ps = {};
+        ps.program = shader.getProgram();
+        ps.rasterState.colorWrite = true;
+        ps.rasterState.depthWrite = false;
 
         api.makeCurrent(swapChain, swapChain);
         api.beginFrame(0, 0, 0);
@@ -213,7 +225,7 @@ TEST_F(BackendTest, ScissorViewportEdgeCases) {
         api.endRenderPass();
 
         EXPECT_IMAGE(renderTarget, getExpectations(),
-                ScreenshotParams(512, 512, "ScissorViewportEdgeCases", 2199186852));
+                ScreenshotParams(512, 512, "ScissorViewportEdgeCases", 0x6BF00F31));
 
         api.commit(swapChain);
         api.endFrame(0);

filament/include/filament/BufferObject.h

@@ -130,7 +130,7 @@ public:
      *
      * @param engine Reference to the filament::Engine associated with this BufferObject.
      * @param buffer A BufferDescriptor representing the data used to initialize the BufferObject.
-     * @param byteOffset Offset in bytes into the BufferObject. Must be multiple of 4.
+     * @param byteOffset Offset in bytes into the BufferObject
      */
     void setBuffer(Engine& engine, BufferDescriptor&& buffer, uint32_t byteOffset = 0);
 

filament/include/filament/IndexBuffer.h

@@ -137,7 +137,7 @@ public:
      * @param buffer A BufferDescriptor representing the data used to initialize the IndexBuffer.
      *               BufferDescriptor points to raw, untyped data that will be interpreted as
      *               either 16-bit or 32-bits indices based on the Type of this IndexBuffer.
-     * @param byteOffset Offset in *bytes* into the IndexBuffer. Must be multiple of 4.
+     * @param byteOffset Offset in *bytes* into the IndexBuffer
      */
     void setBuffer(Engine& engine, BufferDescriptor&& buffer, uint32_t byteOffset = 0);
 

filament/include/filament/MaterialInstance.h

@@ -19,7 +19,7 @@
 
 #include <filament/FilamentAPI.h>
 #include <filament/Color.h>
-#include <filament/Engine.h>
+
 #include <filament/MaterialEnums.h>
 
 #include <backend/DriverEnums.h>
@@ -529,13 +529,6 @@ public:
     void setStencilWriteMask(uint8_t writeMask,
             StencilFace face = StencilFace::FRONT_AND_BACK) noexcept;
 
-    /**
-     * PostProcess and compute domain material instance must be commited manually. This call has
-     * no effect on surface domain materials.
-     * @param engine Filament engine
-     */
-    void commit(Engine& engine) const;
-
 protected:
     // prevent heap allocation
     ~MaterialInstance() = default;

filament/include/filament/Options.h

@@ -373,30 +373,18 @@ struct RenderQuality {
  * @see setAmbientOcclusionOptions()
  */
 struct AmbientOcclusionOptions {
-    enum class AmbientOcclusionType : uint8_t {
-        SAO,        //!< use Scalable Ambient Occlusion
-        GTAO,       //!< use Ground Truth-Based Ambient Occlusion
-    };
-
-    AmbientOcclusionType aoType = AmbientOcclusionType::SAO;//!< Type of ambient occlusion algorithm.
     float radius = 0.3f;    //!< Ambient Occlusion radius in meters, between 0 and ~10.
     float power = 1.0f;     //!< Controls ambient occlusion's contrast. Must be positive.
-
-    /**
-     * Self-occlusion bias in meters. Use to avoid self-occlusion.
-     * Between 0 and a few mm. No effect when aoType set to GTAO
-     */
-    float bias = 0.0005f;
-
+    float bias = 0.0005f;   //!< Self-occlusion bias in meters. Use to avoid self-occlusion. Between 0 and a few mm.
     float resolution = 0.5f;//!< How each dimension of the AO buffer is scaled. Must be either 0.5 or 1.0.
     float intensity = 1.0f; //!< Strength of the Ambient Occlusion effect.
     float bilateralThreshold = 0.05f; //!< depth distance that constitute an edge for filtering
-    QualityLevel quality = QualityLevel::LOW; //!< affects # of samples used for AO and params for filtering
-    QualityLevel lowPassFilter = QualityLevel::MEDIUM; //!< affects AO smoothness. Recommend setting to HIGH when aoType set to GTAO.
+    QualityLevel quality = QualityLevel::LOW; //!< affects # of samples used for AO.
+    QualityLevel lowPassFilter = QualityLevel::MEDIUM; //!< affects AO smoothness
     QualityLevel upsampling = QualityLevel::LOW; //!< affects AO buffer upsampling quality
     bool enabled = false;    //!< enables or disables screen-space ambient occlusion
     bool bentNormals = false; //!< enables bent normals computation from AO, and specular AO
-    float minHorizonAngleRad = 0.0f;  //!< min angle in radian to consider. No effect when aoType set to GTAO.
+    float minHorizonAngleRad = 0.0f;  //!< min angle in radian to consider
     /**
      * Screen Space Cone Tracing (SSCT) options
      * Ambient shadows from dominant light
@@ -414,16 +402,6 @@ struct AmbientOcclusionOptions {
         bool enabled = false;            //!< enables or disables SSCT
     };
     Ssct ssct;                           // %codegen_skip_javascript% %codegen_java_flatten%
-
-    /**
-     * Ground Truth-base Ambient Occlusion (GTAO) options
-     */
-    struct Gtao {
-        uint8_t sampleSliceCount = 4;     //!< # of slices. Higher value makes less noise.
-        uint8_t sampleStepsPerSlice = 3;  //!< # of steps the radius is divided into for integration. Higher value makes less bias.
-        float thicknessHeuristic = 0.004f; //!< thickness heuristic, should be closed to 0
-    };
-    Gtao gtao;                           // %codegen_skip_javascript% %codegen_java_flatten%
 };
 
 /**

filament/include/filament/VertexBuffer.h

@@ -221,7 +221,7 @@ public:
      *               index \p bufferIndex. BufferDescriptor points to raw, untyped data that will
      *               be copied as-is into the buffer.
      * @param byteOffset Offset in *bytes* into the buffer at index \p bufferIndex of this vertex
-     *                   buffer set.  Must be multiple of 4.
+     *                   buffer set.
      */
     void setBufferAt(Engine& engine, uint8_t bufferIndex, BufferDescriptor&& buffer,
             uint32_t byteOffset = 0);

filament/src/FrameInfo.cpp

@@ -20,13 +20,12 @@
 
 #include <backend/DriverEnums.h>
 
-#include <private/utils/Tracing.h>
-
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
 #include <utils/ostream.h>
+#include <utils/Systrace.h>
 
 #include <algorithm>
 #include <atomic>
@@ -91,8 +90,8 @@ void FrameInfoManager::beginFrame(DriverApi& driver, Config const& config, uint3
                 mLast = (mLast + 1) % POOL_COUNT;
                 break;
             case TimerQueryResult::AVAILABLE: {
-                FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
-                FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "FrameInfo::elapsed", uint32_t(elapsed));
+                SYSTRACE_CONTEXT();
+                SYSTRACE_VALUE32("FrameInfo::elapsed", uint32_t(elapsed));
                 // conversion to our duration happens here
                 pFront = mQueries[mLast].pInfo;
                 pFront->frameTime = std::chrono::duration<uint64_t, std::nano>(elapsed);

filament/src/Froxelizer.cpp

@@ -30,12 +30,11 @@
 
 #include <backend/DriverEnums.h>
 
-#include <private/utils/Tracing.h>
-
 #include <utils/BinaryTreeArray.h>
 #include <utils/JobSystem.h>
 #include <utils/Log.h>
 #include <utils/Slice.h>
+#include <utils/Systrace.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
 
@@ -297,7 +296,7 @@ void Froxelizer::updateBoundingSpheres(
         float4 const* UTILS_RESTRICT planesY,
         float const* UTILS_RESTRICT planesZ) noexcept {
 
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     // TODO: this could potentially be parallel_for'ized
 
@@ -580,7 +579,7 @@ void Froxelizer::froxelizeLights(FEngine& engine,
 void Froxelizer::froxelizeLoop(FEngine& engine,
         const mat4f& UTILS_RESTRICT viewMatrix,
         const FScene::LightSoa& UTILS_RESTRICT lightData) noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     Slice<FroxelThreadData> froxelThreadData = mFroxelShardedData;
     memset(froxelThreadData.data(), 0, froxelThreadData.sizeInBytes());
@@ -594,7 +593,7 @@ void Froxelizer::froxelizeLoop(FEngine& engine,
                      spheres, directions, instances, &viewMatrix, &lcm ]
             (size_t const count, size_t const offset, size_t const stride) {
 
-        FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "FroxelizeLoop Job");
+        SYSTRACE_NAME("FroxelizeLoop Job");
 
         const mat4f& projection = mProjection;
         const mat3f& vn = viewMatrix.upperLeft();
@@ -647,7 +646,8 @@ void Froxelizer::froxelizeLoop(FEngine& engine,
 }
 
 void Froxelizer::froxelizeAssignRecordsCompress() noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+
+    SYSTRACE_CALL();
 
     Slice<FroxelThreadData> const froxelThreadData = mFroxelShardedData;
 

filament/src/MaterialInstance.cpp

@@ -398,8 +398,4 @@ bool MaterialInstance::isDepthCullingEnabled() const noexcept {
     return downcast(this)->isDepthCullingEnabled();
 }
 
-void MaterialInstance::commit(Engine& engine) const {
-    downcast(this)->commit(downcast(engine));
-}
-
 } // namespace filament

filament/src/PostProcessManager.cpp

@@ -100,9 +100,7 @@ using namespace backend;
 static constexpr uint8_t kMaxBloomLevels = 12u;
 static_assert(kMaxBloomLevels >= 3, "We require at least 3 bloom levels");
 
-namespace {
-
-constexpr float halton(unsigned int i, unsigned int const b) noexcept {
+constexpr static float halton(unsigned int i, unsigned int const b) noexcept {
     // skipping a bunch of entries makes the average of the sequence closer to 0.5
     i += 409;
     float f = 1.0f;
@@ -115,19 +113,6 @@ constexpr float halton(unsigned int i, unsigned int const b) noexcept {
     return r;
 }
 
-template <typename ValueType>
-void setConstantParameter(FMaterial* const material, std::string_view const name,
-        ValueType value, bool& dirty) noexcept {
-    auto id = material->getSpecializationConstantId(name);
-    if (id.has_value()) {
-        if (material->setConstant(id.value(), value)) {
-            dirty = true;
-        }
-    }
-}
-
-} // anonymous
-
 // ------------------------------------------------------------------------------------------------
 
 PostProcessManager::PostProcessMaterial::PostProcessMaterial(StaticMaterialInfo const& info) noexcept
@@ -247,7 +232,7 @@ PostProcessManager::~PostProcessManager() noexcept = default;
 void PostProcessManager::setFrameUniforms(DriverApi& driver,
         TypedUniformBuffer<PerViewUib>& uniforms) noexcept {
     mPostProcessDescriptorSet.setFrameUniforms(driver, uniforms);
-    mSsrPassDescriptorSet.setFrameUniforms(mEngine, uniforms);
+    mSsrPassDescriptorSet.setFrameUniforms(uniforms);
 }
 
 void PostProcessManager::bindPostProcessDescriptorSet(DriverApi& driver) const noexcept {
@@ -304,8 +289,6 @@ static const PostProcessManager::StaticMaterialInfo sMaterialList[] = {
         { "mipmapDepth",                MATERIAL(MIPMAPDEPTH) },
         { "sao",                        MATERIAL(SAO) },
         { "saoBentNormals",             MATERIAL(SAOBENTNORMALS) },
-        { "gtao",                       MATERIAL(GTAO) },
-        { "gtaoBentNormals",            MATERIAL(GTAOBENTNORMALS) },
         { "separableGaussianBlur1",     MATERIAL(SEPARABLEGAUSSIANBLUR),
                 { {"arraySampler", false}, {"componentCount", 1} } },
         { "separableGaussianBlur1L",    MATERIAL(SEPARABLEGAUSSIANBLUR),
@@ -521,7 +504,6 @@ PostProcessManager::StructurePassOutput PostProcessManager::structure(FrameGraph
                         FrameGraphTexture::Usage::DEPTH_ATTACHMENT);
 
                 if (config.picking) {
-                    // FIXME: the DescriptorSetLayout must specify SAMPLER_FLOAT
                     data.picking = builder.createTexture("Picking Buffer", {
                             .width = width, .height = height,
                             .format = isES2 ? TextureFormat::RGBA8 : TextureFormat::RG32F });
@@ -671,7 +653,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::ssr(FrameGraph& fg,
                     options, passBuilder = passBuilder]
             (FrameGraphResources const& resources, auto const& data, DriverApi& driver) mutable {
                 // set structure sampler
-                mSsrPassDescriptorSet.prepareStructure(mEngine, data.structure ?
+                mSsrPassDescriptorSet.prepareStructure(data.structure ?
                         resources.getTexture(data.structure) : getOneTexture());
 
                 // set screen-space reflections and screen-space refractions
@@ -682,7 +664,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::ssr(FrameGraph& fg,
                 // the history sampler is a regular texture2D
                 TextureHandle const history = data.history ?
                         resources.getTexture(data.history) : getZeroTexture();
-                mSsrPassDescriptorSet.prepareHistorySSR(mEngine, history, reprojection, uvFromViewMatrix, options);
+                mSsrPassDescriptorSet.prepareHistorySSR(history, reprojection, uvFromViewMatrix, options);
 
                 mSsrPassDescriptorSet.commit(mEngine);
 
@@ -863,6 +845,12 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::screenSpaceAmbientOcclusion(
                         0.5f * cameraInfo.projection[0].x * desc.width,
                         0.5f * cameraInfo.projection[1].y * desc.height);
 
+                // Where the falloff function peaks
+                const float peak = 0.1f * options.radius;
+                const float intensity = (f::TAU * peak) * options.intensity;
+                // always square AO result, as it looks much better
+                const float power = options.power * 2.0f;
+
                 const auto invProjection = inverse(cameraInfo.projection);
                 const float inc = (1.0f / (sampleCount - 0.5f)) * spiralTurns * f::TAU;
 
@@ -873,75 +861,40 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::screenSpaceAmbientOcclusion(
                         0.0, 0.0, 0.0, 1.0
                 }};
 
-                std::string_view materialName;
-                if (options.aoType ==
-                        AmbientOcclusionOptions::AmbientOcclusionType::GTAO) {
-                    materialName = computeBentNormals ? "gtaoBentNormals" : "gtao";
-                } else {
-                    materialName = computeBentNormals ? "saoBentNormals" : "sao";
-                }
-
-                auto& material = getPostProcessMaterial(materialName);
-
-                FMaterial const * const ma = material.getMaterial(mEngine);
+                auto& material = computeBentNormals ?
+                            getPostProcessMaterial("saoBentNormals") :
+                            getPostProcessMaterial("sao");
+                FMaterial const* const ma = material.getMaterial(mEngine);
                 FMaterialInstance* const mi = PostProcessMaterial::getMaterialInstance(ma);
-
-                // Set AO type specific material parameters
-                switch (options.aoType) {
-                    case AmbientOcclusionOptions::AmbientOcclusionType::SAO: {
-                        // Where the falloff function peaks
-                        const float peak = 0.1f * options.radius;
-                        const float intensity = (f::TAU * peak) * options.intensity;
-
-                        // always square AO result, as it looks much better
-                        const float power = options.power * 2.0f;
-
-                        mi->setParameter("minHorizonAngleSineSquared",
-                                std::pow(std::sin(options.minHorizonAngleRad), 2.0f));
-                        mi->setParameter("intensity", intensity / sampleCount);
-                        mi->setParameter("power", power);
-                        mi->setParameter("peak2", peak * peak);
-                        mi->setParameter("bias", options.bias);
-                        mi->setParameter("sampleCount",
-                                float2{ sampleCount, 1.0f / (sampleCount - 0.5f) });
-                        mi->setParameter("spiralTurns", spiralTurns);
-                        mi->setParameter("angleIncCosSin", float2{ std::cos(inc), std::sin(inc) });
-                        break;
-                    }
-                    case AmbientOcclusionOptions::AmbientOcclusionType::GTAO: {
-                        const auto sliceCount = static_cast<float>(options.gtao.sampleSliceCount);
-                        mi->setParameter("stepsPerSlice",
-                                static_cast<float>(options.gtao.sampleStepsPerSlice));
-                        mi->setParameter("sliceCount",
-                                float2{ sliceCount, 1.0f / sliceCount });
-                        mi->setParameter("power", options.power);
-                        mi->setParameter("radius", options.radius);
-                        mi->setParameter("intensity", options.intensity);
-                        mi->setParameter("thicknessHeuristic", options.gtao.thicknessHeuristic);
-
-                        break;
-                    }
-                }
-
-                // Set common material parameters
-                mi->setParameter("invRadiusSquared", 1.0f / (options.radius * options.radius));
-                mi->setParameter("depth", depth,
-                        { .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
+                mi->setParameter("depth", depth, {
+                        .filterMin = SamplerMinFilter::NEAREST_MIPMAP_NEAREST });
                 mi->setParameter("screenFromViewMatrix",
                         mat4f(screenFromClipMatrix * cameraInfo.projection));
                 mi->setParameter("resolution",
                         float4{ desc.width, desc.height, 1.0f / desc.width, 1.0f / desc.height });
-                mi->setParameter("projectionScale", projectionScale);
-                mi->setParameter("projectionScaleRadius", projectionScale * options.radius);
-                mi->setParameter("positionParams",
-                        float2{ invProjection[0][0], invProjection[1][1] } * 2.0f);
+                mi->setParameter("invRadiusSquared",
+                        1.0f / (options.radius * options.radius));
+                mi->setParameter("minHorizonAngleSineSquared",
+                        std::pow(std::sin(options.minHorizonAngleRad), 2.0f));
+                mi->setParameter("projectionScale",
+                        projectionScale);
+                mi->setParameter("projectionScaleRadius",
+                        projectionScale * options.radius);
+                mi->setParameter("positionParams", float2{
+                        invProjection[0][0], invProjection[1][1] } * 2.0f);
+                mi->setParameter("peak2", peak * peak);
+                mi->setParameter("bias", options.bias);
+                mi->setParameter("power", power);
+                mi->setParameter("intensity", intensity / sampleCount);
                 mi->setParameter("maxLevel", uint32_t(levelCount - 1));
+                mi->setParameter("sampleCount", float2{ sampleCount, 1.0f / (sampleCount - 0.5f) });
+                mi->setParameter("spiralTurns", spiralTurns);
+                mi->setParameter("angleIncCosSin", float2{ std::cos(inc), std::sin(inc) });
                 mi->setParameter("invFarPlane", 1.0f / -cameraInfo.zf);
+
                 mi->setParameter("ssctShadowDistance", options.ssct.shadowDistance);
-                mi->setParameter("ssctConeAngleTangeant",
-                        std::tan(options.ssct.lightConeRad * 0.5f));
-                mi->setParameter("ssctContactDistanceMaxInv",
-                        1.0f / options.ssct.contactDistanceMax);
+                mi->setParameter("ssctConeAngleTangeant", std::tan(options.ssct.lightConeRad * 0.5f));
+                mi->setParameter("ssctContactDistanceMaxInv", 1.0f / options.ssct.contactDistanceMax);
                 // light direction in view space
                 const mat4f view{ cameraInfo.getUserViewMatrix() };
                 const float3 l = normalize(
@@ -2678,15 +2631,25 @@ void PostProcessManager::configureTemporalAntiAliasingMaterial(
     FMaterial* const ma = getPostProcessMaterial("taa").getMaterial(mEngine);
     bool dirty = false;
 
-    setConstantParameter(ma, "upscaling", taaOptions.upscaling, dirty);
-    setConstantParameter(ma, "historyReprojection", taaOptions.historyReprojection, dirty);
-    setConstantParameter(ma, "filterHistory", taaOptions.filterHistory, dirty);
-    setConstantParameter(ma, "filterInput", taaOptions.filterInput, dirty);
-    setConstantParameter(ma, "useYCoCg", taaOptions.useYCoCg, dirty);
-    setConstantParameter(ma, "preventFlickering", taaOptions.preventFlickering, dirty);
-    setConstantParameter(ma, "boxType", int32_t(taaOptions.boxType), dirty);
-    setConstantParameter(ma, "boxClipping", int32_t(taaOptions.boxClipping), dirty);
-    setConstantParameter(ma, "varianceGamma", taaOptions.varianceGamma, dirty);
+    auto setConstantParameter =
+            [&dirty](FMaterial* const material, std::string_view const name, auto value) noexcept {
+        auto id = material->getSpecializationConstantId(name);
+        if (id.has_value()) {
+            if (material->setConstant(id.value(), value)) {
+                dirty = true;
+            }
+        }
+    };
+
+    setConstantParameter(ma, "upscaling", taaOptions.upscaling);
+    setConstantParameter(ma, "historyReprojection", taaOptions.historyReprojection);
+    setConstantParameter(ma, "filterHistory", taaOptions.filterHistory);
+    setConstantParameter(ma, "filterInput", taaOptions.filterInput);
+    setConstantParameter(ma, "useYCoCg", taaOptions.useYCoCg);
+    setConstantParameter(ma, "preventFlickering", taaOptions.preventFlickering);
+    setConstantParameter(ma, "boxType", int32_t(taaOptions.boxType));
+    setConstantParameter(ma, "boxClipping", int32_t(taaOptions.boxClipping));
+    setConstantParameter(ma, "varianceGamma", taaOptions.varianceGamma);
     if (dirty) {
         ma->invalidate();
         // TODO: call Material::compile(), we can't do that now because it works only
@@ -2701,8 +2664,18 @@ FMaterialInstance* PostProcessManager::configureColorGradingMaterial(
     FMaterial* const ma = material.getMaterial(mEngine);
     bool dirty = false;
 
-    setConstantParameter(ma, "isOneDimensional", colorGrading->isOneDimensional(), dirty);
-    setConstantParameter(ma, "isLDR", colorGrading->isLDR(), dirty);
+    auto setConstantParameter =
+            [&dirty](FMaterial* const material, std::string_view const name, auto value) noexcept {
+        auto id = material->getSpecializationConstantId(name);
+        if (id.has_value()) {
+            if (material->setConstant(id.value(), value)) {
+                dirty = true;
+            }
+        }
+    };
+
+    setConstantParameter(ma, "isOneDimensional", colorGrading->isOneDimensional());
+    setConstantParameter(ma, "isLDR", colorGrading->isLDR());
 
     if (dirty) {
         ma->invalidate();

filament/src/RenderPass.cpp

@@ -40,13 +40,12 @@
 #include "private/backend/CircularBuffer.h"
 #include "private/backend/CommandStream.h"
 
-#include <private/utils/Tracing.h>
-
 #include <utils/compiler.h>
 #include <utils/debug.h>
 #include <utils/JobSystem.h>
 #include <utils/Panic.h>
 #include <utils/Slice.h>
+#include <utils/Systrace.h>
 #include <utils/Range.h>
 
 #include <algorithm>
@@ -193,11 +192,11 @@ void RenderPass::appendCommands(FEngine const& engine,
         Variant const variant,
         float3 const cameraPosition,
         float3 const cameraForwardVector) const noexcept {
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
+    SYSTRACE_CONTEXT();
 
     // trace the number of visible renderables
-    FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "visibleRenderables", visibleRenderables.size());
+    SYSTRACE_VALUE32("visibleRenderables", visibleRenderables.size());
     if (UTILS_UNLIKELY(visibleRenderables.empty())) {
         // no renderables, we still need the sentinel and the command buffer size should be
         // exactly 1.
@@ -273,7 +272,7 @@ void RenderPass::appendCustomCommand(Command* commands,
 
 RenderPass::Command* RenderPass::sortCommands(
         Command* const begin, Command* const end) noexcept {
-    FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "sort commands");
+    SYSTRACE_NAME("sort commands");
 
     std::sort(begin, end);
 
@@ -290,7 +289,7 @@ RenderPass::Command* RenderPass::instanceify(DriverApi& driver,
         DescriptorSetLayoutHandle perRenderableDescriptorSetLayoutHandle,
         Command* curr, Command* const last,
         int32_t const eyeCount) const noexcept {
-    FILAMENT_TRACING_NAME(FILAMENT_TRACING_CATEGORY_FILAMENT, "instanceify");
+    SYSTRACE_NAME("instanceify");
 
     // instanceify works by scanning the **sorted** command stream, looking for repeat draw
     // commands. When one is found, it is replaced by an instanced command.
@@ -493,7 +492,7 @@ void RenderPass::generateCommands(CommandTypeFlags commandTypeFlags, Command* co
         float3 const cameraPosition, float3 const cameraForward,
         uint8_t instancedStereoEyeCount) noexcept {
 
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
 
     // generateCommands() writes both the draw and depth commands simultaneously such that
     // we go throw the list of renderables just once.
@@ -923,14 +922,14 @@ UTILS_NOINLINE // no need to be inlined
 void RenderPass::Executor::execute(FEngine const& engine, DriverApi& driver,
         Command const* first, Command const* last) const noexcept {
 
-    FILAMENT_TRACING_CALL(FILAMENT_TRACING_CATEGORY_FILAMENT);
-    FILAMENT_TRACING_CONTEXT(FILAMENT_TRACING_CATEGORY_FILAMENT);
+    SYSTRACE_CALL();
+    SYSTRACE_CONTEXT();
 
     size_t const capacity = engine.getMinCommandBufferSize();
     CircularBuffer const& circularBuffer = driver.getCircularBuffer();
 
     if (first != last) {
-        FILAMENT_TRACING_VALUE(FILAMENT_TRACING_CATEGORY_FILAMENT, "commandCount", last - first);
+        SYSTRACE_VALUE32("commandCount", last - first);
 
         // The scissor rectangle is associated to a render pass, so the tracking can be local.
         backend::Viewport currentScissor{ 0, 0, INT32_MAX, INT32_MAX };
@@ -943,13 +942,6 @@ void RenderPass::Executor::execute(FEngine const& engine, DriverApi& driver,
             driver.scissor(mScissor);
         }
 
-        // If we have a mColorPassDescriptorSet, we need to use its idea of "VSM" to select
-        // the descriptor set layout. Materials always offer both.
-        // If we don't have a mColorPassDescriptorSet, it doesn't matter because the layout
-        // are chosen via the variant only.
-        bool const useVsmDescriptorSetLayout =
-                mColorPassDescriptorSet ? mColorPassDescriptorSet->isVSM() : false;
-
         bool const polygonOffsetOverride = mPolygonOffsetOverride;
         PipelineState pipeline{
                 // initialize with polygon offset override
@@ -1059,13 +1051,8 @@ void RenderPass::Executor::execute(FEngine const& engine, DriverApi& driver,
 
                     // Each material has its own version of the per-view descriptor-set layout,
                     // because it depends on the material features (e.g. lit/unlit)
-                    // TODO: QUESTION: are
-                    //      Variant::isValidDepthVariant(info.materialVariant) and
-                    //      Variant::isSSRVariant(info.materialVariant)
-                    //      constant? If so we could precompute ma->getPerViewDescriptorSetLayout()
                     pipeline.pipelineLayout.setLayout[+DescriptorSetBindingPoints::PER_VIEW] =
-                            ma->getPerViewDescriptorSetLayout(info.materialVariant,
-                                    useVsmDescriptorSetLayout).getHandle();
+                            ma->getPerViewDescriptorSetLayout(info.materialVariant).getHandle();
 
                     // Each material has a per-material descriptor-set layout which encodes the
                     // material's parameters (ubo and samplers)