Oh boy

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

@@ -593,7 +593,8 @@ void Avatar::addToScene(AvatarSharedPointer self, const render::ScenePointer& sc
     processMaterials();
     for (auto& attachmentModel : _attachmentModels) {
         attachmentModel->addToScene(scene, transaction);
-        attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, true);
+        attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, false);
+        attachmentModel->setCanCastShadow(true, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, false);
     }
 
     _mustFadeIn = true;
@@ -806,6 +807,7 @@ void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
         _skeletonModel->removeFromScene(scene, transaction);
         _skeletonModel->addToScene(scene, transaction);
         _skeletonModel->setVisibleInScene(_isMeshEnableVisible, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, true);
+        _skeletonModel->setCanCastShadow(true, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, true);
         processMaterials();
         canTryFade = true;
         _isAnimatingScale = true;
@@ -814,12 +816,18 @@ void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
         if (attachmentModel->isRenderable() && attachmentModel->needsFixupInScene()) {
             attachmentModel->removeFromScene(scene, transaction);
             attachmentModel->addToScene(scene, transaction);
-            attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, true);
+            attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, false);
+            attachmentModel->setCanCastShadow(true, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, false);
         }
     }
 
     if (_needMeshVisibleSwitch) {
         _skeletonModel->setVisibleInScene(_isMeshEnableVisible, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, true);
+        for (auto attachmentModel : _attachmentModels) {
+            if (attachmentModel->isRenderable()) {
+                attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene, render::ItemKey::TAG_BITS_0 | render::ItemKey::TAG_BITS_1, false);
+            }
+        }
         updateRenderItem(transaction);
         _needMeshVisibleSwitch = false;
     }

libraries/render-utils/src/MeshPartPayload.h

@@ -33,6 +33,7 @@ public:
     typedef Payload::DataPointer Pointer;
 
     virtual void updateKey(bool isVisible, bool isLayered, bool canCastShadow, uint8_t tagBits, bool isGroupCulled = false);
+    virtual void updateKey(const render::ItemKey& key);
 
     virtual void updateMeshPart(const std::shared_ptr<const graphics::Mesh>& drawMesh, int partIndex);
 
@@ -96,6 +97,7 @@ public:
     void notifyLocationChanged() override;
 
     void updateKey(bool isVisible, bool isLayered, bool canCastShadow, uint8_t tagBits, bool isGroupCulled = false) override;
+    void updateKey(const render::ItemKey& key) override;
 
     // matrix palette skinning
     void updateClusterBuffer(const std::vector<glm::mat4>& clusterMatrices);

libraries/render-utils/src/Model.cpp

@@ -103,11 +103,12 @@ Model::Model(QObject* parent, SpatiallyNestable* spatiallyNestableOverride) :
     _snapModelToRegistrationPoint(false),
     _snappedToRegistrationPoint(false),
     _url(HTTP_INVALID_COM),
-    _isVisible(true),
+  //  _isVisible(true),
-    _canCastShadow(false),
+   // _canCastShadow(false),
     _blendNumber(0),
     _appliedBlendNumber(0),
-    _isWireframe(false)
+    _isWireframe(false),
+    _renderItemsKey(render::ItemKey::Builder().withVisible().withTagBits(AllViews).build())
 {
     // we may have been created in the network thread, but we live in the main thread
     if (_viewState) {
@@ -270,7 +271,7 @@ void Model::updateRenderItems() {
         bool isWireframe = self->isWireframe();
         bool isVisible = self->isVisible();
         bool canCastShadow = self->canCastShadow();
-        uint8_t viewTagBits = self->getViewTagBits();
+        uint8_t viewTagBits = self->getViewVisibilityMask();
         bool isLayeredInFront = self->isLayeredInFront();
         bool isLayeredInHUD = self->isLayeredInHUD();
         bool isGroupCulled = self->isGroupCulled();
@@ -772,7 +773,7 @@ void Model::calculateTriangleSets(const FBXGeometry& geometry) {
         }
     }
 }
-
+/*
 void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewTagBits, bool isGroupCulled) {
     if (_isVisible != isVisible || _viewTagBits != viewTagBits || _isGroupCulled != isGroupCulled) {
         _isVisible = isVisible;
@@ -798,24 +799,41 @@ void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene,
         scene->enqueueTransaction(transaction);
     }
 }
+*/
 
-void Model::setCanCastShadow(bool canCastShadow, const render::ScenePointer& scene, uint8_t viewTagBits, bool isGroupCulled) {
+void Model::updateRenderItemsKey(const render::ScenePointer& scene) {
-    if (_canCastShadow != canCastShadow) {
+    auto renderItemsKey = _renderItemsKey;
-        _canCastShadow = canCastShadow;
-
-        bool isVisible = _isVisible;
-        bool isLayeredInFront = _isLayeredInFront;
-        bool isLayeredInHUD = _isLayeredInHUD;
-
     render::Transaction transaction;
-        foreach (auto item, _modelMeshRenderItemsMap.keys()) {
+    foreach(auto item, _modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, 
+        transaction.updateItem<ModelMeshPartPayload>(item, [renderItemsKey](ModelMeshPartPayload& data) {
-                [isVisible, viewTagBits, canCastShadow, isLayeredInFront, isLayeredInHUD, isGroupCulled](ModelMeshPartPayload& data) {
+            data.updateKey(renderItemsKey);
-                    data.updateKey(isVisible, viewTagBits, canCastShadow, isLayeredInFront || isLayeredInHUD, isGroupCulled);
+        });
+    }
+    foreach(auto item, _collisionRenderItemsMap.keys()) {
+        transaction.updateItem<ModelMeshPartPayload>(item, [renderItemsKey](ModelMeshPartPayload& data) {
+            data.updateKey(renderItemsKey);
         });
     }
-
     scene->enqueueTransaction(transaction);
+}
+
+void Model::setVisibleInScene(bool pisVisible, const render::ScenePointer& scene) {
+    if (isVisible() != pisVisible) {
+        auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
+        _renderItemsKey = (pisVisible ? keyBuilder.withVisible() : keyBuilder.withInvisible());
+        updateRenderItemsKey(scene);
+    }
+}
+
+bool Model::isVisible() const {
+    
+}
+
+void Model::setCanCastShadow(bool pcanCastShadow, const render::ScenePointer& scene) {
+    if (canCastShadow() != pcanCastShadow) {
+        auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
+        _renderItemsKey = (pcanCastShadow ? keyBuilder.withShadowCaster() : keyBuilder.withoutShadowCaster());
+        updateRenderItemsKey(scene);
     }
 }
 

libraries/render-utils/src/Model.h

@@ -87,13 +87,29 @@ public:
     const QUrl& getURL() const { return _url; }
 
     // new Scene/Engine rendering support
-    void setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewTagBits, bool isGroupCulled);
+    void setVisibleInScene(bool isVisible, const render::ScenePointer& scene);
+    bool isVisible() const;
 
-    bool canCastShadow() const { return _canCastShadow; }
+    enum ViewVisibilityMask : uint8_t {
-    void setCanCastShadow(bool canCastShadow, const render::ScenePointer& scene, uint8_t viewTagBits, bool isGroupCulled);
+        MainView = 0x01, //render::ItemKey::TAG_BITS_0,
+        SecondaryView = 0x02, //render::ItemKey::TAG_BITS_1,
+        AllViews = 0xFF, //render::ItemKey::TAG_BITS_ALL,
+    };
+    ViewVisibilityMask getViewVisibilityMask() const;
+    void setViewVisibilityMask(uint8_t mask, const render::ScenePointer& scene);
+
+    bool isGroupCulled() const;
+    void setGroupCulled(bool isGroupCulled);
+
+    bool canCastShadow() const;
+    void setCanCastShadow(bool canCastShadow, const render::ScenePointer& scene);
 
     void setLayeredInFront(bool isLayeredInFront, const render::ScenePointer& scene);
     void setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& scene);
+
+    bool isLayeredInFront() const;
+    bool isLayeredInHUD() const;
+
     bool needsFixupInScene() const;
 
     bool needsReload() const { return _needsReload; }
@@ -108,13 +124,7 @@ public:
     void removeFromScene(const render::ScenePointer& scene, render::Transaction& transaction);
     bool isRenderable() const;
 
-    bool isVisible() const { return _isVisible; }
+    void updateRenderItemsKey(const render::ScenePointer& scene);
-    uint8_t getViewTagBits() const { return _viewTagBits; }
-
-    bool isLayeredInFront() const { return _isLayeredInFront; }
-    bool isLayeredInHUD() const { return _isLayeredInHUD; }
-
-    bool isGroupCulled() const { return _isGroupCulled; }
 
     virtual void updateRenderItems();
     void setRenderItemsNeedUpdate();
@@ -404,10 +414,10 @@ protected:
     QVector<float> _blendshapeCoefficients;
 
     QUrl _url;
-    bool _isVisible;
+ //   bool _isVisible;
-    uint8_t _viewTagBits{ render::ItemKey::TAG_BITS_ALL };
+  //  uint8_t _viewTagBits{ render::ItemKey::TAG_BITS_ALL };
 
-    bool _canCastShadow;
+ //   bool _canCastShadow;
 
     gpu::Buffers _blendedVertexBuffers;
 
@@ -471,11 +481,12 @@ protected:
     int _renderInfoDrawCalls { 0 };
     int _renderInfoHasTransparent { false };
 
-    bool _isLayeredInFront { false };
+    render::ItemKey _renderItemsKey;
+ /*   bool _isLayeredInFront { false };
     bool _isLayeredInHUD { false };
 
     bool _isGroupCulled{ false };
-
+    */
     bool shouldInvalidatePayloadShapeKey(int meshIndex);
 
 private: