INtroduce RenderConstants header file to define the alias names for Tag and Layer for Hifi REnder Engine

interface/src/avatar/MyAvatar.cpp

@@ -1126,14 +1126,6 @@ void MyAvatar::setEnableDebugDrawIKChains(bool isEnabled) {
     _enableDebugDrawIKChains = isEnabled;
 }
 
-bool MyAvatar::getEnableMeshVisible() const {
-    return Avatar::getEnableMeshVisible();
-}
-
-void MyAvatar::setEnableMeshVisible(bool isEnabled) {
-    Avatar::setEnableMeshVisible(isEnabled);
-}
-
 void MyAvatar::setEnableInverseKinematics(bool isEnabled) {
     _skeletonModel->getRig().setEnableInverseKinematics(isEnabled);
 }
@@ -1483,7 +1475,7 @@ void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
     _skeletonModelChangeCount++;
     int skeletonModelChangeCount = _skeletonModelChangeCount;
     Avatar::setSkeletonModelURL(skeletonModelURL);
-    _skeletonModel->setViewMask(Model::NoView);
+    _skeletonModel->setTagMask(Render::TAG_NONE);
     _skeletonModel->setGroupCulled(true);
     _skeletonModel->setVisibleInScene(true, qApp->getMain3DScene());
 
@@ -2061,10 +2053,9 @@ 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 ? Model::MainView : Model::NoView;
+                uint8_t modelRenderTagBits = shouldDrawHead ? Render::TAG_ALL_VIEWS : Render::TAG_SECONDARY_VIEW;
-                modelRenderTagBits |= Model::SecondaryView;
 
-                _attachmentModels[i]->setViewMask(modelRenderTagBits);
+                _attachmentModels[i]->setTagMask(modelRenderTagBits);
                 _attachmentModels[i]->setGroupCulled(false);
                 _attachmentModels[i]->setCanCastShadow(true);
                 _attachmentModels[i]->setVisibleInScene(true, qApp->getMain3DScene());

interface/src/avatar/MyAvatar.h

@@ -1159,7 +1159,6 @@ public slots:
      * @function MyAvatar.getEnableMeshVisible
      * @returns {boolean} <code>true</code> if your avatar's mesh is visible, otherwise <code>false</code>.
      */
-    bool getEnableMeshVisible() const override;
 
     /**jsdoc
      * Set whether or not your avatar mesh is visible.
@@ -1171,7 +1170,6 @@ public slots:
      *     MyAvatar.setEnableMeshVisible(true);
      * }, 10000);
      */
-    void setEnableMeshVisible(bool isEnabled) override;
 
     /**jsdoc
      * @function MyAvatar.setEnableInverseKinematics

interface/src/ui/overlays/ModelOverlay.cpp

@@ -103,8 +103,8 @@ void ModelOverlay::update(float deltatime) {
     if (_visibleDirty) {
         _visibleDirty = false;
         // don't show overlays in mirrors or spectator-cam unless _isVisibleInSecondaryCamera is true
-        uint8_t modelRenderTagBits = Model::MainView  | (_isVisibleInSecondaryCamera ? Model::SecondaryView : Model::NoView);
+        uint8_t modelRenderTagMak = (_isVisibleInSecondaryCamera ? Render::TAG_ALL_VIEWS : Render::TAG_MAIN_VIEW);
-        _model->setViewMask(modelRenderTagBits, scene);
+        _model->setTagMask(modelRenderTagMak, scene);
         _model->setVisibleInScene(getVisible(), scene);
     }
     if (_drawInFrontDirty) {

interface/src/ui/overlays/OverlaysPayload.cpp

@@ -36,9 +36,9 @@ namespace render {
         if (overlay->is3D()) {
             auto overlay3D = std::static_pointer_cast<Base3DOverlay>(overlay);
             if (overlay3D->getDrawInFront()) {
-                builder.withLayer(render::Item::LAYER_3D_FRONT);
+                builder.withLayer(Render::LAYER_3D_FRONT);
             } else if (overlay3D->getDrawHUDLayer()) {
-                builder.withLayer(render::Item::LAYER_3D_HUD);
+                builder.withLayer(Render::LAYER_3D_HUD);
             }
 
             if (overlay->isTransparent()) {
@@ -46,7 +46,7 @@ namespace render {
             }
         } else {
             builder.withViewSpace();
-            builder.withLayer(render::Item::LAYER_2D);
+            builder.withLayer(Render::LAYER_2D);
         }
 
         if (!overlay->getVisible()) {
@@ -54,8 +54,8 @@ namespace render {
         }
 
         // always visible in primary view.  if isVisibleInSecondaryCamera, also draw in secondary view
-        uint32_t viewTaskBits = render::ItemKey::TAG_BITS_0 |
+        uint32_t viewTaskBits = Render::TAG_MAIN_VIEW |
-            (overlay->getIsVisibleInSecondaryCamera() ? render::ItemKey::TAG_BITS_1 : render::ItemKey::TAG_BITS_NONE);
+            (overlay->getIsVisibleInSecondaryCamera() ? Render::TAG_SECONDARY_VIEW : Render::TAG_NONE);
 
         builder.withTagBits(viewTaskBits);
 

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

@@ -52,9 +52,8 @@ const glm::vec3 HAND_TO_PALM_OFFSET(0.0f, 0.12f, 0.08f);
 
 namespace render {
     template <> const ItemKey payloadGetKey(const AvatarSharedPointer& avatar) {
-        ItemKey::Builder keyBuilder = ItemKey::Builder::opaqueShape().withTypeMeta().withTagBits(Model::AllViews).withMetaCullGroup();
+        ItemKey::Builder keyBuilder = ItemKey::Builder::opaqueShape().withTypeMeta().withTagBits(Render::TAG_ALL_VIEWS).withMetaCullGroup();
         auto avatarPtr = static_pointer_cast<Avatar>(avatar);
-        auto model = avatarPtr->getSkeletonModel();
         if (!avatarPtr->getEnableMeshVisible()) {
             keyBuilder.withInvisible();
         }
@@ -588,18 +587,18 @@ void Avatar::addToScene(AvatarSharedPointer self, const render::ScenePointer& sc
     _renderBound = getBounds();
     transaction.resetItem(_renderItemID, avatarPayloadPointer);
     _skeletonModel->addToScene(scene, transaction);
-    _skeletonModel->setViewMask(Model::AllViews);
+    _skeletonModel->setTagMask(Render::TAG_ALL_VIEWS);
     _skeletonModel->setGroupCulled(true);
     _skeletonModel->setCanCastShadow(true);
-    _skeletonModel->setVisibleInScene(_isMeshEnableVisible, scene);
+    _skeletonModel->setVisibleInScene(_isMeshVisible, scene);
 
     processMaterials();
     for (auto& attachmentModel : _attachmentModels) {
         attachmentModel->addToScene(scene, transaction);
-        attachmentModel->setViewMask(Model::AllViews);
+        attachmentModel->setTagMask(Render::TAG_ALL_VIEWS);
         attachmentModel->setGroupCulled(false);
         attachmentModel->setCanCastShadow(true);
-        attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene);
+        attachmentModel->setVisibleInScene(_isMeshVisible, scene);
     }
 
     _mustFadeIn = true;
@@ -790,14 +789,14 @@ void Avatar::render(RenderArgs* renderArgs) {
 
 
 void Avatar::setEnableMeshVisible(bool isEnabled) {
-    if (_isMeshEnableVisible != isEnabled) {
+    if (_isMeshVisible != isEnabled) {
-        _isMeshEnableVisible = isEnabled;
+        _isMeshVisible = isEnabled;
         _needMeshVisibleSwitch = true;
     }
 }
 
 bool Avatar::getEnableMeshVisible() const {
-    return _isMeshEnableVisible;
+    return _isMeshVisible;
 }
 
 void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
@@ -812,10 +811,10 @@ void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
         _skeletonModel->removeFromScene(scene, transaction);
         _skeletonModel->addToScene(scene, transaction);
 
-        _skeletonModel->setViewMask(Model::AllViews);
+        _skeletonModel->setTagMask(Render::TAG_ALL_VIEWS);
         _skeletonModel->setGroupCulled(true);
         _skeletonModel->setCanCastShadow(true);
-        _skeletonModel->setVisibleInScene(_isMeshEnableVisible, scene);
+        _skeletonModel->setVisibleInScene(_isMeshVisible, scene);
 
         processMaterials();
         canTryFade = true;
@@ -826,18 +825,18 @@ void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
             attachmentModel->removeFromScene(scene, transaction);
             attachmentModel->addToScene(scene, transaction);
 
-            attachmentModel->setViewMask(Model::AllViews);
+            attachmentModel->setTagMask(Render::TAG_ALL_VIEWS);
             attachmentModel->setGroupCulled(false);
             attachmentModel->setCanCastShadow(true);
-            attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene);
+            attachmentModel->setVisibleInScene(_isMeshVisible, scene);
         }
     }
 
     if (_needMeshVisibleSwitch) {
-        _skeletonModel->setVisibleInScene(_isMeshEnableVisible, scene);
+        _skeletonModel->setVisibleInScene(_isMeshVisible, scene);
         for (auto attachmentModel : _attachmentModels) {
             if (attachmentModel->isRenderable()) {
-                attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene);
+                attachmentModel->setVisibleInScene(_isMeshVisible, scene);
             }
         }
         updateRenderItem(transaction);

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

@@ -538,7 +538,7 @@ protected:
     void processMaterials();
 
     AABox _renderBound;
-    bool _isMeshEnableVisible{ true };
+    bool _isMeshVisible{ true };
     bool _needMeshVisibleSwitch{ true };
 };
 

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -1387,9 +1387,9 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
     entity->stopModelOverrideIfNoParent();
 
     // Default behavior for model is to not be visible in main view if cauterized (aka parented to the avatar's neck joint)
-    auto viewMask = _cauterized ?
+    auto tagMask = _cauterized ?
-        Model::SecondaryView : // draw in every view except the main one (view zero)
+        Render::TAG_SECONDARY_VIEW : // draw in every view except the main one (view zero)
-        Model::AllViews; // draw in all views
+        Render::TAG_ALL_VIEWS; // draw in all views
 
     if (model->isVisible() != _visible) {
         // FIXME: this seems like it could be optimized if we tracked our last known visible state in
@@ -1398,8 +1398,8 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
         model->setVisibleInScene(_visible, scene);
     }
 
-    if (model->getViewMask() != viewMask) {
+    if (model->getTagMask() != tagMask) {
-        model->setViewMask(viewMask, scene);
+        model->setTagMask(tagMask, scene);
     }
 
     // TODO? early exit here when not visible?

libraries/render-utils/src/Model.cpp

@@ -106,7 +106,7 @@ Model::Model(QObject* parent, SpatiallyNestable* spatiallyNestableOverride) :
     _blendNumber(0),
     _appliedBlendNumber(0),
     _isWireframe(false),
-    _renderItemKeyGlobalFlags(render::ItemKey::Builder().withVisible().withTagBits(AllViews).build())
+    _renderItemKeyGlobalFlags(render::ItemKey::Builder().withVisible().withTagBits(Render::TAG_ALL_VIEWS).build())
 {
     // we may have been created in the network thread, but we live in the main thread
     if (_viewState) {
@@ -785,10 +785,10 @@ void Model::updateRenderItemsKey(const render::ScenePointer& scene) {
     scene->enqueueTransaction(transaction);
 }
 
-void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene) {
+void Model::setVisibleInScene(bool visible, const render::ScenePointer& scene) {
-    if (Model::isVisible() != isVisible) {
+    if (Model::isVisible() != visible) {
         auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemKeyGlobalFlags = (isVisible ? keyBuilder.withVisible() : keyBuilder.withInvisible());
+        _renderItemKeyGlobalFlags = (visible ? keyBuilder.withVisible() : keyBuilder.withInvisible());
         updateRenderItemsKey(scene);
     }
 }
@@ -797,10 +797,10 @@ bool Model::isVisible() const {
     return _renderItemKeyGlobalFlags.isVisible();
 }
 
-void Model::setCanCastShadow(bool canCastShadow, const render::ScenePointer& scene) {
+void Model::setCanCastShadow(bool castShadow, const render::ScenePointer& scene) {
-    if (Model::canCastShadow() != canCastShadow) {
+    if (Model::canCastShadow() != castShadow) {
         auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemKeyGlobalFlags = (canCastShadow ? keyBuilder.withShadowCaster() : keyBuilder.withoutShadowCaster());
+        _renderItemKeyGlobalFlags = (castShadow ? keyBuilder.withShadowCaster() : keyBuilder.withoutShadowCaster());
         updateRenderItemsKey(scene);
     }
 }
@@ -809,45 +809,45 @@ bool Model::canCastShadow() const {
     return _renderItemKeyGlobalFlags.isShadowCaster();
 }
 
-void Model::setLayeredInFront(bool isLayeredInFront, const render::ScenePointer& scene) {
+void Model::setLayeredInFront(bool layeredInFront, const render::ScenePointer& scene) {
-    if (Model::isLayeredInFront() != isLayeredInFront) {
+    if (Model::isLayeredInFront() != layeredInFront) {
         auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemKeyGlobalFlags = (isLayeredInFront ? keyBuilder.withLayer(render::Item::LAYER_3D_FRONT) : keyBuilder.withoutLayer());
+        _renderItemKeyGlobalFlags = (layeredInFront ? keyBuilder.withLayer(Render::LAYER_3D_FRONT) : keyBuilder.withoutLayer());
         updateRenderItemsKey(scene);
     }
 }
 
 bool Model::isLayeredInFront() const {
-    return _renderItemKeyGlobalFlags.isLayer(render::Item::LAYER_3D_FRONT);
+    return _renderItemKeyGlobalFlags.isLayer(Render::LAYER_3D_FRONT);
 }
 
-void Model::setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& scene) {
+void Model::setLayeredInHUD(bool layeredInHUD, const render::ScenePointer& scene) {
-    if (Model::isLayeredInHUD() != isLayeredInHUD) {
+    if (Model::isLayeredInHUD() != layeredInHUD) {
         auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemKeyGlobalFlags = (isLayeredInHUD ? keyBuilder.withLayer(render::Item::LAYER_3D_HUD) : keyBuilder.withoutLayer());
+        _renderItemKeyGlobalFlags = (layeredInHUD ? keyBuilder.withLayer(Render::LAYER_3D_HUD) : keyBuilder.withoutLayer());
         updateRenderItemsKey(scene);
     }
 }
 
 bool Model::isLayeredInHUD() const {
-    return _renderItemKeyGlobalFlags.isLayer(render::Item::LAYER_3D_HUD);
+    return _renderItemKeyGlobalFlags.isLayer(Render::LAYER_3D_HUD);
 }
 
-void Model::setViewMask(uint8_t mask, const render::ScenePointer& scene) {
+void Model::setTagMask(uint8_t mask, const render::ScenePointer& scene) {
-    if (Model::getViewMask() != mask) {
+    if (Model::getTagMask() != mask) {
         auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
         _renderItemKeyGlobalFlags = keyBuilder.withTagBits(mask);
         updateRenderItemsKey(scene);
     }
 }
-Model::ViewMask Model::getViewMask() const {
+Render::Tag Model::getTagMask() const {
-    return (Model::ViewMask) _renderItemKeyGlobalFlags.getTagBits();
+    return (Render::Tag) _renderItemKeyGlobalFlags.getTagBits();
 }
 
-void Model::setGroupCulled(bool isGroupCulled, const render::ScenePointer& scene) {
+void Model::setGroupCulled(bool groupCulled, const render::ScenePointer& scene) {
-    if (Model::isGroupCulled() != isGroupCulled) {
+    if (Model::isGroupCulled() != groupCulled) {
         auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
-        _renderItemKeyGlobalFlags = (isGroupCulled ? keyBuilder.withSubMetaCulled() : keyBuilder.withoutSubMetaCulled());
+        _renderItemKeyGlobalFlags = (groupCulled ? keyBuilder.withSubMetaCulled() : keyBuilder.withoutSubMetaCulled());
         updateRenderItemsKey(scene);
     }
 }

libraries/render-utils/src/Model.h

@@ -33,6 +33,7 @@
 #include <TriangleSet.h>
 #include <DualQuaternion.h>
 
+#include "RenderConstants.h"
 #include "GeometryCache.h"
 #include "TextureCache.h"
 #include "Rig.h"
@@ -90,14 +91,8 @@ public:
     void setVisibleInScene(bool isVisible, const render::ScenePointer& scene = nullptr);
     bool isVisible() const;
 
-    enum ViewMask : uint8_t {
+    Render::Tag getTagMask() const;
-        NoView = 0x00, // Not drawn at all
+    void setTagMask(uint8_t mask, const render::ScenePointer& scene = nullptr);
-        MainView = 0x01, //render::ItemKey::TAG_BITS_0,
-        SecondaryView = 0x02, //render::ItemKey::TAG_BITS_1,
-        AllViews = 0xFF, //render::ItemKey::TAG_BITS_ALL,
-    };
-    ViewMask getViewMask() const;
-    void setViewMask(uint8_t mask, const render::ScenePointer& scene = nullptr);
 
     bool isGroupCulled() const;
     void setGroupCulled(bool isGroupCulled, const render::ScenePointer& scene = nullptr);

libraries/render-utils/src/RenderConstants.h

@@ -0,0 +1,37 @@
+//
+//  RenderConstants.h
+//  libraries/render-utils/src
+//
+//  Created by Sam Gateau on 5/30/2018.
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#ifndef hifi_RenderConstants_h
+#define hifi_RenderConstants_h
+
+#include <render/Item.h>
+
+class Render {
+public:
+
+    // Tag is the alias names of render::ItemKey::Tag combinations used in the Hifi Render Engine
+    enum Tag : uint8_t {
+        TAG_NONE = render::ItemKey::TAG_BITS_NONE, // No Tags at all
+        TAG_MAIN_VIEW = render::ItemKey::TAG_BITS_0, // Main view
+        TAG_SECONDARY_VIEW = render::ItemKey::TAG_BITS_1, // Secondary View
+        TAG_ALL_VIEWS = TAG_MAIN_VIEW | TAG_SECONDARY_VIEW, // All views
+    };
+
+    // Layer is the alias names of the render::ItemKey::Layer used in the Hifi Render Engine
+    enum Layer : uint8_t {
+        LAYER_3D = render::ItemKey::LAYER_DEFAULT,
+        LAYER_3D_FRONT = render::ItemKey::LAYER_1,
+        LAYER_3D_HUD = render::ItemKey::LAYER_2,
+        LAYER_2D = render::ItemKey::LAYER_3,
+        LAYER_BACKGROUND = render::ItemKey::LAYER_BACKGROUND,
+    };
+};
+
+#endif // hifi_RenderConstants_h

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -27,6 +27,7 @@
 #include <render/DrawSceneOctree.h>
 #include <render/BlurTask.h>
 
+#include "RenderConstants.h"
 #include "RenderCommonTask.h"
 #include "LightingModel.h"
 #include "StencilMaskPass.h"
@@ -200,8 +201,8 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     const auto overlaysInFrontRangeTimer = task.addJob<BeginGPURangeTimer>("BeginOverlaysInFrontRangeTimer", "BeginOverlaysInFrontRangeTimer");
 
     // Layered Overlays
-    const auto filteredOverlaysOpaque = task.addJob<FilterLayeredItems>("FilterOverlaysLayeredOpaque", overlayOpaques, Item::LAYER_3D_FRONT);
+    const auto filteredOverlaysOpaque = task.addJob<FilterLayeredItems>("FilterOverlaysLayeredOpaque", overlayOpaques, Render::LAYER_3D_FRONT);
-    const auto filteredOverlaysTransparent = task.addJob<FilterLayeredItems>("FilterOverlaysLayeredTransparent", overlayTransparents, Item::LAYER_3D_FRONT);
+    const auto filteredOverlaysTransparent = task.addJob<FilterLayeredItems>("FilterOverlaysLayeredTransparent", overlayTransparents, Render::LAYER_3D_FRONT);
     const auto overlaysInFrontOpaque = filteredOverlaysOpaque.getN<FilterLayeredItems::Outputs>(0);
     const auto overlaysInFrontTransparent = filteredOverlaysTransparent.getN<FilterLayeredItems::Outputs>(0);
 

libraries/render-utils/src/RenderForwardTask.cpp

@@ -23,6 +23,7 @@
 
 #include <render/FilterTask.h>
 
+#include "RenderConstants.h"
 #include "StencilMaskPass.h"
 #include "ZoneRenderer.h"
 #include "FadeEffect.h"
@@ -79,8 +80,8 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend
     task.addJob<PrepareStencil>("PrepareStencil", framebuffer);
 
     // Layered Overlays
-    const auto filteredOverlaysOpaque = task.addJob<FilterLayeredItems>("FilterOverlaysLayeredOpaque", overlayOpaques, Item::LAYER_3D_FRONT);
+    const auto filteredOverlaysOpaque = task.addJob<FilterLayeredItems>("FilterOverlaysLayeredOpaque", overlayOpaques, Render::LAYER_3D_FRONT);
-    const auto filteredOverlaysTransparent = task.addJob<FilterLayeredItems>("FilterOverlaysLayeredTransparent", overlayTransparents, Item::LAYER_3D_FRONT);
+    const auto filteredOverlaysTransparent = task.addJob<FilterLayeredItems>("FilterOverlaysLayeredTransparent", overlayTransparents, Render::LAYER_3D_FRONT);
     const auto overlaysInFrontOpaque = filteredOverlaysOpaque.getN<FilterLayeredItems::Outputs>(0);
     const auto overlaysInFrontTransparent = filteredOverlaysTransparent.getN<FilterLayeredItems::Outputs>(0);
 

libraries/render/src/render/Item.cpp

@@ -28,12 +28,7 @@ const float Item::Status::Value::GREEN = 120.0f;
 const float Item::Status::Value::CYAN = 180.0f;
 const float Item::Status::Value::BLUE = 240.0f;
 const float Item::Status::Value::MAGENTA = 300.0f;
-
+/*
-const uint8_t Item::LAYER_3D = ItemKey::LAYER_DEFAULT;
-const uint8_t Item::LAYER_3D_FRONT = ItemKey::LAYER_1;
-const uint8_t Item::LAYER_3D_HUD = ItemKey::LAYER_2;
-const uint8_t Item::LAYER_2D = ItemKey::LAYER_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 };
@@ -44,11 +39,11 @@ 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;
 
 // Layer bits are derived from the Layer enum, the number of bits needed to represent integer 0 to NUM_LAYERS
-const uint8_t ItemKey::LAYER_BITS_ALL { 0x07 };
+//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

@@ -52,10 +52,21 @@ public:
         TAG_6,
         TAG_7,
 
-        NUM_TAGS
+        NUM_TAGS,
+
+        TAG_BITS_ALL = 0xFF,
+        TAG_BITS_NONE = 0x00,
+        TAG_BITS_0 = 0x01,
+        TAG_BITS_1 = 0x02,
+        TAG_BITS_2 = 0x04,
+        TAG_BITS_3 = 0x08,
+        TAG_BITS_4 = 0x10,
+        TAG_BITS_5 = 0x20,
+        TAG_BITS_6 = 0x40,
+        TAG_BITS_7 = 0x80,
     };
-    // Tag bits are derived from the Tag enum
+ /*   // Tag bits are derived from the Tag enum
-    const static uint8_t TAG_BITS_ALL;
+    constexpr 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;
@@ -65,7 +76,7 @@ public:
     const static uint8_t TAG_BITS_5;
     const static uint8_t TAG_BITS_6;
     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_DEFAULT' meaning that it is NOT layered.
     // THere is NO ordering relationship between layers.
@@ -80,10 +91,12 @@ public:
         LAYER_BACKGROUND, // Last Layer is the background by convention
 
         NUM_LAYERS,
-        NUM_LAYER_BITS = 3
+
+        NUM_LAYER_BITS = 3,
+        LAYER_BITS_ALL = 0x07,
     };
     // Layer bits are derived from the Layer enum, the number of bits needed to represent integer 0 to NUM_LAYERS
-    const static uint8_t LAYER_BITS_ALL;
+ //   const static uint8_t LAYER_BITS_ALL;
 
     enum FlagBit : uint32_t {
         TYPE_SHAPE = 0,   // Item is a Shape: Implements the Shape Interface that draw a Geometry rendered with a Material
@@ -457,11 +470,6 @@ public:
     // Get the layer where the item belongs, simply reflecting the key.
     int getLayer() const { return _key.getLayer(); }
 
-    static const uint8_t LAYER_3D;
-    static const uint8_t LAYER_3D_FRONT;
-    static const uint8_t LAYER_3D_HUD;
-    static const uint8_t LAYER_2D;
-
     // Render call for the item
     void render(RenderArgs* args) const { _payload->render(args); }