vk: fixing renderstandalone

`DebugRegistry::setProperty` is no longer just applicable to debug
builds.

This change was previously added in 6c0bd36 but then reverted
in a7317e7. We re-enable it and separate it from the shadow
changes in this commit.

NEW_RELEASE_NOTES.md

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

README.md

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

RELEASE_NOTES.md

@@ -7,6 +7,10 @@ A new header is inserted each time a *tag* is created.
 Instead, if you are authoring a PR for the main branch, add your release note to
 [NEW_RELEASE_NOTES.md](./NEW_RELEASE_NOTES.md).
 
+## v1.54.2
+
+- Add a `name` API to Filament objects for debugging handle use-after-free assertions
+
 ## v1.54.1
 
 

android/gradle.properties

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

filament/backend/src/metal/MetalBuffer.h

@@ -160,6 +160,8 @@ public:
          size_t size, bool forceGpuBuffer = false);
     ~MetalBuffer();
 
+    [[nodiscard]] bool wasAllocationSuccessful() const noexcept { return mBuffer || mCpuBuffer; }
+
     MetalBuffer(const MetalBuffer& rhs) = delete;
     MetalBuffer& operator=(const MetalBuffer& rhs) = delete;
 

filament/backend/src/metal/MetalBuffer.mm

@@ -53,8 +53,8 @@ MetalBuffer::MetalBuffer(MetalContext& context, BufferObjectBinding bindingType,
         mBuffer = { [context.device newBufferWithLength:size options:MTLResourceStorageModePrivate],
             TrackedMetalBuffer::Type::GENERIC };
     }
-    FILAMENT_CHECK_POSTCONDITION(mBuffer)
-            << "Could not allocate Metal buffer of size " << size << ".";
+    // mBuffer might fail to be allocated. Clients can check for this by calling
+    // wasAllocationSuccessful().
 }
 
 MetalBuffer::~MetalBuffer() {

filament/backend/src/metal/MetalDriver.h

@@ -57,7 +57,6 @@ class MetalDriver final : public DriverBase {
 
 public:
     static Driver* create(MetalPlatform* platform, const Platform::DriverConfig& driverConfig);
-    void runAtNextTick(const std::function<void()>& fn) noexcept;
 
 private:
 
@@ -73,10 +72,12 @@ private:
 
     /*
      * Tasks run regularly on the driver thread.
+     * Not thread-safe; tasks are run from the driver thead and must be enqueued from the driver
+     * thread.
      */
+    void runAtNextTick(const std::function<void()>& fn) noexcept;
     void executeTickOps() noexcept;
     std::vector<std::function<void()>> mTickOps;
-    std::mutex mTickOpsLock;
 
     /*
      * Driver interface

filament/backend/src/metal/MetalDriver.mm

@@ -320,17 +320,40 @@ void MetalDriver::createVertexBufferR(Handle<HwVertexBuffer> vbh,
         uint32_t vertexCount, Handle<HwVertexBufferInfo> vbih) {
     MetalVertexBufferInfo const* const vbi = handle_cast<const MetalVertexBufferInfo>(vbih);
     construct_handle<MetalVertexBuffer>(vbh, *mContext, vertexCount, vbi->bufferCount, vbih);
+    // No actual GPU memory is allocated here, so no need to check for allocation success.
 }
 
 void MetalDriver::createIndexBufferR(Handle<HwIndexBuffer> ibh, ElementType elementType,
         uint32_t indexCount, BufferUsage usage) {
-    auto elementSize = (uint8_t) getElementTypeSize(elementType);
-    construct_handle<MetalIndexBuffer>(ibh, *mContext, usage, elementSize, indexCount);
+    auto elementSize = (uint8_t)getElementTypeSize(elementType);
+    auto* indexBuffer =
+            construct_handle<MetalIndexBuffer>(ibh, *mContext, usage, elementSize, indexCount);
+    auto& buffer = indexBuffer->buffer;
+    // If the allocation was not successful, postpone the error message until the next tick, to give
+    // Filament a chance to call setDebugTag on the handle; this way we get a nicer error message.
+    if (UTILS_UNLIKELY(!buffer.wasAllocationSuccessful())) {
+        const size_t byteCount = buffer.getSize();
+        runAtNextTick([byteCount, this, ibh]() {
+            FILAMENT_CHECK_POSTCONDITION(false)
+                    << "Could not allocate Metal index buffer of size " << byteCount
+                    << ", tag=" << mHandleAllocator.getHandleTag(ibh.getId()).c_str_safe();
+        });
+    }
 }
 
 void MetalDriver::createBufferObjectR(Handle<HwBufferObject> boh, uint32_t byteCount,
         BufferObjectBinding bindingType, BufferUsage usage) {
-    construct_handle<MetalBufferObject>(boh, *mContext, bindingType, usage, byteCount);
+    auto* bufferObject =
+            construct_handle<MetalBufferObject>(boh, *mContext, bindingType, usage, byteCount);
+    // If the allocation was not successful, postpone the error message until the next tick, to give
+    // Filament a chance to call setDebugTag on the handle; this way we get a nicer error message.
+    if (UTILS_UNLIKELY(!bufferObject->getBuffer()->wasAllocationSuccessful())) {
+        runAtNextTick([byteCount, this, boh]() {
+            FILAMENT_CHECK_POSTCONDITION(false)
+                    << "Could not allocate Metal buffer of size " << byteCount
+                    << ", tag=" << mHandleAllocator.getHandleTag(boh.getId()).c_str_safe();
+        });
+    }
 }
 
 void MetalDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint8_t levels,
@@ -2066,15 +2089,12 @@ void MetalDriver::setDebugTag(HandleBase::HandleId handleId, utils::CString tag)
 }
 
 void MetalDriver::runAtNextTick(const std::function<void()>& fn) noexcept {
-    std::lock_guard<std::mutex> const lock(mTickOpsLock);
     mTickOps.push_back(fn);
 }
 
 void MetalDriver::executeTickOps() noexcept {
     std::vector<std::function<void()>> ops;
-    mTickOpsLock.lock();
     std::swap(ops, mTickOps);
-    mTickOpsLock.unlock();
     for (const auto& f : ops) {
         f();
     }

filament/backend/src/metal/MetalHandles.mm

@@ -257,10 +257,6 @@ void MetalSwapChain::present() {
     }
 }
 
-#ifndef FILAMENT_RELEASE_PRESENT_DRAWABLE_MAIN_THREAD
-#define FILAMENT_RELEASE_PRESENT_DRAWABLE_MAIN_THREAD 1
-#endif
-
 class PresentDrawableData {
 public:
     PresentDrawableData() = delete;
@@ -279,14 +275,10 @@ public:
            [that->mDrawable present];
         }
 
-#if FILAMENT_RELEASE_PRESENT_DRAWABLE_MAIN_THREAD == 1
         // mDrawable is acquired on the driver thread. Typically, we would release this object on
         // the same thread, but after receiving consistent crash reports from within
         // [CAMetalDrawable dealloc], we suspect this object requires releasing on the main thread.
         dispatch_async(dispatch_get_main_queue(), ^{ cleanupAndDestroy(that); });
-#else
-        that->mDriver->runAtNextTick([that]() { cleanupAndDestroy(that); });
-#endif
     }
 
 private:

filament/backend/src/vulkan/VulkanConstants.h

@@ -165,14 +165,14 @@ constexpr static const int FVK_REQUIRED_VERSION_MINOR = 1;
 // buffers that have been submitted but have not yet finished rendering. Note that Filament can
 // issue multiple commit calls in a single frame, and that we use a triple buffered swap chain on
 // some platforms.
-constexpr static const int FVK_MAX_COMMAND_BUFFERS = 10;
+constexpr static const int FVK_MAX_COMMAND_BUFFERS = 3;
 
 // Number of command buffer submissions that should occur before an unused pipeline is removed
 // from the cache.
 //
 // If this number is low, VkPipeline construction will occur frequently, which can
 // be extremely slow. If this number is high, the memory footprint will be large.
-constexpr static const int FVK_MAX_PIPELINE_AGE = 10;
+constexpr static const int FVK_MAX_PIPELINE_AGE = 3;
 
 // VulkanPipelineCache does not track which command buffers contain references to which pipelines,
 // instead it simply waits for at least FVK_MAX_COMMAND_BUFFERS submissions to occur before

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -530,6 +530,8 @@ void VulkanDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint
     auto vktexture = mResourceAllocator.construct<VulkanTexture>(th, mPlatform->getDevice(),
             mPlatform->getPhysicalDevice(), mContext, mAllocator, &mCommands, target, levels,
             format, samples, w, h, depth, usage, mStagePool);
+//    FVK_LOGE <<"created texture: " << vktexture->getVkImage() << " dim=" <<
+//            vktexture->width << "x" << vktexture->height << utils::io::endl;
     mResourceManager.acquire(vktexture);
 }
 

filament/backend/src/vulkan/VulkanHandles.cpp

@@ -16,7 +16,6 @@
 
 #include "VulkanHandles.h"
 
-#include "VulkanDriver.h"
 #include "VulkanConstants.h"
 #include "VulkanDriver.h"
 #include "VulkanMemory.h"

filament/backend/src/vulkan/VulkanTexture.cpp

@@ -97,13 +97,11 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
         imageInfo.extent.depth = 1;
     }
 
-    // Filament expects blit() to work with any texture, so we almost always set these usage flags.
-    // TODO: investigate performance implications of setting these flags.
-    constexpr VkImageUsageFlags blittable = VK_IMAGE_USAGE_TRANSFER_DST_BIT |
-            VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-
-    if (any(usage & (TextureUsage::BLIT_DST | TextureUsage::BLIT_SRC))) {
-        imageInfo.usage |= blittable;
+    if (any(usage & TextureUsage::BLIT_SRC)) {
+        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    }
+    if (any(usage & TextureUsage::BLIT_DST)) {
+        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
     }
 
     if (any(usage & TextureUsage::SAMPLEABLE)) {
@@ -121,7 +119,7 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
         imageInfo.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
     }
     if (any(usage & TextureUsage::COLOR_ATTACHMENT)) {
-        imageInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | blittable;
+        imageInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         if (any(usage & TextureUsage::SUBPASS_INPUT)) {
             imageInfo.usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
         }
@@ -130,10 +128,9 @@ VulkanTexture::VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice,
         imageInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
     }
     if (any(usage & TextureUsage::UPLOADABLE)) {
-        imageInfo.usage |= blittable;
+        imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
     }
     if (any(usage & TextureUsage::DEPTH_ATTACHMENT)) {
-        imageInfo.usage |= blittable;
         imageInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 
         // Depth resolves uses a custom shader and therefore needs to be sampleable.

filament/src/PostProcessManager.cpp

@@ -3193,6 +3193,7 @@ FrameGraphId<FrameGraphTexture> PostProcessManager::resolve(FrameGraph& fg,
                 assert_invariant(dst);
                 assert_invariant(srcDesc.format == dstDesc.format);
                 assert_invariant(srcDesc.width == dstDesc.width && srcDesc.height == dstDesc.height);
+                assert_invariant(srcDesc.samples > 1 && dstDesc.samples <= 1);
                 driver.resolve(
                         dst, dstSubDesc.level, dstSubDesc.layer,
                         src, srcSubDesc.level, srcSubDesc.layer);

filament/src/RenderPass.h

@@ -528,7 +528,9 @@ public:
     // like above but allows to set specific flags
     RenderPassBuilder& renderFlags(
             RenderPass::RenderFlags mask, RenderPass::RenderFlags value) noexcept {
-        mFlags = (mFlags & mask) | (value & mask);
+        value &= mask;
+        mFlags &= ~mask;
+        mFlags |= value;
         return *this;
     }
 

filament/src/RendererUtils.cpp

@@ -40,6 +40,7 @@
 #include <utils/Panic.h>
 
 #include <algorithm>
+#include <optional>
 #include <utility>
 
 #include <stddef.h>
@@ -50,8 +51,9 @@ namespace filament {
 using namespace backend;
 using namespace math;
 
-FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
+RendererUtils::ColorPassOutput RendererUtils::colorPass(
         FrameGraph& fg, const char* name, FEngine& engine, FView const& view,
+        ColorPassInput const& colorPassInput,
         FrameGraphTexture::Descriptor const& colorBufferDesc,
         ColorPassConfig const& config, PostProcessManager::ColorGradingConfig colorGradingConfig,
         RenderPass::Executor passExecutor) noexcept {
@@ -67,8 +69,6 @@ FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
         FrameGraphId<FrameGraphTexture> structure;
     };
 
-    Blackboard& blackboard = fg.getBlackboard();
-
     auto& colorPass = fg.addPass<ColorPassData>(name,
             [&](FrameGraph::Builder& builder, ColorPassData& data) {
 
@@ -76,21 +76,21 @@ FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
                 TargetBufferFlags clearDepthFlags = config.clearFlags & TargetBufferFlags::DEPTH;
                 TargetBufferFlags clearStencilFlags = config.clearFlags & TargetBufferFlags::STENCIL;
 
-                data.shadows = blackboard.get<FrameGraphTexture>("shadows");
-                data.ssao = blackboard.get<FrameGraphTexture>("ssao");
-                data.color = blackboard.get<FrameGraphTexture>("color");
-                data.depth = blackboard.get<FrameGraphTexture>("depth");
+                data.color = colorPassInput.linearColor;
+                data.depth = colorPassInput.depth;
+                data.shadows = colorPassInput.shadows;
+                data.ssao = colorPassInput.ssao;
 
                 // Screen-space reflection or refractions
                 if (config.hasScreenSpaceReflectionsOrRefractions) {
-                    data.ssr = blackboard.get<FrameGraphTexture>("ssr");
+                    data.ssr = colorPassInput.ssr;
                     if (data.ssr) {
                         data.ssr = builder.sample(data.ssr);
                     }
                 }
 
                 if (config.hasContactShadows) {
-                    data.structure = blackboard.get<FrameGraphTexture>("structure");
+                    data.structure = colorPassInput.structure;
                     assert_invariant(data.structure);
                     data.structure = builder.sample(data.structure);
                 }
@@ -153,6 +153,8 @@ FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
                 }
 
                 if (colorGradingConfig.asSubpass) {
+                    assert_invariant(config.msaa <= 1);
+                    assert_invariant(colorBufferDesc.samples <= 1);
                     data.output = builder.createTexture("Tonemapped Buffer", {
                             .width = colorBufferDesc.width,
                             .height = colorBufferDesc.height,
@@ -194,7 +196,6 @@ FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
                         .samples = config.msaa,
                         .layerCount = static_cast<uint8_t>(colorBufferDesc.depth),
                         .clearFlags = clearColorFlags | clearDepthFlags | clearStencilFlags});
-                blackboard["depth"] = data.depth;
             },
             [=, passExecutor = std::move(passExecutor), &view, &engine](FrameGraphResources const& resources,
                     ColorPassData const& data, DriverApi& driver) {
@@ -260,24 +261,21 @@ FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
             }
     );
 
-    // when color grading is done as a subpass, the output of the color-pass is the ldr buffer
-    auto output = colorGradingConfig.asSubpass ? colorPass->output : colorPass->color;
-
-    blackboard["color"] = output;
-    return output;
+    return {
+            .linearColor = colorPass->color,
+            .tonemappedColor = colorPass->output,   // can be null
+            .depth = colorPass->depth
+    };
 }
 
-std::pair<FrameGraphId<FrameGraphTexture>, bool> RendererUtils::refractionPass(
+std::optional<RendererUtils::ColorPassOutput> RendererUtils::refractionPass(
         FrameGraph& fg, FEngine& engine, FView const& view,
+        ColorPassInput colorPassInput,
         ColorPassConfig config,
         PostProcessManager::ScreenSpaceRefConfig const& ssrConfig,
         PostProcessManager::ColorGradingConfig colorGradingConfig,
         RenderPass const& pass) noexcept {
 
-    auto& blackboard = fg.getBlackboard();
-    auto input = blackboard.get<FrameGraphTexture>("color");
-    FrameGraphId<FrameGraphTexture> output;
-
     // find the first refractive object in channel 2
     RenderPass::Command const* const refraction = std::partition_point(pass.begin(), pass.end(),
             [](auto const& command) {
@@ -292,34 +290,35 @@ std::pair<FrameGraphId<FrameGraphTexture>, bool> RendererUtils::refractionPass(
 
     // if there wasn't any refractive object, just skip everything below.
     if (UTILS_UNLIKELY(hasScreenSpaceRefraction)) {
-        PostProcessManager& ppm = engine.getPostProcessManager();
-
-        // clear the color/depth buffers, which will orphan (and cull) the color pass
-        input.clear();
-        blackboard.remove("color");
-        blackboard.remove("depth");
-
+        assert_invariant(!colorPassInput.linearColor);
+        assert_invariant(!colorPassInput.depth);
         config.hasScreenSpaceReflectionsOrRefractions = true;
 
-        input = RendererUtils::colorPass(fg, "Color Pass (opaque)", engine, view, {
+        PostProcessManager& ppm = engine.getPostProcessManager();
+        auto const opaquePassOutput = RendererUtils::colorPass(fg,
+                "Color Pass (opaque)", engine, view, colorPassInput, {
                         // When rendering the opaques, we need to conserve the sample buffer,
                         // so create a config that specifies the sample count.
                         .width = config.physicalViewport.width,
                         .height = config.physicalViewport.height,
                         .samples = config.msaa,
                         .format = config.hdrFormat
-                }, config, { .asSubpass = false },
+                },
+                config, { .asSubpass = false, .customResolve = false },
                 pass.getExecutor(pass.begin(), refraction));
 
         // generate the mipmap chain
         PostProcessManager::generateMipmapSSR(ppm, fg,
-                input, ssrConfig.refraction, true, ssrConfig);
+                opaquePassOutput.linearColor,
+                ssrConfig.refraction,
+                true, ssrConfig);
 
         // Now we're doing the refraction pass proper.
-        // This uses the same framebuffer (color and depth) used by the opaque pass. This happens
-        // automatically because these are set in the Blackboard (they were set by the opaque
-        // pass). For this reason, `desc` below is only used in colorPass() for the width and
-        // height.
+        // This uses the same framebuffer (color and depth) used by the opaque pass.
+        // For this reason, the `colorBufferDesc` parameter of colorPass() below is only used  for
+        // the width and height.
+        colorPassInput.linearColor = opaquePassOutput.linearColor;
+        colorPassInput.depth = opaquePassOutput.depth;
 
         // Since we're reusing the existing target we don't want to clear any of its buffer.
         // Important: if this target ended up being an imported target, then the clearFlags
@@ -327,22 +326,25 @@ std::pair<FrameGraphId<FrameGraphTexture>, bool> RendererUtils::refractionPass(
         // and we'd end up clearing the opaque pass. This scenario never happens because it is
         // prevented in Renderer.cpp's final blit.
         config.clearFlags = TargetBufferFlags::NONE;
-        output = RendererUtils::colorPass(fg, "Color Pass (transparent)", engine, view, {
+        auto transparentPassOutput = RendererUtils::colorPass(fg, "Color Pass (transparent)",
+                engine, view, colorPassInput, {
                         .width = config.physicalViewport.width,
                         .height = config.physicalViewport.height },
-                config, colorGradingConfig, pass.getExecutor(refraction, pass.end()));
+                config, colorGradingConfig,
+                pass.getExecutor(refraction, pass.end()));
 
         if (config.msaa > 1 && !colorGradingConfig.asSubpass) {
             // We need to do a resolve here because later passes (such as color grading or DoF) will
             // need to sample from 'output'. However, because we have MSAA, we know we're not
             // sampleable. And this is because in the SSR case, we had to use a renderbuffer to
             // conserve the multi-sample buffer.
-            output = ppm.resolve(fg, "Resolved Color Buffer", output, { .levels = 1 });
+            transparentPassOutput.linearColor = ppm.resolve(fg, "Resolved Color Buffer",
+                    transparentPassOutput.linearColor, { .levels = 1 });
         }
-    } else {
-        output = input;
+        return transparentPassOutput;
     }
-    return { output, hasScreenSpaceRefraction };
+
+    return std::nullopt;
 }
 
 UTILS_NOINLINE

filament/src/RendererUtils.h

@@ -21,14 +21,19 @@
 #include "RenderPass.h"
 
 #include "fg/FrameGraphId.h"
+#include "fg/FrameGraphTexture.h"
+
+#include <filament/Viewport.h>
 
 #include <backend/DriverEnums.h>
 #include <backend/PixelBufferDescriptor.h>
 
+#include <math/vec2.h>
 #include <math/vec4.h>
 
 #include <stdint.h>
 
+#include <optional>
 #include <utility>
 
 namespace filament {
@@ -71,15 +76,32 @@ public:
         bool screenSpaceReflectionHistoryNotReady;
     };
 
-    static FrameGraphId<FrameGraphTexture> colorPass(
+    struct ColorPassInput {
+        FrameGraphId<FrameGraphTexture> linearColor;
+        FrameGraphId<FrameGraphTexture> tonemappedColor;
+        FrameGraphId<FrameGraphTexture> depth;
+        FrameGraphId<FrameGraphTexture> shadows;
+        FrameGraphId<FrameGraphTexture> ssao;
+        FrameGraphId<FrameGraphTexture> ssr;
+        FrameGraphId<FrameGraphTexture> structure;
+    };
+    struct ColorPassOutput {
+        FrameGraphId<FrameGraphTexture> linearColor;
+        FrameGraphId<FrameGraphTexture> tonemappedColor;
+        FrameGraphId<FrameGraphTexture> depth;
+    };
+
+    static ColorPassOutput colorPass(
             FrameGraph& fg, const char* name, FEngine& engine, FView const& view,
+            ColorPassInput const& colorPassInput,
             FrameGraphTexture::Descriptor const& colorBufferDesc,
             ColorPassConfig const& config,
             PostProcessManager::ColorGradingConfig colorGradingConfig,
             RenderPass::Executor passExecutor) noexcept;
 
-    static std::pair<FrameGraphId<FrameGraphTexture>, bool> refractionPass(
+    static std::optional<RendererUtils::ColorPassOutput> refractionPass(
             FrameGraph& fg, FEngine& engine, FView const& view,
+            ColorPassInput colorPassInput,
             ColorPassConfig config,
             PostProcessManager::ScreenSpaceRefConfig const& ssrConfig,
             PostProcessManager::ColorGradingConfig colorGradingConfig,

filament/src/details/DebugRegistry.cpp

@@ -28,12 +28,6 @@
 #include <string_view>
 #include <utility>
 
-#ifndef NDEBUG
-#   define DEBUG_PROPERTIES_WRITABLE true
-#else
-#   define DEBUG_PROPERTIES_WRITABLE false
-#endif
-
 using namespace filament::math;
 using namespace utils;
 
@@ -79,17 +73,15 @@ bool FDebugRegistry::hasProperty(const char* name) const noexcept {
 
 template<typename T>
 bool FDebugRegistry::setProperty(const char* name, T v) noexcept {
-    if constexpr (DEBUG_PROPERTIES_WRITABLE) {
-        auto info = getPropertyInfo(name);
-        T* const addr = static_cast<T*>(info.first);
-        if (addr) {
-            auto old = *addr;
-            *addr = v;
-            if (info.second && old != v) {
-                info.second();
-            }
-            return true;
+    auto info = getPropertyInfo(name);
+    T* const addr = static_cast<T*>(info.first);
+    if (addr) {
+        auto old = *addr;
+        *addr = v;
+        if (info.second && old != v) {
+            info.second();
         }
+        return true;
     }
     return false;
 }

filament/src/details/RenderTarget.cpp

@@ -34,7 +34,7 @@ struct RenderTarget::BuilderDetails {
     uint32_t mWidth{};
     uint32_t mHeight{};
     uint8_t mSamples = 1;   // currently not settable in the public facing API
-    uint8_t mLayerCount = 0;// currently not settable in the public facing API
+    uint8_t mLayerCount = 1;// currently not settable in the public facing API
 };
 
 using BuilderType = RenderTarget;

filament/src/details/Renderer.cpp

@@ -655,16 +655,16 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
     // on qualcomm hardware -- we might need a backend dependent toggle at some point
     const PostProcessManager::ColorGradingConfig colorGradingConfig{
             .asSubpass =
-                    hasColorGrading &&
                     msaaSampleCount <= 1 &&
-                    !bloomOptions.enabled && !dofOptions.enabled && !taaOptions.enabled &&
                     driver.isFrameBufferFetchSupported() &&
+                    hasColorGrading &&
+                    !bloomOptions.enabled && !dofOptions.enabled && !taaOptions.enabled &&
                     !engine.debug.renderer.disable_subpasses,
             .customResolve =
-                    msaaOptions.customResolve &&
                     msaaSampleCount > 1 &&
-                    hasColorGrading &&
                     driver.isFrameBufferFetchMultiSampleSupported() &&
+                    msaaOptions.customResolve &&
+                    hasColorGrading &&
                     !engine.debug.renderer.disable_subpasses,
             .translucent = needsAlphaChannel,
             .fxaa = hasFXAA,
@@ -673,6 +673,9 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
                     TextureFormat::RGBA8 : getLdrFormat(needsAlphaChannel)
     };
 
+    // by construction (msaaSampleCount) both asSubpass and customResolve can't be true
+    assert_invariant(colorGradingConfig.asSubpass + colorGradingConfig.customResolve < 2);
+
     // whether we're scaled at all
      bool scaled = any(notEqual(scale, float2(1.0f)));
 
@@ -695,13 +698,12 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
 
     CameraInfo cameraInfo = view.computeCameraInfo(engine);
 
-    // when colorgrading-as-subpass is active, we know that many other effects are disabled
-    // such as dof, bloom. Moreover, if fxaa and scaling are not enabled, we're essentially in
-    // a very fast rendering path -- in this case, we would need an extra blit to "resolve" the
-    // buffer padding (because there are no other pass that can do it as a side effect).
-    // In this case, it is better to skip the padding, which won't be helping much.
-    const bool noBufferPadding = (colorGradingConfig.asSubpass && !hasFXAA && !scaled)
-            || engine.debug.renderer.disable_buffer_padding;
+    // If fxaa and scaling are not enabled, we're essentially in a very fast rendering path -- in
+    // this case, we would need an extra blit to "resolve" the buffer padding (because there are no
+    // other pass that can do it as a side effect). In this case, it is better to skip the padding,
+    // which won't be helping much.
+    const bool noBufferPadding
+            = (!hasFXAA && !scaled) || engine.debug.renderer.disable_buffer_padding;
 
     // guardBand must be a multiple of 16 to guarantee the same exact rendering up to 4 mip levels.
     float const guardBand = guardBandOptions.enabled ? 16.0f : 0.0f;
@@ -952,7 +954,6 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
             .scale = aoOptions.resolution,
             .picking = view.hasPicking()
     });
-    blackboard["structure"] = structure;
     const auto picking = picking_;
 
 
@@ -1000,7 +1001,6 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
             ssReflectionsOptions.enabled ? TextureFormat::RGBA16F : TextureFormat::R11F_G11F_B10F,
             view.getCameraUser().getFieldOfView(Camera::Fov::VERTICAL), config.scale);
     config.ssrLodOffset = ssrConfig.lodOffset;
-    blackboard["ssr"] = ssrConfig.ssr;
 
     // --------------------------------------------------------------------------------------------
     // screen-space reflections pass
@@ -1104,24 +1104,39 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
     );
 
     // the color pass itself + color-grading as subpass if needed
-    auto colorPassOutput = RendererUtils::colorPass(fg, "Color Pass", mEngine, view,
+    auto colorPassOutput = RendererUtils::colorPass(fg, "Color Pass", mEngine, view, {
+                .shadows = blackboard.get<FrameGraphTexture>("shadows"),
+                .ssao = blackboard.get<FrameGraphTexture>("ssao"),
+                .ssr = ssrConfig.ssr,
+                .structure = structure
+            },
             colorBufferDesc, config, colorGradingConfigForColor, pass.getExecutor());
 
     if (view.isScreenSpaceRefractionEnabled() && !pass.empty()) {
-        // this cancels the colorPass() call above if refraction is active.
-        // the color pass + refraction + color-grading as subpass if needed
-        const auto [output, enabled] = RendererUtils::refractionPass(fg, mEngine, view,
+        // This cancels the colorPass() call above if refraction is active.
+        // The color pass + refraction + color-grading as subpass if needed
+        auto const output = RendererUtils::refractionPass(fg, mEngine, view, {
+                        .shadows = blackboard.get<FrameGraphTexture>("shadows"),
+                        .ssao = blackboard.get<FrameGraphTexture>("ssao"),
+                        .ssr = ssrConfig.ssr,
+                        .structure = structure
+                },
                 config, ssrConfig, colorGradingConfigForColor, pass);
-        colorPassOutput = output;
-        hasScreenSpaceRefraction = enabled;
+
+        hasScreenSpaceRefraction = output.has_value();
+        if (hasScreenSpaceRefraction) {
+            colorPassOutput = output.value();
+        }
     }
 
     if (colorGradingConfig.customResolve) {
+        assert_invariant(fg.getDescriptor(colorPassOutput.linearColor).samples <= 1);
         // TODO: we have to "uncompress" (i.e. detonemap) the color buffer here because it's used
         //       by many other passes (Bloom, TAA, DoF, etc...). We could make this more
         //       efficient by using ARM_shader_framebuffer_fetch. We use a load/store (i.e.
         //       subpass) here because it's more convenient.
-        colorPassOutput = ppm.customResolveUncompressPass(fg, colorPassOutput);
+        colorPassOutput.linearColor =
+                ppm.customResolveUncompressPass(fg, colorPassOutput.linearColor);
     }
 
     // export the color buffer if screen-space reflections are enabled
@@ -1137,7 +1152,9 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
                     // The "output" of this pass is going to be used during the next frame as
                     // an "import".
                     builder.sideEffect();
-                    data.history = builder.sample(colorPassOutput); // FIXME: an access must be declared for detach(), why?
+
+                    // we can't use colorPassOutput here because it could be tonemapped
+                    data.history = builder.sample(colorPassOutput.linearColor); // FIXME: an access must be declared for detach(), why?
                 }, [&view, projection](FrameGraphResources const& resources, auto const& data,
                         backend::DriverApi&) {
                     auto& history = view.getFrameHistory();
@@ -1147,7 +1164,14 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
                 });
     }
 
-    FrameGraphId<FrameGraphTexture> input = colorPassOutput;
+    // this is the output of the color pass / input to post processing,
+    // this is only used later for comparing it with the output after post-processing
+    FrameGraphId<FrameGraphTexture> const postProcessInput = colorGradingConfig.asSubpass ?
+                                                           colorPassOutput.tonemappedColor :
+                                                           colorPassOutput.linearColor;
+
+    // input can change below
+    FrameGraphId<FrameGraphTexture> input = postProcessInput;
     fg.addTrivialSideEffectPass("Finish Color Passes", [&view](DriverApi& driver) {
         // Unbind SSAO sampler, b/c the FrameGraph will delete the texture at the end of the pass.
         view.cleanupRenderPasses();
@@ -1158,8 +1182,7 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
     // if the depth is not used below or if the depth is not MS (e.g. it could have been
     // auto-resolved).
     // In practice, this is used on Vulkan and older Metal devices.
-    auto depth = blackboard.get<FrameGraphTexture>("depth");
-    depth = ppm.resolve(fg, "Resolved Depth Buffer", depth, { .levels = 1 });
+    auto depth = ppm.resolve(fg, "Resolved Depth Buffer", colorPassOutput.depth, { .levels = 1 });
 
     // Debug: CSM visualisation
     if (UTILS_UNLIKELY(engine.debug.shadowmap.visualize_cascades &&
@@ -1275,7 +1298,7 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
     // The intermediate buffer is accomplished with a "fake" opaqueBlit (i.e. blit) operation.
 
     const bool outputIsSwapChain =
-            (input == colorPassOutput) && (viewRenderTarget == mRenderTargetHandle);
+            (input == postProcessInput) && (viewRenderTarget == mRenderTargetHandle);
     if (mightNeedFinalBlit) {
         if (blendModeTranslucent ||
             xvp != svp ||

ios/CocoaPods/Filament.podspec

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

samples/CMakeLists.txt

@@ -39,6 +39,7 @@ set(MATERIAL_SRCS
         materials/sandboxSubsurface.mat
         materials/sandboxUnlit.mat
         materials/texturedLit.mat
+        materials/iconTest.mat
 )
 
 if (CMAKE_CROSSCOMPILING)
@@ -270,6 +271,7 @@ if (NOT ANDROID)
     add_demo(viewtest)
 
     # Sample app specific
+    target_link_libraries(hellotriangle PRIVATE gltf-demo-resources uberarchive gltfio)
     target_link_libraries(frame_generator PRIVATE imageio)
     target_link_libraries(gltf_viewer PRIVATE gltf-demo-resources uberarchive gltfio viewer)
     target_link_libraries(gltf_instances PRIVATE gltf-demo-resources uberarchive gltfio viewer)

samples/hellotriangle.cpp

@@ -1,192 +1,490 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+#include <fstream>
+#include <iostream>
 
 #include <filament/Camera.h>
 #include <filament/Engine.h>
 #include <filament/IndexBuffer.h>
-#include <filament/Material.h>
-#include <filament/MaterialInstance.h>
+#include <filament/LightManager.h>
 #include <filament/RenderableManager.h>
+#include <filament/Renderer.h>
 #include <filament/Scene.h>
 #include <filament/Skybox.h>
-#include <filament/TransformManager.h>
-#include <filament/VertexBuffer.h>
 #include <filament/View.h>
+#include <filament/Viewport.h>
+#include <filament/SwapChain.h>
+#include <filament/Texture.h>
+#include <filament/TransformManager.h>
+#include <filament/RenderTarget.h>
+
+#include <filamat/MaterialBuilder.h>
 
 #include <utils/EntityManager.h>
+#include <utils/Log.h>
 
-#include <filamentapp/Config.h>
-#include <filamentapp/FilamentApp.h>
+#include <math/norm.h>
 
-#include <getopt/getopt.h>
+#include <gltfio/AssetLoader.h>
+#include <gltfio/ResourceLoader.h>
 
-#include <cmath>
-#include <iostream>
+#include <SDL.h>
+#include <SDL_syswm.h>
+#include <SDL_video.h>
 
+#include <filamentapp/NativeWindowHelper.h>
 
 #include "generated/resources/resources.h"
+#include "materials/uberarchive.h"
+
+#include <vector>
 
 using namespace filament;
-using utils::Entity;
-using utils::EntityManager;
+using namespace math;
+using namespace utils;
 
-struct App {
-    Config config;
-    VertexBuffer* vb;
-    IndexBuffer* ib;
-    Material* mat;
-    Camera* cam;
-    Entity camera;
-    Skybox* skybox;
-    Entity renderable;
+namespace {
+
+const static uint32_t gIndices[] = {0, 1, 2, 2, 3, 0};
+
+float const QUAD_WIDTH = .5;
+
+const static math::float3 gVertices[] = {
+    float3 {0, 0, 0} * QUAD_WIDTH,
+    float3 {0, 1, 0} * QUAD_WIDTH,
+    float3 {1, 1, 0} * QUAD_WIDTH,
+    float3 {1, 0, 0} * QUAD_WIDTH,
 };
 
-struct Vertex {
-    filament::math::float2 position;
-    uint32_t color;
+const static math::float2 gUVs[] = {
+    {0, 0},
+    {0, 1},
+    {1, 1},
+    {1, 0},
 };
 
-static const Vertex TRIANGLE_VERTICES[3] = {
-    {{1, 0}, 0xffff0000u},
-    {{cos(M_PI * 2 / 3), sin(M_PI * 2 / 3)}, 0xff00ff00u},
-    {{cos(M_PI * 4 / 3), sin(M_PI * 4 / 3)}, 0xff0000ffu},
-};
+const static short4 tbn = math::packSnorm16(mat3f::packTangentFrame(
+        math::mat3f{float3{1.0f, 0.0f, 0.0f}, float3{0.0f, 0.0f, 1.0f},
+            float3{0.0f, 1.0f, 0.0f}}).xyzw);
 
-static constexpr uint16_t TRIANGLE_INDICES[3] = { 0, 1, 2 };
+const static math::short4 gNormals[]{tbn, tbn, tbn, tbn};
 
-static void printUsage(char* name) {
-    std::string exec_name(utils::Path(name).getName());
-    std::string usage(
-            "HELLOTRIANGLE renders a spinning colored triangle\n"
-            "Usage:\n"
-            "    HELLOTRIANGLE [options]\n"
-            "Options:\n"
-            "   --help, -h\n"
-            "       Prints this message\n\n"
-            "   --api, -a\n"
-            "       Specify the backend API: opengl, vulkan, or metal\n"
-    );
-    const std::string from("HELLOTRIANGLE");
-    for (size_t pos = usage.find(from); pos != std::string::npos; pos = usage.find(from, pos)) {
-        usage.replace(pos, from.length(), exec_name);
+struct TestPrimitive {
+    TestPrimitive(Engine* engine) {
+        vertexBuffer =
+                VertexBuffer::Builder()
+                        .vertexCount(4)
+                        .bufferCount(3)
+                        .attribute(VertexAttribute::POSITION, 0,
+                                VertexBuffer::AttributeType::FLOAT3)
+                        .attribute(VertexAttribute::UV0, 1, VertexBuffer::AttributeType::FLOAT2)
+                        .attribute(VertexAttribute::TANGENTS, 2, VertexBuffer::AttributeType::FLOAT4)
+                        .build(*engine);
+        vertexBuffer->setBufferAt(*engine, 0,
+                VertexBuffer::BufferDescriptor(gVertices,
+                        vertexBuffer->getVertexCount() * sizeof(gVertices[0])));
+        vertexBuffer->setBufferAt(*engine, 1,
+                VertexBuffer::BufferDescriptor(gUVs,
+                        vertexBuffer->getVertexCount() * sizeof(gUVs[0])));
+        vertexBuffer->setBufferAt(*engine, 2,
+                VertexBuffer::BufferDescriptor(gNormals,
+                        vertexBuffer->getVertexCount() * sizeof(gNormals[0])));
+
+        indexBuffer = IndexBuffer::Builder().indexCount(6).build(*engine);
+
+        indexBuffer->setBuffer(*engine, IndexBuffer::BufferDescriptor(gIndices,
+                                                indexBuffer->getIndexCount() * sizeof(uint32_t)));
     }
-    std::cout << usage;
+
+    VertexBuffer* verts() const { return vertexBuffer; }
+    IndexBuffer* inds() const { return indexBuffer; }
+
+private:
+    VertexBuffer* vertexBuffer;
+    IndexBuffer* indexBuffer;
+};
+
+struct TestMaterial {
+    TestMaterial(Engine* engine) {
+        material = Material::Builder()
+                .package(RESOURCES_ICONTEST_DATA, RESOURCES_ICONTEST_SIZE)
+                .build(*engine);
+    }
+
+    MaterialInstance* instance() {
+        auto inst = material->createInstance();
+        instances.push_back(inst);
+        return inst;
+    }
+
+private:
+    Material* material;
+    std::vector<MaterialInstance*> instances;
+};
+
+struct TestTexture {
+    TestTexture(Engine* engine, size_t width, size_t height, bool attachment=false) {
+        auto usage = Texture::Usage::DEFAULT;
+        if (attachment) {
+            usage = usage | Texture::Usage::COLOR_ATTACHMENT;
+        }
+        texture = Texture::Builder()
+            .width(width).height(height).levels(1)
+            .usage(usage)
+            .format(Texture::InternalFormat::RGBA8).build(*engine);
+        uint8_t* data = (uint8_t*) malloc(width * height * 4);
+        std::memset(data, 0xFF, width * height * 4);
+        Texture::PixelBufferDescriptor buffer(data, size_t(width * height * 4),
+                                              Texture::Format::RGBA, Texture::Type::UBYTE,
+                                              [](void* buf, size_t size, void* user) {
+                                                  free(buf);
+                                              });
+        texture->setImage(*engine, 0, 0, 0, 0, width, height, 1, std::move(buffer));
+    }
+    Texture* get() const  { return texture; }
+private:
+    Texture* texture;
+};
+
+std::pair<SDL_Window*, void*> createSDLwindow() {
+    const uint32_t windowFlags = SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI;
+    SDL_Window* win = SDL_CreateWindow("Hello World!", 0, 100, 800, 800, windowFlags);
+    if (win == nullptr) {
+        std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
+        SDL_Quit();
+        return {NULL, NULL};
+    }
+
+    void* nativeWindow = getNativeWindow(win);
+#if defined(__APPLE__)
+    prepareNativeWindow(win);
+    setUpMetalLayer(nativeWindow);
+#endif
+
+    return {win, nativeWindow};
 }
 
-static int handleCommandLineArguments(int argc, char* argv[], App* app) {
-    static constexpr const char* OPTSTR = "ha:";
-    static const struct option OPTIONS[] = {
-            { "help", no_argument,       nullptr, 'h' },
-            { "api",  required_argument, nullptr, 'a' },
-            { nullptr, 0,                nullptr, 0 }
+struct IconScene {
+
+    struct Option {
+        float border=1.4;
+        bool postProcessing=true;
+        bool useSkybox=false;
     };
-    int opt;
-    int option_index = 0;
-    while ((opt = getopt_long(argc, argv, OPTSTR, OPTIONS, &option_index)) >= 0) {
-        std::string arg(optarg ? optarg : "");
-        switch (opt) {
-            default:
-            case 'h':
-                printUsage(argv[0]);
-                exit(0);
-            case 'a':
-                if (arg == "opengl") {
-                    app->config.backend = Engine::Backend::OPENGL;
-                } else if (arg == "vulkan") {
-                    app->config.backend = Engine::Backend::VULKAN;
-                } else if (arg == "metal") {
-                    app->config.backend = Engine::Backend::METAL;
-                } else {
-                    std::cerr << "Unrecognized backend. Must be 'opengl'|'vulkan'|'metal'.\n";
-                    exit(1);
-                }
-                break;
+
+    IconScene(Engine* engine, Renderer* renderer, uint32_t w, uint32_t h, Option option)
+        : engine(engine),
+          renderer(renderer),
+          material(engine),
+          primitives(engine) {
+        cameraEntity = EntityManager::get().create();
+        camera = engine->createCamera(cameraEntity);
+        camera->lookAt(float3(0, 0, -10.f), float3(0, 0, 0), float3(0, 1.0f, 0));
+        float halfWidth = (QUAD_WIDTH / 2) * option.border;
+        camera->setProjection(Camera::Projection::ORTHO,
+                -halfWidth , halfWidth, -halfWidth, halfWidth, -50, 50);
+
+        scene = engine->createScene();
+
+        view = engine->createView();
+        view->setViewport({0, 0, w, h});
+        view->setScene(scene);
+        view->setCamera(camera);
+        view->setPostProcessingEnabled(false);
+
+        Entity renderable = EntityManager::get().create();
+        matInstance = material.instance();
+        RenderableManager::Builder(1)
+                .boundingBox({{-10, -10, -10}, {10, 10, 10}})
+                .material(0, matInstance)
+                .geometry(0, RenderableManager::PrimitiveType::TRIANGLES,
+                        primitives.verts(), primitives.inds(), 0, 6)
+                .culling(false)
+                .build(*engine, renderable);
+
+        scene->addEntity(renderable);
+
+        auto& tcm = engine->getTransformManager();
+        tcm.create(renderable);
+        auto inst = tcm.getInstance(renderable);
+        mat4f xlate = mat4f::translation(float3(QUAD_WIDTH / -2.0, QUAD_WIDTH / -2.0, 0));
+        tcm.setTransform(inst, xlate);
+    }
+
+    void render(Texture* texture, Texture* renderTargetTexture, float3 const& multiplier) {
+        TextureSampler sampler{TextureSampler::MinFilter::NEAREST,
+                TextureSampler::MagFilter::NEAREST};
+
+        matInstance->setParameter("tex", texture, sampler);
+        matInstance->setParameter("multiplier", multiplier);
+
+        RenderTarget* target;
+        if (auto itr = targets.find(renderTargetTexture); itr != targets.end()) {
+            target = itr->second;
+        } else {
+            target = RenderTarget::Builder()
+                    .texture(RenderTarget::AttachmentPoint::COLOR, renderTargetTexture)
+                    .build(*engine);
+            targets[renderTargetTexture] = target;
+        }
+
+        view->setRenderTarget(target);
+        renderer->renderStandaloneView(view);
+    }
+
+    void renderToSwapChain(SwapChain* swapChain, Texture* texture) {
+        TextureSampler sampler{TextureSampler::MinFilter::NEAREST,
+                TextureSampler::MagFilter::NEAREST};
+        matInstance->setParameter("tex", texture, sampler);
+        matInstance->setParameter("multiplier", float3 {1});
+
+        if (renderer->beginFrame(swapChain)) {
+            // for each View
+            renderer->render(view);
+            renderer->endFrame();
         }
     }
-    return optind;
+
+
+private:
+    Engine* engine;
+    Renderer* renderer;
+    View* view;
+    Scene* scene;
+    Camera* camera;
+    TestMaterial material;
+    TestPrimitive primitives;
+    Entity cameraEntity;
+    Skybox* skybox;
+    MaterialInstance* matInstance;
+    std::unordered_map<Texture*, RenderTarget*> targets;
+};
+
+struct MainScene {
+    using TextureMatrix = std::vector<std::vector<Texture*>>;
+
+    MainScene(Engine* engine, Renderer* renderer, uint32_t w, uint32_t h, uint32_t nrows,
+            uint32_t ncols)
+        : renderer(renderer),
+          primitives{engine},
+          material(engine),
+          engine(engine) {
+        cameraEntity = EntityManager::get().create();
+
+        camera = engine->createCamera(cameraEntity);
+        camera->lookAt(float3(0, 0, -10.f), float3(0, 0, 0), float3(0, 1.0f, 0));
+        camera->setProjection(45.0, double(w) / h, 0.1, 50, Camera::Fov::VERTICAL);
+
+        scene = engine->createScene();
+
+//        skybox = Skybox::Builder().color({0.2, 0.2, 0.2, 1.0}).build(*engine);
+//        scene->setSkybox(skybox);
+
+        view = engine->createView();
+        view->setViewport({0, 0, w, h});
+        view->setScene(scene);
+        view->setCamera(camera);
+        view->setPostProcessingEnabled(false);
+
+        root = EntityManager::get().create();
+        auto& tcm = engine->getTransformManager();
+        tcm.create(root);
+        auto rootInst = tcm.getInstance(root);
+        mat4f xlate = mat4f::translation(float3(-QUAD_WIDTH / 2 * nrows , -QUAD_WIDTH / 2 * ncols, 0));
+        tcm.setTransform(rootInst, xlate);
+
+        matInst = material.instance();
+
+        renderable = EntityManager::get().create();
+        scene->addEntity(renderable);
+        RenderableManager::Builder(1)
+                .boundingBox({{-10, -10, -10}, {10, 10, 10}})
+                .material(0, matInst)
+                .geometry(0, RenderableManager::PrimitiveType::TRIANGLES,
+                        primitives.verts(), primitives.inds(), 0, 6)
+                .culling(false)
+                .build(*engine, renderable);
+
+        auto transformInst = tcm.getInstance(renderable);
+        tcm.setParent(transformInst, rootInst);
+    }
+
+    void render(Texture* texture, RenderTarget* target, uint32_t r, uint32_t c) {
+        auto& tcm = engine->getTransformManager();
+        TextureSampler sampler{TextureSampler::MinFilter::NEAREST,
+                TextureSampler::MagFilter::NEAREST};
+        matInst->setParameter("tex", texture, sampler);
+        matInst->setParameter("multiplier", float3 {1});
+
+        auto transformInst = tcm.getInstance(renderable);
+        mat4f xlate = mat4f::translation(float3(QUAD_WIDTH * r, QUAD_WIDTH * c, 0));
+        tcm.setTransform(transformInst, xlate);
+
+        view->setRenderTarget(target);
+        renderer->renderStandaloneView(view);
+    }
+
+    void renderToSwapChain(SwapChain* swapChain, Texture* texture, uint32_t r, uint32_t c){
+        auto& tcm = engine->getTransformManager();
+        TextureSampler sampler{TextureSampler::MinFilter::NEAREST,
+                TextureSampler::MagFilter::NEAREST};
+        matInst->setParameter("tex", texture, sampler);
+        matInst->setParameter("multiplier", float3 {1});
+
+        auto transformInst = tcm.getInstance(renderable);
+        mat4f xlate = mat4f::translation(float3(QUAD_WIDTH * r, QUAD_WIDTH * c, 0));
+        tcm.setTransform(transformInst, xlate);
+
+        if (renderer->beginFrame(swapChain)) {
+            // for each View
+            renderer->render(view);
+            renderer->endFrame();
+        }
+    }
+
+
+    Scene* get() const { return scene; }
+    Camera* getCamera() const { return camera; }
+    View* getView() const { return view; }
+
+private:
+    Renderer* renderer;
+    TestMaterial material;
+    MaterialInstance* matInst;
+    TestPrimitive primitives;
+    TextureMatrix textures;
+    Scene* scene;
+    Entity light;
+    Entity root;
+    Entity renderable;
+    Camera* camera;
+    Entity cameraEntity;
+    Skybox* skybox;
+    View* view;
+    std::vector<Entity> renderables;
+    Engine* engine;
+};
+
 }
 
-int main(int argc, char** argv) {
-    App app{};
-    app.config.title = "hellotriangle";
-    app.config.featureLevel = backend::FeatureLevel::FEATURE_LEVEL_0;
-    handleCommandLineArguments(argc, argv, &app);
+int main() {
+    SDL_Init(SDL_INIT_EVERYTHING);
+    auto const [window, nativeWindow] = createSDLwindow();
 
-    auto setup = [&app](Engine* engine, View* view, Scene* scene) {
-        app.skybox = Skybox::Builder().color({0.1, 0.125, 0.25, 1.0}).build(*engine);
-        scene->setSkybox(app.skybox);
-        view->setPostProcessingEnabled(false);
-        static_assert(sizeof(Vertex) == 12, "Strange vertex size.");
-        app.vb = VertexBuffer::Builder()
-                .vertexCount(3)
-                .bufferCount(1)
-                .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT2, 0, 12)
-                .attribute(VertexAttribute::COLOR, 0, VertexBuffer::AttributeType::UBYTE4, 8, 12)
-                .normalized(VertexAttribute::COLOR)
-                .build(*engine);
-        app.vb->setBufferAt(*engine, 0,
-                VertexBuffer::BufferDescriptor(TRIANGLE_VERTICES, 36, nullptr));
-        app.ib = IndexBuffer::Builder()
-                .indexCount(3)
-                .bufferType(IndexBuffer::IndexType::USHORT)
-                .build(*engine);
-        app.ib->setBuffer(*engine,
-                IndexBuffer::BufferDescriptor(TRIANGLE_INDICES, 6, nullptr));
-        app.mat = Material::Builder()
-                .package(RESOURCES_BAKEDCOLOR_DATA, RESOURCES_BAKEDCOLOR_SIZE)
-                .build(*engine);
-        app.renderable = EntityManager::get().create();
-        RenderableManager::Builder(1)
-                .boundingBox({{ -1, -1, -1 }, { 1, 1, 1 }})
-                .material(0, app.mat->getDefaultInstance())
-                .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, app.vb, app.ib, 0, 3)
-                .culling(false)
-                .receiveShadows(false)
-                .castShadows(false)
-                .build(*engine, app.renderable);
-        scene->addEntity(app.renderable);
-        app.camera = utils::EntityManager::get().create();
-        app.cam = engine->createCamera(app.camera);
-        view->setCamera(app.cam);
+    Engine* engine = Engine::create(filament::backend::Backend::VULKAN);
+    SwapChain* swapChain =
+            engine->createSwapChain(nativeWindow, filament::SwapChain::CONFIG_HAS_STENCIL_BUFFER);
+    Renderer* renderer = engine->createRenderer();
+
+    // Determine the current size of the window in physical pixels.
+    uint32_t w, h;
+    SDL_GL_GetDrawableSize(window, (int*) &w, (int*) &h);
+
+    filamat::MaterialBuilder::init();
+
+    TestTexture matTexture {engine, 27, 27};
+
+    size_t const nrow = 10, ncol = 10;
+
+    uint32_t const iconWidth = 50;
+    uint32_t const iconHeight = 50;
+
+    IconScene iconScene {engine, renderer, iconWidth, iconHeight, {.useSkybox=false} };
+
+    auto buildTargets = [nrow, ncol, engine]() {
+        std::vector<std::vector<Texture*>> targets;
+        for (size_t r = 0; r < nrow; r++) {
+            std::vector<Texture*> row;
+            for (size_t c = 0; c < ncol; c++) {
+                TestTexture ttex {engine, iconWidth, iconHeight, true };
+                row.push_back(ttex.get());
+            }
+            targets.push_back(row);
+        }
+        return targets;
     };
 
-    auto cleanup = [&app](Engine* engine, View*, Scene*) {
-        engine->destroy(app.skybox);
-        engine->destroy(app.renderable);
-        engine->destroy(app.mat);
-        engine->destroy(app.vb);
-        engine->destroy(app.ib);
-        engine->destroyCameraComponent(app.camera);
-        utils::EntityManager::get().destroy(app.camera);
-    };
+    std::vector<std::vector<Texture*>> targets0 = buildTargets();
+    std::vector<std::vector<Texture*>> targets1 = buildTargets();
+    std::vector<std::vector<Texture*>> targets2 = buildTargets();
 
-    FilamentApp::get().animate([&app](Engine* engine, View* view, double now) {
-        constexpr float ZOOM = 1.5f;
-        const uint32_t w = view->getViewport().width;
-        const uint32_t h = view->getViewport().height;
-        const float aspect = (float) w / h;
-        app.cam->setProjection(Camera::Projection::ORTHO,
-            -aspect * ZOOM, aspect * ZOOM,
-            -ZOOM, ZOOM, 0, 1);
-        auto& tcm = engine->getTransformManager();
-        tcm.setTransform(tcm.getInstance(app.renderable),
-                filament::math::mat4f::rotation(now, filament::math::float3{ 0, 0, 1 }));
-    });
+    MainScene scene(engine, renderer, w, h, nrow, ncol);
 
-    FilamentApp::get().run(app.config, setup, cleanup);
+    renderer->setClearOptions({.clear = false});
+    float3 const a {.7, .3, .3};
+    float3 const b {.3, .7, .3};
+    std::vector<std::pair<size_t, size_t>> coords;
+    for (size_t r = 0; r < nrow; r++) {
+        for (size_t c = 0; c < ncol; c++) {
+            coords.push_back({r, c});
+        }
+    }
 
+    IconScene swapChainScene{engine, renderer, w, h, {
+            .border = 1.0f, .postProcessing = false}};
+
+    TestTexture mainTex{engine, w, h, true};
+    auto mainRT = RenderTarget::Builder()
+            .texture(RenderTarget::AttachmentPoint::COLOR, mainTex.get())
+            .build(*engine);
+
+    bool closeWindow = false;
+    size_t count = 0;
+    while (!closeWindow && ++count) {
+        constexpr int kMaxEvents = 16;
+        SDL_Event events[kMaxEvents];
+        int nevents = 0;
+        while (nevents < kMaxEvents && SDL_PollEvent(&events[nevents]) != 0) {
+            nevents++;
+        }
+
+        // Now, loop over the events a second time for app-side processing.
+        for (int i = 0; i < nevents; i++) {
+            const SDL_Event& event = events[i];
+            switch (event.type) {
+                case SDL_QUIT:
+                    closeWindow = true;
+                    break;
+                case SDL_WINDOWEVENT:
+                    switch (event.window.event) {
+                        case SDL_WINDOWEVENT_RESIZED:
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        auto [r, c] = coords[count % coords.size()];
+        float3 color0 = (r + c) % 2 == 0 ? a : b;
+        float3 color1 = (r + c) % 2 == 0 ? b : a;
+        auto rt0 = targets0[r][c];
+        auto rt1 = targets1[r][c];
+        auto rt2 = targets2[r][c];
+        iconScene.render(matTexture.get(), rt0, color0);
+        iconScene.render(rt0, rt1, color1);
+        iconScene.render(rt1, rt2, float3 {.8});
+//        engine->flushAndWait();
+        scene.render(rt2, mainRT, r, c);
+//        engine->flushAndWait();
+//        engine->flush();
+//        scene.renderToSwapChain(swapChain, rt1, r, c);
+
+
+        if (count % 27 == 0) {
+            swapChainScene.renderToSwapChain(swapChain, mainTex.get());
+        }
+        SDL_Delay(16);
+
+        // if (renderer->beginFrame(swapChain)) {
+        //     // for each View
+        //     renderer->render(scene.getView());
+        //     renderer->endFrame();
+        // }
+
+
+//        SDL_Delay(16);
+
+    }
     return 0;
 }

samples/materials/iconTest.mat

@@ -0,0 +1,26 @@
+material {
+    name : Icon,
+    shadingModel : unlit,
+    requires : [
+        uv0
+    ],
+    parameters : [
+        {
+            type : sampler2d,
+            name : tex
+        },
+        {
+            type : float3,
+            name : multiplier
+        }
+    ],
+}
+
+fragment {
+    void material(inout MaterialInputs material) {
+        prepareMaterial(material); 
+        vec3 m = materialParams.multiplier;
+        vec3 rgb = texture(materialParams_tex, getUV0()).rgb * m;
+        material.baseColor = vec4(rgb, 1.0);
+    }
+}

web/filament-js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filament",
-  "version": "1.54.0",
+  "version": "1.54.1",
   "description": "Real-time physically based rendering engine",
   "main": "filament.js",
   "module": "filament.js",