From 873cabe2848bbbecb17525f8791bb90265205017 Mon Sep 17 00:00:00 2001 From: samcake Date: Tue, 29 May 2018 17:46:25 -0700 Subject: [PATCH] Cleaning the code --- interface/src/avatar/MyAvatar.cpp | 4 +- interface/src/ui/overlays/ModelOverlay.cpp | 7 +- interface/src/ui/overlays/Overlay.h | 1 - interface/src/ui/overlays/OverlaysPayload.cpp | 15 --- .../src/avatars-renderer/Avatar.cpp | 4 +- libraries/render-utils/src/Model.cpp | 94 ++++++------------- libraries/render-utils/src/Model.h | 23 +++-- libraries/render/src/render/Item.cpp | 1 - libraries/render/src/render/Item.h | 18 ++-- 9 files changed, 58 insertions(+), 109 deletions(-) diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp index b89e3e6387..4306e9c76c 100755 --- a/interface/src/avatar/MyAvatar.cpp +++ b/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; - modelRenderTagBits |= render::ItemKey::TAG_BITS_1; + uint8_t modelRenderTagBits = shouldDrawHead ? Model::MainView : Model::NoView; + modelRenderTagBits |= Model::SecondaryView; _attachmentModels[i]->setViewMask(modelRenderTagBits); _attachmentModels[i]->setGroupCulled(false); diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp index cb66828dc5..cc40993480 100644 --- a/interface/src/ui/overlays/ModelOverlay.cpp +++ b/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; diff --git a/interface/src/ui/overlays/Overlay.h b/interface/src/ui/overlays/Overlay.h index 2f27d50f7e..890d5178e5 100644 --- a/interface/src/ui/overlays/Overlay.h +++ b/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); diff --git a/interface/src/ui/overlays/OverlaysPayload.cpp b/interface/src/ui/overlays/OverlaysPayload.cpp index 1a79c54ac2..4bb03a5669 100644 --- a/interface/src/ui/overlays/OverlaysPayload.cpp +++ b/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(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); } diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp index 2d675088f7..d23c583cda 100644 --- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp +++ b/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); } diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp index d5a0f243b0..284d9c8e26 100644 --- a/libraries/render-utils/src/Model.cpp +++ b/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(); - bool canCastShadow = self->canCastShadow(); - uint8_t viewTagBits = self->getViewMask(); - bool isLayeredInFront = self->isLayeredInFront(); - bool isLayeredInHUD = self->isLayeredInHUD(); - bool isGroupCulled = self->isGroupCulled(); + auto renderItemKeyGlobalFlags = self->getRenderItemKeyGlobalFlags(); 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(itemID, [modelTransform, meshState, useDualQuaternionSkinning, - invalidatePayloadShapeKey, isWireframe, isVisible, - canCastShadow, viewTagBits, isLayeredInFront, - isLayeredInHUD, isGroupCulled](ModelMeshPartPayload& data) { + invalidatePayloadShapeKey, isWireframe, renderItemKeyGlobalFlags](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.setLayer(isLayeredInFront, isLayeredInHUD); + data.updateKey(renderItemKeyGlobalFlags); data.setShapeKey(invalidatePayloadShapeKey, isWireframe, useDualQuaternionSkinning); }); } @@ -323,8 +313,9 @@ void Model::updateRenderItems() { Transform collisionMeshOffset; collisionMeshOffset.setIdentity(); foreach(auto itemID, self->_collisionRenderItemsMap.keys()) { - transaction.updateItem(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) { + transaction.updateItem(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(item, [isVisible, viewTagBits, isLayeredInFront, canCastShadow, - isLayeredInHUD, isGroupCulled](ModelMeshPartPayload& data) { - data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, canCastShadow, viewTagBits, isGroupCulled); - }); - } - foreach(auto item, _collisionRenderItemsMap.keys()) { - transaction.updateItem(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(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); - _renderItemsKey = (isVisible ? keyBuilder.withVisible() : keyBuilder.withInvisible()); + auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags); + _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); - _renderItemsKey = (canCastShadow ? keyBuilder.withShadowCaster() : keyBuilder.withoutShadowCaster()); + auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags); + _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); - _renderItemsKey = (isLayeredInFront ? keyBuilder.withLayer(render::Item::LAYER_3D_FRONT) : keyBuilder.withoutLayer()); + auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags); + _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); - _renderItemsKey = (isLayeredInHUD ? keyBuilder.withLayer(render::Item::LAYER_3D_HUD) : keyBuilder.withoutLayer()); + auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags); + _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); - _renderItemsKey = keyBuilder.withTagBits(mask); + auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags); + _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); - _renderItemsKey = (isGroupCulled ? keyBuilder.withSubMetaCulled() : keyBuilder.withoutSubMetaCulled()); + auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags); + _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); diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h index fb72f3bf23..cefd760f61 100644 --- a/libraries/render-utils/src/Model.h +++ b/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 _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; - /* bool _isLayeredInFront { false }; - bool _isLayeredInHUD { false }; + // 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. + // The flags concerned are: + // - 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: diff --git a/libraries/render/src/render/Item.cpp b/libraries/render/src/render/Item.cpp index 95cb3c9aed..8ea0474d16 100644 --- a/libraries/render/src/render/Item.cpp +++ b/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; diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h index 6353dca1a3..27aee5e981 100644 --- a/libraries/render/src/render/Item.h +++ b/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. - // Which is equivalent to say that LAYER_NONE, is the default Layer. + // By default an item is in the 'LAYER_DEFAULT' meaning that it is NOT layered. // 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. - // int getLayer() const { return _payload->getLayer(); } + // Get the layer where the item belongs, simply reflecting the key. 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 const ItemKey payloadGetKey(const std::shared_ptr& payloadData) { return ItemKey(); } template const Item::Bound payloadGetBound(const std::shared_ptr& payloadData) { return Item::Bound(); } -template int payloadGetLayer(const std::shared_ptr& payloadData) { return 0; } template void payloadRender(const std::shared_ptr& payloadData, RenderArgs* args) { } // Shape type interface @@ -542,7 +539,6 @@ public: // Payload general interface virtual const ItemKey getKey() const override { return payloadGetKey(_data); } virtual const Item::Bound getBound() const override { return payloadGetBound(_data); } - // virtual int getLayer() const override { return payloadGetLayer(_data); } virtual void render(RenderArgs* args) override { payloadRender(_data, args); }