select the proper descriptor set layout in the rendering loop

Now that the per-view layout can be different based on the type of
shadow, we need to make sure we set the proper layout in the pipeline
and use the corresponding descriptor set.

There are now 16 "per-view" layouts and their corresponding descriptor
set. There are two sets of 8, the current set is determined by the
shadow type on the view.

Then during rendering, when we set the pipeline we need to select the
corresponding layout; each material now offers both versions of the
layout and we just pick the right one.

Author: pixelflinger

filament/src/RenderPass.cpp

@@ -921,7 +921,6 @@ backend::Viewport RenderPass::Executor::applyScissorViewport(
 UTILS_NOINLINE // no need to be inlined
 void RenderPass::Executor::execute(FEngine const& engine, DriverApi& driver,
         Command const* first, Command const* last) const noexcept {
-
     SYSTRACE_CALL();
     SYSTRACE_CONTEXT();
 
@@ -942,6 +941,13 @@ void RenderPass::Executor::execute(FEngine const& engine, DriverApi& driver,
             driver.scissor(mScissor);
         }
 
+        // If we have a mColorPassDescriptorSet, we need to use its idea of "VSM" to select
+        // the descriptor set layout. Materials always offer both.
+        // If we don't have a mColorPassDescriptorSet, it doesn't matter because the layout
+        // are chosen via the variant only.
+        bool const useVsmDescriptorSetLayout =
+                mColorPassDescriptorSet ? mColorPassDescriptorSet->isVSM() : false;
+
         bool const polygonOffsetOverride = mPolygonOffsetOverride;
         PipelineState pipeline{
                 // initialize with polygon offset override
@@ -1051,8 +1057,13 @@ void RenderPass::Executor::execute(FEngine const& engine, DriverApi& driver,
 
                     // Each material has its own version of the per-view descriptor-set layout,
                     // because it depends on the material features (e.g. lit/unlit)
+                    // TODO: QUESTION: are
+                    //      Variant::isValidDepthVariant(info.materialVariant) and
+                    //      Variant::isSSRVariant(info.materialVariant)
+                    //      constant? If so we could precompute ma->getPerViewDescriptorSetLayout()
                     pipeline.pipelineLayout.setLayout[+DescriptorSetBindingPoints::PER_VIEW] =
-                            ma->getPerViewDescriptorSetLayout(info.materialVariant).getHandle();
+                            ma->getPerViewDescriptorSetLayout(info.materialVariant,
+                                    useVsmDescriptorSetLayout).getHandle();
 
                     // Each material has a per-material descriptor-set layout which encodes the
                     // material's parameters (ubo and samplers)

filament/src/details/Material.cpp

@@ -329,11 +329,12 @@ FMaterial::FMaterial(FEngine& engine, const Builder& builder,
 
     parser->hasCustomDepthShader(&mHasCustomDepthShader);
 
-    mPerViewLayoutIndex = ColorPassDescriptorSet::getIndex(
-            mIsVariantLit,
-            mReflectionMode == ReflectionMode::SCREEN_SPACE ||
-            mRefractionMode == RefractionMode::SCREEN_SPACE,
-            !(mVariantFilterMask & +UserVariantFilterBit::FOG));
+    bool const isLit = mIsVariantLit || mHasShadowMultiplier;
+    bool const isSSR = mReflectionMode == ReflectionMode::SCREEN_SPACE ||
+            mRefractionMode == RefractionMode::SCREEN_SPACE;
+    bool const hasFog = !(mVariantFilterMask & UserVariantFilterMask(UserVariantFilterBit::FOG));
+
+    mPerViewLayoutIndex = ColorPassDescriptorSet::getIndex(isLit, isSSR, hasFog);
 
     processBlendingMode(parser);
     processSpecializationConstants(engine, builder, parser);
@@ -407,6 +408,7 @@ void FMaterial::terminate(FEngine& engine) {
 
     DriverApi& driver = engine.getDriverApi();
     mPerViewDescriptorSetLayout.terminate(engine.getDescriptorSetLayoutFactory(), driver);
+    mPerViewDescriptorSetLayoutVsm.terminate(engine.getDescriptorSetLayoutFactory(), driver);
     mDescriptorSetLayout.terminate(engine.getDescriptorSetLayoutFactory(), driver);
 }
 
@@ -1149,17 +1151,23 @@ void FMaterial::processDescriptorSets(FEngine& engine, MaterialParser const* con
     backend::DescriptorSetLayout descriptorSetLayout;
     success = parser->getDescriptorSetLayout(&descriptorSetLayout);
     assert_invariant(success);
-    auto perMatLabel = mName;
-    perMatLabel.append("_perMat");
-    descriptorSetLayout.label = std::move(perMatLabel);
 
     // get the PER_VIEW descriptor binding info
-    auto perViewDescriptorSetLayout =
-            descriptor_sets::getPerViewDescriptorSetLayout(mMaterialDomain, mVariantFilterMask,
-            mIsVariantLit || mHasShadowMultiplier, mReflectionMode, mRefractionMode);
-    auto perViewLabel = mName;
-    perViewLabel.append("_perView");
-    perViewDescriptorSetLayout.label = std::move(perViewLabel);
+    bool const isLit = mIsVariantLit || mHasShadowMultiplier;
+    bool const isSSR = mReflectionMode == ReflectionMode::SCREEN_SPACE ||
+            mRefractionMode == RefractionMode::SCREEN_SPACE;
+    bool const hasFog = !(mVariantFilterMask & UserVariantFilterMask(UserVariantFilterBit::FOG));
+
+    auto perViewDescriptorSetLayout = descriptor_sets::getPerViewDescriptorSetLayout(
+            mMaterialDomain, isLit, isSSR, hasFog, false);
+
+    auto perViewDescriptorSetLayoutVsm = descriptor_sets::getPerViewDescriptorSetLayout(
+            mMaterialDomain, isLit, isSSR, hasFog, true);
+
+    // set the labels
+    descriptorSetLayout.label = CString{ mName }.append("_perMat");
+    perViewDescriptorSetLayout.label = CString{ mName }.append("_perView");
+    perViewDescriptorSetLayoutVsm.label = CString{ mName }.append("_perViewVsm");
 
     // get the PER_RENDERABLE and PER_VIEW descriptor binding info
     for (auto&& [bindingPoint, descriptorSetLayout] : {
@@ -1181,7 +1189,11 @@ void FMaterial::processDescriptorSets(FEngine& engine, MaterialParser const* con
 
     mPerViewDescriptorSetLayout = {
             engine.getDescriptorSetLayoutFactory(),
-            engine.getDriverApi(), perViewDescriptorSetLayout };
+            engine.getDriverApi(), std::move(perViewDescriptorSetLayout) };
+
+    mPerViewDescriptorSetLayoutVsm = {
+            engine.getDescriptorSetLayoutFactory(),
+            engine.getDriverApi(), std::move(perViewDescriptorSetLayoutVsm) };
 }
 
 descriptor_binding_t FMaterial::getSamplerBinding(

filament/src/details/Material.h

@@ -93,7 +93,8 @@ class FMaterial : public Material {
         return mPerViewDescriptorSetLayout;
     }
 
-    DescriptorSetLayout const& getPerViewDescriptorSetLayout(Variant const variant) const noexcept {
+    DescriptorSetLayout const& getPerViewDescriptorSetLayout(
+            Variant const variant, bool const useVsmDescriptorSetLayout) const noexcept {
         if (Variant::isValidDepthVariant(variant)) {
             assert_invariant(mMaterialDomain == MaterialDomain::SURFACE);
             return mEngine.getPerViewDescriptorSetLayoutDepthVariant();
@@ -102,6 +103,10 @@ class FMaterial : public Material {
             assert_invariant(mMaterialDomain == MaterialDomain::SURFACE);
             return mEngine.getPerViewDescriptorSetLayoutSsrVariant();
         }
+        if (useVsmDescriptorSetLayout) {
+            assert_invariant(mMaterialDomain == MaterialDomain::SURFACE);
+            return mPerViewDescriptorSetLayoutVsm;
+        }
         return mPerViewDescriptorSetLayout;
     }
 
@@ -312,6 +317,7 @@ class FMaterial : public Material {
     // try to order by frequency of use
     mutable std::array<backend::Handle<backend::HwProgram>, VARIANT_COUNT> mCachedPrograms;
     DescriptorSetLayout mPerViewDescriptorSetLayout;
+    DescriptorSetLayout mPerViewDescriptorSetLayoutVsm;
     DescriptorSetLayout mDescriptorSetLayout;
     backend::Program::DescriptorSetInfo mProgramDescriptorBindings;
 

filament/src/details/View.cpp

@@ -68,8 +68,10 @@ FView::FView(FEngine& engine)
           mFogEntity(engine.getEntityManager().create()),
           mIsStereoSupported(engine.getDriverApi().isStereoSupported()),
           mUniforms(engine.getDriverApi()),
-          mColorPassDescriptorSet(engine, mUniforms) {
-
+          mColorPassDescriptorSet{
+                { engine, false, mUniforms },
+                { engine, true, mUniforms } }
+{
     DriverApi& driver = engine.getDriverApi();
 
     FDebugRegistry& debugRegistry = engine.getDebugRegistry();
@@ -125,11 +127,13 @@ FView::FView(FEngine& engine)
 
     mDefaultColorGrading = mColorGrading = engine.getDefaultColorGrading();
 
-    mColorPassDescriptorSet.init(
-            engine,
-            mLightUbh,
-            mFroxelizer.getRecordBuffer(),
-            mFroxelizer.getFroxelBuffer());
+    for (auto&& colorPassDescriptorSet : mColorPassDescriptorSet) {
+        colorPassDescriptorSet.init(
+                engine,
+                mLightUbh,
+                mFroxelizer.getRecordBuffer(),
+                mFroxelizer.getFroxelBuffer());
+    }
 }
 
 FView::~FView() noexcept = default;
@@ -146,7 +150,9 @@ void FView::terminate(FEngine& engine) {
 
     ShadowMapManager::terminate(engine, mShadowMapManager);
     mUniforms.terminate(driver);
-    mColorPassDescriptorSet.terminate(engine.getDescriptorSetLayoutFactory(), driver);
+    for (auto&& colorPassDescriptorSet : mColorPassDescriptorSet) {
+        colorPassDescriptorSet.terminate(engine.getDescriptorSetLayoutFactory(), driver);
+    }
     mFroxelizer.terminate(driver);
     mCommonRenderableDescriptorSet.terminate(driver);
 
@@ -429,7 +435,7 @@ void FView::prepareLighting(FEngine& engine, CameraInfo const& cameraInfo) noexc
      */
 
     const float exposure = Exposure::exposure(cameraInfo.ev100);
-    mColorPassDescriptorSet.prepareExposure(cameraInfo.ev100);
+    getColorPassDescriptorSet().prepareExposure(cameraInfo.ev100);
 
     /*
      * Indirect light (IBL)
@@ -446,15 +452,15 @@ void FView::prepareLighting(FEngine& engine, CameraInfo const& cameraInfo) noexc
         FSkybox const* const skybox = scene->getSkybox();
         intensity = skybox ? skybox->getIntensity() : FIndirectLight::DEFAULT_INTENSITY;
     }
-    mColorPassDescriptorSet.prepareAmbientLight(engine, *ibl, intensity, exposure);
+    getColorPassDescriptorSet().prepareAmbientLight(engine, *ibl, intensity, exposure);
 
     /*
      * Directional light (always at index 0)
      */
 
     FLightManager::Instance const directionalLight = lightData.elementAt<FScene::LIGHT_INSTANCE>(0);
     const float3 sceneSpaceDirection = lightData.elementAt<FScene::DIRECTION>(0); // guaranteed normalized
-    mColorPassDescriptorSet.prepareDirectionalLight(engine, exposure, sceneSpaceDirection, directionalLight);
+    getColorPassDescriptorSet().prepareDirectionalLight(engine, exposure, sceneSpaceDirection, directionalLight);
 }
 
 CameraInfo FView::computeCameraInfo(FEngine& engine) const noexcept {
@@ -606,7 +612,7 @@ void FView::prepare(FEngine& engine, DriverApi& driver, RootArenaScope& rootAren
                     cameraInfo.projection, cameraInfo.zn, cameraInfo.zf)) {
                 // TODO: might be more consistent to do this in prepareLighting(), but it's not
                 //       strictly necessary
-                mColorPassDescriptorSet.prepareDynamicLights(mFroxelizer);
+                getColorPassDescriptorSet().prepareDynamicLights(mFroxelizer);
             }
             // We need to pass viewMatrix by value here because it extends the scope of this
             // function.
@@ -797,12 +803,13 @@ void FView::prepare(FEngine& engine, DriverApi& driver, RootArenaScope& rootAren
     auto const& tcm = engine.getTransformManager();
     auto const fogTransform = tcm.getWorldTransformAccurate(tcm.getInstance(mFogEntity));
 
-    mColorPassDescriptorSet.prepareTime(engine, userTime);
-    mColorPassDescriptorSet.prepareFog(engine, cameraInfo, fogTransform, mFogOptions,
+    auto& colorPassDescriptorSet = getColorPassDescriptorSet();
+    colorPassDescriptorSet.prepareTime(engine, userTime);
+    colorPassDescriptorSet.prepareFog(engine, cameraInfo, fogTransform, mFogOptions,
             scene->getIndirectLight());
-    mColorPassDescriptorSet.prepareTemporalNoise(engine, mTemporalAntiAliasingOptions);
-    mColorPassDescriptorSet.prepareBlending(needsAlphaChannel);
-    mColorPassDescriptorSet.prepareMaterialGlobals(mMaterialGlobals);
+    colorPassDescriptorSet.prepareTemporalNoise(engine, mTemporalAntiAliasingOptions);
+    colorPassDescriptorSet.prepareBlending(needsAlphaChannel);
+    colorPassDescriptorSet.prepareMaterialGlobals(mMaterialGlobals);
 }
 
 void FView::computeVisibilityMasks(
@@ -863,12 +870,12 @@ void FView::prepareUpscaler(float2 const scale,
             derivativesScale = 0.5f;
         }
     }
-    mColorPassDescriptorSet.prepareLodBias(bias, derivativesScale);
+    getColorPassDescriptorSet().prepareLodBias(bias, derivativesScale);
 }
 
 void FView::prepareCamera(FEngine& engine, const CameraInfo& cameraInfo) const noexcept {
     SYSTRACE_CALL();
-    mColorPassDescriptorSet.prepareCamera(engine, cameraInfo);
+    getColorPassDescriptorSet().prepareCamera(engine, cameraInfo);
 }
 
 void FView::prepareViewport(
@@ -877,23 +884,23 @@ void FView::prepareViewport(
     SYSTRACE_CALL();
     // TODO: we should pass viewport.{left|bottom} to the backend, so it can offset the
     //       scissor properly.
-    mColorPassDescriptorSet.prepareViewport(physicalViewport, logicalViewport);
+    getColorPassDescriptorSet().prepareViewport(physicalViewport, logicalViewport);
 }
 
 void FView::prepareSSAO(Handle<HwTexture> ssao) const noexcept {
-    mColorPassDescriptorSet.prepareSSAO(ssao, mAmbientOcclusionOptions);
+    getColorPassDescriptorSet().prepareSSAO(ssao, mAmbientOcclusionOptions);
 }
 
 void FView::prepareSSR(Handle<HwTexture> ssr,
         bool const disableSSR,
         float const refractionLodOffset,
         ScreenSpaceReflectionsOptions const& ssrOptions) const noexcept {
-    mColorPassDescriptorSet.prepareSSR(ssr, disableSSR, refractionLodOffset, ssrOptions);
+    getColorPassDescriptorSet().prepareSSR(ssr, disableSSR, refractionLodOffset, ssrOptions);
 }
 
 void FView::prepareStructure(Handle<HwTexture> structure) const noexcept {
     // sampler must be NEAREST
-    mColorPassDescriptorSet.prepareStructure(structure);
+    getColorPassDescriptorSet().prepareStructure(structure);
 }
 
 void FView::prepareShadow(Handle<HwTexture> texture) const noexcept {
@@ -905,37 +912,37 @@ void FView::prepareShadow(Handle<HwTexture> texture) const noexcept {
     }
     switch (mShadowType) {
         case ShadowType::PCF:
-            mColorPassDescriptorSet.prepareShadowPCF(texture, uniforms);
+            getColorPassDescriptorSet().prepareShadowPCF(texture, uniforms);
             break;
         case ShadowType::VSM:
-            mColorPassDescriptorSet.prepareShadowVSM(texture, uniforms, mVsmShadowOptions);
+            getColorPassDescriptorSet().prepareShadowVSM(texture, uniforms, mVsmShadowOptions);
             break;
         case ShadowType::DPCF:
-            mColorPassDescriptorSet.prepareShadowDPCF(texture, uniforms, mSoftShadowOptions);
+            getColorPassDescriptorSet().prepareShadowDPCF(texture, uniforms, mSoftShadowOptions);
             break;
         case ShadowType::PCSS:
-            mColorPassDescriptorSet.prepareShadowPCSS(texture, uniforms, mSoftShadowOptions);
+            getColorPassDescriptorSet().prepareShadowPCSS(texture, uniforms, mSoftShadowOptions);
             break;
         case ShadowType::PCFd:
-            mColorPassDescriptorSet.prepareShadowPCFDebug(texture, uniforms);
+            getColorPassDescriptorSet().prepareShadowPCFDebug(texture, uniforms);
             break;
     }
 }
 
 void FView::prepareShadowMapping(bool const highPrecision) const noexcept {
     if (mHasShadowing) {
         assert_invariant(mShadowMapManager);
-        mColorPassDescriptorSet.prepareShadowMapping(
+        getColorPassDescriptorSet().prepareShadowMapping(
                 mShadowMapManager->getShadowUniformsHandle(), highPrecision);
     }
 }
 
 void FView::commitUniformsAndSamplers(DriverApi& driver) const noexcept {
-    mColorPassDescriptorSet.commit(driver);
+    getColorPassDescriptorSet().commit(driver);
 }
 
 void FView::unbindSamplers(DriverApi& driver) noexcept {
-    mColorPassDescriptorSet.unbindSamplers(driver);
+    getColorPassDescriptorSet().unbindSamplers(driver);
 }
 
 void FView::commitFroxels(DriverApi& driverApi) const noexcept {

filament/src/details/View.h

@@ -440,7 +440,9 @@ class FView : public View {
     static void cullRenderables(utils::JobSystem& js, FScene::RenderableSoa& renderableData,
             Frustum const& frustum, size_t bit) noexcept;
 
-    ColorPassDescriptorSet& getColorPassDescriptorSet() noexcept { return mColorPassDescriptorSet; }
+    ColorPassDescriptorSet& getColorPassDescriptorSet() const noexcept {
+            return mColorPassDescriptorSet[mShadowType == ShadowType::PCF ? 0 : 1];
+    }
 
     // Returns the frame history FIFO. This is typically used by the FrameGraph to access
     // previous frame data.
@@ -587,7 +589,7 @@ class FView : public View {
     RenderQuality mRenderQuality;
 
     mutable TypedUniformBuffer<PerViewUib> mUniforms;
-    mutable ColorPassDescriptorSet mColorPassDescriptorSet;
+    mutable ColorPassDescriptorSet mColorPassDescriptorSet[2];
 
     mutable FrameHistory mFrameHistory{};
 

filament/src/ds/ColorPassDescriptorSet.cpp

@@ -79,7 +79,7 @@ uint8_t ColorPassDescriptorSet::getIndex(
         index |= 0x2;
     }
 
-    if (!fog) {
+    if (fog) {
         // this will remove samplers needed for fog
         index |= 0x4;
     }
@@ -88,27 +88,18 @@ uint8_t ColorPassDescriptorSet::getIndex(
     return index;
 }
 
-
-ColorPassDescriptorSet::ColorPassDescriptorSet(FEngine& engine,
+ColorPassDescriptorSet::ColorPassDescriptorSet(FEngine& engine, bool const vsm,
         TypedUniformBuffer<PerViewUib>& uniforms) noexcept
-        : mUniforms(uniforms) {
-
-    constexpr UserVariantFilterMask filterFog = UserVariantFilterMask(UserVariantFilterBit::FOG);
-    constexpr UserVariantFilterMask keepFog = UserVariantFilterMask(0);
-
+    : mUniforms(uniforms), mIsVsm(vsm) {
     for (bool const lit: { false, true }) {
         for (bool const ssr: { false, true }) {
             for (bool const fog: { false, true }) {
-                auto index = getIndex(lit, ssr, fog);
+                auto const index = getIndex(lit, ssr, fog);
                 mDescriptorSetLayout[index] = {
                         engine.getDescriptorSetLayoutFactory(),
                         engine.getDriverApi(),
                         descriptor_sets::getPerViewDescriptorSetLayout(
-                                MaterialDomain::SURFACE,
-                                fog ? keepFog : filterFog,
-                                lit,
-                                ssr ? ReflectionMode::SCREEN_SPACE : ReflectionMode::DEFAULT,
-                                ssr ? RefractionMode::SCREEN_SPACE : RefractionMode::NONE)
+                                MaterialDomain::SURFACE, lit, ssr, fog, vsm)
                 };
                 mDescriptorSet[index] = DescriptorSet{ mDescriptorSetLayout[index] };
             }