From 513acc529e55e79660fad8f6d47911cec98f44dc Mon Sep 17 00:00:00 2001 From: Sam Gateau Date: Wed, 30 May 2018 23:31:54 -0700 Subject: [PATCH] INtroduce RenderConstants header file to define the alias names for Tag and Layer for Hifi REnder Engine --- interface/src/avatar/MyAvatar.cpp | 15 ++----- interface/src/avatar/MyAvatar.h | 2 - interface/src/ui/overlays/ModelOverlay.cpp | 4 +- interface/src/ui/overlays/OverlaysPayload.cpp | 10 ++--- .../src/avatars-renderer/Avatar.cpp | 29 ++++++------ .../src/avatars-renderer/Avatar.h | 2 +- .../src/RenderableModelEntityItem.cpp | 10 ++--- libraries/render-utils/src/Model.cpp | 44 +++++++++---------- libraries/render-utils/src/Model.h | 11 ++--- libraries/render-utils/src/RenderConstants.h | 37 ++++++++++++++++ .../render-utils/src/RenderDeferredTask.cpp | 5 ++- .../render-utils/src/RenderForwardTask.cpp | 5 ++- libraries/render/src/render/Item.cpp | 11 ++--- libraries/render/src/render/Item.h | 30 ++++++++----- 14 files changed, 120 insertions(+), 95 deletions(-) create mode 100644 libraries/render-utils/src/RenderConstants.h diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp index 8c9bda56c2..45fff2e17d 100755 --- a/interface/src/avatar/MyAvatar.cpp +++ b/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; - modelRenderTagBits |= Model::SecondaryView; + uint8_t modelRenderTagBits = shouldDrawHead ? Render::TAG_ALL_VIEWS : Render::TAG_SECONDARY_VIEW; - _attachmentModels[i]->setViewMask(modelRenderTagBits); + _attachmentModels[i]->setTagMask(modelRenderTagBits); _attachmentModels[i]->setGroupCulled(false); _attachmentModels[i]->setCanCastShadow(true); _attachmentModels[i]->setVisibleInScene(true, qApp->getMain3DScene()); diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h index b0c68899cf..f7cb75d340 100644 --- a/interface/src/avatar/MyAvatar.h +++ b/interface/src/avatar/MyAvatar.h @@ -1159,7 +1159,6 @@ public slots: * @function MyAvatar.getEnableMeshVisible * @returns {boolean} true if your avatar's mesh is visible, otherwise false. */ - 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 diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp index cc40993480..ddf7241c5c 100644 --- a/interface/src/ui/overlays/ModelOverlay.cpp +++ b/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); - _model->setViewMask(modelRenderTagBits, scene); + uint8_t modelRenderTagMak = (_isVisibleInSecondaryCamera ? Render::TAG_ALL_VIEWS : Render::TAG_MAIN_VIEW); + _model->setTagMask(modelRenderTagMak, scene); _model->setVisibleInScene(getVisible(), scene); } if (_drawInFrontDirty) { diff --git a/interface/src/ui/overlays/OverlaysPayload.cpp b/interface/src/ui/overlays/OverlaysPayload.cpp index 4bb03a5669..642ae15d17 100644 --- a/interface/src/ui/overlays/OverlaysPayload.cpp +++ b/interface/src/ui/overlays/OverlaysPayload.cpp @@ -36,9 +36,9 @@ namespace render { if (overlay->is3D()) { auto overlay3D = std::static_pointer_cast(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 | - (overlay->getIsVisibleInSecondaryCamera() ? render::ItemKey::TAG_BITS_1 : render::ItemKey::TAG_BITS_NONE); + uint32_t viewTaskBits = Render::TAG_MAIN_VIEW | + (overlay->getIsVisibleInSecondaryCamera() ? Render::TAG_SECONDARY_VIEW : Render::TAG_NONE); builder.withTagBits(viewTaskBits); diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp index 014ba56365..7eef7fc12a 100644 --- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp +++ b/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); - 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) { - _isMeshEnableVisible = isEnabled; + if (_isMeshVisible != 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); diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.h b/libraries/avatars-renderer/src/avatars-renderer/Avatar.h index f48a981ec3..10c1d9ead2 100644 --- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.h +++ b/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 }; }; diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp index 2dbaa44849..d65e38b688 100644 --- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp +++ b/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 ? - Model::SecondaryView : // draw in every view except the main one (view zero) - Model::AllViews; // draw in all views + auto tagMask = _cauterized ? + Render::TAG_SECONDARY_VIEW : // draw in every view except the main one (view zero) + 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) { - model->setViewMask(viewMask, scene); + if (model->getTagMask() != tagMask) { + model->setTagMask(tagMask, scene); } // TODO? early exit here when not visible? diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp index 284d9c8e26..4530892299 100644 --- a/libraries/render-utils/src/Model.cpp +++ b/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) { - if (Model::isVisible() != isVisible) { +void Model::setVisibleInScene(bool visible, const render::ScenePointer& scene) { + 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) { - if (Model::canCastShadow() != canCastShadow) { +void Model::setCanCastShadow(bool castShadow, const render::ScenePointer& scene) { + 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) { - if (Model::isLayeredInFront() != isLayeredInFront) { +void Model::setLayeredInFront(bool layeredInFront, const render::ScenePointer& scene) { + 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) { - if (Model::isLayeredInHUD() != isLayeredInHUD) { +void Model::setLayeredInHUD(bool layeredInHUD, const render::ScenePointer& scene) { + 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) { - if (Model::getViewMask() != mask) { +void Model::setTagMask(uint8_t mask, const render::ScenePointer& scene) { + if (Model::getTagMask() != mask) { auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags); _renderItemKeyGlobalFlags = keyBuilder.withTagBits(mask); updateRenderItemsKey(scene); } } -Model::ViewMask Model::getViewMask() const { - return (Model::ViewMask) _renderItemKeyGlobalFlags.getTagBits(); +Render::Tag Model::getTagMask() const { + return (Render::Tag) _renderItemKeyGlobalFlags.getTagBits(); } -void Model::setGroupCulled(bool isGroupCulled, const render::ScenePointer& scene) { - if (Model::isGroupCulled() != isGroupCulled) { +void Model::setGroupCulled(bool groupCulled, const render::ScenePointer& scene) { + if (Model::isGroupCulled() != groupCulled) { auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags); - _renderItemKeyGlobalFlags = (isGroupCulled ? keyBuilder.withSubMetaCulled() : keyBuilder.withoutSubMetaCulled()); + _renderItemKeyGlobalFlags = (groupCulled ? keyBuilder.withSubMetaCulled() : keyBuilder.withoutSubMetaCulled()); updateRenderItemsKey(scene); } } diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h index cefd760f61..23b0350dcb 100644 --- a/libraries/render-utils/src/Model.h +++ b/libraries/render-utils/src/Model.h @@ -33,6 +33,7 @@ #include #include +#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 { - 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, - }; - ViewMask getViewMask() const; - void setViewMask(uint8_t mask, const render::ScenePointer& scene = nullptr); + Render::Tag getTagMask() const; + void setTagMask(uint8_t mask, const render::ScenePointer& scene = nullptr); bool isGroupCulled() const; void setGroupCulled(bool isGroupCulled, const render::ScenePointer& scene = nullptr); diff --git a/libraries/render-utils/src/RenderConstants.h b/libraries/render-utils/src/RenderConstants.h new file mode 100644 index 0000000000..96596c47fd --- /dev/null +++ b/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 + +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 diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp index 3ea56f8542..b64cf2e5e0 100644 --- a/libraries/render-utils/src/RenderDeferredTask.cpp +++ b/libraries/render-utils/src/RenderDeferredTask.cpp @@ -27,6 +27,7 @@ #include #include +#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("BeginOverlaysInFrontRangeTimer", "BeginOverlaysInFrontRangeTimer"); // Layered Overlays - const auto filteredOverlaysOpaque = task.addJob("FilterOverlaysLayeredOpaque", overlayOpaques, Item::LAYER_3D_FRONT); - const auto filteredOverlaysTransparent = task.addJob("FilterOverlaysLayeredTransparent", overlayTransparents, Item::LAYER_3D_FRONT); + const auto filteredOverlaysOpaque = task.addJob("FilterOverlaysLayeredOpaque", overlayOpaques, Render::LAYER_3D_FRONT); + const auto filteredOverlaysTransparent = task.addJob("FilterOverlaysLayeredTransparent", overlayTransparents, Render::LAYER_3D_FRONT); const auto overlaysInFrontOpaque = filteredOverlaysOpaque.getN(0); const auto overlaysInFrontTransparent = filteredOverlaysTransparent.getN(0); diff --git a/libraries/render-utils/src/RenderForwardTask.cpp b/libraries/render-utils/src/RenderForwardTask.cpp index 4388a39cf3..9b7d799b86 100755 --- a/libraries/render-utils/src/RenderForwardTask.cpp +++ b/libraries/render-utils/src/RenderForwardTask.cpp @@ -23,6 +23,7 @@ #include +#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", framebuffer); // Layered Overlays - const auto filteredOverlaysOpaque = task.addJob("FilterOverlaysLayeredOpaque", overlayOpaques, Item::LAYER_3D_FRONT); - const auto filteredOverlaysTransparent = task.addJob("FilterOverlaysLayeredTransparent", overlayTransparents, Item::LAYER_3D_FRONT); + const auto filteredOverlaysOpaque = task.addJob("FilterOverlaysLayeredOpaque", overlayOpaques, Render::LAYER_3D_FRONT); + const auto filteredOverlaysTransparent = task.addJob("FilterOverlaysLayeredTransparent", overlayTransparents, Render::LAYER_3D_FRONT); const auto overlaysInFrontOpaque = filteredOverlaysOpaque.getN(0); const auto overlaysInFrontTransparent = filteredOverlaysTransparent.getN(0); diff --git a/libraries/render/src/render/Item.cpp b/libraries/render/src/render/Item.cpp index ab24a11107..bca0364c71 100644 --- a/libraries/render/src/render/Item.cpp +++ b/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; diff --git a/libraries/render/src/render/Item.h b/libraries/render/src/render/Item.h index 45641d42ff..490c7530b3 100644 --- a/libraries/render/src/render/Item.h +++ b/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 - const static uint8_t TAG_BITS_ALL; + /* // Tag bits are derived from the Tag enum + 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); }