Merge branch 'master' of https://github.com/highfidelity/hifi into black

interface/src/Application.cpp

@@ -166,6 +166,7 @@
 #include "scripting/WindowScriptingInterface.h"
 #include "scripting/ControllerScriptingInterface.h"
 #include "scripting/RatesScriptingInterface.h"
+#include "scripting/SelectionScriptingInterface.h"
 #if defined(Q_OS_MAC) || defined(Q_OS_WIN)
 #include "SpeechRecognizer.h"
 #endif
@@ -675,6 +676,7 @@ bool setupEssentials(int& argc, char** argv, bool runningMarkerExisted) {
     DependencyManager::set<Snapshot>();
     DependencyManager::set<CloseEventSender>();
     DependencyManager::set<ResourceManager>();
+    DependencyManager::set<SelectionScriptingInterface>();
     DependencyManager::set<ContextOverlayInterface>();
     DependencyManager::set<Ledger>();
     DependencyManager::set<Wallet>();
@@ -2318,6 +2320,7 @@ void Application::initializeUi() {
     surfaceContext->setContextProperty("ApplicationCompositor", &getApplicationCompositor());
 
     surfaceContext->setContextProperty("AvatarInputs", AvatarInputs::getInstance());
+    surfaceContext->setContextProperty("Selection", DependencyManager::get<SelectionScriptingInterface>().data());
     surfaceContext->setContextProperty("ContextOverlay", DependencyManager::get<ContextOverlayInterface>().data());
 
     if (auto steamClient = PluginManager::getInstance()->getSteamClientPlugin()) {
@@ -5641,17 +5644,6 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
             }
             renderArgs->_debugFlags = renderDebugFlags;
             //ViveControllerManager::getInstance().updateRendering(renderArgs, _main3DScene, transaction);
-
-            RenderArgs::OutlineFlags renderOutlineFlags = RenderArgs::RENDER_OUTLINE_NONE;
-            auto contextOverlayInterface = DependencyManager::get<ContextOverlayInterface>();
-            if (contextOverlayInterface->getEnabled()) {
-                if (DependencyManager::get<ContextOverlayInterface>()->getIsInMarketplaceInspectionMode()) {
-                    renderOutlineFlags = RenderArgs::RENDER_OUTLINE_MARKETPLACE_MODE;
-                } else {
-                    renderOutlineFlags = RenderArgs::RENDER_OUTLINE_WIREFRAMES;
-                }
-            }
-            renderArgs->_outlineFlags = renderOutlineFlags;
         }
     }
 
@@ -6118,6 +6110,7 @@ void Application::registerScriptEngineWithApplicationServices(ScriptEngine* scri
     auto entityScriptServerLog = DependencyManager::get<EntityScriptServerLogClient>();
     scriptEngine->registerGlobalObject("EntityScriptServerLog", entityScriptServerLog.data());
     scriptEngine->registerGlobalObject("AvatarInputs", AvatarInputs::getInstance());
+    scriptEngine->registerGlobalObject("Selection", DependencyManager::get<SelectionScriptingInterface>().data());
     scriptEngine->registerGlobalObject("ContextOverlay", DependencyManager::get<ContextOverlayInterface>().data());
 
     qScriptRegisterMetaType(scriptEngine, OverlayIDtoScriptValue, OverlayIDfromScriptValue);

interface/src/scripting/SelectionScriptingInterface.cpp

@@ -0,0 +1,195 @@
+//
+//  SelectionScriptingInterface.cpp
+//  interface/src/scripting
+//
+//  Created by Zach Fox on 2017-08-22.
+//  Copyright 2017 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
+//
+
+#include "SelectionScriptingInterface.h"
+#include <QDebug>
+#include "Application.h"
+
+GameplayObjects::GameplayObjects() {
+}
+
+bool GameplayObjects::addToGameplayObjects(const QUuid& avatarID) {
+    containsData = true;
+    _avatarIDs.push_back(avatarID);
+    return true;
+}
+bool GameplayObjects::removeFromGameplayObjects(const QUuid& avatarID) {
+    _avatarIDs.erase(std::remove(_avatarIDs.begin(), _avatarIDs.end(), avatarID), _avatarIDs.end());
+    return true;
+}
+
+bool GameplayObjects::addToGameplayObjects(const EntityItemID& entityID) {
+    containsData = true;
+    _entityIDs.push_back(entityID);
+    return true;
+}
+bool GameplayObjects::removeFromGameplayObjects(const EntityItemID& entityID) {
+    _entityIDs.erase(std::remove(_entityIDs.begin(), _entityIDs.end(), entityID), _entityIDs.end());
+    return true;
+}
+
+bool GameplayObjects::addToGameplayObjects(const OverlayID& overlayID) {
+    containsData = true;
+    _overlayIDs.push_back(overlayID);
+    return true;
+}
+bool GameplayObjects::removeFromGameplayObjects(const OverlayID& overlayID) {
+    _overlayIDs.erase(std::remove(_overlayIDs.begin(), _overlayIDs.end(), overlayID), _overlayIDs.end());
+    return true;
+}
+
+
+SelectionScriptingInterface::SelectionScriptingInterface() {
+}
+
+bool SelectionScriptingInterface::addToSelectedItemsList(const QString& listName, const QString& itemType, const QUuid& id) {
+    if (itemType == "avatar") {
+        return addToGameplayObjects(listName, (QUuid)id);
+    } else if (itemType == "entity") {
+        return addToGameplayObjects(listName, (EntityItemID)id);
+    } else if (itemType == "overlay") {
+        return addToGameplayObjects(listName, (OverlayID)id);
+    }
+    return false;
+}
+bool SelectionScriptingInterface::removeFromSelectedItemsList(const QString& listName, const QString& itemType, const QUuid& id) {
+    if (itemType == "avatar") {
+        return removeFromGameplayObjects(listName, (QUuid)id);
+    } else if (itemType == "entity") {
+        return removeFromGameplayObjects(listName, (EntityItemID)id);
+    } else if (itemType == "overlay") {
+        return removeFromGameplayObjects(listName, (OverlayID)id);
+    }
+    return false;
+}
+
+template <class T> bool SelectionScriptingInterface::addToGameplayObjects(const QString& listName, T idToAdd) {
+    GameplayObjects currentList = _selectedItemsListMap.value(listName);
+    currentList.addToGameplayObjects(idToAdd);
+    _selectedItemsListMap.insert(listName, currentList);
+
+    emit selectedItemsListChanged(listName);
+    return true;
+}
+template <class T> bool SelectionScriptingInterface::removeFromGameplayObjects(const QString& listName, T idToRemove) {
+    GameplayObjects currentList = _selectedItemsListMap.value(listName);
+    if (currentList.getContainsData()) {
+        currentList.removeFromGameplayObjects(idToRemove);
+        _selectedItemsListMap.insert(listName, currentList);
+
+        emit selectedItemsListChanged(listName);
+        return true;
+    } else {
+        return false;
+    }
+}
+//
+// END HANDLING GENERIC ITEMS
+//
+
+GameplayObjects SelectionScriptingInterface::getList(const QString& listName) {
+    return _selectedItemsListMap.value(listName);
+}
+
+void SelectionScriptingInterface::printList(const QString& listName) {
+    GameplayObjects currentList = _selectedItemsListMap.value(listName);
+    if (currentList.getContainsData()) {
+
+        qDebug() << "Avatar IDs:";
+        for (auto i : currentList.getAvatarIDs()) {
+            qDebug() << i << ';';
+        }
+        qDebug() << "";
+
+        qDebug() << "Entity IDs:";
+        for (auto j : currentList.getEntityIDs()) {
+            qDebug() << j << ';';
+        }
+        qDebug() << "";
+
+        qDebug() << "Overlay IDs:";
+        for (auto k : currentList.getOverlayIDs()) {
+            qDebug() << k << ';';
+        }
+        qDebug() << "";
+    } else {
+        qDebug() << "List named" << listName << "doesn't exist.";
+    }
+}
+
+bool SelectionScriptingInterface::removeListFromMap(const QString& listName) {
+    if (_selectedItemsListMap.remove(listName)) {
+        emit selectedItemsListChanged(listName);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+
+SelectionToSceneHandler::SelectionToSceneHandler() {
+}
+
+void SelectionToSceneHandler::initialize(const QString& listName) {
+    _listName = listName;
+}
+
+void SelectionToSceneHandler::selectedItemsListChanged(const QString& listName) {
+    if (listName == _listName) {
+        updateSceneFromSelectedList();
+    }
+}
+
+void SelectionToSceneHandler::updateSceneFromSelectedList() {
+    auto mainScene = qApp->getMain3DScene();
+    if (mainScene) {
+        GameplayObjects thisList = DependencyManager::get<SelectionScriptingInterface>()->getList(_listName);
+        render::Transaction transaction;
+        render::ItemIDs finalList;
+        render::ItemID currentID;
+        auto entityTreeRenderer = DependencyManager::get<EntityTreeRenderer>();
+        auto& overlays = qApp->getOverlays();
+
+        for (QUuid& currentAvatarID : thisList.getAvatarIDs()) {
+            auto avatar = std::static_pointer_cast<Avatar>(DependencyManager::get<AvatarManager>()->getAvatarBySessionID(currentAvatarID));
+            if (avatar) {
+                currentID = avatar->getRenderItemID();
+                if (currentID != render::Item::INVALID_ITEM_ID) {
+                    finalList.push_back(currentID);
+                }
+            }
+        }
+
+        for (EntityItemID& currentEntityID : thisList.getEntityIDs()) {
+            currentID = entityTreeRenderer->renderableIdForEntityId(currentEntityID);
+            if (currentID != render::Item::INVALID_ITEM_ID) {
+                finalList.push_back(currentID);
+            }
+        }
+
+        for (OverlayID& currentOverlayID : thisList.getOverlayIDs()) {
+            auto overlay = overlays.getOverlay(currentOverlayID);
+            if (overlay != NULL) {
+                currentID = overlay->getRenderItemID();
+                if (currentID != render::Item::INVALID_ITEM_ID) {
+                    finalList.push_back(currentID);
+                }
+            }
+        }
+
+        render::Selection selection(_listName.toStdString(), finalList);
+        transaction.resetSelection(selection);
+
+        mainScene->enqueueTransaction(transaction);
+    } else {
+        qWarning() << "SelectionToSceneHandler::updateRendererSelectedList(), Unexpected null scene, possibly during application shutdown";
+    }
+}

interface/src/scripting/SelectionScriptingInterface.h

@@ -0,0 +1,91 @@
+
+//  SelectionScriptingInterface.h
+//  interface/src/scripting
+//
+//  Created by Zach Fox on 2017-08-22.
+//  Copyright 2017 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_SelectionScriptingInterface_h
+#define hifi_SelectionScriptingInterface_h
+
+#include <QtCore/QObject>
+#include <QtCore/QMap>
+#include <DependencyManager.h>
+
+#include <AbstractViewStateInterface.h>
+
+#include "RenderableEntityItem.h"
+#include "ui/overlays/Overlay.h"
+#include <avatar/AvatarManager.h>
+
+class GameplayObjects {
+public:
+    GameplayObjects();
+
+    bool getContainsData() { return containsData; }
+
+    std::vector<QUuid> getAvatarIDs() { return _avatarIDs; }
+    bool addToGameplayObjects(const QUuid& avatarID);
+    bool removeFromGameplayObjects(const QUuid& avatarID);
+
+    std::vector<EntityItemID> getEntityIDs() { return _entityIDs; }
+    bool addToGameplayObjects(const EntityItemID& entityID);
+    bool removeFromGameplayObjects(const EntityItemID& entityID);
+
+    std::vector<OverlayID> getOverlayIDs() { return _overlayIDs; }
+    bool addToGameplayObjects(const OverlayID& overlayID);
+    bool removeFromGameplayObjects(const OverlayID& overlayID);
+
+private:
+    bool containsData { false };
+    std::vector<QUuid> _avatarIDs;
+    std::vector<EntityItemID> _entityIDs;
+    std::vector<OverlayID> _overlayIDs;
+};
+
+
+class SelectionScriptingInterface : public QObject, public Dependency {
+    Q_OBJECT
+
+public:
+    SelectionScriptingInterface();
+
+    GameplayObjects getList(const QString& listName);
+
+    Q_INVOKABLE void printList(const QString& listName);
+    Q_INVOKABLE bool removeListFromMap(const QString& listName);
+
+    Q_INVOKABLE bool addToSelectedItemsList(const QString& listName, const QString& itemType, const QUuid& id);
+    Q_INVOKABLE bool removeFromSelectedItemsList(const QString& listName, const QString& itemType, const QUuid& id);
+
+signals:
+    void selectedItemsListChanged(const QString& listName);
+
+private:
+    QMap<QString, GameplayObjects> _selectedItemsListMap;
+
+    template <class T> bool addToGameplayObjects(const QString& listName, T idToAdd);
+    template <class T> bool removeFromGameplayObjects(const QString& listName, T idToRemove);
+};
+
+
+class SelectionToSceneHandler : public QObject {
+    Q_OBJECT
+public:
+    SelectionToSceneHandler();
+    void initialize(const QString& listName);
+
+    void updateSceneFromSelectedList();
+
+public slots:
+    void selectedItemsListChanged(const QString& listName);
+
+private:
+    QString _listName { "" };
+};
+
+#endif // hifi_SelectionScriptingInterface_h

interface/src/ui/overlays/ContextOverlayInterface.cpp

@@ -28,6 +28,9 @@ ContextOverlayInterface::ContextOverlayInterface() {
     _entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();
     _hmdScriptingInterface = DependencyManager::get<HMDScriptingInterface>();
     _tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
+    _selectionScriptingInterface = DependencyManager::get<SelectionScriptingInterface>();
+
+    _selectionToSceneHandler.initialize("contextOverlayHighlightList");
 
     _entityPropertyFlags += PROP_POSITION;
     _entityPropertyFlags += PROP_ROTATION;
@@ -58,6 +61,8 @@ ContextOverlayInterface::ContextOverlayInterface() {
     });
     auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>().data();
     connect(entityScriptingInterface, &EntityScriptingInterface::deletingEntity, this, &ContextOverlayInterface::deletingEntity);
+
+    connect(_selectionScriptingInterface.data(), &SelectionScriptingInterface::selectedItemsListChanged, &_selectionToSceneHandler, &SelectionToSceneHandler::selectedItemsListChanged);
 }
 
 static const uint32_t LEFT_HAND_HW_ID = 1;
@@ -261,25 +266,11 @@ void ContextOverlayInterface::openMarketplace() {
 }
 
 void ContextOverlayInterface::enableEntityHighlight(const EntityItemID& entityItemID) {
-    auto entityTree = qApp->getEntities()->getTree();
-    entityTree->withReadLock([&] {
-        auto entityItem = entityTree->findEntityByEntityItemID(entityItemID);
-        if ((entityItem != NULL) && !entityItem->getShouldHighlight()) {
-            qCDebug(context_overlay) << "Setting 'shouldHighlight' to 'true' for Entity ID:" << entityItemID;
-            entityItem->setShouldHighlight(true);
-        }
-    });
+    _selectionScriptingInterface->addToSelectedItemsList("contextOverlayHighlightList", "entity", entityItemID);
 }
 
 void ContextOverlayInterface::disableEntityHighlight(const EntityItemID& entityItemID) {
-    auto entityTree = qApp->getEntities()->getTree();
-    entityTree->withReadLock([&] {
-        auto entityItem = entityTree->findEntityByEntityItemID(entityItemID);
-        if ((entityItem != NULL) && entityItem->getShouldHighlight()) {
-            qCDebug(context_overlay) << "Setting 'shouldHighlight' to 'false' for Entity ID:" << entityItemID;
-            entityItem->setShouldHighlight(false);
-        }
-    });
+    _selectionScriptingInterface->removeFromSelectedItemsList("contextOverlayHighlightList", "entity", entityItemID);
 }
 
 void ContextOverlayInterface::deletingEntity(const EntityItemID& entityID) {

interface/src/ui/overlays/ContextOverlayInterface.h

@@ -25,6 +25,7 @@
 #include "ui/overlays/Image3DOverlay.h"
 #include "ui/overlays/Overlays.h"
 #include "scripting/HMDScriptingInterface.h"
+#include "scripting/SelectionScriptingInterface.h"
 
 #include "EntityTree.h"
 #include "ContextOverlayLogging.h"
@@ -42,6 +43,7 @@ class ContextOverlayInterface : public QObject, public Dependency  {
     EntityPropertyFlags _entityPropertyFlags;
     QSharedPointer<HMDScriptingInterface> _hmdScriptingInterface;
     QSharedPointer<TabletScriptingInterface> _tabletScriptingInterface;
+    QSharedPointer<SelectionScriptingInterface> _selectionScriptingInterface;
     OverlayID _contextOverlayID { UNKNOWN_OVERLAY_ID };
     std::shared_ptr<Image3DOverlay> _contextOverlay { nullptr };
 public:
@@ -81,6 +83,8 @@ private:
     void disableEntityHighlight(const EntityItemID& entityItemID);
 
     void deletingEntity(const EntityItemID& entityItemID);
+
+    SelectionToSceneHandler _selectionToSceneHandler;
 };
 
 #endif // hifi_ContextOverlayInterface_h

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

@@ -242,6 +242,7 @@ public:
     void addToScene(AvatarSharedPointer self, const render::ScenePointer& scene);
     void ensureInScene(AvatarSharedPointer self, const render::ScenePointer& scene);
     bool isInScene() const { return render::Item::isValidID(_renderItemID); }
+    render::ItemID getRenderItemID() { return _renderItemID; }
     bool isMoving() const { return _moving; }
 
     void setPhysicsCallback(AvatarPhysicsCallback cb);

libraries/entities-renderer/src/EntityTreeRenderer.h

@@ -147,6 +147,7 @@ public slots:
     void setDisplayModelBounds(bool value) { _displayModelBounds = value; }
     void setPrecisionPicking(bool value) { _setPrecisionPickingOperator(_mouseRayPickID, value); }
     EntityRendererPointer renderableForEntityId(const EntityItemID& id) const;
+    render::ItemID renderableIdForEntityId(const EntityItemID& id) const;
 
 protected:
     virtual OctreePointer createTree() override {
@@ -156,7 +157,6 @@ protected:
     }
 
 private:
-    render::ItemID renderableIdForEntityId(const EntityItemID& id) const;
     EntityRendererPointer renderableForEntity(const EntityItemPointer& entity) const { return renderableForEntityId(entity->getID()); }
     render::ItemID renderableIdForEntity(const EntityItemPointer& entity) const { return renderableIdForEntityId(entity->getID()); }
 

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -1080,7 +1080,6 @@ void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& sce
     }
 
     _marketplaceEntity = entity->getMarketplaceID().length() != 0;
-    _shouldHighlight = entity->getShouldHighlight();
     _animating = entity->isAnimatingSomething();
 
     withWriteLock([&] {
@@ -1207,17 +1206,6 @@ void ModelEntityRenderer::doRender(RenderArgs* args) {
         model = _model;
     });
 
-    // this simple logic should say we set showingEntityHighlight to true whenever we are in marketplace mode and we have a marketplace id, or
-    // whenever we are not set to none and shouldHighlight is true.
-    bool showingEntityHighlight = ((bool)(args->_outlineFlags & (int)RenderArgs::RENDER_OUTLINE_MARKETPLACE_MODE) && _marketplaceEntity != 0) ||
-                                  (args->_outlineFlags != RenderArgs::RENDER_OUTLINE_NONE && _shouldHighlight);
-    if (showingEntityHighlight) {
-        static glm::vec4 yellowColor(1.0f, 1.0f, 0.0f, 1.0f);
-        gpu::Batch& batch = *args->_batch;
-        batch.setModelTransform(_modelTransform); // we want to include the scale as well
-        DependencyManager::get<GeometryCache>()->renderWireCubeInstance(args, batch, yellowColor);
-    }
-
     if (_model && _model->didVisualGeometryRequestFail()) {
         static glm::vec4 greenColor(0.0f, 1.0f, 0.0f, 1.0f);
         gpu::Batch& batch = *args->_batch;

libraries/entities/src/EntityItem.cpp

@@ -94,7 +94,6 @@ EntityPropertyFlags EntityItem::getEntityProperties(EncodeBitstreamParams& param
     requestedProperties += PROP_LOCKED;
     requestedProperties += PROP_USER_DATA;
     requestedProperties += PROP_MARKETPLACE_ID;
-    requestedProperties += PROP_SHOULD_HIGHLIGHT;
     requestedProperties += PROP_NAME;
     requestedProperties += PROP_HREF;
     requestedProperties += PROP_DESCRIPTION;
@@ -240,7 +239,6 @@ OctreeElement::AppendState EntityItem::appendEntityData(OctreePacketData* packet
         APPEND_ENTITY_PROPERTY(PROP_LOCKED, getLocked());
         APPEND_ENTITY_PROPERTY(PROP_USER_DATA, getUserData());
         APPEND_ENTITY_PROPERTY(PROP_MARKETPLACE_ID, getMarketplaceID());
-        APPEND_ENTITY_PROPERTY(PROP_SHOULD_HIGHLIGHT, getShouldHighlight());
         APPEND_ENTITY_PROPERTY(PROP_NAME, getName());
         APPEND_ENTITY_PROPERTY(PROP_COLLISION_SOUND_URL, getCollisionSoundURL());
         APPEND_ENTITY_PROPERTY(PROP_HREF, getHref());
@@ -792,10 +790,6 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
         READ_ENTITY_PROPERTY(PROP_MARKETPLACE_ID, QString, setMarketplaceID);
     }
 
-    if (args.bitstreamVersion >= VERSION_ENTITIES_HAS_SHOULD_HIGHLIGHT) {
-        READ_ENTITY_PROPERTY(PROP_SHOULD_HIGHLIGHT, bool, setShouldHighlight);
-    }
-
     READ_ENTITY_PROPERTY(PROP_NAME, QString, setName);
     READ_ENTITY_PROPERTY(PROP_COLLISION_SOUND_URL, QString, setCollisionSoundURL);
     READ_ENTITY_PROPERTY(PROP_HREF, QString, setHref);
@@ -2772,20 +2766,6 @@ void EntityItem::setMarketplaceID(const QString& value) {
     });
 }
 
-bool EntityItem::getShouldHighlight() const {
-    bool result;
-    withReadLock([&] {
-        result = _shouldHighlight;
-    });
-    return result;
-}
-
-void EntityItem::setShouldHighlight(const bool value) {
-    withWriteLock([&] {
-        _shouldHighlight = value;
-    });
-}
-
 uint32_t EntityItem::getDirtyFlags() const { 
     uint32_t result;
     withReadLock([&] {

libraries/entities/src/EntityItemProperties.cpp

@@ -289,7 +289,6 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
     CHECK_PROPERTY_CHANGE(PROP_RADIUS_START, radiusStart);
     CHECK_PROPERTY_CHANGE(PROP_RADIUS_FINISH, radiusFinish);
     CHECK_PROPERTY_CHANGE(PROP_MARKETPLACE_ID, marketplaceID);
-    CHECK_PROPERTY_CHANGE(PROP_SHOULD_HIGHLIGHT, shouldHighlight);
     CHECK_PROPERTY_CHANGE(PROP_NAME, name);
     CHECK_PROPERTY_CHANGE(PROP_BACKGROUND_MODE, backgroundMode);
     CHECK_PROPERTY_CHANGE(PROP_SOURCE_URL, sourceUrl);
@@ -407,7 +406,6 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
     COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_LOCKED, locked);
     COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_USER_DATA, userData);
     COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_MARKETPLACE_ID, marketplaceID);
-    COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_SHOULD_HIGHLIGHT, shouldHighlight);
     COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_NAME, name);
     COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_COLLISION_SOUND_URL, collisionSoundURL);
 
@@ -984,7 +982,6 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
         ADD_PROPERTY_TO_MAP(PROP_RADIUS_START, RadiusStart, radiusStart, float);
         ADD_PROPERTY_TO_MAP(PROP_RADIUS_FINISH, RadiusFinish, radiusFinish, float);
         ADD_PROPERTY_TO_MAP(PROP_MARKETPLACE_ID, MarketplaceID, marketplaceID, QString);
-        ADD_PROPERTY_TO_MAP(PROP_SHOULD_HIGHLIGHT, ShouldHighlight, shouldHighlight, bool);
         ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_COLOR, KeyLightColor, keyLightColor, xColor);
         ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_INTENSITY, KeyLightIntensity, keyLightIntensity, float);
         ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_AMBIENT_INTENSITY, KeyLightAmbientIntensity, keyLightAmbientIntensity, float);
@@ -1337,7 +1334,6 @@ bool EntityItemProperties::encodeEntityEditPacket(PacketType command, EntityItem
                 APPEND_ENTITY_PROPERTY(PROP_SHAPE, properties.getShape());
             }
             APPEND_ENTITY_PROPERTY(PROP_MARKETPLACE_ID, properties.getMarketplaceID());
-            APPEND_ENTITY_PROPERTY(PROP_SHOULD_HIGHLIGHT, properties.getShouldHighlight());
             APPEND_ENTITY_PROPERTY(PROP_NAME, properties.getName());
             APPEND_ENTITY_PROPERTY(PROP_COLLISION_SOUND_URL, properties.getCollisionSoundURL());
             APPEND_ENTITY_PROPERTY(PROP_ACTION_DATA, properties.getActionData());
@@ -1636,7 +1632,6 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
     }
 
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MARKETPLACE_ID, QString, setMarketplaceID);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SHOULD_HIGHLIGHT, bool, setShouldHighlight);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_NAME, QString, setName);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLLISION_SOUND_URL, QString, setCollisionSoundURL);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACTION_DATA, QByteArray, setActionData);
@@ -1751,7 +1746,6 @@ void EntityItemProperties::markAllChanged() {
     //_alphaFinishChanged = true;
 
     _marketplaceIDChanged = true;
-    _shouldHighlightChanged = true;
 
     _keyLight.markAllChanged();
 

libraries/entities/src/EntityItemProperties.h

@@ -171,7 +171,6 @@ public:
     DEFINE_PROPERTY(PROP_RADIUS_FINISH, RadiusFinish, radiusFinish, float, particle::DEFAULT_RADIUS_FINISH);
     DEFINE_PROPERTY(PROP_EMITTER_SHOULD_TRAIL, EmitterShouldTrail, emitterShouldTrail, bool, particle::DEFAULT_EMITTER_SHOULD_TRAIL);
     DEFINE_PROPERTY_REF(PROP_MARKETPLACE_ID, MarketplaceID, marketplaceID, QString, ENTITY_ITEM_DEFAULT_MARKETPLACE_ID);
-    DEFINE_PROPERTY_REF(PROP_SHOULD_HIGHLIGHT, ShouldHighlight, shouldHighlight, bool, ENTITY_ITEM_DEFAULT_SHOULD_HIGHLIGHT);
     DEFINE_PROPERTY_GROUP(KeyLight, keyLight, KeyLightPropertyGroup);
     DEFINE_PROPERTY_REF(PROP_VOXEL_VOLUME_SIZE, VoxelVolumeSize, voxelVolumeSize, glm::vec3, PolyVoxEntityItem::DEFAULT_VOXEL_VOLUME_SIZE);
     DEFINE_PROPERTY_REF(PROP_VOXEL_DATA, VoxelData, voxelData, QByteArray, PolyVoxEntityItem::DEFAULT_VOXEL_DATA);

libraries/entities/src/EntityItemPropertiesDefaults.h

@@ -27,7 +27,6 @@ const glm::vec3 ENTITY_ITEM_HALF_VEC3 = glm::vec3(0.5f);
 const bool ENTITY_ITEM_DEFAULT_LOCKED = false;
 const QString ENTITY_ITEM_DEFAULT_USER_DATA = QString("");
 const QString ENTITY_ITEM_DEFAULT_MARKETPLACE_ID = QString("");
-const bool ENTITY_ITEM_DEFAULT_SHOULD_HIGHLIGHT = false;
 const QUuid ENTITY_ITEM_DEFAULT_SIMULATOR_ID = QUuid();
 
 const float ENTITY_ITEM_DEFAULT_ALPHA = 1.0f;

libraries/entities/src/EntityPropertyFlags.h

@@ -78,7 +78,6 @@ enum EntityPropertyList {
 
     PROP_COMPOUND_SHAPE_URL, // used by Model + zones entities
     PROP_MARKETPLACE_ID, // all entities
-    PROP_SHOULD_HIGHLIGHT, // all entities
     PROP_ACCELERATION, // all entities
     PROP_SIMULATION_OWNER, // formerly known as PROP_SIMULATOR_ID
     PROP_NAME, // all entities

libraries/networking/src/udt/PacketHeaders.cpp

@@ -30,7 +30,7 @@ PacketVersion versionForPacketType(PacketType packetType) {
         case PacketType::EntityEdit:
         case PacketType::EntityData:
         case PacketType::EntityPhysics:
-            return VERSION_ENTITIES_HAS_SHOULD_HIGHLIGHT;
+            return VERSION_ENTITIES_HAS_HIGHLIGHT_SCRIPTING_INTERFACE;
         case PacketType::EntityQuery:
             return static_cast<PacketVersion>(EntityQueryPacketVersion::JSONFilterWithFamilyTree);
         case PacketType::AvatarIdentity:

libraries/networking/src/udt/PacketHeaders.h

@@ -259,6 +259,7 @@ const PacketVersion VERSION_ENTITIES_ZONE_FILTERS = 68;
 const PacketVersion VERSION_ENTITIES_HINGE_CONSTRAINT = 69;
 const PacketVersion VERSION_ENTITIES_BULLET_DYNAMICS = 70;
 const PacketVersion VERSION_ENTITIES_HAS_SHOULD_HIGHLIGHT = 71;
+const PacketVersion VERSION_ENTITIES_HAS_HIGHLIGHT_SCRIPTING_INTERFACE = 72;
 
 enum class EntityQueryPacketVersion: PacketVersion {
     JSONFilter = 18,

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -218,6 +218,10 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
         }
 
         task.addJob<DebugZoneLighting>("DrawZoneStack", deferredFrameTransform);
+        
+        // Render.getConfig("RenderMainView.DrawSelectionBounds").enabled = true
+        const auto selectedMetas = task.addJob<SelectItems>("PassTestSelection", metas, "contextOverlayHighlightList");
+        task.addJob<DrawBounds>("DrawSelectionBounds", selectedMetas);
     }
 
     // AA job to be revisited

libraries/render/src/render/Args.h

@@ -63,12 +63,6 @@ namespace render {
     public:
         enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE, MIRROR_RENDER_MODE, SECONDARY_CAMERA_RENDER_MODE };
         enum DisplayMode { MONO, STEREO_MONITOR, STEREO_HMD };
-        enum OutlineFlags {
-            RENDER_OUTLINE_NONE = 0,
-            RENDER_OUTLINE_WIREFRAMES = 1,
-            RENDER_OUTLINE_MARKETPLACE_MODE = 2,
-            RENDER_OUTLINE_SHADER = 4
-        };
         enum DebugFlags {
             RENDER_DEBUG_NONE = 0,
             RENDER_DEBUG_HULLS = 1
@@ -115,7 +109,6 @@ namespace render {
         int _boundaryLevelAdjust { 0 };
         RenderMode _renderMode { DEFAULT_RENDER_MODE };
         DisplayMode _displayMode { MONO };
-        OutlineFlags _outlineFlags{ RENDER_OUTLINE_NONE };
         DebugFlags _debugFlags { RENDER_DEBUG_NONE };
         gpu::Batch* _batch = nullptr;