Testing stencilling 3

docs/Materials.md.html

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

filament/backend/src/opengl/OpenGLContext.cpp

@@ -541,6 +541,9 @@ void OpenGLContext::initBugs(Bugs* bugs, Extensions const& exts,
             bugs->delay_fbo_destruction = true;
             // PowerVR seems to have no problem with this (which is good for us)
             bugs->allow_read_only_ancillary_feedback_loop = true;
+            // PowerVR doesn't respect lengths passed to glShaderSource, so concatenate them into a
+            // single string.
+            bugs->concatenate_shader_strings = true;
         } else if (strstr(renderer, "Apple")) {
             // Apple GPU
         } else if (strstr(renderer, "Tegra") ||

filament/backend/src/opengl/OpenGLContext.h

@@ -316,6 +316,12 @@ public:
         // bugs or performance issues.
         bool force_feature_level0;
 
+        // Some drivers don't respect the length argument of glShaderSource() and (apparently)
+        // require each shader source string to be null-terminated. This works around the issue by
+        // concatenating the strings into a single null-terminated string before passing it to
+        // glShaderSource().
+        bool concatenate_shader_strings;
+
     } bugs = {};
 
     // state getters -- as needed.
@@ -562,6 +568,9 @@ private:
             {   bugs.force_feature_level0,
                     "force_feature_level0",
                     ""},
+            {   bugs.concatenate_shader_strings,
+                    "concatenate_shader_strings",
+                    ""},
     }};
 
     // this is chosen to minimize code size

filament/backend/src/opengl/ShaderCompilerService.cpp

@@ -597,30 +597,40 @@ void ShaderCompilerService::compileShaders(OpenGLContext& context,
                 version = "#version 310 es\n";
             }
 
-            std::array<std::string_view, 5> sources = {
-                version,
-                prolog,
-                specializationConstantString,
-                packingFunctions,
-                { body.data(), body.size() - 1 }  // null-terminated
+            const std::array<const char*, 5> sources = {
+                    version.data(),
+                    prolog.data(),
+                    specializationConstantString.c_str(),
+                    packingFunctions.data(),
+                    body.data()
             };
 
-            // Some of the sources may be zero-length. Remove them as to avoid passing lengths of
-            // zero to glShaderSource(). glShaderSource should work with lengths of zero, but some
-            // drivers instead interpret zero as a sentinel for a null-terminated string.
-            auto partitionPoint = std::stable_partition(
-                    sources.begin(), sources.end(), [](std::string_view s) { return !s.empty(); });
-            size_t count = std::distance(sources.begin(), partitionPoint);
-
-            std::array<const char*, 5> shaderStrings;
-            std::array<GLint, 5> lengths;
-            for (size_t i = 0; i < count; i++) {
-                shaderStrings[i] = sources[i].data();
-                lengths[i] = sources[i].size();
-            }
+            const std::array<GLint, 5> lengths = {
+                    (GLint)version.length(),
+                    (GLint)prolog.length(),
+                    (GLint)specializationConstantString.length(),
+                    (GLint)packingFunctions.length(),
+                    (GLint)body.length() - 1 // null terminated
+            };
 
             GLuint const shaderId = glCreateShader(glShaderType);
-            glShaderSource(shaderId, count, shaderStrings.data(), lengths.data());
+
+            if (UTILS_UNLIKELY(context.bugs.concatenate_shader_strings)) {
+                size_t totalSize = 0;
+                for (size_t i = 0; i < sources.size(); i++) {
+                    totalSize += lengths[i];
+                }
+                std::string concatenatedShaderSource;
+                concatenatedShaderSource.reserve(totalSize);
+                for (size_t i = 0; i < sources.size(); i++) {
+                    concatenatedShaderSource.append(sources[i], lengths[i]);
+                }
+                const GLchar* ptr = concatenatedShaderSource.c_str();
+                GLint length = concatenatedShaderSource.length();
+                glShaderSource(shaderId, 1, &ptr, &length);
+            } else {
+                glShaderSource(shaderId, sources.size(), sources.data(), lengths.data());
+            }
 
             glCompileShader(shaderId);
 

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -606,7 +606,7 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
         }
     }
 
-    VulkanAttachment depthStencil[2] = {};
+    VulkanAttachment depthStencil;
     if (depth.handle) {
         depthStencil[0] = {
             .texture = mResourceAllocator.handle_cast<VulkanTexture*>(depth.handle),
@@ -621,19 +621,8 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
         attachmentCount++;
     }
 
-    if (stencil.handle) {
-        depthStencil[1] = {
-            .texture = mResourceAllocator.handle_cast<VulkanTexture*>(stencil.handle),
-            .level = stencil.level,
-            .baseViewIndex = stencil.baseViewIndex,
-            .layerCount = layerCount,
-            .layer = stencil.layer,
-        };
-        UTILS_UNUSED_IN_RELEASE VkExtent2D extent = depthStencil[1].getExtent2D();
-        tmin = { std::min(tmin.x, extent.width), std::min(tmin.y, extent.height) };
-        tmax = { std::max(tmax.x, extent.width), std::max(tmax.y, extent.height) };
-        attachmentCount++;
-    }
+    // The stencil buffer is always assumed to be part of the depth-stencil buffer.    
+    assert_invariant(!stencil.handle || stencil.handle == depth.handle);
 
     // All attachments must have the same dimensions, which must be greater than or equal to the
     // render target dimensions.

filament/backend/src/vulkan/VulkanHandles.cpp

@@ -314,7 +314,7 @@ void VulkanRenderTarget::bindToSwapChain(VulkanSwapChain& swapChain) {
     assert_invariant(!mOffscreen);
     VkExtent2D const extent = swapChain.getExtent();
     mColor[0] = { .texture = swapChain.getCurrentColor() };
-    mDepth = { .texture = swapChain.getDepth() };
+    mDepthStencil = { .texture = swapChain.getDepth() };
     width = extent.width;
     height = extent.height;
 }
@@ -323,7 +323,7 @@ VulkanRenderTarget::VulkanRenderTarget(VkDevice device, VkPhysicalDevice physica
         VulkanContext const& context, VmaAllocator allocator, VulkanCommands* commands,
         uint32_t width, uint32_t height, uint8_t samples,
         VulkanAttachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT],
-        VulkanAttachment depthStencil[2], VulkanStagePool& stagePool, uint8_t layerCount)
+        VulkanAttachment depthStencil, VulkanStagePool& stagePool, uint8_t layerCount)
     : HwRenderTarget(width, height),
       VulkanResource(VulkanResourceType::RENDER_TARGET),
       mOffscreen(true),
@@ -332,8 +332,8 @@ VulkanRenderTarget::VulkanRenderTarget(VkDevice device, VkPhysicalDevice physica
     for (int index = 0; index < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; index++) {
         mColor[index] = color[index];
     }
-    mDepth = depthStencil[0];
-    VulkanTexture* depthTexture = (VulkanTexture*) mDepth.texture;
+    mDepthStencil = depthStencil[0];
+    VulkanTexture* depthTexture = (VulkanTexture*) mDepthStencil.texture;
 
     if (samples == 1) {
         return;
@@ -372,7 +372,7 @@ VulkanRenderTarget::VulkanRenderTarget(VkDevice device, VkPhysicalDevice physica
 
     // There is no need for sidecar depth if the depth texture is already MSAA.
     if (depthTexture->samples > 1) {
-        mMsaaDepthAttachment = mDepth;
+        mMsaaDepthAttachment = mDepthStencil;
         return;
     }
 
@@ -392,7 +392,7 @@ VulkanRenderTarget::VulkanRenderTarget(VkDevice device, VkPhysicalDevice physica
     mMsaaDepthAttachment = {
         .texture = msTexture,
         .level = msLevel,
-        .layer = mDepth.layer,
+        .layer = mDepthStencil.layer,
     };
 }
 
@@ -418,8 +418,8 @@ VulkanAttachment& VulkanRenderTarget::getMsaaColor(int target) {
     return mMsaaAttachments[target];
 }
 
-VulkanAttachment& VulkanRenderTarget::getDepth() {
-    return mDepth;
+VulkanAttachment& VulkanRenderTarget::getDepthStencil() {
+    return mDepthStencil;
 }
 
 VulkanAttachment& VulkanRenderTarget::getMsaaDepth() {

filament/backend/src/vulkan/VulkanHandles.h

@@ -304,7 +304,7 @@ struct VulkanRenderTarget : private HwRenderTarget, VulkanResource {
             VulkanContext const& context, VmaAllocator allocator,
             VulkanCommands* commands, uint32_t width, uint32_t height,
             uint8_t samples, VulkanAttachment color[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT],
-            VulkanAttachment depthStencil[2], VulkanStagePool& stagePool, uint8_t layerCount);
+            VulkanAttachment depthStencil, VulkanStagePool& stagePool, uint8_t layerCount);
 
     // Creates a special "default" render target (i.e. associated with the swap chain)
     explicit VulkanRenderTarget();
@@ -326,7 +326,7 @@ struct VulkanRenderTarget : private HwRenderTarget, VulkanResource {
 
 private:
     VulkanAttachment mColor[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT] = {};
-    VulkanAttachment mDepth = {};
+    VulkanAttachment mDepthStencil = {};
     VulkanAttachment mMsaaAttachments[MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT] = {};
     VulkanAttachment mMsaaDepthAttachment = {};
     const bool mOffscreen : 1;

filament/src/FrameSkipper.cpp

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

filament/src/FrameSkipper.h

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

filament/src/RendererUtils.cpp

@@ -75,6 +75,7 @@ FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
                 TargetBufferFlags const clearColorFlags = config.clearFlags & TargetBufferFlags::COLOR;
                 TargetBufferFlags clearDepthFlags = config.clearFlags & TargetBufferFlags::DEPTH;
                 TargetBufferFlags clearStencilFlags = config.clearFlags & TargetBufferFlags::STENCIL;
+                uint8_t layerCount = 1;
 
                 data.shadows = blackboard.get<FrameGraphTexture>("shadows");
                 data.ssao = blackboard.get<FrameGraphTexture>("ssao");
@@ -171,6 +172,9 @@ FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
 
                 data.color = builder.write(data.color, FrameGraphTexture::Usage::COLOR_ATTACHMENT);
                 data.depth = builder.write(data.depth, FrameGraphTexture::Usage::DEPTH_ATTACHMENT);
+                if (view.hasStereo() && engine.getConfig().stereoscopicType == StereoscopicType::MULTIVIEW) {
+                    layerCount = engine.getConfig().stereoscopicEyeCount;
+                }
 
                 /*
                  * There is a bit of magic happening here regarding the viewport used.
@@ -192,7 +196,7 @@ FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
                         .stencil = data.stencil },
                         .clearColor = config.clearColor,
                         .samples = config.msaa,
-                        .layerCount = static_cast<uint8_t>(colorBufferDesc.depth),
+                        .layerCount = layerCount,
                         .clearFlags = clearColorFlags | clearDepthFlags | clearStencilFlags});
                 blackboard["depth"] = data.depth;
             },

filament/src/ShadowMapManager.cpp

@@ -371,13 +371,7 @@ FrameGraphId<FrameGraphTexture> ShadowMapManager::render(FEngine& engine, FrameG
                     if (view.isFrontFaceWindingInverted()) {
                         renderPassFlags |= RenderPass::HAS_INVERSE_FRONT_FACES;
                     }
-
-                    bool const canUseDepthClamp =
-                            !view.hasVSM() &&
-                            mIsDepthClampSupported &&
-                            engine.debug.shadowmap.depth_clamp;
-
-                    if (canUseDepthClamp) {
+                    if (mIsDepthClampSupported && engine.debug.shadowmap.depth_clamp) {
                         renderPassFlags |= RenderPass::HAS_DEPTH_CLAMP;
                     }
 
@@ -656,14 +650,9 @@ ShadowMapManager::ShadowTechnique ShadowMapManager::updateCascadeShadowMaps(FEng
             cameraInfo.zf = -nearFarPlanes[i + 1];
             updateNearFarPlanes(&cameraInfo.cullingProjection, cameraInfo.zn, cameraInfo.zf);
 
-            bool const canUseDepthClamp =
-                    !view.hasVSM() &&
-                    mIsDepthClampSupported &&
-                    engine.debug.shadowmap.depth_clamp;
-
             auto shaderParameters = shadowMap.updateDirectional(engine,
                     lightData, 0, cameraInfo, shadowMapInfo, sceneInfo,
-                    canUseDepthClamp);
+                    mIsDepthClampSupported && engine.debug.shadowmap.depth_clamp);
 
             if (shadowMap.hasVisibleShadows()) {
                 const size_t shadowIndex = shadowMap.getShadowIndex();

filament/src/fg/PassNode.cpp

@@ -190,10 +190,10 @@ void RenderPassNode::resolve() noexcept {
                 minHeight = std::min(minHeight, h);
                 maxHeight = std::max(maxHeight, h);
             }
+            // additionally, clear implies discardStart
+            rt.backend.params.flags.discardStart |= (
+                    rt.descriptor.clearFlags & rt.targetBufferFlags);
         }
-        // additionally, clear implies discardStart
-        rt.backend.params.flags.discardStart |= (
-                rt.descriptor.clearFlags & rt.targetBufferFlags);
 
         assert_invariant(minWidth == maxWidth);
         assert_invariant(minHeight == maxHeight);

libs/filamat/include/filamat/MaterialBuilder.h

@@ -323,9 +323,6 @@ public:
     //! Custom variables (all float4).
     MaterialBuilder& variable(Variable v, const char* name) noexcept;
 
-    MaterialBuilder& variable(Variable v, const char* name,
-            ParameterPrecision precision) noexcept;
-
     /**
      * Require a specified attribute.
      *
@@ -711,17 +708,11 @@ public:
         ShaderStage stage;
     };
 
-    struct CustomVariable {
-        utils::CString name;
-        Precision precision = Precision::DEFAULT;
-        bool hasPrecision = false;
-    };
-
     static constexpr size_t MATERIAL_PROPERTIES_COUNT = filament::MATERIAL_PROPERTIES_COUNT;
     using Property = filament::Property;
 
     using PropertyList = bool[MATERIAL_PROPERTIES_COUNT];
-    using VariableList = CustomVariable[MATERIAL_VARIABLES_COUNT];
+    using VariableList = utils::CString[MATERIAL_VARIABLES_COUNT];
     using OutputList = std::vector<Output>;
 
     static constexpr size_t MAX_COLOR_OUTPUT = filament::backend::MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT;

libs/filamat/src/GLSLPostProcessor.cpp

@@ -671,15 +671,13 @@ void GLSLPostProcessor::fixupClipDistance(
 // - triggers a crash on some Adreno drivers (b/291140208, b/289401984, b/289393290)
 // However Metal requires this pass in order to correctly generate half-precision MSL
 //
-// Note: CreateSimplificationPass() used to creates a lot of problems:
+// CreateSimplificationPass() creates a lot of problems:
 // - Adreno GPU show artifacts after running simplification passes (Vulkan)
 // - spirv-cross fails generating working glsl
 //      (https://github.com/KhronosGroup/SPIRV-Cross/issues/2162)
-//
-// However this problem was addressed in spirv-cross here:
-//      https://github.com/KhronosGroup/SPIRV-Cross/pull/2163
-//
-// The simplification passes below are necessary when targeting Metal, otherwise the
+// - generally it makes the code more complicated, e.g.: replacing for loops with
+//   while-if-break, unclear if it helps for anything.
+// However, the simplification passes below are necessary when targeting Metal, otherwise the
 // result is mismatched half / float assignments in MSL.
 
 
@@ -712,11 +710,11 @@ void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config c
     RegisterPass(CreateAggressiveDCEPass());
     RegisterPass(CreateRedundancyEliminationPass());
     RegisterPass(CreateCombineAccessChainsPass());
-    RegisterPass(CreateSimplificationPass());
+    RegisterPass(CreateSimplificationPass(), MaterialBuilder::TargetApi::METAL);
     RegisterPass(CreateVectorDCEPass());
     RegisterPass(CreateDeadInsertElimPass());
     RegisterPass(CreateDeadBranchElimPass());
-    RegisterPass(CreateSimplificationPass());
+    RegisterPass(CreateSimplificationPass(), MaterialBuilder::TargetApi::METAL);
     RegisterPass(CreateIfConversionPass());
     RegisterPass(CreateCopyPropagateArraysPass());
     RegisterPass(CreateReduceLoadSizePass());
@@ -725,7 +723,7 @@ void GLSLPostProcessor::registerPerformancePasses(Optimizer& optimizer, Config c
     RegisterPass(CreateRedundancyEliminationPass());
     RegisterPass(CreateDeadBranchElimPass());
     RegisterPass(CreateBlockMergePass());
-    RegisterPass(CreateSimplificationPass());
+    RegisterPass(CreateSimplificationPass(), MaterialBuilder::TargetApi::METAL);
 }
 
 void GLSLPostProcessor::registerSizePasses(Optimizer& optimizer, Config const& config) {

libs/filamat/src/MaterialBuilder.cpp

@@ -234,21 +234,7 @@ MaterialBuilder& MaterialBuilder::variable(Variable v, const char* name) noexcep
         case Variable::CUSTOM2:
         case Variable::CUSTOM3:
             assert(size_t(v) < MATERIAL_VARIABLES_COUNT);
-            mVariables[size_t(v)] = { CString(name), Precision::DEFAULT, false };
-            break;
-    }
-    return *this;
-}
-
-MaterialBuilder& MaterialBuilder::variable(Variable v,
-        const char* name, ParameterPrecision precision) noexcept {
-    switch (v) {
-        case Variable::CUSTOM0:
-        case Variable::CUSTOM1:
-        case Variable::CUSTOM2:
-        case Variable::CUSTOM3:
-            assert(size_t(v) < MATERIAL_VARIABLES_COUNT);
-            mVariables[size_t(v)] = { CString(name), precision, true };
+            mVariables[size_t(v)] = CString(name);
             break;
     }
     return *this;
@@ -1397,7 +1383,7 @@ bool MaterialBuilder::checkMaterialLevelFeatures(MaterialInfo const& info) const
 
 bool MaterialBuilder::hasCustomVaryings() const noexcept {
     for (const auto& variable : mVariables) {
-        if (!variable.name.empty()) {
+        if (!variable.empty()) {
             return true;
         }
     }

libs/filamat/src/shaders/CodeGenerator.cpp

@@ -451,20 +451,15 @@ io::sstream& CodeGenerator::generatePostProcessMain(io::sstream& out, ShaderStag
 }
 
 io::sstream& CodeGenerator::generateVariable(io::sstream& out, ShaderStage stage,
-        const MaterialBuilder::CustomVariable& variable, size_t index) {
-    auto const& name = variable.name;
-    const char* precisionString = getPrecisionQualifier(variable.precision);
+        const CString& name, size_t index) {
+
     if (!name.empty()) {
         if (stage == ShaderStage::VERTEX) {
             out << "\n#define VARIABLE_CUSTOM" << index << " " << name.c_str() << "\n";
             out << "\n#define VARIABLE_CUSTOM_AT" << index << " variable_" << name.c_str() << "\n";
-            out << "LAYOUT_LOCATION(" << index << ") VARYING " << precisionString << " vec4 variable_" << name.c_str() << ";\n";
+            out << "LAYOUT_LOCATION(" << index << ") VARYING vec4 variable_" << name.c_str() << ";\n";
         } else if (stage == ShaderStage::FRAGMENT) {
-            if (!variable.hasPrecision && variable.precision == Precision::DEFAULT) {
-                // for backward compatibility
-                precisionString = "highp";
-            }
-            out << "\nLAYOUT_LOCATION(" << index << ") VARYING " << precisionString << " vec4 variable_" << name.c_str() << ";\n";
+            out << "\nLAYOUT_LOCATION(" << index << ") VARYING highp vec4 variable_" << name.c_str() << ";\n";
         }
     }
     return out;

libs/filamat/src/shaders/CodeGenerator.h

@@ -103,7 +103,7 @@ public:
 
     // generate declarations for custom interpolants
     static utils::io::sstream& generateVariable(utils::io::sstream& out, ShaderStage stage,
-            const MaterialBuilder::CustomVariable& variable, size_t index);
+            const utils::CString& name, size_t index);
 
     // generate declarations for non-custom "in" variables
     utils::io::sstream& generateShaderInputs(utils::io::sstream& out, ShaderStage type,

libs/viewer/include/viewer/AutomationEngine.h

@@ -224,9 +224,6 @@ public:
      */
     static void exportSettings(const Settings& settings, const char* filename);
 
-    static void exportScreenshot(View* view, Renderer* renderer, std::string filename,
-            bool autoclose, AutomationEngine* automationEngine);
-
     Options getOptions() const { return mOptions; }
     bool isRunning() const { return mIsRunning; }
     size_t currentTest() const { return mCurrentTest; }

libs/viewer/src/AutomationEngine.cpp

@@ -56,7 +56,7 @@ static void convertRGBAtoRGB(void* buffer, uint32_t width, uint32_t height) {
     }
 }
 
-void AutomationEngine::exportScreenshot(View* view, Renderer* renderer, std::string filename,
+static void exportScreenshot(View* view, Renderer* renderer, std::string filename,
         bool autoclose, AutomationEngine* automationEngine) {
     const Viewport& vp = view->getViewport();
     const size_t byteCount = vp.width * vp.height * 4;
@@ -244,8 +244,7 @@ void AutomationEngine::tick(Engine* engine, const ViewerContent& content, float
     }
 
     if (mOptions.exportScreenshots) {
-        AutomationEngine::exportScreenshot(
-                content.view, content.renderer, prefix + ".ppm", isLastTest, this);
+        exportScreenshot(content.view, content.renderer, prefix + ".ppm", isLastTest, this);
     }
 
     if (isLastTest) {

samples/gltf_viewer.cpp

@@ -61,10 +61,8 @@
 #include <algorithm>
 #include <array>
 #include <fstream>
-#include <iomanip>
 #include <iostream>
 #include <set>
-#include <sstream>
 #include <string>
 
 #include "generated/resources/gltf_demo.h"
@@ -139,8 +137,6 @@ struct App {
 
     AutomationSpec* automationSpec = nullptr;
     AutomationEngine* automationEngine = nullptr;
-    bool screenshot = false;
-    uint8_t screenshotSeq = 0;
 };
 
 static const char* DEFAULT_IBL = "assets/ibl/lightroom_14b";
@@ -881,15 +877,10 @@ int main(int argc, char** argv) {
 
             if (ImGui::CollapsingHeader("Debug")) {
                 auto& debug = engine->getDebugRegistry();
-                if (engine->getBackend() == Engine::Backend::METAL) {
-                    if (ImGui::Button("Capture frame")) {
-                        bool* captureFrame =
-                                debug.getPropertyAddress<bool>("d.renderer.doFrameCapture");
-                        *captureFrame = true;
-                    }
-                }
-                if (ImGui::Button("Screenshot")) {
-                    app.screenshot = true;
+                if (ImGui::Button("Capture frame")) {
+                    bool* captureFrame =
+                            debug.getPropertyAddress<bool>("d.renderer.doFrameCapture");
+                    *captureFrame = true;
                 }
                 ImGui::Checkbox("Disable buffer padding",
                         debug.getPropertyAddress<bool>("d.renderer.disable_buffer_padding"));
@@ -1147,14 +1138,6 @@ int main(int argc, char** argv) {
     };
 
     auto postRender = [&app](Engine* engine, View* view, Scene*, Renderer* renderer) {
-        if (app.screenshot) {
-            std::ostringstream stringStream;
-            stringStream << "screenshot" << std::setfill('0') << std::setw(2) << +app.screenshotSeq;
-            AutomationEngine::exportScreenshot(
-                    view, renderer, stringStream.str() + ".ppm", false, app.automationEngine);
-            ++app.screenshotSeq;
-            app.screenshot = false;
-        }
         if (app.automationEngine->shouldClose()) {
             FilamentApp::get().close();
             return;

samples/hellotriangle.cpp

@@ -20,6 +20,7 @@
 #include <filament/Material.h>
 #include <filament/MaterialInstance.h>
 #include <filament/RenderableManager.h>
+#include <filament/Renderer.h>
 #include <filament/Scene.h>
 #include <filament/Skybox.h>
 #include <filament/TransformManager.h>
@@ -46,23 +47,33 @@ using utils::EntityManager;
 struct App {
     Config config;
     VertexBuffer* vb;
+    VertexBuffer* vb2;
     IndexBuffer* ib;
     Material* mat;
     Camera* cam;
     Entity camera;
     Skybox* skybox;
     Entity renderable;
+    Entity r2;
 };
 
 struct Vertex {
-    filament::math::float2 position;
+    filament::math::float3 position;
     uint32_t color;
 };
 
+float const z = 5;
+
 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},
+    {{1, 0, z}, 0xffff0000u},
+    {{cos(M_PI * 2 / 3), sin(M_PI * 2 / 3), z}, 0xff00ff00u},
+    {{cos(M_PI * 4 / 3), sin(M_PI * 4 / 3), z}, 0xff0000ffu},
+};
+
+static Vertex T2[3] = {
+        TRIANGLE_VERTICES[0],
+        TRIANGLE_VERTICES[1],
+        TRIANGLE_VERTICES[2],
 };
 
 static constexpr uint16_t TRIANGLE_INDICES[3] = { 0, 1, 2 };
@@ -120,25 +131,36 @@ static int handleCommandLineArguments(int argc, char* argv[], App* app) {
 }
 
 int main(int argc, char** argv) {
+    T2[0].position.z = z - 10;
+    T2[1].position.z = z - 10;
+    T2[2].position.z = z - 10;
+
+    T2[0].color = 0xFF0000FF;
+    T2[1].color = 0xFF0000FF;
+    T2[2].color = 0xFF0000FF;
+
     App app{};
     app.config.title = "hellotriangle";
     app.config.featureLevel = backend::FeatureLevel::FEATURE_LEVEL_0;
     handleCommandLineArguments(argc, argv, &app);
 
     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()
+        view->setStencilBufferEnabled(true);
+
+        static_assert(sizeof(Vertex) == 16, "Strange vertex size.");
+        auto builder = 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);
+                .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT3, 0, 16)
+                .attribute(VertexAttribute::COLOR, 0, VertexBuffer::AttributeType::UBYTE4, 12, 16)
+                .normalized(VertexAttribute::COLOR);
+        app.vb = builder.build(*engine);
+        app.vb2 = builder.build(*engine);
         app.vb->setBufferAt(*engine, 0,
-                VertexBuffer::BufferDescriptor(TRIANGLE_VERTICES, 36, nullptr));
+                VertexBuffer::BufferDescriptor(TRIANGLE_VERTICES, 48, nullptr));
+        app.vb2->setBufferAt(*engine, 0,
+                VertexBuffer::BufferDescriptor(T2, 48, nullptr));
         app.ib = IndexBuffer::Builder()
                 .indexCount(3)
                 .bufferType(IndexBuffer::IndexType::USHORT)
@@ -149,22 +171,67 @@ int main(int argc, char** argv) {
                 .package(RESOURCES_BAKEDCOLOR_DATA, RESOURCES_BAKEDCOLOR_SIZE)
                 .build(*engine);
         app.renderable = EntityManager::get().create();
+        app.r2 = EntityManager::get().create();
+
+        auto inst1 = app.mat->createInstance();
+        inst1->setDepthWrite(false);        
+        inst1->setDepthFunc(MaterialInstance::DepthFunc::A);        
+        inst1->setDepthCulling(false);
+        
+        inst1->setStencilWrite(true);
+        inst1->setStencilCompareFunction(MaterialInstance::StencilCompareFunc::E);
+        inst1->setStencilOpDepthStencilPass(MaterialInstance::StencilOperation::REPLACE);
+        inst1->setStencilReferenceValue(6);
+
+        auto inst2 = app.mat->createInstance();
+        inst2->setDepthWrite(false);
+        inst2->setDepthFunc(MaterialInstance::DepthFunc::A);
+        inst2->setDepthCulling(false);
+        
+        inst2->setStencilWrite(true);
+        inst2->setStencilCompareFunction(MaterialInstance::StencilCompareFunc::L);
+        inst2->setStencilOpDepthStencilPass(MaterialInstance::StencilOperation::REPLACE);
+        inst2->setStencilReferenceValue(6);
+
+
+        auto& renderableMan = engine->getRenderableManager();
+
         RenderableManager::Builder(1)
                 .boundingBox({{ -1, -1, -1 }, { 1, 1, 1 }})
-                .material(0, app.mat->getDefaultInstance())
+                .material(0, inst1)
                 .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, app.vb, app.ib, 0, 3)
                 .culling(false)
                 .receiveShadows(false)
                 .castShadows(false)
                 .build(*engine, app.renderable);
+
+
+        RenderableManager::Builder(1)
+                .boundingBox({{ -1, -1, -1 }, { 1, 1, 1 }})
+                .material(0, inst2)
+                .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, app.vb2, app.ib, 0, 3)
+                .culling(false)
+                .receiveShadows(false)
+                .castShadows(false)
+                .build(*engine, app.r2);
+
         scene->addEntity(app.renderable);
+
+
+        auto r1inst = renderableMan.getInstance(app.renderable);
+        renderableMan.setPriority(r1inst, 7);
+
+        scene->addEntity(app.r2);        
+        auto r2inst = renderableMan.getInstance(app.r2);
+        renderableMan.setPriority(r2inst, 6);
+
         app.camera = utils::EntityManager::get().create();
         app.cam = engine->createCamera(app.camera);
         view->setCamera(app.cam);
     };
 
     auto cleanup = [&app](Engine* engine, View*, Scene*) {
-        engine->destroy(app.skybox);
+//        engine->destroy(app.skybox);
         engine->destroy(app.renderable);
         engine->destroy(app.mat);
         engine->destroy(app.vb);
@@ -174,19 +241,24 @@ int main(int argc, char** argv) {
     };
 
     FilamentApp::get().animate([&app](Engine* engine, View* view, double now) {
-        constexpr float ZOOM = 1.5f;
+        constexpr float ZOOM = 1.5;
         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);
+            -ZOOM, ZOOM, -100, 100);
         auto& tcm = engine->getTransformManager();
         tcm.setTransform(tcm.getInstance(app.renderable),
                 filament::math::mat4f::rotation(now, filament::math::float3{ 0, 0, 1 }));
     });
 
-    FilamentApp::get().run(app.config, setup, cleanup);
+
+    auto preRender = [](Engine*, View* view, Scene*, Renderer* renderer) {
+        renderer->setClearOptions({ .clearStencil = 0u, .clear = true });
+    };
+
+    FilamentApp::get().run(app.config, setup, cleanup, {}, preRender);
 
     return 0;
 }

tools/matc/src/matc/ParametersProcessor.cpp

@@ -615,51 +615,14 @@ static bool processVariables(MaterialBuilder& builder, const JsonishValue& value
     }
 
     for (size_t i = 0; i < elements.size(); i++) {
-        ParameterPrecision precision = ParameterPrecision::DEFAULT;
-        MaterialBuilder::Variable v = intToVariable(i);
-        std::string nameString;
-
         auto elementValue = elements[i];
-        if (elementValue->getType() == JsonishValue::Type::OBJECT) {
-
-            JsonishObject const& jsonObject = *elementValue->toJsonObject();
-
-            const JsonishValue* nameValue = jsonObject.getValue("name");
-            if (!nameValue) {
-                std::cerr << "variables: entry without 'name' key." << std::endl;
-                return false;
-            }
-            if (nameValue->getType() != JsonishValue::STRING) {
-                std::cerr << "variables: name value must be STRING." << std::endl;
-                return false;
-            }
-
-            const JsonishValue* precisionValue = jsonObject.getValue("precision");
-            if (precisionValue) {
-                if (precisionValue->getType() != JsonishValue::STRING) {
-                    std::cerr << "variables: precision must be a STRING." << std::endl;
-                    return false;
-                }
-                auto precisionString = precisionValue->toJsonString();
-                if (!Enums::isValid<ParameterPrecision>(precisionString->getString())){
-                    return logEnumIssue("variables", *precisionString, Enums::map<ParameterPrecision>());
-                }
-            }
-
-            nameString = nameValue->toJsonString()->getString();
-            if (precisionValue) {
-                precision = Enums::toEnum<ParameterPrecision>(
-                        precisionValue->toJsonString()->getString());
-            }
-            builder.variable(v, nameString.c_str(), precision);
-        } else if (elementValue->getType() == JsonishValue::Type::STRING) {
-            nameString = elementValue->toJsonString()->getString();
-            builder.variable(v, nameString.c_str());
-        } else {
+        MaterialBuilder::Variable v = intToVariable(i);
+        if (elementValue->getType() != JsonishValue::Type::STRING) {
             std::cerr << "variables: array index " << i << " is not a STRING. found:" <<
                     JsonishValue::typeToString(elementValue->getType()) << std::endl;
             return false;
         }
+        builder.variable(v, elementValue->toJsonString()->getString().c_str());
     }
 
     return true;