Cleaning the code

interface/src/avatar/MyAvatar.cpp

@@ -2061,8 +2061,8 @@ void MyAvatar::preDisplaySide(const 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) {
-                uint8_t modelRenderTagBits = shouldDrawHead ? render::ItemKey::TAG_BITS_0 : render::ItemKey::TAG_BITS_NONE;
+                uint8_t modelRenderTagBits = shouldDrawHead ? Model::MainView : Model::NoView;
-                modelRenderTagBits |= render::ItemKey::TAG_BITS_1;
+                modelRenderTagBits |= Model::SecondaryView;
 
                 _attachmentModels[i]->setViewMask(modelRenderTagBits);
                 _attachmentModels[i]->setGroupCulled(false);

interface/src/ui/overlays/ModelOverlay.cpp

@@ -103,12 +103,9 @@ void ModelOverlay::update(float deltatime) {
     if (_visibleDirty) {
         _visibleDirty = false;
         // don't show overlays in mirrors or spectator-cam unless _isVisibleInSecondaryCamera is true
-        _model->setViewMask((_isVisibleInSecondaryCamera ? render::ItemKey::TAG_BITS_1 : render::ItemKey::TAG_BITS_NONE), scene);
+        uint8_t modelRenderTagBits = Model::MainView  | (_isVisibleInSecondaryCamera ? Model::SecondaryView : Model::NoView);
+        _model->setViewMask(modelRenderTagBits, scene);
         _model->setVisibleInScene(getVisible(), scene);
-        /*,
-                                  render::ItemKey::TAG_BITS_0 |
-                                  (_isVisibleInSecondaryCamera ? render::ItemKey::TAG_BITS_1 : render::ItemKey::TAG_BITS_NONE),
-                                  false);*/
     }
     if (_drawInFrontDirty) {
         _drawInFrontDirty = false;

interface/src/ui/overlays/Overlay.h

@@ -132,7 +132,6 @@ private:
 namespace render {
    template <> const ItemKey payloadGetKey(const Overlay::Pointer& overlay);
    template <> const Item::Bound payloadGetBound(const Overlay::Pointer& overlay);
-   template <> int payloadGetLayer(const Overlay::Pointer& overlay);
    template <> void payloadRender(const Overlay::Pointer& overlay, RenderArgs* args);
    template <> const ShapeKey shapeGetShapeKey(const Overlay::Pointer& overlay);
    template <> uint32_t metaFetchMetaSubItems(const Overlay::Pointer& overlay, ItemIDs& subItems);

interface/src/ui/overlays/OverlaysPayload.cpp

@@ -64,20 +64,6 @@ namespace render {
     template <> const Item::Bound payloadGetBound(const Overlay::Pointer& overlay) {
         return overlay->getBounds();
     }
-    template <> int payloadGetLayer(const Overlay::Pointer& overlay) {
-        if (overlay->is3D()) {
-            auto overlay3D = std::dynamic_pointer_cast<Base3DOverlay>(overlay);
-            if (overlay3D->getDrawInFront()) {
-                return Item::LAYER_3D_FRONT;
-            } else if (overlay3D->getDrawHUDLayer()) {
-                return Item::LAYER_3D_HUD;
-            } else {
-                return Item::LAYER_3D;
-            }
-        } else {
-            return Item::LAYER_2D;
-        }
-    }
     template <> void payloadRender(const Overlay::Pointer& overlay, RenderArgs* args) {
         if (args) {
             overlay->render(args);
@@ -87,7 +73,6 @@ namespace render {
         return overlay->getShapeKey();
     }
 
-
     template <> uint32_t metaFetchMetaSubItems(const Overlay::Pointer& overlay, ItemIDs& subItems) {
         return overlay->fetchMetaSubItems(subItems);
     }

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

@@ -597,7 +597,7 @@ void Avatar::addToScene(AvatarSharedPointer self, const render::ScenePointer& sc
     for (auto& attachmentModel : _attachmentModels) {
         attachmentModel->addToScene(scene, transaction);
         attachmentModel->setViewMask(Model::AllViews);
-        attachmentModel->setGroupCulled(true);
+        attachmentModel->setGroupCulled(false);
         attachmentModel->setCanCastShadow(true);
         attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene);
     }
@@ -827,7 +827,7 @@ void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
             attachmentModel->addToScene(scene, transaction);
 
             attachmentModel->setViewMask(Model::AllViews);
-            attachmentModel->setGroupCulled(true);
+            attachmentModel->setGroupCulled(false);
             attachmentModel->setCanCastShadow(true);
             attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene);
         }

libraries/render-utils/src/Model.cpp

@@ -103,12 +103,10 @@ Model::Model(QObject* parent, SpatiallyNestable* spatiallyNestableOverride) :
     _snapModelToRegistrationPoint(false),
     _snappedToRegistrationPoint(false),
     _url(HTTP_INVALID_COM),
-  //  _isVisible(true),
-   // _canCastShadow(false),
     _blendNumber(0),
     _appliedBlendNumber(0),
     _isWireframe(false),
-    _renderItemsKey(render::ItemKey::Builder().withVisible().withTagBits(AllViews).build())
+    _renderItemKeyGlobalFlags(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) {
@@ -269,12 +267,7 @@ void Model::updateRenderItems() {
         modelTransform.setScale(glm::vec3(1.0f));
 
         bool isWireframe = self->isWireframe();
-        bool isVisible = self->isVisible();
+        auto renderItemKeyGlobalFlags = self->getRenderItemKeyGlobalFlags();
-        bool canCastShadow = self->canCastShadow();
-        uint8_t viewTagBits = self->getViewMask();
-        bool isLayeredInFront = self->isLayeredInFront();
-        bool isLayeredInHUD = self->isLayeredInHUD();
-        bool isGroupCulled = self->isGroupCulled();
 
         render::Transaction transaction;
         for (int i = 0; i < (int) self->_modelMeshRenderItemIDs.size(); i++) {
@@ -288,9 +281,7 @@ void Model::updateRenderItems() {
             bool useDualQuaternionSkinning = self->getUseDualQuaternionSkinning();
 
             transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, meshState, useDualQuaternionSkinning,
-                                                                  invalidatePayloadShapeKey, isWireframe, isVisible,
+                                                                  invalidatePayloadShapeKey, isWireframe, renderItemKeyGlobalFlags](ModelMeshPartPayload& data) {
-                                                                  canCastShadow, viewTagBits, isLayeredInFront,
-                                                                  isLayeredInHUD, isGroupCulled](ModelMeshPartPayload& data) {
                 if (useDualQuaternionSkinning) {
                     data.updateClusterBuffer(meshState.clusterDualQuaternions);
                 } else {
@@ -314,8 +305,7 @@ void Model::updateRenderItems() {
                 }
                 data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
 
-                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, canCastShadow, viewTagBits, isGroupCulled);
+                data.updateKey(renderItemKeyGlobalFlags);
-             //   data.setLayer(isLayeredInFront, isLayeredInHUD);
                 data.setShapeKey(invalidatePayloadShapeKey, isWireframe, useDualQuaternionSkinning);
             });
         }
@@ -323,8 +313,9 @@ void Model::updateRenderItems() {
         Transform collisionMeshOffset;
         collisionMeshOffset.setIdentity();
         foreach(auto itemID, self->_collisionRenderItemsMap.keys()) {
-            transaction.updateItem<MeshPartPayload>(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) {
+            transaction.updateItem<MeshPartPayload>(itemID, [renderItemKeyGlobalFlags, modelTransform, collisionMeshOffset](MeshPartPayload& data) {
                 // update the model transform for this render item.
+                data.updateKey(renderItemKeyGlobalFlags);
                 data.updateTransform(modelTransform, collisionMeshOffset);
             });
         }
@@ -773,40 +764,13 @@ 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;
-        _viewTagBits = viewTagBits;
-        _isGroupCulled = isGroupCulled;
-
-        bool isLayeredInFront = _isLayeredInFront;
-        bool isLayeredInHUD = _isLayeredInHUD;
-        bool canCastShadow = _canCastShadow;
-        render::Transaction transaction;
-        foreach (auto item, _modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront, canCastShadow,
-                                                                isLayeredInHUD, isGroupCulled](ModelMeshPartPayload& data) {
-                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, canCastShadow, viewTagBits, isGroupCulled);
-            });
-        }
-        foreach(auto item, _collisionRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront, canCastShadow,
-                                                                isLayeredInHUD, isGroupCulled](ModelMeshPartPayload& data) {
-                data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, canCastShadow, viewTagBits, isGroupCulled);
-            });
-        }
-        scene->enqueueTransaction(transaction);
-    }
-}
-*/
 
 void Model::updateRenderItemsKey(const render::ScenePointer& scene) {
     if (!scene) {
         _needsFixupInScene = true;
         return;
     }
-    auto renderItemsKey = _renderItemsKey;
+    auto renderItemsKey = _renderItemKeyGlobalFlags;
     render::Transaction transaction;
     foreach(auto item, _modelMeshRenderItemsMap.keys()) {
         transaction.updateItem<ModelMeshPartPayload>(item, [renderItemsKey](ModelMeshPartPayload& data) {
@@ -823,72 +787,76 @@ void Model::updateRenderItemsKey(const render::ScenePointer& scene) {
 
 void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene) {
     if (Model::isVisible() != isVisible) {
-        auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
+        auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemsKey = (isVisible ? keyBuilder.withVisible() : keyBuilder.withInvisible());
+        _renderItemKeyGlobalFlags = (isVisible ? keyBuilder.withVisible() : keyBuilder.withInvisible());
         updateRenderItemsKey(scene);
     }
 }
 
 bool Model::isVisible() const {
-    return _renderItemsKey.isVisible();
+    return _renderItemKeyGlobalFlags.isVisible();
 }
 
 void Model::setCanCastShadow(bool canCastShadow, const render::ScenePointer& scene) {
     if (Model::canCastShadow() != canCastShadow) {
-        auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
+        auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemsKey = (canCastShadow ? keyBuilder.withShadowCaster() : keyBuilder.withoutShadowCaster());
+        _renderItemKeyGlobalFlags = (canCastShadow ? keyBuilder.withShadowCaster() : keyBuilder.withoutShadowCaster());
         updateRenderItemsKey(scene);
     }
 }
 
 bool Model::canCastShadow() const {
-    return _renderItemsKey.isShadowCaster();
+    return _renderItemKeyGlobalFlags.isShadowCaster();
 }
 
 void Model::setLayeredInFront(bool isLayeredInFront, const render::ScenePointer& scene) {
     if (Model::isLayeredInFront() != isLayeredInFront) {
-        auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
+        auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemsKey = (isLayeredInFront ? keyBuilder.withLayer(render::Item::LAYER_3D_FRONT) : keyBuilder.withoutLayer());
+        _renderItemKeyGlobalFlags = (isLayeredInFront ? keyBuilder.withLayer(render::Item::LAYER_3D_FRONT) : keyBuilder.withoutLayer());
         updateRenderItemsKey(scene);
     }
 }
 
 bool Model::isLayeredInFront() const {
-    return _renderItemsKey.isLayer(render::Item::LAYER_3D_FRONT);
+    return _renderItemKeyGlobalFlags.isLayer(render::Item::LAYER_3D_FRONT);
 }
 
 void Model::setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& scene) {
     if (Model::isLayeredInHUD() != isLayeredInHUD) {
-        auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
+        auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemsKey = (isLayeredInHUD ? keyBuilder.withLayer(render::Item::LAYER_3D_HUD) : keyBuilder.withoutLayer());
+        _renderItemKeyGlobalFlags = (isLayeredInHUD ? keyBuilder.withLayer(render::Item::LAYER_3D_HUD) : keyBuilder.withoutLayer());
         updateRenderItemsKey(scene);
     }
 }
 
 bool Model::isLayeredInHUD() const {
-    return _renderItemsKey.isLayer(render::Item::LAYER_3D_HUD);
+    return _renderItemKeyGlobalFlags.isLayer(render::Item::LAYER_3D_HUD);
 }
 
 void Model::setViewMask(uint8_t mask, const render::ScenePointer& scene) {
     if (Model::getViewMask() != mask) {
-        auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
+        auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemsKey = keyBuilder.withTagBits(mask);
+        _renderItemKeyGlobalFlags = keyBuilder.withTagBits(mask);
         updateRenderItemsKey(scene);
     }
 }
 Model::ViewMask Model::getViewMask() const {
-    return (Model::ViewMask) _renderItemsKey.getTagBits();
+    return (Model::ViewMask) _renderItemKeyGlobalFlags.getTagBits();
 }
 
 void Model::setGroupCulled(bool isGroupCulled, const render::ScenePointer& scene) {
     if (Model::isGroupCulled() != isGroupCulled) {
-        auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
+        auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemsKey = (isGroupCulled ? keyBuilder.withSubMetaCulled() : keyBuilder.withoutSubMetaCulled());
+        _renderItemKeyGlobalFlags = (isGroupCulled ? keyBuilder.withSubMetaCulled() : keyBuilder.withoutSubMetaCulled());
         updateRenderItemsKey(scene);
     }
 }
 bool Model::isGroupCulled() const {
-    return _renderItemsKey.isSubMetaCulled();
+    return _renderItemKeyGlobalFlags.isSubMetaCulled();
+}
+
+const render::ItemKey Model::getRenderItemKeyGlobalFlags() const {
+    return _renderItemKeyGlobalFlags;
 }
 
 bool Model::addToScene(const render::ScenePointer& scene,
@@ -1690,7 +1658,7 @@ void Model::addMaterial(graphics::MaterialLayer material, const std::string& par
     for (auto shapeID : shapeIDs) {
         if (shapeID < _modelMeshRenderItemIDs.size()) {
             auto itemID = _modelMeshRenderItemIDs[shapeID];
-            auto renderItemsKey = _renderItemsKey;
+            auto renderItemsKey = _renderItemKeyGlobalFlags;
             bool wireframe = isWireframe();
             auto meshIndex = _modelMeshRenderItemShapes[shapeID].meshIndex;
             bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKey(meshIndex);
@@ -1714,7 +1682,7 @@ void Model::removeMaterial(graphics::MaterialPointer material, const std::string
         if (shapeID < _modelMeshRenderItemIDs.size()) {
             auto itemID = _modelMeshRenderItemIDs[shapeID];
             bool visible = isVisible();
-            auto renderItemsKey = _renderItemsKey;
+            auto renderItemsKey = _renderItemKeyGlobalFlags;
             bool wireframe = isWireframe();
             auto meshIndex = _modelMeshRenderItemShapes[shapeID].meshIndex;
             bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKey(meshIndex);

libraries/render-utils/src/Model.h

@@ -91,6 +91,7 @@ public:
     bool isVisible() const;
 
     enum ViewMask : uint8_t {
+        NoView = 0x00, // Not drawn at all
         MainView = 0x01, //render::ItemKey::TAG_BITS_0,
         SecondaryView = 0x02, //render::ItemKey::TAG_BITS_1,
         AllViews = 0xFF, //render::ItemKey::TAG_BITS_ALL,
@@ -110,6 +111,9 @@ public:
     bool isLayeredInFront() const;
     bool isLayeredInHUD() const;
 
+    // Access the current RenderItemKey Global Flags used by the model and applied to the render items  representing the parts of the model.
+    const render::ItemKey getRenderItemKeyGlobalFlags() const;
+
     bool needsFixupInScene() const;
 
     bool needsReload() const { return _needsReload; }
@@ -414,10 +418,6 @@ protected:
     QVector<float> _blendshapeCoefficients;
 
     QUrl _url;
- //   bool _isVisible;
-  //  uint8_t _viewTagBits{ render::ItemKey::TAG_BITS_ALL };
-
- //   bool _canCastShadow;
 
     gpu::Buffers _blendedVertexBuffers;
 
@@ -481,12 +481,17 @@ protected:
     int _renderInfoDrawCalls { 0 };
     int _renderInfoHasTransparent { false };
 
-    render::ItemKey _renderItemsKey;
+    // This Render ItemKey Global Flags capture the Model wide global set of flags that should be communicated to all the render items representing the Model.
- /*   bool _isLayeredInFront { false };
+    // The flags concerned are:
-    bool _isLayeredInHUD { false };
+    //  - isVisible: if true the Model is visible globally in the scene, regardless of the other flags in the item keys (tags or layer or shadow caster).
+    //  - TagBits: the view mask defined through the TagBits telling in which view the Model is rendered if visible.
+    //  - Layer: In which Layer this Model lives.
+    //  - CastShadow: if true and visible and rendered in the view, the Model cast shadows if in a Light volume casting shadows.
+    //  - CullGroup: if true, the render items representing the parts of the Model are culled by a single Meta render item that knows about them, they are not culled individually.
+    //               For this to work, a Meta RI must exists and knows about the RIs of this Model.
+    //  
+    render::ItemKey _renderItemKeyGlobalFlags;
 
-    bool _isGroupCulled{ false };
-    */
     bool shouldInvalidatePayloadShapeKey(int meshIndex);
 
 private:

libraries/render/src/render/Item.cpp

@@ -49,7 +49,6 @@ 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;
 
 // Layer bits are derived from the Layer enum, the number of bits needed to represent integer 0 to NUM_LAYERS
-//const uint8_t ItemKey::NUM_LAYER_BITS { 3 };
 const uint8_t ItemKey::LAYER_BITS_ALL { 0x07 };
 
 const uint32_t ItemKey::KEY_LAYER_BITS_MASK = ((uint32_t)ItemKey::LAYER_BITS_ALL) << FIRST_LAYER_BIT;

libraries/render/src/render/Item.h

@@ -67,11 +67,10 @@ public:
     const static uint8_t TAG_BITS_7;
 
     // Items are organized in layers, an item belongs to one of the 8 Layers available.
-    // By default an item is in the 'LAYER_NONE' meaning that it is NOT layered.
+    // By default an item is in the 'LAYER_DEFAULT' meaning that it is NOT layered.
-    // Which is equivalent to say that LAYER_NONE, is the default Layer.
     // THere is NO ordering relationship between layers.
     enum Layer : uint8_t {
-        LAYER_NONE = 0, // layer 0 is a 'NOT' layer, items are not considered layered, this is the default value
+        LAYER_DEFAULT = 0, // layer 0 aka Default is a 'NOT' layer, items are not considered layered, this is the default value
         LAYER_1,
         LAYER_2,
         LAYER_3,
@@ -164,7 +163,7 @@ public:
         Builder& withTagBits(uint8_t tagBits) { _flags = evalTagBitsWithKeyBits(tagBits, _flags.to_ulong()); return (*this); }
 
         Builder& withLayer(uint8_t layer) { _flags = evalLayerBitsWithKeyBits(layer, _flags.to_ulong()); return (*this); }
-        Builder& withoutLayer() { return withLayer(LAYER_NONE); }
+        Builder& withoutLayer() { return withLayer(LAYER_DEFAULT); }
 
         // Convenient standard keys that we will keep on using all over the place
         static Builder opaqueShape() { return Builder().withTypeShape(); }
@@ -206,7 +205,7 @@ public:
 
     uint8_t getLayer() const { return ((_flags.to_ulong() & KEY_LAYER_BITS_MASK) >> FIRST_LAYER_BIT); }
     bool isLayer(uint8_t layer) const { return getLayer() == layer; }
-    bool isLayered() const { return getLayer() != LAYER_NONE; }
+    bool isLayered() const { return getLayer() != LAYER_DEFAULT; }
     bool isSpatial() const { return !isLayered(); }
 
     // Probably not public, flags used by the scene
@@ -277,7 +276,7 @@ public:
         // 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& withoutLayered() { _value = ItemKey::evalLayerBitsWithKeyBits(ItemKey::LAYER_NONE, _value.to_ulong()); _mask |= ItemKey::KEY_LAYER_BITS_MASK; return (*this); }
+        Builder& withoutLayered() { _value = ItemKey::evalLayerBitsWithKeyBits(ItemKey::LAYER_DEFAULT, _value.to_ulong()); _mask |= ItemKey::KEY_LAYER_BITS_MASK; return (*this); }
         Builder& withLayer(uint8_t layer) { _value = ItemKey::evalLayerBitsWithKeyBits(layer, _value.to_ulong()); _mask |= ItemKey::KEY_LAYER_BITS_MASK; return (*this); }
 
         Builder& withNothing()          { _value.reset(); _mask.reset(); return (*this); }
@@ -458,12 +457,11 @@ public:
     // Get the bound of the item expressed in world space (or eye space depending on the key.isWorldSpace())
     const Bound getBound() const { return _payload->getBound(); }
 
-    // Get the layer where the item belongs.
+    // Get the layer where the item belongs, simply reflecting the key.
- //   int getLayer() const { return _payload->getLayer(); }
     int getLayer() const { return _key.getLayer(); }
 
     static const uint8_t LAYER_2D{ ItemKey::LAYER_1 };
-    static const uint8_t LAYER_3D{ ItemKey::LAYER_NONE };
+    static const uint8_t LAYER_3D{ ItemKey::LAYER_DEFAULT };
     static const uint8_t LAYER_3D_FRONT{ ItemKey::LAYER_2 };
     static const uint8_t LAYER_3D_HUD{ ItemKey::LAYER_3 };
 
@@ -515,7 +513,6 @@ inline QDebug operator<<(QDebug debug, const Item& item) {
 // Item shared interface supported by the payload
 template <class T> const ItemKey payloadGetKey(const std::shared_ptr<T>& payloadData) { return ItemKey(); }
 template <class T> const Item::Bound payloadGetBound(const std::shared_ptr<T>& payloadData) { return Item::Bound(); }
-template <class T> int payloadGetLayer(const std::shared_ptr<T>& payloadData) { return 0; }
 template <class T> void payloadRender(const std::shared_ptr<T>& payloadData, RenderArgs* args) { }
 
 // Shape type interface
@@ -542,7 +539,6 @@ public:
     // Payload general interface
     virtual const ItemKey getKey() const override { return payloadGetKey<T>(_data); }
     virtual const Item::Bound getBound() const override { return payloadGetBound<T>(_data); }
- //   virtual int getLayer() const override { return payloadGetLayer<T>(_data); }
 
     virtual void render(RenderArgs* args) override { payloadRender<T>(_data, args); }