From e7a3d98ae5ede6b5643029b3abb5f97963283273 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Thu, 11 Jan 2018 19:34:54 -0800
Subject: [PATCH 01/23] don't draw head-descendent entities when in 1st-person
 camera mode

---
 interface/src/avatar/MyAvatar.cpp             | 19 +++++++++++++++++++
 interface/src/avatar/MyAvatar.h               |  2 ++
 .../src/RenderableModelEntityItem.cpp         |  5 +++--
 libraries/entities/src/EntityItem.h           |  4 ++++
 4 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index e863a58e14..b680925b3e 100755
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -46,6 +46,7 @@
 #include <recording/Frame.h>
 #include <RecordingScriptingInterface.h>
 #include <trackers/FaceTracker.h>
+#include <RenderableModelEntityItem.h>
 
 #include "MyHead.h"
 #include "MySkeletonModel.h"
@@ -501,11 +502,29 @@ void MyAvatar::updateEyeContactTarget(float deltaTime) {
 extern QByteArray avatarStateToFrame(const AvatarData* _avatar);
 extern void avatarStateFromFrame(const QByteArray& frameData, AvatarData* _avatar);
 
+void MyAvatar::updateChildCauterization(SpatiallyNestablePointer object) {
+    if (object->getNestableType() == NestableType::Entity) {
+        EntityItemPointer entity = std::static_pointer_cast<EntityItem>(object);
+        entity->setCauterized(!_prevShouldDrawHead);
+    }
+}
+
 void MyAvatar::simulate(float deltaTime) {
     PerformanceTimer perfTimer("simulate");
 
     animateScaleChanges(deltaTime);
 
+    const std::unordered_set<int>& headBoneSet = _skeletonModel->getCauterizeBoneSet();
+    forEachChild([&](SpatiallyNestablePointer object) {
+        bool isChildOfHead = headBoneSet.find(object->getParentJointIndex()) != headBoneSet.end();
+        if (isChildOfHead) {
+            updateChildCauterization(object);
+            object->forEachDescendant([&](SpatiallyNestablePointer descendant) {
+                updateChildCauterization(descendant);
+            });
+        }
+    });
+
     {
         PerformanceTimer perfTimer("transform");
         bool stepAction = false;
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index ab74460d4e..7b82a64e23 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -841,6 +841,8 @@ private:
 
     // height of user in sensor space, when standing erect.
     ThreadSafeValueCache<float> _userHeight { DEFAULT_AVATAR_HEIGHT };
+
+    void updateChildCauterization(SpatiallyNestablePointer object);
 };
 
 QScriptValue audioListenModeToScriptValue(QScriptEngine* engine, const AudioListenerMode& audioListenerMode);
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index 86237e75a4..a08cf23d7b 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -1281,11 +1281,12 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
 
     entity->updateModelBounds();
 
-    if (model->isVisible() != _visible) {
+    bool shouldBeVisible = _visible && !entity->getCauterized();
+    if (model->isVisible() != shouldBeVisible) {
         // 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);
+        model->setVisibleInScene(shouldBeVisible, scene);
     }
     // TODO? early exit here when not visible?
 
diff --git a/libraries/entities/src/EntityItem.h b/libraries/entities/src/EntityItem.h
index ecfb7b5dcd..68639e0d3a 100644
--- a/libraries/entities/src/EntityItem.h
+++ b/libraries/entities/src/EntityItem.h
@@ -469,6 +469,9 @@ public:
     static QString _marketplacePublicKey;
     static void retrieveMarketplacePublicKey();
 
+    void setCauterized(bool value) { _cauterized = value; }
+    bool getCauterized() const { return _cauterized; }
+
 signals:
     void requestRenderUpdate();
 
@@ -622,6 +625,7 @@ protected:
     quint64 _lastUpdatedAccelerationTimestamp { 0 };
     quint64 _lastUpdatedQueryAACubeTimestamp { 0 };
 
+    bool _cauterized { false }; // it true, don't draw because it would obscure 1st-person camera
 };
 
 #endif // hifi_EntityItem_h

From 9d4ab13a10df7ffc139df39c5fc24b33f473b302 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Thu, 11 Jan 2018 19:45:15 -0800
Subject: [PATCH 02/23] cauterize all head-based entities rather than just
 models

---
 libraries/entities-renderer/src/RenderableEntityItem.cpp     | 2 +-
 .../entities-renderer/src/RenderableModelEntityItem.cpp      | 5 ++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp
index fb9aba636b..49bc4deac5 100644
--- a/libraries/entities-renderer/src/RenderableEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp
@@ -365,7 +365,7 @@ void EntityRenderer::doRenderUpdateSynchronous(const ScenePointer& scene, Transa
         }
 
         _moving = entity->isMovingRelativeToParent();
-        _visible = entity->getVisible();
+        _visible = entity->getVisible() && !entity->getCauterized();
         _needsRenderUpdate = false;
     });
 }
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index a08cf23d7b..86237e75a4 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -1281,12 +1281,11 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
 
     entity->updateModelBounds();
 
-    bool shouldBeVisible = _visible && !entity->getCauterized();
-    if (model->isVisible() != shouldBeVisible) {
+    if (model->isVisible() != _visible) {
         // 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(shouldBeVisible, scene);
+        model->setVisibleInScene(_visible, scene);
     }
     // TODO? early exit here when not visible?
 

From 9bdb89df2ea40108f440df59f89feb2a8d92c144 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Fri, 12 Jan 2018 07:26:09 -0800
Subject: [PATCH 03/23] trying to get mirror to work

---
 libraries/entities-renderer/src/RenderableEntityItem.cpp | 6 ++++--
 libraries/entities-renderer/src/RenderableEntityItem.h   | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp
index 49bc4deac5..8d9cc326f3 100644
--- a/libraries/entities-renderer/src/RenderableEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp
@@ -185,7 +185,8 @@ void EntityRenderer::render(RenderArgs* args) {
         emit requestRenderUpdate();
     }
 
-    if (_visible) {
+    bool defaultMode = args->_renderMode == RenderArgs::DEFAULT_RENDER_MODE;
+    if (_visible && (defaultMode || !_cauterized)) {
         doRender(args);
     }
 }
@@ -365,7 +366,8 @@ void EntityRenderer::doRenderUpdateSynchronous(const ScenePointer& scene, Transa
         }
 
         _moving = entity->isMovingRelativeToParent();
-        _visible = entity->getVisible() && !entity->getCauterized();
+        _visible = entity->getVisible();
+        _cauterized = entity->getCauterized();
         _needsRenderUpdate = false;
     });
 }
diff --git a/libraries/entities-renderer/src/RenderableEntityItem.h b/libraries/entities-renderer/src/RenderableEntityItem.h
index 8eb82e2c6e..f8685df5da 100644
--- a/libraries/entities-renderer/src/RenderableEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableEntityItem.h
@@ -124,6 +124,7 @@ protected:
     bool _isFading{ _entitiesShouldFadeFunction() };
     bool _prevIsTransparent { false };
     bool _visible { false };
+    bool _cauterized { false };
     bool _moving { false };
     bool _needsRenderUpdate { false };
     // Only touched on the rendering thread

From 227dbd6f684b96755429f18b356a41cc607a0733 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Fri, 12 Jan 2018 08:52:07 -0800
Subject: [PATCH 04/23] put this back to a working state

---
 libraries/entities-renderer/src/RenderableEntityItem.cpp     | 3 +--
 .../entities-renderer/src/RenderableModelEntityItem.cpp      | 5 +++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp
index 8d9cc326f3..f2876da40a 100644
--- a/libraries/entities-renderer/src/RenderableEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp
@@ -185,8 +185,7 @@ void EntityRenderer::render(RenderArgs* args) {
         emit requestRenderUpdate();
     }
 
-    bool defaultMode = args->_renderMode == RenderArgs::DEFAULT_RENDER_MODE;
-    if (_visible && (defaultMode || !_cauterized)) {
+    if (_visible) {
         doRender(args);
     }
 }
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index 86237e75a4..a6d34f5826 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -1281,11 +1281,12 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
 
     entity->updateModelBounds();
 
-    if (model->isVisible() != _visible) {
+    bool visible = _visible && !_cauterized;
+    if (model->isVisible() != visible) {
         // 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);
+        model->setVisibleInScene(visible, scene);
     }
     // TODO? early exit here when not visible?
 

From dbdc50ed244b7cc9a18c766d7afa2d5c439eee96 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Fri, 12 Jan 2018 08:56:06 -0800
Subject: [PATCH 05/23] also cauterize non-models that are children of head

---
 libraries/entities-renderer/src/RenderableEntityItem.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp
index f2876da40a..c51e1bccd7 100644
--- a/libraries/entities-renderer/src/RenderableEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp
@@ -185,7 +185,7 @@ void EntityRenderer::render(RenderArgs* args) {
         emit requestRenderUpdate();
     }
 
-    if (_visible) {
+    if (_visible && !_cauterized) {
         doRender(args);
     }
 }

From f81f50a6d282061fe2e5a271b4d852513f0513b4 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Fri, 12 Jan 2018 09:08:52 -0800
Subject: [PATCH 06/23] non-models act correctly in mirror now'

---
 libraries/entities-renderer/src/RenderableEntityItem.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp
index c51e1bccd7..f3ef956146 100644
--- a/libraries/entities-renderer/src/RenderableEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp
@@ -185,7 +185,12 @@ void EntityRenderer::render(RenderArgs* args) {
         emit requestRenderUpdate();
     }
 
-    if (_visible && !_cauterized) {
+    auto& renderMode = args->_renderMode;
+    bool cauterized = (renderMode != RenderArgs::RenderMode::SHADOW_RENDER_MODE &&
+                       renderMode != RenderArgs::RenderMode::SECONDARY_CAMERA_RENDER_MODE) &&
+        _cauterized;
+
+    if (_visible && !cauterized) {
         doRender(args);
     }
 }

From 836b69ab1b65a4d1618ffe052a60871d5d669e74 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Fri, 12 Jan 2018 17:42:18 -0800
Subject: [PATCH 07/23] exposing several visibility flags

---
 .../render-utils/src/RenderShadowTask.cpp     |  2 +-
 libraries/render-utils/src/RenderViewTask.cpp |  4 +--
 libraries/render-utils/src/RenderViewTask.h   |  2 +-
 libraries/render/src/render/Item.h            | 35 +++++++++++++++----
 .../src/render/RenderFetchCullSortTask.cpp    |  4 +--
 .../src/render/RenderFetchCullSortTask.h      |  2 +-
 6 files changed, 35 insertions(+), 14 deletions(-)

diff --git a/libraries/render-utils/src/RenderShadowTask.cpp b/libraries/render-utils/src/RenderShadowTask.cpp
index 2e5b7132e4..02f6d70e43 100644
--- a/libraries/render-utils/src/RenderShadowTask.cpp
+++ b/libraries/render-utils/src/RenderShadowTask.cpp
@@ -264,7 +264,7 @@ void RenderShadowCascadeSetup::run(const render::RenderContextPointer& renderCon
 
     const auto globalShadow = lightStage->getCurrentKeyShadow();
     if (globalShadow && _cascadeIndex<globalShadow->getCascadeCount()) {
-        output.edit1() = ItemFilter::Builder::visibleWorldItems().withTypeShape().withOpaque().withoutLayered();
+        output.edit1() = ItemFilter::Builder::visibleWorldItems(0x08).withTypeShape().withOpaque().withoutLayered();
 
         globalShadow->setKeylightCascadeFrustum(_cascadeIndex, args->getViewFrustum(), SHADOW_FRUSTUM_NEAR, SHADOW_FRUSTUM_FAR);
 
diff --git a/libraries/render-utils/src/RenderViewTask.cpp b/libraries/render-utils/src/RenderViewTask.cpp
index dc6c66e058..434e069d28 100644
--- a/libraries/render-utils/src/RenderViewTask.cpp
+++ b/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) {
+void RenderViewTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, bool isDeferred, uint8_t visibilityMask) {
    // 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);
+    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, visibilityMask);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
 
     if (isDeferred) {
diff --git a/libraries/render-utils/src/RenderViewTask.h b/libraries/render-utils/src/RenderViewTask.h
index eb61f56eab..9c2bbe0281 100644
--- a/libraries/render-utils/src/RenderViewTask.h
+++ b/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);
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred, uint8_t visibilityMask = 0xFF);
 
 };
 
diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h
index 77f5910b9e..c2f1312ec2 100644
--- a/libraries/render/src/render/Item.h
+++ b/libraries/render/src/render/Item.h
@@ -46,7 +46,10 @@ public:
         VIEW_SPACE,       // Transformed in view space, and not in world space
         DYNAMIC,          // Dynamic and bound will change unlike static item
         DEFORMED,         // Deformed within bound, not solid
-        INVISIBLE,        // Visible or not? could be just here to cast shadow
+        INVISIBLE0,       // Visible or not in this mask index?
+        INVISIBLE1,       // Visible or not in this mask index?
+        INVISIBLE2,       // Visible or not in this mask index?
+        INVISIBLE3,       // Visible or not in this mask index?
         SHADOW_CASTER,    // Item cast shadows
         PICKABLE,         // Item can be picked/selected
         LAYERED,          // Item belongs to one of the layers different from the default layer
@@ -57,6 +60,12 @@ public:
     };
     typedef std::bitset<NUM_FLAGS> Flags;
 
+    // VISIBLE MASK is defined from several bits in the Key.
+    // An Item can be visible in some mask bits and not other allowing for per view rendering
+    // Beware that the visibility mask is the oposite of what stored in the key vals.
+    const static uint8_t NUM_VISIBLE_MASK_INDICES{ 4 };
+    const static uint8_t VISIBLE_MASK_ALL{ 0x0F };
+
     // The key is the Flags
     Flags _flags;
 
@@ -82,7 +91,7 @@ public:
         Builder& withViewSpace() { _flags.set(VIEW_SPACE); return (*this); }
         Builder& withDynamic() { _flags.set(DYNAMIC); return (*this); }
         Builder& withDeformed() { _flags.set(DEFORMED); return (*this); }
-        Builder& withInvisible() { _flags.set(INVISIBLE); return (*this); }
+        Builder& withInvisible(uint8_t maskIndex = 0) { _flags.set(INVISIBLE0 + maskIndex); return (*this); }
         Builder& withShadowCaster() { _flags.set(SHADOW_CASTER); return (*this); }
         Builder& withPickable() { _flags.set(PICKABLE); return (*this); }
         Builder& withLayered() { _flags.set(LAYERED); return (*this); }
@@ -111,8 +120,10 @@ public:
     bool isRigid() const { return !_flags[DEFORMED]; }
     bool isDeformed() const { return _flags[DEFORMED]; }
 
-    bool isVisible() const { return !_flags[INVISIBLE]; }
-    bool isInvisible() const { return _flags[INVISIBLE]; }
+    bool isVisible(uint8_t maskIndex) const { return !_flags[INVISIBLE0 + maskIndex]; }
+    bool isInvisible(uint8_t maskIndex) const { return _flags[INVISIBLE0 + maskIndex]; }
+    uint8_t getVisibleMask() const { return (~(_flags.to_ulong() >> INVISIBLE0) & VISIBLE_MASK_ALL);}
+    bool isVisibleMask(uint8_t mask) const { return getVisibleMask() & mask; }
 
     bool isShadowCaster() const { return _flags[SHADOW_CASTER]; }
 
@@ -171,8 +182,18 @@ public:
         Builder& withRigid()            { _value.reset(ItemKey::DEFORMED); _mask.set(ItemKey::DEFORMED); return (*this); }
         Builder& withDeformed()         { _value.set(ItemKey::DEFORMED);  _mask.set(ItemKey::DEFORMED); return (*this); }
 
-        Builder& withVisible()          { _value.reset(ItemKey::INVISIBLE); _mask.set(ItemKey::INVISIBLE); return (*this); }
-        Builder& withInvisible()        { _value.set(ItemKey::INVISIBLE);  _mask.set(ItemKey::INVISIBLE); return (*this); }
+        Builder& withVisible(uint8_t maskIndex)          { _value.reset(ItemKey::INVISIBLE0 + maskIndex); _mask.set(ItemKey::INVISIBLE0 + maskIndex); return (*this); }
+        Builder& withInvisible(uint8_t maskIndex)        { _value.set(ItemKey::INVISIBLE0 + maskIndex);  _mask.set(ItemKey::INVISIBLE0 + maskIndex); return (*this); }
+        Builder& withVisibilityMask(uint8_t mask) {
+            for (int i = 0; i < ItemKey::NUM_VISIBLE_MASK_INDICES; i++) {
+                if ((1 << i) && mask) {
+                    withVisible(i);
+                } else {
+                    withInvisible(i);
+                }
+            }
+            return (*this);
+        }
 
         Builder& withNoShadowCaster()   { _value.reset(ItemKey::SHADOW_CASTER); _mask.set(ItemKey::SHADOW_CASTER); return (*this); }
         Builder& withShadowCaster()     { _value.set(ItemKey::SHADOW_CASTER);  _mask.set(ItemKey::SHADOW_CASTER); return (*this); }
@@ -185,7 +206,7 @@ public:
         Builder& withNothing()          { _value.reset(); _mask.reset(); return (*this); }
 
         // Convenient standard keys that we will keep on using all over the place
-        static Builder visibleWorldItems() { return Builder().withVisible().withWorldSpace(); }
+        static Builder visibleWorldItems(uint8_t visibilityMask) { return Builder().withVisibilityMask(visibilityMask).withWorldSpace(); }
         static Builder opaqueShape() { return Builder().withTypeShape().withOpaque().withWorldSpace(); }
         static Builder transparentShape() { return Builder().withTypeShape().withTransparent().withWorldSpace(); }
         static Builder light() { return Builder().withTypeLight(); }
diff --git a/libraries/render/src/render/RenderFetchCullSortTask.cpp b/libraries/render/src/render/RenderFetchCullSortTask.cpp
index d7294fa2bd..25c40ea7f7 100644
--- a/libraries/render/src/render/RenderFetchCullSortTask.cpp
+++ b/libraries/render/src/render/RenderFetchCullSortTask.cpp
@@ -17,12 +17,12 @@
 
 using namespace render;
 
-void RenderFetchCullSortTask::build(JobModel& task, const Varying& input, Varying& output, CullFunctor cullFunctor) {
+void RenderFetchCullSortTask::build(JobModel& task, const Varying& input, Varying& output, CullFunctor cullFunctor, uint8_t visibilityMask) {
     cullFunctor = cullFunctor ? cullFunctor : [](const RenderArgs*, const AABox&){ return true; };
 
     // CPU jobs:
     // Fetch and cull the items from the scene
-    const ItemFilter filter = ItemFilter::Builder::visibleWorldItems().withoutLayered();
+    const ItemFilter filter = ItemFilter::Builder::visibleWorldItems(visibilityMask).withoutLayered();
     const auto spatialFilter = render::Varying(filter);
     const auto spatialSelection = task.addJob<FetchSpatialTree>("FetchSceneSelection", spatialFilter);
     const auto cullInputs = CullSpatialSelection::Inputs(spatialSelection, spatialFilter).asVarying();
diff --git a/libraries/render/src/render/RenderFetchCullSortTask.h b/libraries/render/src/render/RenderFetchCullSortTask.h
index b25480ae3a..3e5ad2bad8 100644
--- a/libraries/render/src/render/RenderFetchCullSortTask.h
+++ b/libraries/render/src/render/RenderFetchCullSortTask.h
@@ -36,7 +36,7 @@ public:
 
     RenderFetchCullSortTask() {}
 
-    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor);
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, uint8_t visibilityMask = 0xFF);
 };
 
 #endif // hifi_RenderFetchCullSortTask_h

From 7a9740d25878a8f516329eeefbca7f68f0c30b31 Mon Sep 17 00:00:00 2001
From: Sam Gateau <samuel.gateau@gmail.com>
Date: Thu, 18 Jan 2018 02:18:46 -0800
Subject: [PATCH 08/23] visible-perview

---
 interface/src/Application.cpp                 |  2 +-
 interface/src/SecondaryCamera.cpp             |  2 +-
 .../render-utils/src/CauterizedModel.cpp      |  2 +-
 .../render-utils/src/MeshPartPayload.cpp      |  5 ++++-
 libraries/render-utils/src/MeshPartPayload.h  |  2 +-
 .../render-utils/src/RenderShadowTask.cpp     |  2 +-
 libraries/render-utils/src/RenderViewTask.cpp |  4 ++--
 libraries/render-utils/src/RenderViewTask.h   |  2 +-
 libraries/render/src/render/Item.h            | 19 +++++++++++++------
 .../src/render/RenderFetchCullSortTask.cpp    | 18 +++++++++---------
 .../src/render/RenderFetchCullSortTask.h      |  2 +-
 11 files changed, 35 insertions(+), 25 deletions(-)

diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 6849bd07b5..e9ea9a0295 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -2200,7 +2200,7 @@ void Application::initializeGL() {
     bool isDeferred = !QProcessEnvironment::systemEnvironment().contains(RENDER_FORWARD);
     _renderEngine->addJob<UpdateSceneTask>("UpdateScene");
     _renderEngine->addJob<SecondaryCameraRenderTask>("SecondaryCameraJob", cullFunctor);
-    _renderEngine->addJob<RenderViewTask>("RenderMainView", cullFunctor, isDeferred);
+    _renderEngine->addJob<RenderViewTask>("RenderMainView", cullFunctor, isDeferred, render::ItemKey::VISIBLE_MASK_0, render::ItemKey::VISIBLE_MASK_0);
     _renderEngine->load();
     _renderEngine->registerScene(_main3DScene);
 
diff --git a/interface/src/SecondaryCamera.cpp b/interface/src/SecondaryCamera.cpp
index 4cfa4d6156..35eff68ab3 100644
--- a/interface/src/SecondaryCamera.cpp
+++ b/interface/src/SecondaryCamera.cpp
@@ -20,7 +20,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);
+    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, render::ItemKey::VISIBLE_MASK_1, render::ItemKey::VISIBLE_MASK_1);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
     if (!isDeferred) {
         task.addJob<RenderForwardTask>("Forward", items);
diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index e3f26a43d8..09b6ada8e4 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/libraries/render-utils/src/CauterizedModel.cpp
@@ -247,7 +247,7 @@ void CauterizedModel::updateRenderItems() {
                     data.updateTransformForCauterizedMesh(renderTransform);
 
                     data.setEnableCauterization(enableCauterization);
-                    data.setKey(isVisible, isLayeredInFront || isLayeredInHUD);
+                    data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, enableCauterization);
                     data.setLayer(isLayeredInFront, isLayeredInHUD);
                     data.setShapeKey(invalidatePayloadShapeKey, isWireframe);
                 });
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index c506887fc4..ead2a767db 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -389,13 +389,16 @@ void ModelMeshPartPayload::updateTransformForSkinnedMesh(const Transform& render
     _worldBound.transform(boundTransform);
 }
 
-void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered) {
+void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, bool isCauterized) {
     ItemKey::Builder builder;
     builder.withTypeShape();
 
     if (!isVisible) {
         builder.withInvisible();
     }
+    else if (isCauterized) {
+        builder.withInvisible(0); // hide these items in the vibility mask #0
+    }
 
     if (isLayered) {
         builder.withLayered();
diff --git a/libraries/render-utils/src/MeshPartPayload.h b/libraries/render-utils/src/MeshPartPayload.h
index 8160b9f009..ee515c7b3d 100644
--- a/libraries/render-utils/src/MeshPartPayload.h
+++ b/libraries/render-utils/src/MeshPartPayload.h
@@ -103,7 +103,7 @@ public:
     render::ShapeKey getShapeKey() const override; // shape interface
     void render(RenderArgs* args) override;
 
-    void setKey(bool isVisible, bool isLayered);
+    void setKey(bool isVisible, bool isLayered, bool isCauterized = false);
     void setLayer(bool isLayeredInFront, bool isLayeredInHUD);
     void setShapeKey(bool invalidateShapeKey, bool isWireframe);
 
diff --git a/libraries/render-utils/src/RenderShadowTask.cpp b/libraries/render-utils/src/RenderShadowTask.cpp
index 378b164e67..7a7714e1e0 100644
--- a/libraries/render-utils/src/RenderShadowTask.cpp
+++ b/libraries/render-utils/src/RenderShadowTask.cpp
@@ -264,7 +264,7 @@ void RenderShadowCascadeSetup::run(const render::RenderContextPointer& renderCon
 
     const auto globalShadow = lightStage->getCurrentKeyShadow();
     if (globalShadow && _cascadeIndex<globalShadow->getCascadeCount()) {
-        output.edit1() = ItemFilter::Builder::visibleWorldItems(0x08).withTypeShape().withOpaque().withoutLayered();
+        output.edit1() = ItemFilter::Builder::visibleWorldItems(0x00, 0x00).withTypeShape().withOpaque().withoutLayered();
 
         globalShadow->setKeylightCascadeFrustum(_cascadeIndex, args->getViewFrustum(), SHADOW_FRUSTUM_NEAR, SHADOW_FRUSTUM_FAR);
 
diff --git a/libraries/render-utils/src/RenderViewTask.cpp b/libraries/render-utils/src/RenderViewTask.cpp
index 434e069d28..83868e1443 100644
--- a/libraries/render-utils/src/RenderViewTask.cpp
+++ b/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) {
+void RenderViewTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, bool isDeferred, uint8_t visibilityMask, uint8_t visibilityMaskTouched) {
    // 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);
+    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, visibilityMask, visibilityMaskTouched);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
 
     if (isDeferred) {
diff --git a/libraries/render-utils/src/RenderViewTask.h b/libraries/render-utils/src/RenderViewTask.h
index 9c2bbe0281..faace7349e 100644
--- a/libraries/render-utils/src/RenderViewTask.h
+++ b/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);
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred, uint8_t visibilityMask = 0xFF, uint8_t visibilityMaskTouched = 0x00);
 
 };
 
diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h
index 8594bc2954..3da7b07d7d 100644
--- a/libraries/render/src/render/Item.h
+++ b/libraries/render/src/render/Item.h
@@ -65,6 +65,10 @@ public:
     // Beware that the visibility mask is the oposite of what stored in the key vals.
     const static uint8_t NUM_VISIBLE_MASK_INDICES{ 4 };
     const static uint8_t VISIBLE_MASK_ALL{ 0x0F };
+    const static uint8_t VISIBLE_MASK_0{ 0x01 };
+    const static uint8_t VISIBLE_MASK_1{ 0x02 };
+    const static uint8_t VISIBLE_MASK_2{ 0x04 };
+    const static uint8_t VISIBLE_MASK_3{ 0x08 };
 
     // The key is the Flags
     Flags _flags;
@@ -184,12 +188,15 @@ public:
 
         Builder& withVisible(uint8_t maskIndex)          { _value.reset(ItemKey::INVISIBLE0 + maskIndex); _mask.set(ItemKey::INVISIBLE0 + maskIndex); return (*this); }
         Builder& withInvisible(uint8_t maskIndex)        { _value.set(ItemKey::INVISIBLE0 + maskIndex);  _mask.set(ItemKey::INVISIBLE0 + maskIndex); return (*this); }
-        Builder& withVisibilityMask(uint8_t mask) {
+        Builder& withVisibilityMask(uint8_t mask, uint8_t touchBits) {
             for (int i = 0; i < ItemKey::NUM_VISIBLE_MASK_INDICES; i++) {
-                if ((1 << i) && mask) {
-                    withVisible(i);
-                } else {
-                    withInvisible(i);
+                if ((1 << i) & touchBits) {
+                    if ((1 << i) & mask) {
+                        withVisible(i);
+                    }
+                    else {
+                        withInvisible(i);
+                    }
                 }
             }
             return (*this);
@@ -206,7 +213,7 @@ public:
         Builder& withNothing()          { _value.reset(); _mask.reset(); return (*this); }
 
         // Convenient standard keys that we will keep on using all over the place
-        static Builder visibleWorldItems(uint8_t visibilityMask) { return Builder().withVisibilityMask(visibilityMask).withWorldSpace(); }
+        static Builder visibleWorldItems(uint8_t visibilityMask, uint8_t visibilityMaskTouched) { return Builder().withVisibilityMask(visibilityMask, visibilityMaskTouched).withWorldSpace(); }
         static Builder opaqueShape() { return Builder().withTypeShape().withOpaque().withWorldSpace(); }
         static Builder transparentShape() { return Builder().withTypeShape().withTransparent().withWorldSpace(); }
         static Builder light() { return Builder().withTypeLight(); }
diff --git a/libraries/render/src/render/RenderFetchCullSortTask.cpp b/libraries/render/src/render/RenderFetchCullSortTask.cpp
index 25c40ea7f7..b4e1a618dc 100644
--- a/libraries/render/src/render/RenderFetchCullSortTask.cpp
+++ b/libraries/render/src/render/RenderFetchCullSortTask.cpp
@@ -17,12 +17,12 @@
 
 using namespace render;
 
-void RenderFetchCullSortTask::build(JobModel& task, const Varying& input, Varying& output, CullFunctor cullFunctor, uint8_t visibilityMask) {
+void RenderFetchCullSortTask::build(JobModel& task, const Varying& input, Varying& output, CullFunctor cullFunctor, uint8_t visibilityMask, uint8_t visibilityMaskTouched) {
     cullFunctor = cullFunctor ? cullFunctor : [](const RenderArgs*, const AABox&){ return true; };
 
     // CPU jobs:
     // Fetch and cull the items from the scene
-    const ItemFilter filter = ItemFilter::Builder::visibleWorldItems(visibilityMask).withoutLayered();
+    const ItemFilter filter = ItemFilter::Builder::visibleWorldItems(visibilityMask, visibilityMaskTouched).withoutLayered();
     const auto spatialFilter = render::Varying(filter);
     const auto spatialSelection = task.addJob<FetchSpatialTree>("FetchSceneSelection", spatialFilter);
     const auto cullInputs = CullSpatialSelection::Inputs(spatialSelection, spatialFilter).asVarying();
@@ -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(),
-            ItemFilter::Builder::transparentShape(),
-            ItemFilter::Builder::light(),
-            ItemFilter::Builder::meta()
+            ItemFilter::Builder::opaqueShape().withVisibilityMask(visibilityMask, visibilityMaskTouched),
+            ItemFilter::Builder::transparentShape().withVisibilityMask(visibilityMask, visibilityMaskTouched),
+            ItemFilter::Builder::light().withVisibilityMask(visibilityMask, visibilityMaskTouched),
+            ItemFilter::Builder::meta().withVisibilityMask(visibilityMask, visibilityMaskTouched)
         } };
     MultiFilterItems<NUM_NON_SPATIAL_FILTERS>::ItemFilterArray nonspatialFilters = { {
-            ItemFilter::Builder::opaqueShape(),
-            ItemFilter::Builder::transparentShape(),
-            ItemFilter::Builder::background()
+            ItemFilter::Builder::opaqueShape().withVisibilityMask(visibilityMask, visibilityMaskTouched),
+            ItemFilter::Builder::transparentShape().withVisibilityMask(visibilityMask, visibilityMaskTouched),
+            ItemFilter::Builder::background().withVisibilityMask(visibilityMask, visibilityMaskTouched)
         } };
     const auto filteredSpatialBuckets = 
         task.addJob<MultiFilterItems<NUM_SPATIAL_FILTERS>>("FilterSceneSelection", culledSpatialSelection, spatialFilters)
diff --git a/libraries/render/src/render/RenderFetchCullSortTask.h b/libraries/render/src/render/RenderFetchCullSortTask.h
index 3e5ad2bad8..9aa235b3fb 100644
--- a/libraries/render/src/render/RenderFetchCullSortTask.h
+++ b/libraries/render/src/render/RenderFetchCullSortTask.h
@@ -36,7 +36,7 @@ public:
 
     RenderFetchCullSortTask() {}
 
-    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, uint8_t visibilityMask = 0xFF);
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, uint8_t visibilityMask = 0xFF, uint8_t visibilityMaskTouched = 0x00);
 };
 
 #endif // hifi_RenderFetchCullSortTask_h

From 97a4f141eb6048c3d245a02716f58c0bb4f67cdc Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Thu, 18 Jan 2018 08:12:14 -0800
Subject: [PATCH 09/23] fix link trouble

---
 libraries/render/src/render/Item.cpp |  8 ++++++++
 libraries/render/src/render/Item.h   | 12 ++++++------
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/libraries/render/src/render/Item.cpp b/libraries/render/src/render/Item.cpp
index 036c7d3a99..75c38ec615 100644
--- a/libraries/render/src/render/Item.cpp
+++ b/libraries/render/src/render/Item.cpp
@@ -34,6 +34,14 @@ const int Item::LAYER_3D = 1;
 const int Item::LAYER_3D_FRONT = 2;
 const int Item::LAYER_3D_HUD = 3;
 
+const uint8_t ItemKey::NUM_VISIBLE_MASK_INDICES { 4 };
+const uint8_t ItemKey::VISIBLE_MASK_ALL { 0x0F };
+const uint8_t ItemKey::VISIBLE_MASK_0 { 0x01 };
+const uint8_t ItemKey::VISIBLE_MASK_1 { 0x02 };
+const uint8_t ItemKey::VISIBLE_MASK_2 { 0x04 };
+const uint8_t ItemKey::VISIBLE_MASK_3 { 0x08 };
+
+
 void Item::Status::Value::setScale(float scale) {
     _scale = (std::numeric_limits<unsigned short>::max() -1) * 0.5f * (1.0f + std::max(std::min(scale, 1.0f), 0.0f));
  }
diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h
index 3da7b07d7d..ebf3980489 100644
--- a/libraries/render/src/render/Item.h
+++ b/libraries/render/src/render/Item.h
@@ -63,12 +63,12 @@ public:
     // VISIBLE MASK is defined from several bits in the Key.
     // An Item can be visible in some mask bits and not other allowing for per view rendering
     // Beware that the visibility mask is the oposite of what stored in the key vals.
-    const static uint8_t NUM_VISIBLE_MASK_INDICES{ 4 };
-    const static uint8_t VISIBLE_MASK_ALL{ 0x0F };
-    const static uint8_t VISIBLE_MASK_0{ 0x01 };
-    const static uint8_t VISIBLE_MASK_1{ 0x02 };
-    const static uint8_t VISIBLE_MASK_2{ 0x04 };
-    const static uint8_t VISIBLE_MASK_3{ 0x08 };
+    const static uint8_t NUM_VISIBLE_MASK_INDICES;
+    const static uint8_t VISIBLE_MASK_ALL;
+    const static uint8_t VISIBLE_MASK_0;
+    const static uint8_t VISIBLE_MASK_1;
+    const static uint8_t VISIBLE_MASK_2;
+    const static uint8_t VISIBLE_MASK_3;
 
     // The key is the Flags
     Flags _flags;

From 1c819c84224b077fa1e203429478a0916d9b4805 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Thu, 18 Jan 2018 09:12:37 -0800
Subject: [PATCH 10/23] formatting

---
 libraries/entities-renderer/src/RenderableEntityItem.cpp | 4 ++--
 libraries/render-utils/src/MeshPartPayload.cpp           | 3 +--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp
index f3ef956146..0988c696dd 100644
--- a/libraries/entities-renderer/src/RenderableEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp
@@ -187,8 +187,8 @@ void EntityRenderer::render(RenderArgs* args) {
 
     auto& renderMode = args->_renderMode;
     bool cauterized = (renderMode != RenderArgs::RenderMode::SHADOW_RENDER_MODE &&
-                       renderMode != RenderArgs::RenderMode::SECONDARY_CAMERA_RENDER_MODE) &&
-        _cauterized;
+                       renderMode != RenderArgs::RenderMode::SECONDARY_CAMERA_RENDER_MODE &&
+                       _cauterized);
 
     if (_visible && !cauterized) {
         doRender(args);
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index ead2a767db..de03f2e03d 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -395,8 +395,7 @@ void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, bool isCauteri
 
     if (!isVisible) {
         builder.withInvisible();
-    }
-    else if (isCauterized) {
+    } else if (isCauterized) {
         builder.withInvisible(0); // hide these items in the vibility mask #0
     }
 

From fb974b0b9c93f77d75fe460ae7fcfa03c83e43ad Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Thu, 18 Jan 2018 10:09:23 -0800
Subject: [PATCH 11/23] attempt to straighten out use of view-visibility masks

---
 interface/src/avatar/MyAvatar.cpp                |  9 +++++----
 interface/src/ui/overlays/ModelOverlay.cpp       |  3 ++-
 .../src/RenderableModelEntityItem.cpp            | 10 +++++++---
 libraries/render-utils/src/CauterizedModel.cpp   |  2 +-
 libraries/render-utils/src/MeshPartPayload.cpp   |  6 +++---
 libraries/render-utils/src/MeshPartPayload.h     |  2 +-
 libraries/render-utils/src/Model.cpp             | 16 ++++++++--------
 libraries/render-utils/src/Model.h               |  2 +-
 8 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 0b5bdad6ae..e9205157b4 100755
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -1078,7 +1078,7 @@ void MyAvatar::setEnableDebugDrawIKChains(bool isEnabled) {
 }
 
 void MyAvatar::setEnableMeshVisible(bool isEnabled) {
-    _skeletonModel->setVisibleInScene(isEnabled, qApp->getMain3DScene());
+    _skeletonModel->setVisibleInScene(isEnabled, qApp->getMain3DScene(), render::ItemKey::VISIBLE_MASK_ALL);
 }
 
 void MyAvatar::setEnableInverseKinematics(bool isEnabled) {
@@ -1428,7 +1428,7 @@ void MyAvatar::clearJointsData() {
 
 void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
     Avatar::setSkeletonModelURL(skeletonModelURL);
-    _skeletonModel->setVisibleInScene(true, qApp->getMain3DScene());
+    _skeletonModel->setVisibleInScene(true, qApp->getMain3DScene(), render::ItemKey::VISIBLE_MASK_ALL);
     _headBoneSet.clear();
     emit skeletonChanged();
 
@@ -1742,7 +1742,7 @@ void MyAvatar::attach(const QString& modelURL, const QString& jointName,
 
 void MyAvatar::setVisibleInSceneIfReady(Model* model, const render::ScenePointer& scene, bool visible) {
     if (model->isActive() && model->isRenderable()) {
-        model->setVisibleInScene(visible, scene);
+        model->setVisibleInScene(visible, scene, render::ItemKey::VISIBLE_MASK_ALL);
     }
 }
 
@@ -1937,7 +1937,8 @@ void MyAvatar::preDisplaySide(RenderArgs* renderArgs) {
                 _attachmentData[i].jointName.compare("RightEye", Qt::CaseInsensitive) == 0 ||
                 _attachmentData[i].jointName.compare("HeadTop_End", Qt::CaseInsensitive) == 0 ||
                 _attachmentData[i].jointName.compare("Face", Qt::CaseInsensitive) == 0) {
-                _attachmentModels[i]->setVisibleInScene(shouldDrawHead, qApp->getMain3DScene());
+                _attachmentModels[i]->setVisibleInScene(shouldDrawHead, qApp->getMain3DScene(),
+                                                        render::ItemKey::VISIBLE_MASK_ALL);
             }
         }
     }
diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp
index ec586771af..f556bc9e24 100644
--- a/interface/src/ui/overlays/ModelOverlay.cpp
+++ b/interface/src/ui/overlays/ModelOverlay.cpp
@@ -86,7 +86,8 @@ void ModelOverlay::update(float deltatime) {
     }
     if (_visibleDirty) {
         _visibleDirty = false;
-        _model->setVisibleInScene(getVisible(), scene);
+        // don't show overlays in mirrors
+        _model->setVisibleInScene(getVisible(), scene, render::ItemKey::VISIBLE_MASK_ALL & ~render::ItemKey::VISIBLE_MASK_1);
     }
     if (_drawInFrontDirty) {
         _drawInFrontDirty = false;
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index f7d7eb2a06..421f8769b5 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -1333,12 +1333,16 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
     entity->updateModelBounds();
     entity->stopModelOverrideIfNoParent();
 
-    bool visible = _visible && !_cauterized;
-    if (model->isVisible() != visible) {
+    if (model->isVisible() != _visible) {
         // 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);
+        if (_cauterized) {
+            // draw this in every view except the main one
+            model->setVisibleInScene(_visible, scene, render::ItemKey::VISIBLE_MASK_ALL & ~render::ItemKey::VISIBLE_MASK_0);
+        } else {
+            model->setVisibleInScene(_visible, scene, render::ItemKey::VISIBLE_MASK_ALL);
+        }
     }
     // TODO? early exit here when not visible?
 
diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 09b6ada8e4..809be09436 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/libraries/render-utils/src/CauterizedModel.cpp
@@ -247,7 +247,7 @@ void CauterizedModel::updateRenderItems() {
                     data.updateTransformForCauterizedMesh(renderTransform);
 
                     data.setEnableCauterization(enableCauterization);
-                    data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, enableCauterization);
+                    data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
                     data.setLayer(isLayeredInFront, isLayeredInHUD);
                     data.setShapeKey(invalidatePayloadShapeKey, isWireframe);
                 });
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index de03f2e03d..797f385695 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -389,14 +389,14 @@ void ModelMeshPartPayload::updateTransformForSkinnedMesh(const Transform& render
     _worldBound.transform(boundTransform);
 }
 
-void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, bool isCauterized) {
+void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, uint8_t viewVisiblityMask) {
     ItemKey::Builder builder;
     builder.withTypeShape();
 
     if (!isVisible) {
         builder.withInvisible();
-    } else if (isCauterized) {
-        builder.withInvisible(0); // hide these items in the vibility mask #0
+    } else {
+        builder.withInvisible(viewVisiblityMask);
     }
 
     if (isLayered) {
diff --git a/libraries/render-utils/src/MeshPartPayload.h b/libraries/render-utils/src/MeshPartPayload.h
index ee515c7b3d..cf64879b3c 100644
--- a/libraries/render-utils/src/MeshPartPayload.h
+++ b/libraries/render-utils/src/MeshPartPayload.h
@@ -103,7 +103,7 @@ public:
     render::ShapeKey getShapeKey() const override; // shape interface
     void render(RenderArgs* args) override;
 
-    void setKey(bool isVisible, bool isLayered, bool isCauterized = false);
+    void setKey(bool isVisible, bool isLayered, uint8_t viewVisiblityMask);
     void setLayer(bool isLayeredInFront, bool isLayeredInHUD);
     void setShapeKey(bool invalidateShapeKey, bool isWireframe);
 
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 6922e95d39..b04ff00f98 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -297,7 +297,7 @@ void Model::updateRenderItems() {
                 }
                 data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
 
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
                 data.setShapeKey(invalidatePayloadShapeKey, isWireframe);
             });
@@ -659,7 +659,7 @@ void Model::calculateTriangleSets() {
     }
 }
 
-void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene) {
+void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t visibleMask) {
     if (_isVisible != isVisible) {
         _isVisible = isVisible;
 
@@ -669,12 +669,12 @@ void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene)
         render::Transaction transaction;
         foreach (auto item, _modelMeshRenderItemsMap.keys()) {
             transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
             transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
             });
         }
         scene->enqueueTransaction(transaction);
@@ -692,13 +692,13 @@ void Model::setLayeredInFront(bool isLayeredInFront, const render::ScenePointer&
         render::Transaction transaction;
         foreach(auto item, _modelMeshRenderItemsMap.keys()) {
             transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
             transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
@@ -716,13 +716,13 @@ void Model::setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& sce
         render::Transaction transaction;
         foreach(auto item, _modelMeshRenderItemsMap.keys()) {
             transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
             transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index 560aa82f0c..8d2619bf13 100644
--- a/libraries/render-utils/src/Model.h
+++ b/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);
+    void setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t visibleMask);
     void setLayeredInFront(bool isLayeredInFront, const render::ScenePointer& scene);
     void setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& scene);
     bool needsFixupInScene() const;

From 0ad4cdc41b47618bdb712fad907b54e980281c12 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Thu, 18 Jan 2018 13:15:47 -0800
Subject: [PATCH 12/23] works now

---
 .../src/RenderableModelEntityItem.cpp         | 13 +++---
 .../render-utils/src/MeshPartPayload.cpp      | 13 +++++-
 libraries/render-utils/src/Model.cpp          | 46 ++++++++++++-------
 libraries/render-utils/src/Model.h            |  4 +-
 4 files changed, 50 insertions(+), 26 deletions(-)

diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index 421f8769b5..80c5c97799 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -1333,16 +1333,15 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
     entity->updateModelBounds();
     entity->stopModelOverrideIfNoParent();
 
-    if (model->isVisible() != _visible) {
+    uint32_t viewVisiblityMask = _cauterized ?
+        (render::ItemKey::VISIBLE_MASK_ALL & ~render::ItemKey::VISIBLE_MASK_0) : // draw in every view except the main one
+        render::ItemKey::VISIBLE_MASK_ALL;
+
+    if (model->isVisible() != _visible || model->getViewVisibilityMask() != viewVisiblityMask) {
         // 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.
-        if (_cauterized) {
-            // draw this in every view except the main one
-            model->setVisibleInScene(_visible, scene, render::ItemKey::VISIBLE_MASK_ALL & ~render::ItemKey::VISIBLE_MASK_0);
-        } else {
-            model->setVisibleInScene(_visible, scene, render::ItemKey::VISIBLE_MASK_ALL);
-        }
+        model->setVisibleInScene(_visible, scene, viewVisiblityMask);
     }
     // TODO? early exit here when not visible?
 
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index 797f385695..b917f3df03 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -396,7 +396,18 @@ void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, uint8_t viewVi
     if (!isVisible) {
         builder.withInvisible();
     } else {
-        builder.withInvisible(viewVisiblityMask);
+        if (!(viewVisiblityMask & render::ItemKey::VISIBLE_MASK_0)) {
+            builder.withInvisible(render::ItemKey::INVISIBLE0 - render::ItemKey::INVISIBLE0);
+        }
+        if (!(viewVisiblityMask & render::ItemKey::VISIBLE_MASK_1)) {
+            builder.withInvisible(render::ItemKey::INVISIBLE1 - render::ItemKey::INVISIBLE0);
+        }
+        if (!(viewVisiblityMask & render::ItemKey::VISIBLE_MASK_2)) {
+            builder.withInvisible(render::ItemKey::INVISIBLE2 - render::ItemKey::INVISIBLE0);
+        }
+        if (!(viewVisiblityMask & render::ItemKey::VISIBLE_MASK_3)) {
+            builder.withInvisible(render::ItemKey::INVISIBLE3 - render::ItemKey::INVISIBLE0);
+        }
     }
 
     if (isLayered) {
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index b04ff00f98..9e6ec064b4 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -268,6 +268,7 @@ void Model::updateRenderItems() {
 
         bool isWireframe = self->isWireframe();
         bool isVisible = self->isVisible();
+        uint8_t viewVisibilityMask = self->getViewVisibilityMask();
         bool isLayeredInFront = self->isLayeredInFront();
         bool isLayeredInHUD = self->isLayeredInHUD();
 
@@ -280,8 +281,10 @@ void Model::updateRenderItems() {
 
             bool invalidatePayloadShapeKey = self->shouldInvalidatePayloadShapeKey(meshIndex);
 
-            transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, clusterTransforms, invalidatePayloadShapeKey,
-                    isWireframe, isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
+            transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, clusterTransforms,
+                                                                  invalidatePayloadShapeKey, isWireframe, isVisible,
+                                                                  viewVisibilityMask, isLayeredInFront,
+                                                                  isLayeredInHUD](ModelMeshPartPayload& data) {
                 data.updateClusterBuffer(clusterTransforms);
 
                 Transform renderTransform = modelTransform;
@@ -297,7 +300,7 @@ void Model::updateRenderItems() {
                 }
                 data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
 
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
                 data.setShapeKey(invalidatePayloadShapeKey, isWireframe);
             });
@@ -659,22 +662,25 @@ void Model::calculateTriangleSets() {
     }
 }
 
-void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t visibleMask) {
-    if (_isVisible != isVisible) {
+void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewVisibilityMask) {
+    if (_isVisible != isVisible || _viewVisibilityMask != viewVisibilityMask) {
         _isVisible = isVisible;
+        _viewVisibilityMask = viewVisibilityMask;
 
         bool isLayeredInFront = _isLayeredInFront;
         bool isLayeredInHUD = _isLayeredInHUD;
 
         render::Transaction transaction;
         foreach (auto item, _modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+                                                                isLayeredInHUD](ModelMeshPartPayload& data) {
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, 14);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+                                                                isLayeredInHUD](ModelMeshPartPayload& data) {
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, 14);
             });
         }
         scene->enqueueTransaction(transaction);
@@ -687,18 +693,21 @@ void Model::setLayeredInFront(bool isLayeredInFront, const render::ScenePointer&
         _isLayeredInFront = isLayeredInFront;
 
         bool isVisible = _isVisible;
+        uint8_t viewVisibilityMask = _viewVisibilityMask;
         bool isLayeredInHUD = _isLayeredInHUD;
 
         render::Transaction transaction;
         foreach(auto item, _modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+                                                                isLayeredInHUD](ModelMeshPartPayload& data) {
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+                                                                isLayeredInHUD](ModelMeshPartPayload& data) {
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
@@ -711,18 +720,21 @@ void Model::setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& sce
         _isLayeredInHUD = isLayeredInHUD;
 
         bool isVisible = _isVisible;
+        uint8_t viewVisibilityMask = _viewVisibilityMask;
         bool isLayeredInFront = _isLayeredInFront;
 
         render::Transaction transaction;
         foreach(auto item, _modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+                                                                isLayeredInHUD](ModelMeshPartPayload& data) {
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, isLayeredInFront, isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
+            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
+                                                                isLayeredInHUD](ModelMeshPartPayload& data) {
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
                 data.setLayer(isLayeredInFront, isLayeredInHUD);
             });
         }
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index 8d2619bf13..c2f8a3d972 100644
--- a/libraries/render-utils/src/Model.h
+++ b/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 visibleMask);
+    void setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewVisiblityMask);
     void setLayeredInFront(bool isLayeredInFront, const render::ScenePointer& scene);
     void setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& scene);
     bool needsFixupInScene() const;
@@ -104,6 +104,7 @@ public:
     bool isRenderable() const;
 
     bool isVisible() const { return _isVisible; }
+    uint8_t getViewVisibilityMask() const { return _viewVisibilityMask; }
 
     bool isLayeredInFront() const { return _isLayeredInFront; }
     bool isLayeredInHUD() const { return _isLayeredInHUD; }
@@ -388,6 +389,7 @@ protected:
 
     QUrl _url;
     bool _isVisible;
+    uint32_t _viewVisibilityMask { 0 };
 
     gpu::Buffers _blendedVertexBuffers;
 

From 7c32d3c5360497bb8e531ad1fc1e49edc2879136 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Thu, 18 Jan 2018 13:49:17 -0800
Subject: [PATCH 13/23] flip logic back around

---
 interface/src/ui/overlays/ModelOverlay.cpp                | 2 +-
 .../entities-renderer/src/RenderableModelEntityItem.cpp   | 4 ++--
 libraries/render-utils/src/MeshPartPayload.cpp            | 8 ++++----
 libraries/render-utils/src/Model.cpp                      | 4 ++--
 libraries/render-utils/src/Model.h                        | 2 +-
 5 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp
index f556bc9e24..7ba8694683 100644
--- a/interface/src/ui/overlays/ModelOverlay.cpp
+++ b/interface/src/ui/overlays/ModelOverlay.cpp
@@ -87,7 +87,7 @@ void ModelOverlay::update(float deltatime) {
     if (_visibleDirty) {
         _visibleDirty = false;
         // don't show overlays in mirrors
-        _model->setVisibleInScene(getVisible(), scene, render::ItemKey::VISIBLE_MASK_ALL & ~render::ItemKey::VISIBLE_MASK_1);
+        _model->setVisibleInScene(getVisible(), scene, render::ItemKey::VISIBLE_MASK_1);
     }
     if (_drawInFrontDirty) {
         _drawInFrontDirty = false;
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index 80c5c97799..8257e53eea 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -1334,8 +1334,8 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
     entity->stopModelOverrideIfNoParent();
 
     uint32_t viewVisiblityMask = _cauterized ?
-        (render::ItemKey::VISIBLE_MASK_ALL & ~render::ItemKey::VISIBLE_MASK_0) : // draw in every view except the main one
-        render::ItemKey::VISIBLE_MASK_ALL;
+        render::ItemKey::VISIBLE_MASK_0 : // draw in every view except the main one
+        render::ItemKey::VISIBLE_MASK_ALL; // draw in all views
 
     if (model->isVisible() != _visible || model->getViewVisibilityMask() != viewVisiblityMask) {
         // FIXME: this seems like it could be optimized if we tracked our last known visible state in
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index b917f3df03..f0412d8332 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -396,16 +396,16 @@ void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, uint8_t viewVi
     if (!isVisible) {
         builder.withInvisible();
     } else {
-        if (!(viewVisiblityMask & render::ItemKey::VISIBLE_MASK_0)) {
+        if (viewVisiblityMask & render::ItemKey::VISIBLE_MASK_0) {
             builder.withInvisible(render::ItemKey::INVISIBLE0 - render::ItemKey::INVISIBLE0);
         }
-        if (!(viewVisiblityMask & render::ItemKey::VISIBLE_MASK_1)) {
+        if (viewVisiblityMask & render::ItemKey::VISIBLE_MASK_1) {
             builder.withInvisible(render::ItemKey::INVISIBLE1 - render::ItemKey::INVISIBLE0);
         }
-        if (!(viewVisiblityMask & render::ItemKey::VISIBLE_MASK_2)) {
+        if (viewVisiblityMask & render::ItemKey::VISIBLE_MASK_2) {
             builder.withInvisible(render::ItemKey::INVISIBLE2 - render::ItemKey::INVISIBLE0);
         }
-        if (!(viewVisiblityMask & render::ItemKey::VISIBLE_MASK_3)) {
+        if (viewVisiblityMask & render::ItemKey::VISIBLE_MASK_3) {
             builder.withInvisible(render::ItemKey::INVISIBLE3 - render::ItemKey::INVISIBLE0);
         }
     }
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 9e6ec064b4..60eb0c4280 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -674,13 +674,13 @@ void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene,
         foreach (auto item, _modelMeshRenderItemsMap.keys()) {
             transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
                                                                 isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, 14);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
             });
         }
         foreach(auto item, _collisionRenderItemsMap.keys()) {
             transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewVisibilityMask, isLayeredInFront,
                                                                 isLayeredInHUD](ModelMeshPartPayload& data) {
-                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, 14);
+                data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, viewVisibilityMask);
             });
         }
         scene->enqueueTransaction(transaction);
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index c2f8a3d972..5f58906e9f 100644
--- a/libraries/render-utils/src/Model.h
+++ b/libraries/render-utils/src/Model.h
@@ -389,7 +389,7 @@ protected:
 
     QUrl _url;
     bool _isVisible;
-    uint32_t _viewVisibilityMask { 0 };
+    uint8_t _viewVisibilityMask { 0 };
 
     gpu::Buffers _blendedVertexBuffers;
 

From 31c007d1672a970dc5a1bfbe11b88801fb36f55b Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Thu, 18 Jan 2018 14:15:30 -0800
Subject: [PATCH 14/23] more backwards logic, added withViewVisibilityMask call
 in ItemKey

---
 interface/src/avatar/MyAvatar.cpp                |  8 ++++----
 .../src/RenderableModelEntityItem.cpp            |  4 ++--
 libraries/entities/src/EntityItem.h              |  2 +-
 libraries/render-utils/src/CauterizedModel.cpp   |  2 +-
 libraries/render-utils/src/MeshPartPayload.cpp   | 13 +------------
 libraries/render/src/render/Item.cpp             |  1 +
 libraries/render/src/render/Item.h               | 16 ++++++++++++++++
 7 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index e9205157b4..317eede6e9 100755
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -1078,7 +1078,7 @@ void MyAvatar::setEnableDebugDrawIKChains(bool isEnabled) {
 }
 
 void MyAvatar::setEnableMeshVisible(bool isEnabled) {
-    _skeletonModel->setVisibleInScene(isEnabled, qApp->getMain3DScene(), render::ItemKey::VISIBLE_MASK_ALL);
+    _skeletonModel->setVisibleInScene(isEnabled, qApp->getMain3DScene(), render::ItemKey::VISIBLE_MASK_NONE);
 }
 
 void MyAvatar::setEnableInverseKinematics(bool isEnabled) {
@@ -1428,7 +1428,7 @@ void MyAvatar::clearJointsData() {
 
 void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
     Avatar::setSkeletonModelURL(skeletonModelURL);
-    _skeletonModel->setVisibleInScene(true, qApp->getMain3DScene(), render::ItemKey::VISIBLE_MASK_ALL);
+    _skeletonModel->setVisibleInScene(true, qApp->getMain3DScene(), render::ItemKey::VISIBLE_MASK_NONE);
     _headBoneSet.clear();
     emit skeletonChanged();
 
@@ -1742,7 +1742,7 @@ void MyAvatar::attach(const QString& modelURL, const QString& jointName,
 
 void MyAvatar::setVisibleInSceneIfReady(Model* model, const render::ScenePointer& scene, bool visible) {
     if (model->isActive() && model->isRenderable()) {
-        model->setVisibleInScene(visible, scene, render::ItemKey::VISIBLE_MASK_ALL);
+        model->setVisibleInScene(visible, scene, render::ItemKey::VISIBLE_MASK_NONE);
     }
 }
 
@@ -1938,7 +1938,7 @@ void MyAvatar::preDisplaySide(RenderArgs* renderArgs) {
                 _attachmentData[i].jointName.compare("HeadTop_End", Qt::CaseInsensitive) == 0 ||
                 _attachmentData[i].jointName.compare("Face", Qt::CaseInsensitive) == 0) {
                 _attachmentModels[i]->setVisibleInScene(shouldDrawHead, qApp->getMain3DScene(),
-                                                        render::ItemKey::VISIBLE_MASK_ALL);
+                                                        render::ItemKey::VISIBLE_MASK_NONE);
             }
         }
     }
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index 8257e53eea..a6991f101c 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -1334,8 +1334,8 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
     entity->stopModelOverrideIfNoParent();
 
     uint32_t viewVisiblityMask = _cauterized ?
-        render::ItemKey::VISIBLE_MASK_0 : // draw in every view except the main one
-        render::ItemKey::VISIBLE_MASK_ALL; // draw in all views
+        render::ItemKey::VISIBLE_MASK_0 : // draw in every view except the main one (view zero)
+        render::ItemKey::VISIBLE_MASK_NONE; // draw in all views
 
     if (model->isVisible() != _visible || model->getViewVisibilityMask() != viewVisiblityMask) {
         // FIXME: this seems like it could be optimized if we tracked our last known visible state in
diff --git a/libraries/entities/src/EntityItem.h b/libraries/entities/src/EntityItem.h
index 68639e0d3a..3024d646ff 100644
--- a/libraries/entities/src/EntityItem.h
+++ b/libraries/entities/src/EntityItem.h
@@ -625,7 +625,7 @@ protected:
     quint64 _lastUpdatedAccelerationTimestamp { 0 };
     quint64 _lastUpdatedQueryAACubeTimestamp { 0 };
 
-    bool _cauterized { false }; // it true, don't draw because it would obscure 1st-person camera
+    bool _cauterized { false }; // if true, don't draw because it would obscure 1st-person camera
 };
 
 #endif // hifi_EntityItem_h
diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 809be09436..f67f5ef358 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/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::VISIBLE_MASK_ALL);
+                    data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_NONE);
                     data.setLayer(isLayeredInFront, isLayeredInHUD);
                     data.setShapeKey(invalidatePayloadShapeKey, isWireframe);
                 });
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index f0412d8332..da636eed06 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -396,18 +396,7 @@ void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, uint8_t viewVi
     if (!isVisible) {
         builder.withInvisible();
     } else {
-        if (viewVisiblityMask & render::ItemKey::VISIBLE_MASK_0) {
-            builder.withInvisible(render::ItemKey::INVISIBLE0 - render::ItemKey::INVISIBLE0);
-        }
-        if (viewVisiblityMask & render::ItemKey::VISIBLE_MASK_1) {
-            builder.withInvisible(render::ItemKey::INVISIBLE1 - render::ItemKey::INVISIBLE0);
-        }
-        if (viewVisiblityMask & render::ItemKey::VISIBLE_MASK_2) {
-            builder.withInvisible(render::ItemKey::INVISIBLE2 - render::ItemKey::INVISIBLE0);
-        }
-        if (viewVisiblityMask & render::ItemKey::VISIBLE_MASK_3) {
-            builder.withInvisible(render::ItemKey::INVISIBLE3 - render::ItemKey::INVISIBLE0);
-        }
+        builder.withViewVisibilityMask(viewVisiblityMask);
     }
 
     if (isLayered) {
diff --git a/libraries/render/src/render/Item.cpp b/libraries/render/src/render/Item.cpp
index 75c38ec615..0e4502a47c 100644
--- a/libraries/render/src/render/Item.cpp
+++ b/libraries/render/src/render/Item.cpp
@@ -36,6 +36,7 @@ const int Item::LAYER_3D_HUD = 3;
 
 const uint8_t ItemKey::NUM_VISIBLE_MASK_INDICES { 4 };
 const uint8_t ItemKey::VISIBLE_MASK_ALL { 0x0F };
+const uint8_t ItemKey::VISIBLE_MASK_NONE { 0x00 };
 const uint8_t ItemKey::VISIBLE_MASK_0 { 0x01 };
 const uint8_t ItemKey::VISIBLE_MASK_1 { 0x02 };
 const uint8_t ItemKey::VISIBLE_MASK_2 { 0x04 };
diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h
index ebf3980489..552e721073 100644
--- a/libraries/render/src/render/Item.h
+++ b/libraries/render/src/render/Item.h
@@ -65,6 +65,7 @@ public:
     // Beware that the visibility mask is the oposite of what stored in the key vals.
     const static uint8_t NUM_VISIBLE_MASK_INDICES;
     const static uint8_t VISIBLE_MASK_ALL;
+    const static uint8_t VISIBLE_MASK_NONE;
     const static uint8_t VISIBLE_MASK_0;
     const static uint8_t VISIBLE_MASK_1;
     const static uint8_t VISIBLE_MASK_2;
@@ -96,6 +97,21 @@ public:
         Builder& withDynamic() { _flags.set(DYNAMIC); return (*this); }
         Builder& withDeformed() { _flags.set(DEFORMED); return (*this); }
         Builder& withInvisible(uint8_t maskIndex = 0) { _flags.set(INVISIBLE0 + maskIndex); return (*this); }
+        Builder& withViewVisibilityMask(uint8_t mask) {
+            if (mask & render::ItemKey::VISIBLE_MASK_0) {
+                _flags.set(INVISIBLE0);
+            }
+            if (mask & render::ItemKey::VISIBLE_MASK_1) {
+                _flags.set(INVISIBLE1);
+            }
+            if (mask & render::ItemKey::VISIBLE_MASK_2) {
+                _flags.set(INVISIBLE2);
+            }
+            if (mask & render::ItemKey::VISIBLE_MASK_3) {
+                _flags.set(INVISIBLE3);
+            }
+            return (*this);
+        }
         Builder& withShadowCaster() { _flags.set(SHADOW_CASTER); return (*this); }
         Builder& withPickable() { _flags.set(PICKABLE); return (*this); }
         Builder& withLayered() { _flags.set(LAYERED); return (*this); }

From 6aa389cad08f42b0e434dd20bbe17338adce9e78 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Fri, 19 Jan 2018 09:53:41 -0800
Subject: [PATCH 15/23] trying to now show overlays in mirrors

---
 interface/src/ui/overlays/OverlaysPayload.cpp |  7 +++++++
 libraries/render/src/render/Item.h            | 12 +++++++++++-
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/interface/src/ui/overlays/OverlaysPayload.cpp b/interface/src/ui/overlays/OverlaysPayload.cpp
index fceb261503..4bbe21f9a6 100644
--- a/interface/src/ui/overlays/OverlaysPayload.cpp
+++ b/interface/src/ui/overlays/OverlaysPayload.cpp
@@ -44,6 +44,13 @@ namespace render {
         } else {
             builder.withViewSpace();
         }
+
+        if (overlay->getVisible()) {
+            builder.withViewVisibilityMask(render::ItemKey::VISIBLE_MASK_1); // don't draw overlays in mirror
+        } else {
+            builder.withViewVisibilityMask(render::ItemKey::VISIBLE_MASK_ALL);
+        }
+
         return builder.build();
     }
     template <> const Item::Bound payloadGetBound(const Overlay::Pointer& overlay) {
diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h
index 552e721073..9ea8421f1a 100644
--- a/libraries/render/src/render/Item.h
+++ b/libraries/render/src/render/Item.h
@@ -96,7 +96,17 @@ public:
         Builder& withViewSpace() { _flags.set(VIEW_SPACE); return (*this); }
         Builder& withDynamic() { _flags.set(DYNAMIC); return (*this); }
         Builder& withDeformed() { _flags.set(DEFORMED); return (*this); }
-        Builder& withInvisible(uint8_t maskIndex = 0) { _flags.set(INVISIBLE0 + maskIndex); return (*this); }
+        Builder& withInvisible(uint8_t maskIndex = NUM_VISIBLE_MASK_INDICES) {
+            if (maskIndex == NUM_VISIBLE_MASK_INDICES) {
+                _flags.set(INVISIBLE0);
+                _flags.set(INVISIBLE1);
+                _flags.set(INVISIBLE2);
+                _flags.set(INVISIBLE3);
+            } else {
+                _flags.set(INVISIBLE0 + maskIndex);
+            }
+            return (*this);
+        }
         Builder& withViewVisibilityMask(uint8_t mask) {
             if (mask & render::ItemKey::VISIBLE_MASK_0) {
                 _flags.set(INVISIBLE0);

From d38d13cbb94d067f12d8fda6d4ff5f7ede15c95c Mon Sep 17 00:00:00 2001
From: Sam Gateau <samuel.gateau@gmail.com>
Date: Sun, 21 Jan 2018 23:47:45 -0800
Subject: [PATCH 16/23] Trying to address the overlays to not be visisble in
 2nd camera

---
 interface/src/ui/overlays/ModelOverlay.cpp    | 8 +++++---
 interface/src/ui/overlays/OverlaysPayload.cpp | 4 ++--
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp
index 79a7df338b..34644735ed 100644
--- a/interface/src/ui/overlays/ModelOverlay.cpp
+++ b/interface/src/ui/overlays/ModelOverlay.cpp
@@ -87,7 +87,7 @@ void ModelOverlay::update(float deltatime) {
     if (_visibleDirty) {
         _visibleDirty = false;
         // don't show overlays in mirrors
-        _model->setVisibleInScene(getVisible(), scene, render::ItemKey::VISIBLE_MASK_1);
+        _model->setVisibleInScene(getVisible(), scene, render::ItemKey::VISIBLE_MASK_0 * getVisible());
     }
     if (_drawInFrontDirty) {
         _drawInFrontDirty = false;
@@ -121,8 +121,10 @@ void ModelOverlay::removeFromScene(Overlay::Pointer overlay, const render::Scene
 }
 
 void ModelOverlay::setVisible(bool visible) {
-    Overlay::setVisible(visible);
-    _visibleDirty = true;
+    if (visible != getVisible()) {
+        Overlay::setVisible(visible);
+        _visibleDirty = true;
+    }
 }
 
 void ModelOverlay::setDrawInFront(bool drawInFront) {
diff --git a/interface/src/ui/overlays/OverlaysPayload.cpp b/interface/src/ui/overlays/OverlaysPayload.cpp
index 30743964a4..c071c44d42 100644
--- a/interface/src/ui/overlays/OverlaysPayload.cpp
+++ b/interface/src/ui/overlays/OverlaysPayload.cpp
@@ -46,9 +46,9 @@ namespace render {
         }
 
         if (overlay->getVisible()) {
-            builder.withViewVisibilityMask(render::ItemKey::VISIBLE_MASK_1); // don't draw overlays in mirror
+            builder.withViewVisibilityMask(render::ItemKey::VISIBLE_MASK_0); // don't draw overlays in mirror
         } else {
-            builder.withViewVisibilityMask(render::ItemKey::VISIBLE_MASK_ALL);
+            builder.withViewVisibilityMask(render::ItemKey::VISIBLE_MASK_NONE);
         }
 
         return builder.build();

From ae6a95ec0d4f9f3aea4c3c54236e1220b14740b4 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Wed, 24 Jan 2018 18:07:35 -0800
Subject: [PATCH 17/23] fixing my bugs on vissibility

---
 interface/src/SecondaryCamera.cpp          |  2 +-
 interface/src/ui/overlays/ModelOverlay.cpp |  2 +-
 libraries/render-utils/src/Model.h         |  2 +-
 libraries/render/src/render/Item.h         | 20 ++++++++++++++++----
 4 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/interface/src/SecondaryCamera.cpp b/interface/src/SecondaryCamera.cpp
index cad4f7f1b5..9d5b6a44a5 100644
--- a/interface/src/SecondaryCamera.cpp
+++ b/interface/src/SecondaryCamera.cpp
@@ -205,7 +205,7 @@ public:
 
 void SecondaryCameraRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred) {
     const auto cachedArg = task.addJob<SecondaryCameraJob>("SecondaryCamera");
-    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor);
+    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, render::ItemKey::VISIBLE_MASK_1, render::ItemKey::VISIBLE_MASK_1);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
     if (!isDeferred) {
         task.addJob<RenderForwardTask>("Forward", items);
diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp
index 367cb397d1..59d4521307 100644
--- a/interface/src/ui/overlays/ModelOverlay.cpp
+++ b/interface/src/ui/overlays/ModelOverlay.cpp
@@ -87,7 +87,7 @@ void ModelOverlay::update(float deltatime) {
     if (_visibleDirty) {
         _visibleDirty = false;
         // don't show overlays in mirrors
-        _model->setVisibleInScene(getVisible(), scene, render::ItemKey::VISIBLE_MASK_0 * getVisible());
+        _model->setVisibleInScene(getVisible(), scene, render::ItemKey::VISIBLE_MASK_0);
     }
     if (_drawInFrontDirty) {
         _drawInFrontDirty = false;
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index 5f58906e9f..d9845de9ed 100644
--- a/libraries/render-utils/src/Model.h
+++ b/libraries/render-utils/src/Model.h
@@ -389,7 +389,7 @@ protected:
 
     QUrl _url;
     bool _isVisible;
-    uint8_t _viewVisibilityMask { 0 };
+    uint8_t _viewVisibilityMask { render::ItemKey::VISIBLE_MASK_ALL };
 
     gpu::Buffers _blendedVertexBuffers;
 
diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h
index 9ea8421f1a..18e626d005 100644
--- a/libraries/render/src/render/Item.h
+++ b/libraries/render/src/render/Item.h
@@ -96,6 +96,18 @@ public:
         Builder& withViewSpace() { _flags.set(VIEW_SPACE); return (*this); }
         Builder& withDynamic() { _flags.set(DYNAMIC); return (*this); }
         Builder& withDeformed() { _flags.set(DEFORMED); return (*this); }
+        Builder& withVisible(uint8_t maskIndex = NUM_VISIBLE_MASK_INDICES) {
+            if (maskIndex == NUM_VISIBLE_MASK_INDICES) {
+                _flags.reset(INVISIBLE0);
+                _flags.reset(INVISIBLE1);
+                _flags.reset(INVISIBLE2);
+                _flags.reset(INVISIBLE3);
+            }
+            else {
+                _flags.reset(INVISIBLE0 + maskIndex);
+            }
+            return (*this);
+        }
         Builder& withInvisible(uint8_t maskIndex = NUM_VISIBLE_MASK_INDICES) {
             if (maskIndex == NUM_VISIBLE_MASK_INDICES) {
                 _flags.set(INVISIBLE0);
@@ -109,16 +121,16 @@ public:
         }
         Builder& withViewVisibilityMask(uint8_t mask) {
             if (mask & render::ItemKey::VISIBLE_MASK_0) {
-                _flags.set(INVISIBLE0);
+                _flags.reset(INVISIBLE0);
             }
             if (mask & render::ItemKey::VISIBLE_MASK_1) {
-                _flags.set(INVISIBLE1);
+                _flags.reset(INVISIBLE1);
             }
             if (mask & render::ItemKey::VISIBLE_MASK_2) {
-                _flags.set(INVISIBLE2);
+                _flags.reset(INVISIBLE2);
             }
             if (mask & render::ItemKey::VISIBLE_MASK_3) {
-                _flags.set(INVISIBLE3);
+                _flags.reset(INVISIBLE3);
             }
             return (*this);
         }

From 2f4e61888fb4636d140b0ece98f46c1e016b581c Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Thu, 25 Jan 2018 16:57:35 -0800
Subject: [PATCH 18/23] Making it work maybe

---
 interface/src/ui/overlays/ModelOverlay.h      |  2 +-
 interface/src/ui/overlays/OverlaysPayload.cpp |  4 ++--
 .../src/RenderableModelEntityItem.cpp         |  4 ++--
 .../render-utils/src/CauterizedModel.cpp      |  2 +-
 .../render-utils/src/MeshPartPayload.cpp      |  2 +-
 libraries/render/src/render/Item.h            | 20 ++++++++-----------
 6 files changed, 15 insertions(+), 19 deletions(-)

diff --git a/interface/src/ui/overlays/ModelOverlay.h b/interface/src/ui/overlays/ModelOverlay.h
index a39f762210..a012969621 100644
--- a/interface/src/ui/overlays/ModelOverlay.h
+++ b/interface/src/ui/overlays/ModelOverlay.h
@@ -106,7 +106,7 @@ private:
     bool _jointMappingCompleted { false };
     QVector<int> _jointMapping; // domain is index into model-joints, range is index into animation-joints
 
-    bool _visibleDirty { false };
+    bool _visibleDirty { true };
     bool _drawInFrontDirty { false };
     bool _drawInHUDDirty { false };
 
diff --git a/interface/src/ui/overlays/OverlaysPayload.cpp b/interface/src/ui/overlays/OverlaysPayload.cpp
index c071c44d42..937de1a236 100644
--- a/interface/src/ui/overlays/OverlaysPayload.cpp
+++ b/interface/src/ui/overlays/OverlaysPayload.cpp
@@ -46,9 +46,9 @@ namespace render {
         }
 
         if (overlay->getVisible()) {
-            builder.withViewVisibilityMask(render::ItemKey::VISIBLE_MASK_0); // don't draw overlays in mirror
+            builder.withVisibilityMask(render::ItemKey::VISIBLE_MASK_0); // don't draw overlays in mirror
         } else {
-            builder.withViewVisibilityMask(render::ItemKey::VISIBLE_MASK_NONE);
+            builder.withVisibilityMask(render::ItemKey::VISIBLE_MASK_NONE);
         }
 
         return builder.build();
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index 0ae7efb652..ee3557346d 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -1334,8 +1334,8 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
     entity->stopModelOverrideIfNoParent();
 
     uint32_t viewVisiblityMask = _cauterized ?
-        render::ItemKey::VISIBLE_MASK_0 : // draw in every view except the main one (view zero)
-        render::ItemKey::VISIBLE_MASK_NONE; // draw in all views
+        render::ItemKey::VISIBLE_MASK_1 : // draw in every view except the main one (view zero)
+        render::ItemKey::VISIBLE_MASK_ALL; // draw in all views
 
     if (model->isVisible() != _visible || model->getViewVisibilityMask() != viewVisiblityMask) {
         // FIXME: this seems like it could be optimized if we tracked our last known visible state in
diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index f67f5ef358..809be09436 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/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::VISIBLE_MASK_NONE);
+                    data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::VISIBLE_MASK_ALL);
                     data.setLayer(isLayeredInFront, isLayeredInHUD);
                     data.setShapeKey(invalidatePayloadShapeKey, isWireframe);
                 });
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index da636eed06..451b168465 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -396,7 +396,7 @@ void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, uint8_t viewVi
     if (!isVisible) {
         builder.withInvisible();
     } else {
-        builder.withViewVisibilityMask(viewVisiblityMask);
+        builder.withVisibilityMask(viewVisiblityMask);
     }
 
     if (isLayered) {
diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h
index 18e626d005..97eaefcb53 100644
--- a/libraries/render/src/render/Item.h
+++ b/libraries/render/src/render/Item.h
@@ -119,18 +119,14 @@ public:
             }
             return (*this);
         }
-        Builder& withViewVisibilityMask(uint8_t mask) {
-            if (mask & render::ItemKey::VISIBLE_MASK_0) {
-                _flags.reset(INVISIBLE0);
-            }
-            if (mask & render::ItemKey::VISIBLE_MASK_1) {
-                _flags.reset(INVISIBLE1);
-            }
-            if (mask & render::ItemKey::VISIBLE_MASK_2) {
-                _flags.reset(INVISIBLE2);
-            }
-            if (mask & render::ItemKey::VISIBLE_MASK_3) {
-                _flags.reset(INVISIBLE3);
+        Builder& withVisibilityMask(uint8_t mask) {
+            for (int i = 0; i < ItemKey::NUM_VISIBLE_MASK_INDICES; i++) {
+                if ((1 << i) & mask) {
+                    withVisible(i);
+                }
+                else {
+                    withInvisible(i);
+                }
             }
             return (*this);
         }

From 51dac0437422f119d4457ca24c93b9db9e07fb55 Mon Sep 17 00:00:00 2001
From: Sam Gateau <samuel.gateau@gmail.com>
Date: Fri, 26 Jan 2018 02:59:43 -0800
Subject: [PATCH 19/23] Introducing the tag in lieu of the vsisiblity mask

---
 interface/src/Application.cpp                 |   2 +-
 interface/src/SecondaryCamera.cpp             |   4 +-
 interface/src/avatar/MyAvatar.cpp             |   8 +-
 interface/src/ui/overlays/ModelOverlay.cpp    |   2 +-
 interface/src/ui/overlays/OverlaysPayload.cpp |   8 +-
 .../src/RenderableModelEntityItem.cpp         |   4 +-
 .../render-utils/src/CauterizedModel.cpp      |   2 +-
 .../render-utils/src/MeshPartPayload.cpp      |   4 +-
 libraries/render-utils/src/Model.h            |   2 +-
 .../render-utils/src/RenderShadowTask.cpp     |   2 +-
 libraries/render/src/render/Item.cpp          |  20 ++-
 libraries/render/src/render/Item.h            | 138 ++++++++----------
 .../src/render/RenderFetchCullSortTask.cpp    |  18 +--
 .../src/render/RenderFetchCullSortTask.h      |   2 +-
 14 files changed, 102 insertions(+), 114 deletions(-)

diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 3284ed902e..bdb97bcdd8 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -2274,7 +2274,7 @@ void Application::initializeGL() {
 #ifndef Q_OS_ANDROID
     _renderEngine->addJob<SecondaryCameraRenderTask>("SecondaryCameraJob", cullFunctor, !DISABLE_DEFERRED);
 #endif
-    _renderEngine->addJob<RenderViewTask>("RenderMainView", cullFunctor, !DISABLE_DEFERRED, render::ItemKey::VISIBLE_MASK_0, render::ItemKey::VISIBLE_MASK_0);
+    _renderEngine->addJob<RenderViewTask>("RenderMainView", cullFunctor, !DISABLE_DEFERRED, render::ItemKey::TAG_BITS_0, render::ItemKey::TAG_BITS_0);
     _renderEngine->load();
     _renderEngine->registerScene(_main3DScene);
 
diff --git a/interface/src/SecondaryCamera.cpp b/interface/src/SecondaryCamera.cpp
index 9d5b6a44a5..1ae1cc3559 100644
--- a/interface/src/SecondaryCamera.cpp
+++ b/interface/src/SecondaryCamera.cpp
@@ -20,7 +20,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::VISIBLE_MASK_1, render::ItemKey::VISIBLE_MASK_1);
+    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
     if (!isDeferred) {
         task.addJob<RenderForwardTask>("Forward", items);
@@ -205,7 +205,7 @@ public:
 
 void SecondaryCameraRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred) {
     const auto cachedArg = task.addJob<SecondaryCameraJob>("SecondaryCamera");
-    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, render::ItemKey::VISIBLE_MASK_1, render::ItemKey::VISIBLE_MASK_1);
+    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
     if (!isDeferred) {
         task.addJob<RenderForwardTask>("Forward", items);
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index dd51de2079..a63af4435b 100755
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -1078,7 +1078,7 @@ void MyAvatar::setEnableDebugDrawIKChains(bool isEnabled) {
 }
 
 void MyAvatar::setEnableMeshVisible(bool isEnabled) {
-    _skeletonModel->setVisibleInScene(isEnabled, qApp->getMain3DScene(), render::ItemKey::VISIBLE_MASK_NONE);
+    _skeletonModel->setVisibleInScene(isEnabled, qApp->getMain3DScene(), render::ItemKey::TAG_BITS_NONE);
 }
 
 void MyAvatar::setEnableInverseKinematics(bool isEnabled) {
@@ -1428,7 +1428,7 @@ void MyAvatar::clearJointsData() {
 
 void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
     Avatar::setSkeletonModelURL(skeletonModelURL);
-    _skeletonModel->setVisibleInScene(true, qApp->getMain3DScene(), render::ItemKey::VISIBLE_MASK_NONE);
+    _skeletonModel->setVisibleInScene(true, qApp->getMain3DScene(), render::ItemKey::TAG_BITS_NONE);
     _headBoneSet.clear();
     emit skeletonChanged();
 
@@ -1742,7 +1742,7 @@ void MyAvatar::attach(const QString& modelURL, const QString& jointName,
 
 void MyAvatar::setVisibleInSceneIfReady(Model* model, const render::ScenePointer& scene, bool visible) {
     if (model->isActive() && model->isRenderable()) {
-        model->setVisibleInScene(visible, scene, render::ItemKey::VISIBLE_MASK_NONE);
+        model->setVisibleInScene(visible, scene, render::ItemKey::TAG_BITS_NONE);
     }
 }
 
@@ -1938,7 +1938,7 @@ void MyAvatar::preDisplaySide(RenderArgs* renderArgs) {
                 _attachmentData[i].jointName.compare("HeadTop_End", Qt::CaseInsensitive) == 0 ||
                 _attachmentData[i].jointName.compare("Face", Qt::CaseInsensitive) == 0) {
                 _attachmentModels[i]->setVisibleInScene(shouldDrawHead, qApp->getMain3DScene(),
-                                                        render::ItemKey::VISIBLE_MASK_NONE);
+                                                        render::ItemKey::TAG_BITS_NONE);
             }
         }
     }
diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp
index 59d4521307..015a1a4a3b 100644
--- a/interface/src/ui/overlays/ModelOverlay.cpp
+++ b/interface/src/ui/overlays/ModelOverlay.cpp
@@ -87,7 +87,7 @@ void ModelOverlay::update(float deltatime) {
     if (_visibleDirty) {
         _visibleDirty = false;
         // don't show overlays in mirrors
-        _model->setVisibleInScene(getVisible(), scene, render::ItemKey::VISIBLE_MASK_0);
+        _model->setVisibleInScene(getVisible(), scene, render::ItemKey::TAG_BITS_0);
     }
     if (_drawInFrontDirty) {
         _drawInFrontDirty = false;
diff --git a/interface/src/ui/overlays/OverlaysPayload.cpp b/interface/src/ui/overlays/OverlaysPayload.cpp
index 937de1a236..f99ced0021 100644
--- a/interface/src/ui/overlays/OverlaysPayload.cpp
+++ b/interface/src/ui/overlays/OverlaysPayload.cpp
@@ -45,12 +45,12 @@ namespace render {
             builder.withViewSpace();
         }
 
-        if (overlay->getVisible()) {
-            builder.withVisibilityMask(render::ItemKey::VISIBLE_MASK_0); // don't draw overlays in mirror
-        } else {
-            builder.withVisibilityMask(render::ItemKey::VISIBLE_MASK_NONE);
+        if (!overlay->getVisible()) {
+            builder.withInvisible();
         }
 
+        builder.withTagBits(render::ItemKey::TAG_BITS_0); // Only draw overlays in main view
+
         return builder.build();
     }
     template <> const Item::Bound payloadGetBound(const Overlay::Pointer& overlay) {
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index ee3557346d..190864cecf 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -1334,8 +1334,8 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
     entity->stopModelOverrideIfNoParent();
 
     uint32_t viewVisiblityMask = _cauterized ?
-        render::ItemKey::VISIBLE_MASK_1 : // draw in every view except the main one (view zero)
-        render::ItemKey::VISIBLE_MASK_ALL; // draw in all views
+        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) {
         // FIXME: this seems like it could be optimized if we tracked our last known visible state in
diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 809be09436..574d3d741c 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/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::VISIBLE_MASK_ALL);
+                    data.setKey(isVisible, isLayeredInFront || isLayeredInHUD, render::ItemKey::TAG_BITS_ALL);
                     data.setLayer(isLayeredInFront, isLayeredInHUD);
                     data.setShapeKey(invalidatePayloadShapeKey, isWireframe);
                 });
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index 451b168465..aaec28e210 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@@ -395,10 +395,10 @@ void ModelMeshPartPayload::setKey(bool isVisible, bool isLayered, uint8_t viewVi
 
     if (!isVisible) {
         builder.withInvisible();
-    } else {
-        builder.withVisibilityMask(viewVisiblityMask);
     }
 
+    builder.withTagBits(render::ItemKey::TAG_BITS_ALL); // Draw models in all tags
+
     if (isLayered) {
         builder.withLayered();
     }
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index d9845de9ed..1fa14f92d6 100644
--- a/libraries/render-utils/src/Model.h
+++ b/libraries/render-utils/src/Model.h
@@ -389,7 +389,7 @@ protected:
 
     QUrl _url;
     bool _isVisible;
-    uint8_t _viewVisibilityMask { render::ItemKey::VISIBLE_MASK_ALL };
+    uint8_t _viewVisibilityMask { render::ItemKey::TAG_BITS_ALL };
 
     gpu::Buffers _blendedVertexBuffers;
 
diff --git a/libraries/render-utils/src/RenderShadowTask.cpp b/libraries/render-utils/src/RenderShadowTask.cpp
index 7a7714e1e0..d83dfd73a5 100644
--- a/libraries/render-utils/src/RenderShadowTask.cpp
+++ b/libraries/render-utils/src/RenderShadowTask.cpp
@@ -264,7 +264,7 @@ void RenderShadowCascadeSetup::run(const render::RenderContextPointer& renderCon
 
     const auto globalShadow = lightStage->getCurrentKeyShadow();
     if (globalShadow && _cascadeIndex<globalShadow->getCascadeCount()) {
-        output.edit1() = ItemFilter::Builder::visibleWorldItems(0x00, 0x00).withTypeShape().withOpaque().withoutLayered();
+        output.edit1() = ItemFilter::Builder::visibleWorldItems().withTypeShape().withOpaque().withoutLayered();
 
         globalShadow->setKeylightCascadeFrustum(_cascadeIndex, args->getViewFrustum(), SHADOW_FRUSTUM_NEAR, SHADOW_FRUSTUM_FAR);
 
diff --git a/libraries/render/src/render/Item.cpp b/libraries/render/src/render/Item.cpp
index 0e4502a47c..1bf20ab510 100644
--- a/libraries/render/src/render/Item.cpp
+++ b/libraries/render/src/render/Item.cpp
@@ -34,13 +34,19 @@ const int Item::LAYER_3D = 1;
 const int Item::LAYER_3D_FRONT = 2;
 const int Item::LAYER_3D_HUD = 3;
 
-const uint8_t ItemKey::NUM_VISIBLE_MASK_INDICES { 4 };
-const uint8_t ItemKey::VISIBLE_MASK_ALL { 0x0F };
-const uint8_t ItemKey::VISIBLE_MASK_NONE { 0x00 };
-const uint8_t ItemKey::VISIBLE_MASK_0 { 0x01 };
-const uint8_t ItemKey::VISIBLE_MASK_1 { 0x02 };
-const uint8_t ItemKey::VISIBLE_MASK_2 { 0x04 };
-const uint8_t ItemKey::VISIBLE_MASK_3 { 0x08 };
+const uint8_t ItemKey::TAG_BITS_ALL{ 0xFF };
+const uint8_t ItemKey::TAG_BITS_NONE{ 0x00 };
+const uint8_t ItemKey::TAG_BITS_0{ 0x01 };
+const uint8_t ItemKey::TAG_BITS_1{ 0x02 };
+const uint8_t ItemKey::TAG_BITS_2{ 0x04 };
+const uint8_t ItemKey::TAG_BITS_3{ 0x08 };
+const uint8_t ItemKey::TAG_BITS_4 { 0x10 };
+const uint8_t ItemKey::TAG_BITS_5{ 0x20 };
+const uint8_t ItemKey::TAG_BITS_6{ 0x40 };
+const uint8_t ItemKey::TAG_BITS_7 { 0x80 };
+
+const uint32_t ItemKey::KEY_TAG_BITS_MASK = ((uint32_t) ItemKey::TAG_BITS_ALL) << FIRST_TAG_BIT;
+
 
 
 void Item::Status::Value::setScale(float scale) {
diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h
index 97eaefcb53..4833bd2f42 100644
--- a/libraries/render/src/render/Item.h
+++ b/libraries/render/src/render/Item.h
@@ -38,38 +38,61 @@ class Context;
 // Key is the KEY to filter Items and create specialized lists
 class ItemKey {
 public:
-    enum FlagBit {
+    // 8 tags are available to organize the items and filter them against as fields of the ItemKey.
+    // TAG & TAG_BITS are defined from several bits in the Key.
+    // An Item can be tagged and filtering can rely on the tags to keep or exclude items
+    // ItemKey are not taged by default
+    enum Tag : uint8_t {
+        TAG_0 = 0, // 8 Tags 
+        TAG_1,
+        TAG_2,
+        TAG_3,
+        TAG_4,
+        TAG_5,
+        TAG_6,
+        TAG_7,
+
+        NUM_TAGS,
+    };
+    // Tag bits are derived from the Tag enum
+    const static uint8_t TAG_BITS_ALL;
+    const static uint8_t TAG_BITS_NONE;
+    const static uint8_t TAG_BITS_0;
+    const static uint8_t TAG_BITS_1;
+    const static uint8_t TAG_BITS_2;
+    const static uint8_t TAG_BITS_3;
+    const static uint8_t TAG_BITS_4;
+    const static uint8_t TAG_BITS_5;
+    const static uint8_t TAG_BITS_6;
+    const static uint8_t TAG_BITS_7;
+
+    enum FlagBit : uint32_t {
         TYPE_SHAPE = 0,   // Item is a Shape
         TYPE_LIGHT,       // Item is a Light
         TYPE_META,        // Item is a Meta: meanning it s used to represent a higher level object, potentially represented by other render items
+
         TRANSLUCENT,      // Transparent and not opaque, for some odd reason TRANSPARENCY doesn't work...
         VIEW_SPACE,       // Transformed in view space, and not in world space
         DYNAMIC,          // Dynamic and bound will change unlike static item
         DEFORMED,         // Deformed within bound, not solid
-        INVISIBLE0,       // Visible or not in this mask index?
-        INVISIBLE1,       // Visible or not in this mask index?
-        INVISIBLE2,       // Visible or not in this mask index?
-        INVISIBLE3,       // Visible or not in this mask index?
+        INVISIBLE,        // Visible or not in the scene?
         SHADOW_CASTER,    // Item cast shadows
-        PICKABLE,         // Item can be picked/selected
         LAYERED,          // Item belongs to one of the layers different from the default layer
 
-        SMALLER,
+        FIRST_TAG_BIT, // 8 Tags available to organize the items and filter them against
+        LAST_TAG_BIT = FIRST_TAG_BIT + NUM_TAGS,
+
+        __SMALLER,        // Reserved bit for spatialized item to indicate that it is smaller than expected in the cell in which it belongs (probably because it overlaps over several smaller cells)
 
         NUM_FLAGS,      // Not a valid flag
     };
     typedef std::bitset<NUM_FLAGS> Flags;
 
-    // VISIBLE MASK is defined from several bits in the Key.
-    // An Item can be visible in some mask bits and not other allowing for per view rendering
-    // Beware that the visibility mask is the oposite of what stored in the key vals.
-    const static uint8_t NUM_VISIBLE_MASK_INDICES;
-    const static uint8_t VISIBLE_MASK_ALL;
-    const static uint8_t VISIBLE_MASK_NONE;
-    const static uint8_t VISIBLE_MASK_0;
-    const static uint8_t VISIBLE_MASK_1;
-    const static uint8_t VISIBLE_MASK_2;
-    const static uint8_t VISIBLE_MASK_3;
+    // All the bits touching tag bits sets to true
+    const static uint32_t KEY_TAG_BITS_MASK;
+    static uint32_t evalTagBitsWithKeyBits(uint8_t tagBits, const uint32_t keyBits) {
+        return (keyBits & ~KEY_TAG_BITS_MASK) | (((uint32_t)tagBits) << FIRST_TAG_BIT);
+    }
 
     // The key is the Flags
     Flags _flags;
@@ -96,44 +119,14 @@ public:
         Builder& withViewSpace() { _flags.set(VIEW_SPACE); return (*this); }
         Builder& withDynamic() { _flags.set(DYNAMIC); return (*this); }
         Builder& withDeformed() { _flags.set(DEFORMED); return (*this); }
-        Builder& withVisible(uint8_t maskIndex = NUM_VISIBLE_MASK_INDICES) {
-            if (maskIndex == NUM_VISIBLE_MASK_INDICES) {
-                _flags.reset(INVISIBLE0);
-                _flags.reset(INVISIBLE1);
-                _flags.reset(INVISIBLE2);
-                _flags.reset(INVISIBLE3);
-            }
-            else {
-                _flags.reset(INVISIBLE0 + maskIndex);
-            }
-            return (*this);
-        }
-        Builder& withInvisible(uint8_t maskIndex = NUM_VISIBLE_MASK_INDICES) {
-            if (maskIndex == NUM_VISIBLE_MASK_INDICES) {
-                _flags.set(INVISIBLE0);
-                _flags.set(INVISIBLE1);
-                _flags.set(INVISIBLE2);
-                _flags.set(INVISIBLE3);
-            } else {
-                _flags.set(INVISIBLE0 + maskIndex);
-            }
-            return (*this);
-        }
-        Builder& withVisibilityMask(uint8_t mask) {
-            for (int i = 0; i < ItemKey::NUM_VISIBLE_MASK_INDICES; i++) {
-                if ((1 << i) & mask) {
-                    withVisible(i);
-                }
-                else {
-                    withInvisible(i);
-                }
-            }
-            return (*this);
-        }
+        Builder& withInvisible() { _flags.set(INVISIBLE); return (*this); }
         Builder& withShadowCaster() { _flags.set(SHADOW_CASTER); return (*this); }
-        Builder& withPickable() { _flags.set(PICKABLE); return (*this); }
         Builder& withLayered() { _flags.set(LAYERED); return (*this); }
 
+        Builder& withTag(Tag tag) { _flags.set(FIRST_TAG_BIT + tag); return (*this); }
+        // Set ALL the tags in one call using the Tag bits
+        Builder& withTagBits(uint8_t tagBits) { _flags = evalTagBitsWithKeyBits(tagBits, _flags.to_ulong()); return (*this); }
+
         // Convenient standard keys that we will keep on using all over the place
         static Builder opaqueShape() { return Builder().withTypeShape(); }
         static Builder transparentShape() { return Builder().withTypeShape().withTransparent(); }
@@ -158,21 +151,20 @@ public:
     bool isRigid() const { return !_flags[DEFORMED]; }
     bool isDeformed() const { return _flags[DEFORMED]; }
 
-    bool isVisible(uint8_t maskIndex) const { return !_flags[INVISIBLE0 + maskIndex]; }
-    bool isInvisible(uint8_t maskIndex) const { return _flags[INVISIBLE0 + maskIndex]; }
-    uint8_t getVisibleMask() const { return (~(_flags.to_ulong() >> INVISIBLE0) & VISIBLE_MASK_ALL);}
-    bool isVisibleMask(uint8_t mask) const { return getVisibleMask() & mask; }
+    bool isVisible() const { return !_flags[INVISIBLE]; }
+    bool isInvisible() const { return _flags[INVISIBLE]; }
 
     bool isShadowCaster() const { return _flags[SHADOW_CASTER]; }
 
-    bool isPickable() const { return _flags[PICKABLE]; }
-
     bool isLayered() const { return _flags[LAYERED]; }
     bool isSpatial() const { return !isLayered(); }
 
+    bool isTag(Tag tag) const { return _flags[FIRST_TAG_BIT + tag]; }
+    uint8_t getTagBits() const { return ((_flags.to_ulong() & KEY_TAG_BITS_MASK) >> FIRST_TAG_BIT); }
+
     // Probably not public, flags used by the scene
-    bool isSmall() const { return _flags[SMALLER]; }
-    void setSmaller(bool smaller) { (smaller ? _flags.set(SMALLER) : _flags.reset(SMALLER)); }
+    bool isSmall() const { return _flags[__SMALLER]; }
+    void setSmaller(bool smaller) { (smaller ? _flags.set(__SMALLER) : _flags.reset(__SMALLER)); }
 
     bool operator==(const ItemKey& key) { return (_flags == key._flags); }
     bool operator!=(const ItemKey& key) { return (_flags != key._flags); }
@@ -220,34 +212,24 @@ public:
         Builder& withRigid()            { _value.reset(ItemKey::DEFORMED); _mask.set(ItemKey::DEFORMED); return (*this); }
         Builder& withDeformed()         { _value.set(ItemKey::DEFORMED);  _mask.set(ItemKey::DEFORMED); return (*this); }
 
-        Builder& withVisible(uint8_t maskIndex)          { _value.reset(ItemKey::INVISIBLE0 + maskIndex); _mask.set(ItemKey::INVISIBLE0 + maskIndex); return (*this); }
-        Builder& withInvisible(uint8_t maskIndex)        { _value.set(ItemKey::INVISIBLE0 + maskIndex);  _mask.set(ItemKey::INVISIBLE0 + maskIndex); return (*this); }
-        Builder& withVisibilityMask(uint8_t mask, uint8_t touchBits) {
-            for (int i = 0; i < ItemKey::NUM_VISIBLE_MASK_INDICES; i++) {
-                if ((1 << i) & touchBits) {
-                    if ((1 << i) & mask) {
-                        withVisible(i);
-                    }
-                    else {
-                        withInvisible(i);
-                    }
-                }
-            }
-            return (*this);
-        }
+        Builder& withVisible()          { _value.reset(ItemKey::INVISIBLE); _mask.set(ItemKey::INVISIBLE); return (*this); }
+        Builder& withInvisible()        { _value.set(ItemKey::INVISIBLE);  _mask.set(ItemKey::INVISIBLE); return (*this); }
 
         Builder& withNoShadowCaster()   { _value.reset(ItemKey::SHADOW_CASTER); _mask.set(ItemKey::SHADOW_CASTER); return (*this); }
         Builder& withShadowCaster()     { _value.set(ItemKey::SHADOW_CASTER);  _mask.set(ItemKey::SHADOW_CASTER); return (*this); }
 
-        Builder& withPickable()         { _value.set(ItemKey::PICKABLE);  _mask.set(ItemKey::PICKABLE); return (*this); }
-
         Builder& withoutLayered()       { _value.reset(ItemKey::LAYERED); _mask.set(ItemKey::LAYERED); return (*this); }
         Builder& withLayered()          { _value.set(ItemKey::LAYERED);  _mask.set(ItemKey::LAYERED); return (*this); }
 
+        Builder& withoutTag(ItemKey::Tag tagIndex)    { _value.reset(ItemKey::FIRST_TAG_BIT + tagIndex);  _mask.set(ItemKey::FIRST_TAG_BIT + tagIndex); return (*this); }
+        Builder& withTag(ItemKey::Tag tagIndex)       { _value.set(ItemKey::FIRST_TAG_BIT + tagIndex);  _mask.set(ItemKey::FIRST_TAG_BIT + tagIndex); return (*this); }
+        // Set ALL the tags in one call using the Tag bits and the Tag bits touched
+        Builder& withTagBits(uint8_t tagBits, uint8_t tagMask) { _value = ItemKey::evalTagBitsWithKeyBits(tagBits, _value.to_ulong()); _mask = ItemKey::evalTagBitsWithKeyBits(tagMask, _mask.to_ulong()); return (*this); }
+
         Builder& withNothing()          { _value.reset(); _mask.reset(); return (*this); }
 
         // Convenient standard keys that we will keep on using all over the place
-        static Builder visibleWorldItems(uint8_t visibilityMask, uint8_t visibilityMaskTouched) { return Builder().withVisibilityMask(visibilityMask, visibilityMaskTouched).withWorldSpace(); }
+        static Builder visibleWorldItems() { return Builder().withVisible().withWorldSpace(); }
         static Builder opaqueShape() { return Builder().withTypeShape().withOpaque().withWorldSpace(); }
         static Builder transparentShape() { return Builder().withTypeShape().withTransparent().withWorldSpace(); }
         static Builder light() { return Builder().withTypeLight(); }
diff --git a/libraries/render/src/render/RenderFetchCullSortTask.cpp b/libraries/render/src/render/RenderFetchCullSortTask.cpp
index b4e1a618dc..a402c3bc9d 100644
--- a/libraries/render/src/render/RenderFetchCullSortTask.cpp
+++ b/libraries/render/src/render/RenderFetchCullSortTask.cpp
@@ -17,12 +17,12 @@
 
 using namespace render;
 
-void RenderFetchCullSortTask::build(JobModel& task, const Varying& input, Varying& output, CullFunctor cullFunctor, uint8_t visibilityMask, uint8_t visibilityMaskTouched) {
+void RenderFetchCullSortTask::build(JobModel& task, const Varying& input, Varying& output, CullFunctor cullFunctor, uint8_t tagBits, uint8_t tagMask) {
     cullFunctor = cullFunctor ? cullFunctor : [](const RenderArgs*, const AABox&){ return true; };
 
     // CPU jobs:
     // Fetch and cull the items from the scene
-    const ItemFilter filter = ItemFilter::Builder::visibleWorldItems(visibilityMask, visibilityMaskTouched).withoutLayered();
+    const ItemFilter filter = ItemFilter::Builder::visibleWorldItems().withoutLayered().withTagBits(tagBits, tagMask);
     const auto spatialFilter = render::Varying(filter);
     const auto spatialSelection = task.addJob<FetchSpatialTree>("FetchSceneSelection", spatialFilter);
     const auto cullInputs = CullSpatialSelection::Inputs(spatialSelection, spatialFilter).asVarying();
@@ -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().withVisibilityMask(visibilityMask, visibilityMaskTouched),
-            ItemFilter::Builder::transparentShape().withVisibilityMask(visibilityMask, visibilityMaskTouched),
-            ItemFilter::Builder::light().withVisibilityMask(visibilityMask, visibilityMaskTouched),
-            ItemFilter::Builder::meta().withVisibilityMask(visibilityMask, visibilityMaskTouched)
+            ItemFilter::Builder::opaqueShape().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::transparentShape().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::light().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::meta().withVisible().withTagBits(tagBits, tagMask)
         } };
     MultiFilterItems<NUM_NON_SPATIAL_FILTERS>::ItemFilterArray nonspatialFilters = { {
-            ItemFilter::Builder::opaqueShape().withVisibilityMask(visibilityMask, visibilityMaskTouched),
-            ItemFilter::Builder::transparentShape().withVisibilityMask(visibilityMask, visibilityMaskTouched),
-            ItemFilter::Builder::background().withVisibilityMask(visibilityMask, visibilityMaskTouched)
+            ItemFilter::Builder::opaqueShape().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::transparentShape().withVisible().withTagBits(tagBits, tagMask),
+            ItemFilter::Builder::background().withVisible().withTagBits(tagBits, tagMask)
         } };
     const auto filteredSpatialBuckets = 
         task.addJob<MultiFilterItems<NUM_SPATIAL_FILTERS>>("FilterSceneSelection", culledSpatialSelection, spatialFilters)
diff --git a/libraries/render/src/render/RenderFetchCullSortTask.h b/libraries/render/src/render/RenderFetchCullSortTask.h
index 9aa235b3fb..8c9f2e7304 100644
--- a/libraries/render/src/render/RenderFetchCullSortTask.h
+++ b/libraries/render/src/render/RenderFetchCullSortTask.h
@@ -36,7 +36,7 @@ public:
 
     RenderFetchCullSortTask() {}
 
-    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, uint8_t visibilityMask = 0xFF, uint8_t visibilityMaskTouched = 0x00);
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, uint8_t tagBits = 0x00, uint8_t tagMask = 0x00);
 };
 
 #endif // hifi_RenderFetchCullSortTask_h

From 8dfa3aace3c25fe0d966c9931a856309281518e8 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Fri, 26 Jan 2018 17:34:37 -0800
Subject: [PATCH 20/23] cleaning en route

---
 interface/src/Application_render.cpp          |  2 +-
 interface/src/SecondaryCamera.cpp             |  1 +
 .../src/avatars-renderer/Avatar.cpp           |  2 +-
 .../src/RenderableEntityItem.cpp              |  4 +-
 .../src/RenderableModelEntityItem.cpp         | 11 ++---
 .../RenderableParticleEffectEntityItem.cpp    |  4 +-
 .../src/RenderablePolyLineEntityItem.cpp      |  2 +-
 .../src/RenderableZoneEntityItem.cpp          |  2 +-
 libraries/render-utils/src/AnimDebugDraw.cpp  |  2 +-
 .../render-utils/src/CauterizedModel.cpp      |  2 +-
 libraries/render-utils/src/LightPayload.cpp   |  9 ++++-
 .../render-utils/src/MeshPartPayload.cpp      | 26 ++++++++----
 libraries/render-utils/src/MeshPartPayload.h  |  9 +++--
 libraries/render-utils/src/Model.cpp          | 40 +++++++++----------
 libraries/render-utils/src/Model.h            |  6 +--
 .../render-utils/src/RenderShadowTask.cpp     |  4 +-
 libraries/render-utils/src/RenderShadowTask.h |  2 +-
 libraries/render-utils/src/RenderViewTask.cpp |  4 +-
 libraries/render-utils/src/RenderViewTask.h   |  2 +-
 .../src/render/RenderFetchCullSortTask.cpp    | 14 +++----
 20 files changed, 85 insertions(+), 63 deletions(-)

diff --git a/interface/src/Application_render.cpp b/interface/src/Application_render.cpp
index 1231e5834b..e1f198eed2 100644
--- a/interface/src/Application_render.cpp
+++ b/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)) {
diff --git a/interface/src/SecondaryCamera.cpp b/interface/src/SecondaryCamera.cpp
index 1ae1cc3559..748f1595db 100644
--- a/interface/src/SecondaryCamera.cpp
+++ b/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>());
diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
index 500a24763d..86635cd3bf 100644
--- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
+++ b/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();
diff --git a/libraries/entities-renderer/src/RenderableEntityItem.cpp b/libraries/entities-renderer/src/RenderableEntityItem.cpp
index 0988c696dd..aca2f4d35b 100644
--- a/libraries/entities-renderer/src/RenderableEntityItem.cpp
+++ b/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) {
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index 190864cecf..87767db4f4 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/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?
 
diff --git a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
index 2059487426..af95878213 100644
--- a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
+++ b/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();
     }
 }
 
diff --git a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp
index 4d223669b4..42110170a0 100644
--- a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp
+++ b/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() {
diff --git a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp b/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
index b43944f26a..04f07c5bd3 100644
--- a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
+++ b/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 {
diff --git a/libraries/render-utils/src/AnimDebugDraw.cpp b/libraries/render-utils/src/AnimDebugDraw.cpp
index c22e99cbbc..4b5b06ab0b 100644
--- a/libraries/render-utils/src/AnimDebugDraw.cpp
+++ b/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);
diff --git a/libraries/render-utils/src/CauterizedModel.cpp b/libraries/render-utils/src/CauterizedModel.cpp
index 574d3d741c..e30c72e9d4 100644
--- a/libraries/render-utils/src/CauterizedModel.cpp
+++ b/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);
                 });
diff --git a/libraries/render-utils/src/LightPayload.cpp b/libraries/render-utils/src/LightPayload.cpp
index 09334faa13..f1eef19498 100644
--- a/libraries/render-utils/src/LightPayload.cpp
+++ b/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.withInvisible();
+        builder.withTagBits(ItemKey::TAG_BITS_ALL);
+        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();
         }
diff --git a/libraries/render-utils/src/MeshPartPayload.cpp b/libraries/render-utils/src/MeshPartPayload.cpp
index aaec28e210..9655b60a78 100644
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/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;
diff --git a/libraries/render-utils/src/MeshPartPayload.h b/libraries/render-utils/src/MeshPartPayload.h
index cf64879b3c..21f9dc2e68 100644
--- a/libraries/render-utils/src/MeshPartPayload.h
+++ b/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 };
 };
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 4103dffefc..56bed15376 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/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) {
-    if (_isVisible != isVisible || _viewVisibilityMask != viewVisibilityMask) {
+void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewTagBits) {
+    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);
             });
         }
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index 1fa14f92d6..72527e1fde 100644
--- a/libraries/render-utils/src/Model.h
+++ b/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;
 
diff --git a/libraries/render-utils/src/RenderShadowTask.cpp b/libraries/render-utils/src/RenderShadowTask.cpp
index d83dfd73a5..20af1278ac 100644
--- a/libraries/render-utils/src/RenderShadowTask.cpp
+++ b/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;
 
diff --git a/libraries/render-utils/src/RenderShadowTask.h b/libraries/render-utils/src/RenderShadowTask.h
index d8d4c624e7..2bc325cc81 100644
--- a/libraries/render-utils/src/RenderShadowTask.h
+++ b/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);
 };
diff --git a/libraries/render-utils/src/RenderViewTask.cpp b/libraries/render-utils/src/RenderViewTask.cpp
index 83868e1443..42d3044b1b 100644
--- a/libraries/render-utils/src/RenderViewTask.cpp
+++ b/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) {
diff --git a/libraries/render-utils/src/RenderViewTask.h b/libraries/render-utils/src/RenderViewTask.h
index faace7349e..5da3d18474 100644
--- a/libraries/render-utils/src/RenderViewTask.h
+++ b/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);
 
 };
 
diff --git a/libraries/render/src/render/RenderFetchCullSortTask.cpp b/libraries/render/src/render/RenderFetchCullSortTask.cpp
index a402c3bc9d..bb6bd462f6 100644
--- a/libraries/render/src/render/RenderFetchCullSortTask.cpp
+++ b/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::transparentShape().withVisible().withTagBits(tagBits, tagMask),
-            ItemFilter::Builder::light().withVisible().withTagBits(tagBits, tagMask),
-            ItemFilter::Builder::meta().withVisible().withTagBits(tagBits, tagMask)
+            ItemFilter::Builder::opaqueShape(),
+            ItemFilter::Builder::transparentShape(),
+            ItemFilter::Builder::light(),
+            ItemFilter::Builder::meta()
         } };
     MultiFilterItems<NUM_NON_SPATIAL_FILTERS>::ItemFilterArray nonspatialFilters = { {
-            ItemFilter::Builder::opaqueShape().withVisible().withTagBits(tagBits, tagMask),
-            ItemFilter::Builder::transparentShape().withVisible().withTagBits(tagBits, tagMask),
-            ItemFilter::Builder::background().withVisible().withTagBits(tagBits, tagMask)
+            ItemFilter::Builder::opaqueShape(),
+            ItemFilter::Builder::transparentShape(),
+            ItemFilter::Builder::background()
         } };
     const auto filteredSpatialBuckets = 
         task.addJob<MultiFilterItems<NUM_SPATIAL_FILTERS>>("FilterSceneSelection", culledSpatialSelection, spatialFilters)

From 1fd4c5c1a45199581e89e63a1b1ffb89cdbdfd65 Mon Sep 17 00:00:00 2001
From: samcake <samuel.gateau@gmail.com>
Date: Mon, 29 Jan 2018 12:20:51 -0800
Subject: [PATCH 21/23] Integrating the tag flags to the render item key and
 adding configration of the render pipelien with the Tag information

---
 interface/src/SecondaryCamera.cpp                       | 2 +-
 libraries/render-utils/src/RenderShadowTask.cpp         | 6 ++----
 libraries/render-utils/src/RenderShadowTask.h           | 4 +++-
 libraries/render-utils/src/RenderViewTask.cpp           | 2 +-
 libraries/render/src/render/CullTask.cpp                | 6 ++++--
 libraries/render/src/render/CullTask.h                  | 4 ++--
 libraries/render/src/render/RenderFetchCullSortTask.cpp | 4 +++-
 7 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/interface/src/SecondaryCamera.cpp b/interface/src/SecondaryCamera.cpp
index 748f1595db..6b8e370689 100644
--- a/interface/src/SecondaryCamera.cpp
+++ b/interface/src/SecondaryCamera.cpp
@@ -20,7 +20,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);
+    task.addJob<RenderShadowTask>("RenderShadowTask", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1);
     const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, render::ItemKey::TAG_BITS_1, render::ItemKey::TAG_BITS_1);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
     if (!isDeferred) {
diff --git a/libraries/render-utils/src/RenderShadowTask.cpp b/libraries/render-utils/src/RenderShadowTask.cpp
index 20af1278ac..19a3f4ed73 100644
--- a/libraries/render-utils/src/RenderShadowTask.cpp
+++ b/libraries/render-utils/src/RenderShadowTask.cpp
@@ -216,7 +216,7 @@ void RenderShadowTask::build(JobModel& task, const render::Varying& input, rende
     task.addJob<RenderShadowSetup>("ShadowSetup");
 
     for (auto i = 0; i < SHADOW_CASCADE_MAX_COUNT; i++) {
-        const auto setupOutput = task.addJob<RenderShadowCascadeSetup>("ShadowCascadeSetup", i);
+        const auto setupOutput = task.addJob<RenderShadowCascadeSetup>("ShadowCascadeSetup", i, tagBits, tagMask);
         const auto shadowFilter = setupOutput.getN<RenderShadowCascadeSetup::Outputs>(1);
 
         // CPU jobs:
@@ -259,14 +259,12 @@ 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;
 
     const auto globalShadow = lightStage->getCurrentKeyShadow();
     if (globalShadow && _cascadeIndex<globalShadow->getCascadeCount()) {
-        output.edit1() = ItemFilter::Builder::visibleWorldItems().withTypeShape().withOpaque().withoutLayered();
+        output.edit1() = ItemFilter::Builder::visibleWorldItems().withTypeShape().withOpaque().withoutLayered().withTagBits(_tagBits, _tagMask);
 
         globalShadow->setKeylightCascadeFrustum(_cascadeIndex, args->getViewFrustum(), SHADOW_FRUSTUM_NEAR, SHADOW_FRUSTUM_FAR);
 
diff --git a/libraries/render-utils/src/RenderShadowTask.h b/libraries/render-utils/src/RenderShadowTask.h
index 2bc325cc81..33e0ad4daa 100644
--- a/libraries/render-utils/src/RenderShadowTask.h
+++ b/libraries/render-utils/src/RenderShadowTask.h
@@ -67,12 +67,14 @@ public:
     using Outputs = render::VaryingSet3<RenderArgs::RenderMode, render::ItemFilter, float>;
     using JobModel = render::Job::ModelO<RenderShadowCascadeSetup, Outputs>;
 
-    RenderShadowCascadeSetup(unsigned int cascadeIndex) : _cascadeIndex{ cascadeIndex } {}
+    RenderShadowCascadeSetup(unsigned int cascadeIndex, uint8_t tagBits = 0x00, uint8_t tagMask = 0x00) : _cascadeIndex{ cascadeIndex }, _tagBits(tagBits), _tagMask(tagMask) {}
     void run(const render::RenderContextPointer& renderContext, Outputs& output);
 
 private:
 
     unsigned int _cascadeIndex;
+    uint8_t _tagBits{ 0x00 };
+    uint8_t _tagMask{ 0x00 };
 };
 
 class RenderShadowCascadeTeardown {
diff --git a/libraries/render-utils/src/RenderViewTask.cpp b/libraries/render-utils/src/RenderViewTask.cpp
index 42d3044b1b..19924b4ddc 100644
--- a/libraries/render-utils/src/RenderViewTask.cpp
+++ b/libraries/render-utils/src/RenderViewTask.cpp
@@ -28,7 +28,7 @@ void RenderViewTask::build(JobModel& task, const render::Varying& input, render:
         const auto threshold = 1e-3f;
         return relativeBoundRadius > threshold;
         return true;
-    });
+    }, tagBits, tagMask);
 
     const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor, tagBits, tagMask);
     assert(items.canCast<RenderFetchCullSortTask::Output>());
diff --git a/libraries/render/src/render/CullTask.cpp b/libraries/render/src/render/CullTask.cpp
index 70331cdb47..8d99c3e8f2 100644
--- a/libraries/render/src/render/CullTask.cpp
+++ b/libraries/render/src/render/CullTask.cpp
@@ -61,7 +61,7 @@ void render::cullItems(const RenderContextPointer& renderContext, const CullFunc
     details._rendered += (int)outItems.size();
 }
 
-void FetchNonspatialItems::run(const RenderContextPointer& renderContext, ItemBounds& outItems) {
+void FetchNonspatialItems::run(const RenderContextPointer& renderContext, const ItemFilter& filter, ItemBounds& outItems) {
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
     auto& scene = renderContext->_scene;
@@ -72,7 +72,9 @@ void FetchNonspatialItems::run(const RenderContextPointer& renderContext, ItemBo
     outItems.reserve(items.size());
     for (auto& id : items) {
         auto& item = scene->getItem(id);
-        outItems.emplace_back(ItemBound(id, item.getBound()));
+        if (filter.test(item.getKey())) {
+            outItems.emplace_back(ItemBound(id, item.getBound()));
+        }
     }
 }
 
diff --git a/libraries/render/src/render/CullTask.h b/libraries/render/src/render/CullTask.h
index 486c4f4cdf..4461537109 100644
--- a/libraries/render/src/render/CullTask.h
+++ b/libraries/render/src/render/CullTask.h
@@ -24,8 +24,8 @@ namespace render {
 
     class FetchNonspatialItems {
     public:
-        using JobModel = Job::ModelO<FetchNonspatialItems, ItemBounds>;
-        void run(const RenderContextPointer& renderContext, ItemBounds& outItems);
+        using JobModel = Job::ModelIO<FetchNonspatialItems, ItemFilter, ItemBounds>;
+        void run(const RenderContextPointer& renderContext, const ItemFilter& filter, ItemBounds& outItems);
     };
 
     class FetchSpatialTreeConfig : public Job::Config {
diff --git a/libraries/render/src/render/RenderFetchCullSortTask.cpp b/libraries/render/src/render/RenderFetchCullSortTask.cpp
index bb6bd462f6..7f60d5bb52 100644
--- a/libraries/render/src/render/RenderFetchCullSortTask.cpp
+++ b/libraries/render/src/render/RenderFetchCullSortTask.cpp
@@ -29,7 +29,9 @@ void RenderFetchCullSortTask::build(JobModel& task, const Varying& input, Varyin
     const auto culledSpatialSelection = task.addJob<CullSpatialSelection>("CullSceneSelection", cullInputs, cullFunctor, RenderDetails::ITEM);
 
     // Overlays are not culled
-    const auto nonspatialSelection = task.addJob<FetchNonspatialItems>("FetchOverlaySelection");
+    const ItemFilter overlayfilter = ItemFilter::Builder().withVisible().withTagBits(tagBits, tagMask);
+    const auto nonspatialFilter = render::Varying(overlayfilter);
+    const auto nonspatialSelection = task.addJob<FetchNonspatialItems>("FetchOverlaySelection", nonspatialFilter);
 
     // Multi filter visible items into different buckets
     const int NUM_SPATIAL_FILTERS = 4; 

From 96b6e85745fff6e3bc31363bb07d5164fda91728 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Wed, 31 Jan 2018 12:24:23 -0800
Subject: [PATCH 22/23] formatting

---
 libraries/render/src/render/Item.cpp | 16 ++++++++--------
 libraries/render/src/render/Item.h   |  4 ++--
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/libraries/render/src/render/Item.cpp b/libraries/render/src/render/Item.cpp
index 1bf20ab510..612dba076b 100644
--- a/libraries/render/src/render/Item.cpp
+++ b/libraries/render/src/render/Item.cpp
@@ -34,15 +34,15 @@ const int Item::LAYER_3D = 1;
 const int Item::LAYER_3D_FRONT = 2;
 const int Item::LAYER_3D_HUD = 3;
 
-const uint8_t ItemKey::TAG_BITS_ALL{ 0xFF };
-const uint8_t ItemKey::TAG_BITS_NONE{ 0x00 };
-const uint8_t ItemKey::TAG_BITS_0{ 0x01 };
-const uint8_t ItemKey::TAG_BITS_1{ 0x02 };
-const uint8_t ItemKey::TAG_BITS_2{ 0x04 };
-const uint8_t ItemKey::TAG_BITS_3{ 0x08 };
+const uint8_t ItemKey::TAG_BITS_ALL { 0xFF };
+const uint8_t ItemKey::TAG_BITS_NONE { 0x00 };
+const uint8_t ItemKey::TAG_BITS_0 { 0x01 };
+const uint8_t ItemKey::TAG_BITS_1 { 0x02 };
+const uint8_t ItemKey::TAG_BITS_2 { 0x04 };
+const uint8_t ItemKey::TAG_BITS_3 { 0x08 };
 const uint8_t ItemKey::TAG_BITS_4 { 0x10 };
-const uint8_t ItemKey::TAG_BITS_5{ 0x20 };
-const uint8_t ItemKey::TAG_BITS_6{ 0x40 };
+const uint8_t ItemKey::TAG_BITS_5 { 0x20 };
+const uint8_t ItemKey::TAG_BITS_6 { 0x40 };
 const uint8_t ItemKey::TAG_BITS_7 { 0x80 };
 
 const uint32_t ItemKey::KEY_TAG_BITS_MASK = ((uint32_t) ItemKey::TAG_BITS_ALL) << FIRST_TAG_BIT;
diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h
index 4833bd2f42..ff4b3a0458 100644
--- a/libraries/render/src/render/Item.h
+++ b/libraries/render/src/render/Item.h
@@ -43,7 +43,7 @@ public:
     // An Item can be tagged and filtering can rely on the tags to keep or exclude items
     // ItemKey are not taged by default
     enum Tag : uint8_t {
-        TAG_0 = 0, // 8 Tags 
+        TAG_0 = 0, // 8 Tags
         TAG_1,
         TAG_2,
         TAG_3,
@@ -52,7 +52,7 @@ public:
         TAG_6,
         TAG_7,
 
-        NUM_TAGS,
+        NUM_TAGS
     };
     // Tag bits are derived from the Tag enum
     const static uint8_t TAG_BITS_ALL;

From 14d5029f4d4893664b0ec1d36953d0ccfa6bf38b Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Fri, 2 Feb 2018 08:56:11 -0800
Subject: [PATCH 23/23] only update cauterization of child entities when
 something relevant changes

---
 interface/src/avatar/MyAvatar.cpp           | 38 +++++++++++++++------
 interface/src/avatar/MyAvatar.h             |  7 ++++
 libraries/render-utils/src/LightPayload.cpp |  2 +-
 3 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 3cf7874b50..54bdd79de5 100755
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -504,6 +504,16 @@ void MyAvatar::updateEyeContactTarget(float deltaTime) {
 extern QByteArray avatarStateToFrame(const AvatarData* _avatar);
 extern void avatarStateFromFrame(const QByteArray& frameData, AvatarData* _avatar);
 
+void MyAvatar::beParentOfChild(SpatiallyNestablePointer newChild) const {
+    _cauterizationNeedsUpdate = true;
+    SpatiallyNestable::beParentOfChild(newChild);
+}
+
+void MyAvatar::forgetChild(SpatiallyNestablePointer newChild) const {
+    _cauterizationNeedsUpdate = true;
+    SpatiallyNestable::forgetChild(newChild);
+}
+
 void MyAvatar::updateChildCauterization(SpatiallyNestablePointer object) {
     if (object->getNestableType() == NestableType::Entity) {
         EntityItemPointer entity = std::static_pointer_cast<EntityItem>(object);
@@ -516,16 +526,19 @@ void MyAvatar::simulate(float deltaTime) {
 
     animateScaleChanges(deltaTime);
 
-    const std::unordered_set<int>& headBoneSet = _skeletonModel->getCauterizeBoneSet();
-    forEachChild([&](SpatiallyNestablePointer object) {
-        bool isChildOfHead = headBoneSet.find(object->getParentJointIndex()) != headBoneSet.end();
-        if (isChildOfHead) {
-            updateChildCauterization(object);
-            object->forEachDescendant([&](SpatiallyNestablePointer descendant) {
-                updateChildCauterization(descendant);
-            });
-        }
-    });
+    if (_cauterizationNeedsUpdate) {
+        const std::unordered_set<int>& headBoneSet = _skeletonModel->getCauterizeBoneSet();
+        forEachChild([&](SpatiallyNestablePointer object) {
+            bool isChildOfHead = headBoneSet.find(object->getParentJointIndex()) != headBoneSet.end();
+            if (isChildOfHead) {
+                updateChildCauterization(object);
+                object->forEachDescendant([&](SpatiallyNestablePointer descendant) {
+                    updateChildCauterization(descendant);
+                });
+            }
+        });
+        _cauterizationNeedsUpdate = false;
+    }
 
     {
         PerformanceTimer perfTimer("transform");
@@ -1438,6 +1451,7 @@ void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
     Avatar::setSkeletonModelURL(skeletonModelURL);
     _skeletonModel->setVisibleInScene(true, qApp->getMain3DScene(), render::ItemKey::TAG_BITS_NONE);
     _headBoneSet.clear();
+    _cauterizationNeedsUpdate = true;
     emit skeletonChanged();
 
 }
@@ -1809,6 +1823,8 @@ void MyAvatar::initHeadBones() {
         }
         q.pop();
     }
+
+    _cauterizationNeedsUpdate = true;
 }
 
 QUrl MyAvatar::getAnimGraphOverrideUrl() const {
@@ -1879,6 +1895,7 @@ void MyAvatar::postUpdate(float deltaTime, const render::ScenePointer& scene) {
         _fstAnimGraphOverrideUrl = _skeletonModel->getGeometry()->getAnimGraphOverrideUrl();
         initAnimGraph();
         _isAnimatingScale = true;
+        _cauterizationNeedsUpdate = true;
     }
 
     if (_enableDebugDrawDefaultPose || _enableDebugDrawAnimPose) {
@@ -1967,6 +1984,7 @@ void MyAvatar::preDisplaySide(RenderArgs* renderArgs) {
     // toggle using the cauterizedBones depending on where the camera is and the rendering pass type.
     const bool shouldDrawHead = shouldRenderHead(renderArgs);
     if (shouldDrawHead != _prevShouldDrawHead) {
+        _cauterizationNeedsUpdate = true;
         _skeletonModel->setEnableCauterization(!shouldDrawHead);
 
         for (int i = 0; i < _attachmentData.size(); i++) {
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index c32013b8d1..97e82b87f5 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -633,6 +633,11 @@ signals:
 private slots:
     void leaveDomain();
 
+
+protected:
+    virtual void beParentOfChild(SpatiallyNestablePointer newChild) const override;
+    virtual void forgetChild(SpatiallyNestablePointer newChild) const override;
+
 private:
 
     bool requiresSafeLanding(const glm::vec3& positionIn, glm::vec3& positionOut);
@@ -812,6 +817,8 @@ private:
     bool _enableDebugDrawIKChains { false };
     bool _enableDebugDrawDetailedCollision { false };
 
+    mutable bool _cauterizationNeedsUpdate; // do we need to scan children and update their "cauterized" state?
+
     AudioListenerMode _audioListenerMode;
     glm::vec3 _customListenPosition;
     glm::quat _customListenOrientation;
diff --git a/libraries/render-utils/src/LightPayload.cpp b/libraries/render-utils/src/LightPayload.cpp
index f1eef19498..79e0c1d94d 100644
--- a/libraries/render-utils/src/LightPayload.cpp
+++ b/libraries/render-utils/src/LightPayload.cpp
@@ -19,7 +19,7 @@ namespace render {
         ItemKey::Builder builder;
         builder.withTypeLight();
         builder.withTagBits(ItemKey::TAG_BITS_ALL);
-        if (!payload) {
+        if (payload) {
             if (!payload->isVisible()) {
                 builder.withInvisible();
             }