cleaning en route

interface/src/Application_render.cpp

@@ -178,7 +178,7 @@ public:
 render::ItemID WorldBoxRenderData::_item{ render::Item::INVALID_ITEM_ID };
 
 namespace render {
-    template <> const ItemKey payloadGetKey(const WorldBoxRenderData::Pointer& stuff) { return ItemKey::Builder::opaqueShape(); }
+    template <> const ItemKey payloadGetKey(const WorldBoxRenderData::Pointer& stuff) { return ItemKey::Builder::opaqueShape().withTagBits(ItemKey::TAG_BITS_0 | ItemKey::TAG_BITS_1); }
     template <> const Item::Bound payloadGetBound(const WorldBoxRenderData::Pointer& stuff) { return Item::Bound(); }
     template <> void payloadRender(const WorldBoxRenderData::Pointer& stuff, RenderArgs* args) {
         if (Menu::getInstance()->isOptionChecked(MenuOption::WorldAxes)) {

interface/src/SecondaryCamera.cpp

@@ -19,6 +19,7 @@
 using RenderArgsPointer = std::shared_ptr<RenderArgs>;
 
 void MainRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred) {
+    
     task.addJob<RenderShadowTask>("RenderShadowTask", cullFunctor);
     const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1);
     assert(items.canCast<RenderFetchCullSortTask::Output>());

libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp

@@ -50,7 +50,7 @@ const glm::vec3 HAND_TO_PALM_OFFSET(0.0f, 0.12f, 0.08f);
 
 namespace render {
     template <> const ItemKey payloadGetKey(const AvatarSharedPointer& avatar) {
-        return ItemKey::Builder::opaqueShape().withTypeMeta();
+        return ItemKey::Builder::opaqueShape().withTypeMeta().withTagBits(ItemKey::TAG_BITS_0 | ItemKey::TAG_BITS_1);
     }
     template <> const Item::Bound payloadGetBound(const AvatarSharedPointer& avatar) {
         return static_pointer_cast<Avatar>(avatar)->getBounds();

libraries/entities-renderer/src/RenderableEntityItem.cpp

@@ -159,10 +159,10 @@ Item::Bound EntityRenderer::getBound() {
 
 ItemKey EntityRenderer::getKey() {
     if (isTransparent()) {
-        return ItemKey::Builder::transparentShape().withTypeMeta();
+        return ItemKey::Builder::transparentShape().withTypeMeta().withTagBits(render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1);
     }
 
-    return ItemKey::Builder::opaqueShape().withTypeMeta();
+    return ItemKey::Builder::opaqueShape().withTypeMeta().withTagBits(render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1);
 }
 
 uint32_t EntityRenderer::metaFetchMetaSubItems(ItemIDs& subItems) {

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -1014,9 +1014,9 @@ ModelEntityRenderer::ModelEntityRenderer(const EntityItemPointer& entity) : Pare
 
 void ModelEntityRenderer::setKey(bool didVisualGeometryRequestSucceed) {
     if (didVisualGeometryRequestSucceed) {
-        _itemKey = ItemKey::Builder().withTypeMeta();
+        _itemKey = ItemKey::Builder().withTypeMeta().withTagBits(render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1);
     } else {
-        _itemKey = ItemKey::Builder().withTypeMeta().withTypeShape();
+        _itemKey = ItemKey::Builder().withTypeMeta().withTypeShape().withTagBits(render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1);
     }
 }
 
@@ -1333,15 +1333,16 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
     entity->updateModelBounds();
     entity->stopModelOverrideIfNoParent();
 
-    uint32_t viewVisiblityMask = _cauterized ?
+    // Default behavior for model is to not be visible in main view if cauterized (aka parented to the avatar's neck joint)
+    uint32_t viewTaskBits = _cauterized ?
         render::ItemKey::TAG_BITS_1 : // draw in every view except the main one (view zero)
         render::ItemKey::TAG_BITS_ALL; // draw in all views
 
-    if (model->isVisible() != _visible || model->getViewVisibilityMask() != viewVisiblityMask) {
+    if (model->isVisible() != _visible || model->getViewTagBits() != viewTaskBits) {
         // FIXME: this seems like it could be optimized if we tracked our last known visible state in
         //        the renderable item. As it stands now the model checks it's visible/invisible state
         //        so most of the time we don't do anything in this function.
-        model->setVisibleInScene(_visible, scene, viewVisiblityMask);
+        model->setVisibleInScene(_visible, scene, viewTaskBits);
     }
     // TODO? early exit here when not visible?
 

libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp

@@ -147,9 +147,9 @@ void ParticleEffectEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEn
 
 ItemKey ParticleEffectEntityRenderer::getKey() {
     if (_visible) {
-        return ItemKey::Builder::transparentShape();
+        return ItemKey::Builder::transparentShape().withTagBits(render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1);
     } else {
-        return ItemKey::Builder().withInvisible().build();
+        return ItemKey::Builder().withInvisible().withTagBits(render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1).build();
     }
 }
 

libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp

@@ -112,7 +112,7 @@ PolyLineEntityRenderer::PolyLineEntityRenderer(const EntityItemPointer& entity)
 }
 
 ItemKey PolyLineEntityRenderer::getKey() {
-    return ItemKey::Builder::transparentShape().withTypeMeta();
+    return ItemKey::Builder::transparentShape().withTypeMeta().withTagBits(render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1);
 }
 
 ShapeKey PolyLineEntityRenderer::getShapeKey() {

libraries/entities-renderer/src/RenderableZoneEntityItem.cpp

@@ -269,7 +269,7 @@ void ZoneEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointe
 
 
 ItemKey ZoneEntityRenderer::getKey() {
-    return ItemKey::Builder().withTypeMeta().build();
+    return ItemKey::Builder().withTypeMeta().withTagBits(render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1).build();
 }
 
 bool ZoneEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {

libraries/render-utils/src/AnimDebugDraw.cpp

@@ -67,7 +67,7 @@ public:
 typedef render::Payload<AnimDebugDrawData> AnimDebugDrawPayload;
 
 namespace render {
-    template <> const ItemKey payloadGetKey(const AnimDebugDrawData::Pointer& data) { return (data->_isVisible ? ItemKey::Builder::opaqueShape() : ItemKey::Builder::opaqueShape().withInvisible()); }
+    template <> const ItemKey payloadGetKey(const AnimDebugDrawData::Pointer& data) { return (data->_isVisible ? ItemKey::Builder::opaqueShape() : ItemKey::Builder::opaqueShape().withInvisible()).withTagBits(ItemKey::TAG_BITS_ALL); }
     template <> const Item::Bound payloadGetBound(const AnimDebugDrawData::Pointer& data) { return data->_bound; }
     template <> void payloadRender(const AnimDebugDrawData::Pointer& data, RenderArgs* args) {
         data->render(args);

libraries/render-utils/src/CauterizedModel.cpp

@@ -247,7 +247,7 @@ void CauterizedModel::updateRenderItems() {
                     data.updateTransformForCauterizedMesh(renderTransform);
 
                     data.setEnableCauterization(enableCauterization);
-                    data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::TAG_BITS_ALL);
+                    data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::TAG_BITS_ALL);
                     data.setLayer(isLayeredInFront, isLayeredInHUD);
                     data.setShapeKey(invalidatePayloadShapeKey, isWireframe);
                 });

libraries/render-utils/src/LightPayload.cpp

@@ -18,9 +18,13 @@ namespace render {
     template <> const ItemKey payloadGetKey(const LightPayload::Pointer& payload) {
         ItemKey::Builder builder;
         builder.withTypeLight();
-        if (!payload || !payload->isVisible()) {
+        builder.withTagBits(ItemKey::TAG_BITS_ALL);
-            builder.withInvisible();
+        if (!payload) {
+            if (!payload->isVisible()) {
+                builder.withInvisible();
+            }
         }
+
         return builder.build();
     }
 
@@ -87,6 +91,7 @@ namespace render {
     template <> const ItemKey payloadGetKey(const KeyLightPayload::Pointer& payload) {
         ItemKey::Builder builder;
         builder.withTypeLight();
+        builder.withTagBits(ItemKey::TAG_BITS_ALL);
         if (!payload || !payload->isVisible()) {
             builder.withInvisible();
         }

libraries/render-utils/src/MeshPartPayload.cpp

@@ -71,10 +71,20 @@ void MeshPartPayload::updateMaterial(graphics::MaterialPointer drawMaterial) {
     _drawMaterial = drawMaterial;
 }
 
-ItemKey MeshPartPayload::getKey() const {
+void MeshPartPayload::updateKey(bool isVisible, bool isLayered, uint8_t tagBits) {
     ItemKey::Builder builder;
     builder.withTypeShape();
 
+    if (!isVisible) {
+        builder.withInvisible();
+    }
+
+    builder.withTagBits(tagBits);
+
+    if (isLayered) {
+        builder.withLayered();
+    }
+
     if (_drawMaterial) {
         auto matKey = _drawMaterial->getKey();
         if (matKey.isTranslucent()) {
@@ -82,7 +92,11 @@ ItemKey MeshPartPayload::getKey() const {
         }
     }
 
-    return builder.build();
+    _itemKey = builder.build();
+}
+
+ItemKey MeshPartPayload::getKey() const {
+    return _itemKey;
 }
 
 Item::Bound MeshPartPayload::getBound() const {
@@ -389,7 +403,7 @@ void ModelMeshPartPayload::updateTransformForSkinnedMesh(const Transform& render
     _worldBound.transform(boundTransform);
 }
 
-void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, uint8_t viewVisiblityMask) {
+void ModelMeshPartPayload::updateKey(bool isVisible, bool isLayered, uint8_t tagBits) {
     ItemKey::Builder builder;
     builder.withTypeShape();
 
@@ -397,7 +411,7 @@ void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, uint8_t viewVi
         builder.withInvisible();
     }
 
-    builder.withTagBits(render::ItemKey::TAG_BITS_ALL); // Draw models in all tags
+    builder.withTagBits(tagBits);
 
     if (isLayered) {
         builder.withLayered();
@@ -417,10 +431,6 @@ void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, uint8_t viewVi
     _itemKey = builder.build();
 }
 
-ItemKey ModelMeshPartPayload::getKey() const {
-    return _itemKey;
-}
-
 void ModelMeshPartPayload::setLayer(bool isLayeredInFront, bool isLayeredInHUD) {
     if (isLayeredInFront) {
         _layer = Item::LAYER_3D_FRONT;

libraries/render-utils/src/MeshPartPayload.h

@@ -33,6 +33,8 @@ public:
     typedef render::Payload<MeshPartPayload> Payload;
     typedef Payload::DataPointer Pointer;
 
+    virtual void updateKey(bool isVisible, bool isLayered, uint8_t tagBits);
+
     virtual void updateMeshPart(const std::shared_ptr<const graphics::Mesh>& drawMesh, int partIndex);
 
     virtual void notifyLocationChanged() {}
@@ -70,6 +72,9 @@ public:
     size_t getMaterialTextureSize() { return _drawMaterial ? _drawMaterial->getTextureSize() : 0; }
     int getMaterialTextureCount() { return _drawMaterial ? _drawMaterial->getTextureCount() : 0; }
     bool hasTextureInfo() const { return _drawMaterial ? _drawMaterial->hasTextureInfo() : false; }
+
+protected:
+    render::ItemKey _itemKey{ render::ItemKey::Builder::opaqueShape().build() };
 };
 
 namespace render {
@@ -94,16 +99,15 @@ public:
     using TransformType = glm::mat4;
 #endif
 
+    void updateKey(bool isVisible, bool isLayered, uint8_t tagBits) override;
     void updateClusterBuffer(const std::vector<TransformType>& clusterTransforms);
     void updateTransformForSkinnedMesh(const Transform& renderTransform, const Transform& boundTransform);
 
     // Render Item interface
-    render::ItemKey getKey() const override;
     int getLayer() const;
     render::ShapeKey getShapeKey() const override; // shape interface
     void render(RenderArgs* args) override;
 
-    void setKey(bool isVisible, bool isLayered, uint8_t viewVisiblityMask);
     void setLayer(bool isLayeredInFront, bool isLayeredInHUD);
     void setShapeKey(bool invalidateShapeKey, bool isWireframe);
 
@@ -126,7 +130,6 @@ private:
     void initCache(const ModelPointer& model);
 
     gpu::BufferPointer _blendedVertexBuffer;
-    render::ItemKey _itemKey { render::ItemKey::Builder::opaqueShape().build() };
     render::ShapeKey _shapeKey { render::ShapeKey::Builder::invalid() };
     int _layer { render::Item::LAYER_3D };
 };

libraries/render-utils/src/Model.cpp

@@ -268,7 +268,7 @@ void Model::updateRenderItems() {
 
         bool isWireframe = self->isWireframe();
         bool isVisible = self->isVisible();
-        uint8_t viewVisibilityMask = self->getViewVisibilityMask();
+        uint8_t viewTagBits = self->getViewTagBits();
         bool isLayeredInFront = self->isLayeredInFront();
         bool isLayeredInHUD = self->isLayeredInHUD();
 
@@ -283,7 +283,7 @@ void Model::updateRenderItems() {
 
             transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, clusterTransforms,
                                                                   invalidatePayloadShapeKey, isWireframe, isVisible,
-                                                                  viewVisibilityMask, isLayeredInFront,
+                                                                  viewTagBits, isLayeredInFront,
                                                                   isLayeredInHUD](ModelMeshPartPayload& data) {
                 data.updateClusterBuffer(clusterTransforms);
 
@@ -300,7 +300,7 @@ void Model::updateRenderItems() {
                 }
                 data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
 
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
+                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, viewTagBits);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
                 data.setShapeKey(invalidatePayloadShapeKey, isWireframe);
             });
@@ -662,25 +662,25 @@ void Model::calculateTriangleSets() {
     }
 }
 
-void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewVisibilityMask) {
+void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewTagBits) {
-    if (_isVisible != isVisible || _viewVisibilityMask != viewVisibilityMask) {
+    if (_isVisible != isVisible || _viewTagBits != viewTagBits) {
         _isVisible = isVisible;
-        _viewVisibilityMask = viewVisibilityMask;
+        _viewTagBits = viewTagBits;
 
         bool isLayeredInFront = _isLayeredInFront;
         bool isLayeredInHUD = _isLayeredInHUD;
 
         render::Transaction transaction;
         foreach (auto item, _modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront,
                                                                 isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
+                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, viewTagBits);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront,
                                                                 isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
+                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, viewTagBits);
             });
         }
         scene->enqueueTransaction(transaction);
@@ -693,21 +693,21 @@ void Model::setLayeredInFront(bool isLayeredInFront, const render::ScenePointer&
         _isLayeredInFront = isLayeredInFront;
 
         bool isVisible = _isVisible;
-        uint8_t viewVisibilityMask = _viewVisibilityMask;
+        uint8_t viewTagBits = _viewTagBits;
         bool isLayeredInHUD = _isLayeredInHUD;
 
         render::Transaction transaction;
         foreach(auto item, _modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront,
                                                                 isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
+                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, viewTagBits);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront,
                                                                 isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
+                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, viewTagBits);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
@@ -720,21 +720,21 @@ void Model::setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& sce
         _isLayeredInHUD = isLayeredInHUD;
 
         bool isVisible = _isVisible;
-        uint8_t viewVisibilityMask = _viewVisibilityMask;
+        uint8_t viewTagBits = _viewTagBits;
         bool isLayeredInFront = _isLayeredInFront;
 
         render::Transaction transaction;
         foreach(auto item, _modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront,
                                                                 isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
+                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, viewTagBits);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront,
                                                                 isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
+                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, viewTagBits);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }

libraries/render-utils/src/Model.h

@@ -86,7 +86,7 @@ public:
     const QUrl& getURL() const { return _url; }
 
     // new Scene/Engine rendering support
-    void setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewVisiblityMask);
+    void setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewTagBits);
     void setLayeredInFront(bool isLayeredInFront, const render::ScenePointer& scene);
     void setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& scene);
     bool needsFixupInScene() const;
@@ -104,7 +104,7 @@ public:
     bool isRenderable() const;
 
     bool isVisible() const { return _isVisible; }
-    uint8_t getViewVisibilityMask() const { return _viewVisibilityMask; }
+    uint8_t getViewTagBits() const { return _viewTagBits; }
 
     bool isLayeredInFront() const { return _isLayeredInFront; }
     bool isLayeredInHUD() const { return _isLayeredInHUD; }
@@ -389,7 +389,7 @@ protected:
 
     QUrl _url;
     bool _isVisible;
-    uint8_t _viewVisibilityMask { render::ItemKey::TAG_BITS_ALL };
+    uint8_t _viewTagBits{ render::ItemKey::TAG_BITS_ALL };
 
     gpu::Buffers _blendedVertexBuffers;
 

libraries/render-utils/src/RenderShadowTask.cpp

@@ -200,7 +200,7 @@ void RenderShadowMap::run(const render::RenderContextPointer& renderContext, con
     });
 }
 
-void RenderShadowTask::build(JobModel& task, const render::Varying& input, render::Varying& output, CullFunctor cullFunctor) {
+void RenderShadowTask::build(JobModel& task, const render::Varying& input, render::Varying& output, CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask) {
     cullFunctor = cullFunctor ? cullFunctor : [](const RenderArgs*, const AABox&) { return true; };
 
     // Prepare the ShapePipeline
@@ -259,6 +259,8 @@ void RenderShadowCascadeSetup::run(const render::RenderContextPointer& renderCon
     // Cache old render args
     RenderArgs* args = renderContext->args;
 
+ //   const auto& filterMask = inputs;
+
     output.edit0() = args->_renderMode;
     output.edit2() = args->_sizeScale;
 

libraries/render-utils/src/RenderShadowTask.h

@@ -48,7 +48,7 @@ public:
     using JobModel = render::Task::Model<RenderShadowTask, Config>;
 
     RenderShadowTask() {}
-    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor shouldRender);
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor shouldRender, uint8_t tagBits = 0x00, uint8_t tagMask = 0x00);
 
     void configure(const Config& configuration);
 };

libraries/render-utils/src/RenderViewTask.cpp

@@ -14,7 +14,7 @@
 #include "RenderDeferredTask.h"
 #include "RenderForwardTask.h"
 
-void RenderViewTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, bool isDeferred, uint8_t visibilityMask, uint8_t visibilityMaskTouched) {
+void RenderViewTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, bool isDeferred, uint8_t tagBits, uint8_t tagMask) {
    // auto items = input.get<Input>();
 
     // Shadows use an orthographic projection because they are linked to sunlights
@@ -30,7 +30,7 @@ void RenderViewTask::build(JobModel& task, const render::Varying& input, render:
         return true;
     });
 
-    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, visibilityMask, visibilityMaskTouched);
+    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, tagBits, tagMask);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
 
     if (isDeferred) {

libraries/render-utils/src/RenderViewTask.h

@@ -23,7 +23,7 @@ public:
 
     RenderViewTask() {}
 
-    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred, uint8_t visibilityMask = 0xFF, uint8_t visibilityMaskTouched = 0x00);
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred, uint8_t tagBits = 0x00, uint8_t tagMask = 0x00);
 
 };
 

libraries/render/src/render/RenderFetchCullSortTask.cpp

@@ -40,15 +40,15 @@ void RenderFetchCullSortTask::build(JobModel& task, const Varying& input, Varyin
     const int META_BUCKET = 3;
     const int BACKGROUND_BUCKET = 2;
     MultiFilterItems<NUM_SPATIAL_FILTERS>::ItemFilterArray spatialFilters = { {
-            ItemFilter::Builder::opaqueShape().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::opaqueShape(),
-            ItemFilter::Builder::transparentShape().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::transparentShape(),
-            ItemFilter::Builder::light().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::light(),
-            ItemFilter::Builder::meta().withVisible().withTagBits(tagBits, tagMask)
+            ItemFilter::Builder::meta()
         } };
     MultiFilterItems<NUM_NON_SPATIAL_FILTERS>::ItemFilterArray nonspatialFilters = { {
-            ItemFilter::Builder::opaqueShape().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::opaqueShape(),
-            ItemFilter::Builder::transparentShape().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::transparentShape(),
-            ItemFilter::Builder::background().withVisible().withTagBits(tagBits, tagMask)
+            ItemFilter::Builder::background()
         } };
     const auto filteredSpatialBuckets = 
         task.addJob<MultiFilterItems<NUM_SPATIAL_FILTERS>>("FilterSceneSelection", culledSpatialSelection, spatialFilters)