diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 488e97b5e6..a00cfb37d2 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -170,6 +170,7 @@
 #include "ui/StandAloneJSConsole.h"
 #include "ui/Stats.h"
 #include "ui/UpdateDialog.h"
+#include "ui/overlays/Overlays.h"
 #include "Util.h"
 #include "InterfaceParentFinder.h"
 
@@ -528,7 +529,7 @@ bool setupEssentials(int& argc, char** argv) {
 // to take care of highlighting keyboard focused items, rather than
 // continuing to overburden Application.cpp
 std::shared_ptr<Cube3DOverlay> _keyboardFocusHighlight{ nullptr };
-int _keyboardFocusHighlightID{ -1 };
+OverlayID _keyboardFocusHighlightID{ -1 };
 
 
 // FIXME hack access to the internal share context for the Chromium helper
@@ -1227,12 +1228,12 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
     // Keyboard focus handling for Web overlays.
     auto overlays = &(qApp->getOverlays());
 
-    connect(overlays, &Overlays::mousePressOnOverlay, [=](unsigned int overlayID, const PointerEvent& event) {
+    connect(overlays, &Overlays::mousePressOnOverlay, [=](OverlayID overlayID, const PointerEvent& event) {
         setKeyboardFocusEntity(UNKNOWN_ENTITY_ID);
         setKeyboardFocusOverlay(overlayID);
     });
 
-    connect(overlays, &Overlays::overlayDeleted, [=](unsigned int overlayID) {
+    connect(overlays, &Overlays::overlayDeleted, [=](OverlayID overlayID) {
         if (overlayID == _keyboardFocusedOverlay.get()) {
             setKeyboardFocusOverlay(UNKNOWN_OVERLAY_ID);
         }
@@ -1682,9 +1683,9 @@ void Application::cleanupBeforeQuit() {
     _applicationStateDevice.reset();
 
     {
-        if (_keyboardFocusHighlightID > 0) {
+        if (_keyboardFocusHighlightID) {
             getOverlays().deleteOverlay(_keyboardFocusHighlightID);
-            _keyboardFocusHighlightID = -1;
+			_keyboardFocusHighlightID = UNKNOWN_OVERLAY_ID;
         }
         _keyboardFocusHighlight = nullptr;
     }
@@ -4090,7 +4091,7 @@ void Application::rotationModeChanged() const {
 
 void Application::setKeyboardFocusHighlight(const glm::vec3& position, const glm::quat& rotation, const glm::vec3& dimensions) {
     // Create focus
-    if (_keyboardFocusHighlightID < 0 || !getOverlays().isAddedOverlay(_keyboardFocusHighlightID)) {
+	if (_keyboardFocusHighlightID == UNKNOWN_OVERLAY_ID || !getOverlays().isAddedOverlay(_keyboardFocusHighlightID)) {
         _keyboardFocusHighlight = std::make_shared<Cube3DOverlay>();
         _keyboardFocusHighlight->setAlpha(1.0f);
         _keyboardFocusHighlight->setBorderSize(1.0f);
@@ -4152,11 +4153,11 @@ void Application::setKeyboardFocusEntity(EntityItemID entityItemID) {
     }
 }
 
-unsigned int Application::getKeyboardFocusOverlay() {
+OverlayID Application::getKeyboardFocusOverlay() {
     return _keyboardFocusedOverlay.get();
 }
 
-void Application::setKeyboardFocusOverlay(unsigned int overlayID) {
+void Application::setKeyboardFocusOverlay(OverlayID overlayID) {
     if (overlayID != _keyboardFocusedOverlay.get()) {
         _keyboardFocusedOverlay.set(overlayID);
 
@@ -5527,6 +5528,8 @@ void Application::registerScriptEngineWithApplicationServices(ScriptEngine* scri
     auto entityScriptServerLog = DependencyManager::get<EntityScriptServerLogClient>();
     scriptEngine->registerGlobalObject("EntityScriptServerLog", entityScriptServerLog.data());
 
+    qScriptRegisterMetaType(scriptEngine, OverlayIDtoScriptValue, OverlayIDfromScriptValue);
+
     // connect this script engines printedMessage signal to the global ScriptEngines these various messages
     connect(scriptEngine, &ScriptEngine::printedMessage, DependencyManager::get<ScriptEngines>().data(), &ScriptEngines::onPrintedMessage);
     connect(scriptEngine, &ScriptEngine::errorMessage, DependencyManager::get<ScriptEngines>().data(), &ScriptEngines::onErrorMessage);
diff --git a/interface/src/Application.h b/interface/src/Application.h
index cab830ec88..7dcb35babc 100644
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@@ -381,8 +381,8 @@ public slots:
     void setKeyboardFocusEntity(QUuid id);
     void setKeyboardFocusEntity(EntityItemID entityItemID);
 
-    unsigned int getKeyboardFocusOverlay();
-    void setKeyboardFocusOverlay(unsigned int overlayID);
+    OverlayID getKeyboardFocusOverlay();
+    void setKeyboardFocusOverlay(OverlayID overlayID);
 
     void addAssetToWorldMessageClose();
 
@@ -610,7 +610,7 @@ private:
     DialogsManagerScriptingInterface* _dialogsManagerScriptingInterface = new DialogsManagerScriptingInterface();
 
     ThreadSafeValueCache<EntityItemID> _keyboardFocusedEntity;
-    ThreadSafeValueCache<unsigned int> _keyboardFocusedOverlay;
+    ThreadSafeValueCache<OverlayID> _keyboardFocusedOverlay;
     quint64 _lastAcceptedKeyPress = 0;
     bool _isForeground = true; // starts out assumed to be in foreground
     bool _inPaint = false;
diff --git a/interface/src/devices/DdeFaceTracker.h b/interface/src/devices/DdeFaceTracker.h
index 931ab099e9..973c3b224e 100644
--- a/interface/src/devices/DdeFaceTracker.h
+++ b/interface/src/devices/DdeFaceTracker.h
@@ -149,7 +149,7 @@ private:
     int _calibrationCount;
     QVector<float> _calibrationValues;
     TextOverlay* _calibrationBillboard;
-    int _calibrationBillboardID;
+    OverlayID _calibrationBillboardID;
     QString _calibrationMessage;
     bool _isCalibrated;
     void addCalibrationDatum();
diff --git a/interface/src/ui/overlays/Overlay.cpp b/interface/src/ui/overlays/Overlay.cpp
index 82b90d228c..8ce4b7e97a 100644
--- a/interface/src/ui/overlays/Overlay.cpp
+++ b/interface/src/ui/overlays/Overlay.cpp
@@ -204,3 +204,25 @@ void Overlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::
     render::Item::clearID(_renderItemID);
 }
 
+QScriptValue OverlayIDtoScriptValue(QScriptEngine* engine, const OverlayID& id) {
+    return QScriptValue(id.id);
+}
+
+void OverlayIDfromScriptValue(const QScriptValue &object, OverlayID& id) {
+    id = object.toUInt32();
+}
+
+QVector<OverlayID> qVectorOverlayIDFromScriptValue(const QScriptValue& array) {
+    if (!array.isArray()) {
+        return QVector<OverlayID>();
+    }
+    QVector<OverlayID> newVector;
+    int length = array.property("length").toInteger();
+    newVector.reserve(length);
+    for (int i = 0; i < length; i++) {
+        OverlayID id;
+        OverlayIDfromScriptValue(array.property(i), id);
+        newVector << id;
+    }
+    return newVector;
+}
diff --git a/interface/src/ui/overlays/Overlay.h b/interface/src/ui/overlays/Overlay.h
index 51792b24b3..d55b72a189 100644
--- a/interface/src/ui/overlays/Overlay.h
+++ b/interface/src/ui/overlays/Overlay.h
@@ -15,6 +15,24 @@
 #include <SharedUtil.h> // for xColor
 #include <render/Scene.h>
 
+class OverlayID {
+public:
+    OverlayID() {}
+    OverlayID(int value) { id = value; }
+
+    OverlayID& operator=(const OverlayID& other) { id = other.id; return *this; }
+    OverlayID& operator++() { id++; return *this; }
+
+    // OverlayID& operator=(unsigned int value) { id = value; return *this; }
+    bool operator==(const OverlayID& other) const { return id == other.id; }
+    bool operator!=(const OverlayID& other) const { return id != other.id; }
+    // bool operator<(const OverlayID& other) const { return id < other.id; }
+    // bool operator>(const OverlayID& other) const { return id > other.id; }
+    operator bool() const { return id != 0; }
+
+    unsigned int id;
+};
+
 class Overlay : public QObject {
     Q_OBJECT
 
@@ -32,8 +50,8 @@ public:
     Overlay(const Overlay* overlay);
     ~Overlay();
 
-    unsigned int getOverlayID() { return _overlayID; }
-    void setOverlayID(unsigned int overlayID) { _overlayID = overlayID; }
+    OverlayID getOverlayID() { return _overlayID; }
+    void setOverlayID(OverlayID overlayID) { _overlayID = overlayID; }
 
     virtual void update(float deltatime) {}
     virtual void render(RenderArgs* args) = 0;
@@ -89,7 +107,7 @@ protected:
 
     render::ItemID _renderItemID{ render::Item::INVALID_ITEM_ID };
 
-    unsigned int _overlayID; // what Overlays.cpp knows this instance as
+    OverlayID _overlayID; // what Overlays.cpp knows this instance as
 
     bool _isLoaded;
     float _alpha;
@@ -117,5 +135,11 @@ namespace render {
    template <> const ShapeKey shapeGetShapeKey(const Overlay::Pointer& overlay);
 }
 
+Q_DECLARE_METATYPE(OverlayID);
+Q_DECLARE_METATYPE(QVector<OverlayID>);
+QScriptValue OverlayIDtoScriptValue(QScriptEngine* engine, const OverlayID& id);
+void OverlayIDfromScriptValue(const QScriptValue &object, OverlayID& id);
+QVector<OverlayID> qVectorOverlayIDFromScriptValue(const QScriptValue& array);
+
  
 #endif // hifi_Overlay_h
diff --git a/interface/src/ui/overlays/OverlayPanel.cpp b/interface/src/ui/overlays/OverlayPanel.cpp
index cb57c6ec6b..484e1da216 100644
--- a/interface/src/ui/overlays/OverlayPanel.cpp
+++ b/interface/src/ui/overlays/OverlayPanel.cpp
@@ -51,13 +51,13 @@ void propertyBindingFromVariant(const QVariant& objectVar, PropertyBinding& valu
 }
 
 
-void OverlayPanel::addChild(unsigned int childId) {
+void OverlayPanel::addChild(OverlayID childId) {
     if (!_children.contains(childId)) {
         _children.append(childId);
     }
 }
 
-void OverlayPanel::removeChild(unsigned int childId) {
+void OverlayPanel::removeChild(OverlayID childId) {
     if (_children.contains(childId)) {
         _children.removeOne(childId);
     }
@@ -89,7 +89,7 @@ QVariant OverlayPanel::getProperty(const QString &property) {
     if (property == "children") {
         QVariantList array;
         for (int i = 0; i < _children.length(); i++) {
-            array.append(_children[i]);
+            array.append(OverlayIDtoScriptValue(nullptr, _children[i]));
         }
         return array;
     }
diff --git a/interface/src/ui/overlays/OverlayPanel.h b/interface/src/ui/overlays/OverlayPanel.h
index b0b8cdb989..5bffe3851e 100644
--- a/interface/src/ui/overlays/OverlayPanel.h
+++ b/interface/src/ui/overlays/OverlayPanel.h
@@ -20,6 +20,7 @@
 
 #include "PanelAttachable.h"
 #include "Billboardable.h"
+#include "Overlay.h"
 
 class PropertyBinding {
 public:
@@ -54,10 +55,10 @@ public:
     void setAnchorScale(const glm::vec3& scale) { _anchorTransform.setScale(scale); }
     void setVisible(bool visible) { _visible = visible; }
 
-    const QList<unsigned int>& getChildren() { return _children; }
-    void addChild(unsigned int childId);
-    void removeChild(unsigned int childId);
-    unsigned int popLastChild() { return _children.takeLast(); }
+    const QList<OverlayID>& getChildren() { return _children; }
+    void addChild(OverlayID childId);
+    void removeChild(OverlayID childId);
+    OverlayID popLastChild() { return _children.takeLast(); }
 
     void setProperties(const QVariantMap& properties);
     QVariant getProperty(const QString& property);
@@ -74,7 +75,7 @@ private:
     QUuid _anchorRotationBindEntity;
 
     bool _visible = true;
-    QList<unsigned int> _children;
+    QList<OverlayID> _children;
 
     QScriptEngine* _scriptEngine;
 };
diff --git a/interface/src/ui/overlays/Overlays.cpp b/interface/src/ui/overlays/Overlays.cpp
index e81e48f2bc..42e6d2c679 100644
--- a/interface/src/ui/overlays/Overlays.cpp
+++ b/interface/src/ui/overlays/Overlays.cpp
@@ -139,7 +139,7 @@ void Overlays::enable() {
     _enabled = true;
 }
 
-Overlay::Pointer Overlays::getOverlay(unsigned int id) const {
+Overlay::Pointer Overlays::getOverlay(OverlayID id) const {
     if (_overlaysHUD.contains(id)) {
         return _overlaysHUD[id];
     }
@@ -149,7 +149,7 @@ Overlay::Pointer Overlays::getOverlay(unsigned int id) const {
     return nullptr;
 }
 
-unsigned int Overlays::addOverlay(const QString& type, const QVariant& properties) {
+OverlayID Overlays::addOverlay(const QString& type, const QVariant& properties) {
     Overlay::Pointer thisOverlay = nullptr;
 
     if (type == ImageOverlay::TYPE) {
@@ -191,11 +191,11 @@ unsigned int Overlays::addOverlay(const QString& type, const QVariant& propertie
     return 0;
 }
 
-unsigned int Overlays::addOverlay(Overlay::Pointer overlay) {
+OverlayID Overlays::addOverlay(Overlay::Pointer overlay) {
     QWriteLocker lock(&_lock);
-    unsigned int thisID = _nextOverlayID;
+    OverlayID thisID = _nextOverlayID;
     overlay->setOverlayID(thisID);
-    _nextOverlayID++;
+    ++_nextOverlayID;
     if (overlay->is3D()) {
         _overlaysWorld[thisID] = overlay;
 
@@ -210,11 +210,11 @@ unsigned int Overlays::addOverlay(Overlay::Pointer overlay) {
     return thisID;
 }
 
-unsigned int Overlays::cloneOverlay(unsigned int id) {
+OverlayID Overlays::cloneOverlay(OverlayID id) {
     Overlay::Pointer thisOverlay = getOverlay(id);
 
     if (thisOverlay) {
-        unsigned int cloneId = addOverlay(Overlay::Pointer(thisOverlay->createClone()));
+        OverlayID cloneId = addOverlay(Overlay::Pointer(thisOverlay->createClone()));
         auto attachable = std::dynamic_pointer_cast<PanelAttachable>(thisOverlay);
         if (attachable && attachable->getParentPanel()) {
             attachable->getParentPanel()->addChild(cloneId);
@@ -225,7 +225,7 @@ unsigned int Overlays::cloneOverlay(unsigned int id) {
     return 0;  // Not found
 }
 
-bool Overlays::editOverlay(unsigned int id, const QVariant& properties) {
+bool Overlays::editOverlay(OverlayID id, const QVariant& properties) {
     QWriteLocker lock(&_lock);
 
     Overlay::Pointer thisOverlay = getOverlay(id);
@@ -243,7 +243,7 @@ bool Overlays::editOverlays(const QVariant& propertiesById) {
     QWriteLocker lock(&_lock);
     for (const auto& key : map.keys()) {
         bool convertSuccess;
-        unsigned int id = key.toUInt(&convertSuccess);
+        OverlayID id = key.toUInt(&convertSuccess);
         if (!convertSuccess) {
             success = false;
             continue;
@@ -260,7 +260,7 @@ bool Overlays::editOverlays(const QVariant& propertiesById) {
     return success;
 }
 
-void Overlays::deleteOverlay(unsigned int id) {
+void Overlays::deleteOverlay(OverlayID id) {
     Overlay::Pointer overlayToDelete;
 
     {
@@ -286,7 +286,7 @@ void Overlays::deleteOverlay(unsigned int id) {
     emit overlayDeleted(id);
 }
 
-QString Overlays::getOverlayType(unsigned int overlayId) const {
+QString Overlays::getOverlayType(OverlayID overlayId) const {
     Overlay::Pointer overlay = getOverlay(overlayId);
     if (overlay) {
         return overlay->getType();
@@ -294,7 +294,7 @@ QString Overlays::getOverlayType(unsigned int overlayId) const {
     return "";
 }
 
-QObject* Overlays::getOverlayObject(unsigned int id) {
+QObject* Overlays::getOverlayObject(OverlayID id) {
     Overlay::Pointer thisOverlay = getOverlay(id);
     if (thisOverlay) {
         return qobject_cast<QObject*>(&(*thisOverlay));
@@ -302,7 +302,7 @@ QObject* Overlays::getOverlayObject(unsigned int id) {
     return nullptr;
 }
 
-unsigned int Overlays::getParentPanel(unsigned int childId) const {
+OverlayID Overlays::getParentPanel(OverlayID childId) const {
     Overlay::Pointer overlay = getOverlay(childId);
     auto attachable = std::dynamic_pointer_cast<PanelAttachable>(overlay);
     if (attachable) {
@@ -313,7 +313,7 @@ unsigned int Overlays::getParentPanel(unsigned int childId) const {
     return 0;
 }
 
-void Overlays::setParentPanel(unsigned int childId, unsigned int panelId) {
+void Overlays::setParentPanel(OverlayID childId, OverlayID panelId) {
     auto attachable = std::dynamic_pointer_cast<PanelAttachable>(getOverlay(childId));
     if (attachable) {
         if (_panels.contains(panelId)) {
@@ -343,13 +343,13 @@ void Overlays::setParentPanel(unsigned int childId, unsigned int panelId) {
     }
 }
 
-unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {
+OverlayID Overlays::getOverlayAtPoint(const glm::vec2& point) {
     glm::vec2 pointCopy = point;
     QReadLocker lock(&_lock);
     if (!_enabled) {
         return 0;
     }
-    QMapIterator<unsigned int, Overlay::Pointer> i(_overlaysHUD);
+    QMapIterator<OverlayID, Overlay::Pointer> i(_overlaysHUD);
     i.toBack();
 
     const float LARGE_NEGATIVE_FLOAT = -9999999;
@@ -361,7 +361,7 @@ unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {
 
     while (i.hasPrevious()) {
         i.previous();
-        unsigned int thisID = i.key();
+        OverlayID thisID = i.key();
         if (i.value()->is3D()) {
             auto thisOverlay = std::dynamic_pointer_cast<Base3DOverlay>(i.value());
             if (thisOverlay && !thisOverlay->getIgnoreRayIntersection()) {
@@ -381,7 +381,7 @@ unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {
     return 0; // not found
 }
 
-OverlayPropertyResult Overlays::getProperty(unsigned int id, const QString& property) {
+OverlayPropertyResult Overlays::getProperty(OverlayID id, const QString& property) {
     OverlayPropertyResult result;
     Overlay::Pointer thisOverlay = getOverlay(id);
     QReadLocker lock(&_lock);
@@ -406,15 +406,21 @@ void OverlayPropertyResultFromScriptValue(const QScriptValue& object, OverlayPro
 }
 
 
-RayToOverlayIntersectionResult Overlays::findRayIntersection(const PickRay& ray) {
+RayToOverlayIntersectionResult Overlays::findRayIntersection(const PickRay& ray, bool precisionPicking,
+                                                             const QScriptValue& overlayIDsToInclude,
+                                                             const QScriptValue& overlayIDsToDiscard,
+                                                             bool visibleOnly, bool collidableOnly) {
     float bestDistance = std::numeric_limits<float>::max();
     bool bestIsFront = false;
+    const QVector<OverlayID> overlaysToInclude = qVectorOverlayIDFromScriptValue(overlayIDsToInclude);
+    const QVector<OverlayID> overlaysToDiscard = qVectorOverlayIDFromScriptValue(overlayIDsToDiscard);
+
     RayToOverlayIntersectionResult result;
-    QMapIterator<unsigned int, Overlay::Pointer> i(_overlaysWorld);
+    QMapIterator<OverlayID, Overlay::Pointer> i(_overlaysWorld);
     i.toBack();
     while (i.hasPrevious()) {
         i.previous();
-        unsigned int thisID = i.key();
+        OverlayID thisID = i.key();
         auto thisOverlay = std::dynamic_pointer_cast<Base3DOverlay>(i.value());
         if (thisOverlay && thisOverlay->getVisible() && !thisOverlay->getIgnoreRayIntersection() && thisOverlay->isLoaded()) {
             float thisDistance;
@@ -454,7 +460,7 @@ RayToOverlayIntersectionResult::RayToOverlayIntersectionResult() :
 QScriptValue RayToOverlayIntersectionResultToScriptValue(QScriptEngine* engine, const RayToOverlayIntersectionResult& value) {
     auto obj = engine->newObject();
     obj.setProperty("intersects", value.intersects);
-    obj.setProperty("overlayID", value.overlayID);
+	obj.setProperty("overlayID", OverlayIDtoScriptValue(engine, value.overlayID));
     obj.setProperty("distance", value.distance);
 
     QString faceName = "";    
@@ -523,7 +529,7 @@ void RayToOverlayIntersectionResultFromScriptValue(const QScriptValue& objectVar
     value.extraInfo = object["extraInfo"].toString();
 }
 
-bool Overlays::isLoaded(unsigned int id) {
+bool Overlays::isLoaded(OverlayID id) {
     QReadLocker lock(&_lock);
     Overlay::Pointer thisOverlay = getOverlay(id);
     if (!thisOverlay) {
@@ -532,7 +538,7 @@ bool Overlays::isLoaded(unsigned int id) {
     return thisOverlay->isLoaded();
 }
 
-QSizeF Overlays::textSize(unsigned int id, const QString& text) const {
+QSizeF Overlays::textSize(OverlayID id, const QString& text) const {
     Overlay::Pointer thisOverlay = _overlaysHUD[id];
     if (thisOverlay) {
         if (auto textOverlay = std::dynamic_pointer_cast<TextOverlay>(thisOverlay)) {
@@ -547,30 +553,30 @@ QSizeF Overlays::textSize(unsigned int id, const QString& text) const {
     return QSizeF(0.0f, 0.0f);
 }
 
-unsigned int Overlays::addPanel(OverlayPanel::Pointer panel) {
+OverlayID Overlays::addPanel(OverlayPanel::Pointer panel) {
     QWriteLocker lock(&_lock);
 
-    unsigned int thisID = _nextOverlayID;
-    _nextOverlayID++;
+    OverlayID thisID = _nextOverlayID;
+    ++_nextOverlayID;
     _panels[thisID] = panel;
 
     return thisID;
 }
 
-unsigned int Overlays::addPanel(const QVariant& properties) {
+OverlayID Overlays::addPanel(const QVariant& properties) {
     OverlayPanel::Pointer panel = std::make_shared<OverlayPanel>();
     panel->init(_scriptEngine);
     panel->setProperties(properties.toMap());
     return addPanel(panel);
 }
 
-void Overlays::editPanel(unsigned int panelId, const QVariant& properties) {
+void Overlays::editPanel(OverlayID panelId, const QVariant& properties) {
     if (_panels.contains(panelId)) {
         _panels[panelId]->setProperties(properties.toMap());
     }
 }
 
-OverlayPropertyResult Overlays::getPanelProperty(unsigned int panelId, const QString& property) {
+OverlayPropertyResult Overlays::getPanelProperty(OverlayID panelId, const QString& property) {
     OverlayPropertyResult result;
     if (_panels.contains(panelId)) {
         OverlayPanel::Pointer thisPanel = getPanel(panelId);
@@ -581,7 +587,7 @@ OverlayPropertyResult Overlays::getPanelProperty(unsigned int panelId, const QSt
 }
 
 
-void Overlays::deletePanel(unsigned int panelId) {
+void Overlays::deletePanel(OverlayID panelId) {
     OverlayPanel::Pointer panelToDelete;
 
     {
@@ -594,7 +600,7 @@ void Overlays::deletePanel(unsigned int panelId) {
     }
 
     while (!panelToDelete->getChildren().isEmpty()) {
-        unsigned int childId = panelToDelete->popLastChild();
+        OverlayID childId = panelToDelete->popLastChild();
         deleteOverlay(childId);
         deletePanel(childId);
     }
@@ -602,39 +608,39 @@ void Overlays::deletePanel(unsigned int panelId) {
     emit panelDeleted(panelId);
 }
 
-bool Overlays::isAddedOverlay(unsigned int id) {
+bool Overlays::isAddedOverlay(OverlayID id) {
     return _overlaysHUD.contains(id) || _overlaysWorld.contains(id);
 }
 
-void Overlays::sendMousePressOnOverlay(unsigned int overlayID, const PointerEvent& event) {
+void Overlays::sendMousePressOnOverlay(OverlayID overlayID, const PointerEvent& event) {
     emit mousePressOnOverlay(overlayID, event);
 }
 
-void Overlays::sendMouseReleaseOnOverlay(unsigned int overlayID, const PointerEvent& event) {
+void Overlays::sendMouseReleaseOnOverlay(OverlayID overlayID, const PointerEvent& event) {
     emit mouseReleaseOnOverlay(overlayID, event);
 }
 
-void Overlays::sendMouseMoveOnOverlay(unsigned int overlayID, const PointerEvent& event) {
+void Overlays::sendMouseMoveOnOverlay(OverlayID overlayID, const PointerEvent& event) {
     emit mouseMoveOnOverlay(overlayID, event);
 }
 
-void Overlays::sendHoverEnterOverlay(unsigned int id, PointerEvent event) {
+void Overlays::sendHoverEnterOverlay(OverlayID id, PointerEvent event) {
     emit hoverEnterOverlay(id, event);
 }
 
-void Overlays::sendHoverOverOverlay(unsigned int  id, PointerEvent event) {
+void Overlays::sendHoverOverOverlay(OverlayID  id, PointerEvent event) {
     emit hoverOverOverlay(id, event);
 }
 
-void Overlays::sendHoverLeaveOverlay(unsigned int  id, PointerEvent event) {
+void Overlays::sendHoverLeaveOverlay(OverlayID  id, PointerEvent event) {
     emit hoverLeaveOverlay(id, event);
 }
 
-unsigned int Overlays::getKeyboardFocusOverlay() const {
+OverlayID Overlays::getKeyboardFocusOverlay() const {
     return qApp->getKeyboardFocusOverlay();
 }
 
-void Overlays::setKeyboardFocusOverlay(unsigned int id) {
+void Overlays::setKeyboardFocusOverlay(OverlayID id) {
     qApp->setKeyboardFocusOverlay(id);
 }
 
diff --git a/interface/src/ui/overlays/Overlays.h b/interface/src/ui/overlays/Overlays.h
index 90644206ee..5c784739cb 100644
--- a/interface/src/ui/overlays/Overlays.h
+++ b/interface/src/ui/overlays/Overlays.h
@@ -53,7 +53,7 @@ class RayToOverlayIntersectionResult {
 public:
     RayToOverlayIntersectionResult();
     bool intersects;
-    unsigned int overlayID;
+    OverlayID overlayID;
     float distance;
     BoxFace face;
     glm::vec3 surfaceNormal;
@@ -77,12 +77,12 @@ void RayToOverlayIntersectionResultFromScriptValue(const QScriptValue& object, R
  * @namespace Overlays
  */
 
-const unsigned int UNKNOWN_OVERLAY_ID = 0;
+const OverlayID UNKNOWN_OVERLAY_ID = 0;
 
 class Overlays : public QObject {
     Q_OBJECT
 
-    Q_PROPERTY(unsigned int keyboardFocusOverlay READ getKeyboardFocusOverlay WRITE setKeyboardFocusOverlay)
+    Q_PROPERTY(OverlayID keyboardFocusOverlay READ getKeyboardFocusOverlay WRITE setKeyboardFocusOverlay)
 
 public:
     Overlays();
@@ -93,12 +93,12 @@ public:
     void disable();
     void enable();
 
-    Overlay::Pointer getOverlay(unsigned int id) const;
-    OverlayPanel::Pointer getPanel(unsigned int id) const { return _panels[id]; }
+    Overlay::Pointer getOverlay(OverlayID id) const;
+    OverlayPanel::Pointer getPanel(OverlayID id) const { return _panels[id]; }
 
     /// adds an overlay that's already been created
-    unsigned int addOverlay(Overlay* overlay) { return addOverlay(Overlay::Pointer(overlay)); }
-    unsigned int addOverlay(Overlay::Pointer overlay);
+    OverlayID addOverlay(Overlay* overlay) { return addOverlay(Overlay::Pointer(overlay)); }
+    OverlayID addOverlay(Overlay::Pointer overlay);
 
     void mousePressEvent(QMouseEvent* event);
     void mouseReleaseEvent(QMouseEvent* event);
@@ -116,7 +116,7 @@ public slots:
      * @param {Overlays.OverlayProperties} The properties of the overlay that you want to add.
      * @return {Overlays.OverlayID} The ID of the newly created overlay.
      */
-    unsigned int addOverlay(const QString& type, const QVariant& properties);
+    OverlayID addOverlay(const QString& type, const QVariant& properties);
 
     /**jsdoc
      * Create a clone of an existing overlay.
@@ -125,7 +125,7 @@ public slots:
      * @param {Overlays.OverlayID} overlayID The ID of the overlay to clone.
      * @return {Overlays.OverlayID} The ID of the new overlay.
      */
-    unsigned int cloneOverlay(unsigned int id);
+    OverlayID cloneOverlay(OverlayID id);
 
     /**jsdoc
      * Edit an overlay's properties. 
@@ -134,7 +134,7 @@ public slots:
      * @param {Overlays.OverlayID} overlayID The ID of the overlay to edit.
      * @return {bool} `true` if the overlay was found and edited, otherwise false.
      */
-    bool editOverlay(unsigned int id, const QVariant& properties);
+    bool editOverlay(OverlayID id, const QVariant& properties);
 
     /// edits an overlay updating only the included properties, will return the identified OverlayID in case of
     /// successful edit, if the input id is for an unknown overlay this function will have no effect
@@ -146,7 +146,7 @@ public slots:
      * @function Overlays.deleteOverlay
      * @param {Overlays.OverlayID} overlayID The ID of the overlay to delete.
      */
-    void deleteOverlay(unsigned int id);
+    void deleteOverlay(OverlayID id);
 
     /**jsdoc
      * Get the type of an overlay.
@@ -155,7 +155,7 @@ public slots:
      * @param {Overlays.OverlayID} overlayID The ID of the overlay to get the type of.
      * @return {string} The type of the overlay if found, otherwise the empty string.
      */
-    QString getOverlayType(unsigned int overlayId) const;
+    QString getOverlayType(OverlayID overlayId) const;
 
     /**jsdoc
     * Get the overlay Script object.
@@ -164,7 +164,7 @@ public slots:
     * @param {Overlays.OverlayID} overlayID The ID of the overlay to get the script object of.
     * @return {Object} The script object for the overlay if found.
     */
-    QObject* getOverlayObject(unsigned int id);
+    QObject* getOverlayObject(OverlayID id);
 
     /**jsdoc
      * Get the ID of the overlay at a particular point on the HUD/screen.
@@ -174,7 +174,7 @@ public slots:
      * @return {Overlays.OverlayID} The ID of the overlay at the point specified.
      *     If no overlay is found, `0` will be returned.
      */
-    unsigned int getOverlayAtPoint(const glm::vec2& point);
+    OverlayID getOverlayAtPoint(const glm::vec2& point);
 
     /**jsdoc
      * Get the value of a an overlay's property.
@@ -185,16 +185,26 @@ public slots:
      * @return {Object} The value of the property. If the overlay or the property could
      *     not be found, `undefined` will be returned.
      */
-    OverlayPropertyResult getProperty(unsigned int id, const QString& property);
+    OverlayPropertyResult getProperty(OverlayID id, const QString& property);
 
     /*jsdoc
      * Find the closest 3D overlay hit by a pick ray.
      *
      * @function Overlays.findRayIntersection
      * @param {PickRay} The PickRay to use for finding overlays.
+     * @param {bool} Unused; Exists to match Entity interface
+     * @param {List of Overlays.OverlayID} Whitelist for intersection test.
+     * @param {List of Overlays.OverlayID} Blacklist for intersection test.
+     * @param {bool} Unused; Exists to match Entity interface
+     * @param {bool} Unused; Exists to match Entity interface
      * @return {Overlays.RayToOverlayIntersectionResult} The result of the ray cast.
      */
-    RayToOverlayIntersectionResult findRayIntersection(const PickRay& ray);
+    RayToOverlayIntersectionResult findRayIntersection(const PickRay& ray,
+                                                       bool precisionPicking = false,
+                                                       const QScriptValue& overlayIDsToInclude = QScriptValue(),
+                                                       const QScriptValue& overlayIDsToDiscard = QScriptValue(),
+                                                       bool visibleOnly = false,
+                                                       bool collidableOnly = false);
 
     /**jsdoc
      * Check whether an overlay's assets have been loaded. For example, if the
@@ -204,7 +214,7 @@ public slots:
      * @param {Overlays.OverlayID} The ID of the overlay to check.
      * @return {bool} `true` if the overlay's assets have been loaded, otherwise `false`.
      */
-    bool isLoaded(unsigned int id);
+    bool isLoaded(OverlayID id);
 
     /**jsdoc
      * Calculates the size of the given text in the specified overlay if it is a text overlay.
@@ -216,7 +226,7 @@ public slots:
      * @param {string} The string to measure.
      * @return {Vec2} The size of the text.
      */
-    QSizeF textSize(unsigned int id, const QString& text) const;
+    QSizeF textSize(OverlayID id, const QString& text) const;
 
     /**jsdoc
      * Get the width of the virtual 2D HUD.
@@ -235,39 +245,39 @@ public slots:
     float height() const;
 
     /// return true if there is an overlay with that id else false
-    bool isAddedOverlay(unsigned int id);
+    bool isAddedOverlay(OverlayID id);
 
-    unsigned int getParentPanel(unsigned int childId) const;
-    void setParentPanel(unsigned int childId, unsigned int panelId);
+    OverlayID getParentPanel(OverlayID childId) const;
+    void setParentPanel(OverlayID childId, OverlayID panelId);
 
     /// adds a panel that has already been created
-    unsigned int addPanel(OverlayPanel::Pointer panel);
+    OverlayID addPanel(OverlayPanel::Pointer panel);
 
     /// creates and adds a panel based on a set of properties
-    unsigned int addPanel(const QVariant& properties);
+    OverlayID addPanel(const QVariant& properties);
 
     /// edit the properties of a panel
-    void editPanel(unsigned int panelId, const QVariant& properties);
+    void editPanel(OverlayID panelId, const QVariant& properties);
 
     /// get a property of a panel
-    OverlayPropertyResult getPanelProperty(unsigned int panelId, const QString& property);
+    OverlayPropertyResult getPanelProperty(OverlayID panelId, const QString& property);
 
     /// deletes a panel and all child overlays
-    void deletePanel(unsigned int panelId);
+    void deletePanel(OverlayID panelId);
 
     /// return true if there is a panel with that id else false
-    bool isAddedPanel(unsigned int id) { return _panels.contains(id); }
+    bool isAddedPanel(OverlayID id) { return _panels.contains(id); }
 
-    void sendMousePressOnOverlay(unsigned int overlayID, const PointerEvent& event);
-    void sendMouseReleaseOnOverlay(unsigned int overlayID, const PointerEvent& event);
-    void sendMouseMoveOnOverlay(unsigned int overlayID, const PointerEvent& event);
+    void sendMousePressOnOverlay(OverlayID overlayID, const PointerEvent& event);
+    void sendMouseReleaseOnOverlay(OverlayID overlayID, const PointerEvent& event);
+    void sendMouseMoveOnOverlay(OverlayID overlayID, const PointerEvent& event);
 
-    void sendHoverEnterOverlay(unsigned int id, PointerEvent event);
-    void sendHoverOverOverlay(unsigned int id, PointerEvent event);
-    void sendHoverLeaveOverlay(unsigned int id, PointerEvent event);
+    void sendHoverEnterOverlay(OverlayID id, PointerEvent event);
+    void sendHoverOverOverlay(OverlayID id, PointerEvent event);
+    void sendHoverLeaveOverlay(OverlayID id, PointerEvent event);
 
-    unsigned int getKeyboardFocusOverlay() const;
-    void setKeyboardFocusOverlay(unsigned int id);
+    OverlayID getKeyboardFocusOverlay() const;
+    void setKeyboardFocusOverlay(OverlayID id);
 
 signals:
     /**jsdoc
@@ -276,26 +286,26 @@ signals:
      * @function Overlays.overlayDeleted
      * @param {OverlayID} The ID of the overlay that was deleted.
      */
-    void overlayDeleted(unsigned int id);
-    void panelDeleted(unsigned int id);
+    void overlayDeleted(OverlayID id);
+    void panelDeleted(OverlayID id);
 
-    void mousePressOnOverlay(unsigned int overlayID, const PointerEvent& event);
-    void mouseReleaseOnOverlay(unsigned int overlayID, const PointerEvent& event);
-    void mouseMoveOnOverlay(unsigned int overlayID, const PointerEvent& event);
+    void mousePressOnOverlay(OverlayID overlayID, const PointerEvent& event);
+    void mouseReleaseOnOverlay(OverlayID overlayID, const PointerEvent& event);
+    void mouseMoveOnOverlay(OverlayID overlayID, const PointerEvent& event);
     void mousePressOffOverlay();
 
-    void hoverEnterOverlay(unsigned int overlayID, const PointerEvent& event);
-    void hoverOverOverlay(unsigned int overlayID, const PointerEvent& event);
-    void hoverLeaveOverlay(unsigned int overlayID, const PointerEvent& event);
+    void hoverEnterOverlay(OverlayID overlayID, const PointerEvent& event);
+    void hoverOverOverlay(OverlayID overlayID, const PointerEvent& event);
+    void hoverLeaveOverlay(OverlayID overlayID, const PointerEvent& event);
 
 private:
     void cleanupOverlaysToDelete();
 
-    QMap<unsigned int, Overlay::Pointer> _overlaysHUD;
-    QMap<unsigned int, Overlay::Pointer> _overlaysWorld;
-    QMap<unsigned int, OverlayPanel::Pointer> _panels;
+    QMap<OverlayID, Overlay::Pointer> _overlaysHUD;
+    QMap<OverlayID, Overlay::Pointer> _overlaysWorld;
+    QMap<OverlayID, OverlayPanel::Pointer> _panels;
     QList<Overlay::Pointer> _overlaysToDelete;
-    unsigned int _nextOverlayID;
+    OverlayID _nextOverlayID;
 
     QReadWriteLock _lock;
     QReadWriteLock _deleteLock;
@@ -305,8 +315,8 @@ private:
     PointerEvent calculatePointerEvent(Overlay::Pointer overlay, PickRay ray, RayToOverlayIntersectionResult rayPickResult,
         QMouseEvent* event, PointerEvent::EventType eventType);
 
-    unsigned int _currentClickingOnOverlayID { UNKNOWN_OVERLAY_ID };
-    unsigned int _currentHoverOverOverlayID { UNKNOWN_OVERLAY_ID };
+    OverlayID _currentClickingOnOverlayID { UNKNOWN_OVERLAY_ID };
+    OverlayID _currentHoverOverOverlayID { UNKNOWN_OVERLAY_ID };
 };
 
 #endif // hifi_Overlays_h
diff --git a/interface/src/ui/overlays/Web3DOverlay.cpp b/interface/src/ui/overlays/Web3DOverlay.cpp
index cb649e8766..bfc37ccf60 100644
--- a/interface/src/ui/overlays/Web3DOverlay.cpp
+++ b/interface/src/ui/overlays/Web3DOverlay.cpp
@@ -198,7 +198,7 @@ void Web3DOverlay::render(RenderArgs* args) {
         _webSurface->getRootItem()->setProperty("scriptURL", _scriptURL);
         currentContext->makeCurrent(currentSurface);
 
-        auto forwardPointerEvent = [=](unsigned int overlayID, const PointerEvent& event) {
+        auto forwardPointerEvent = [=](OverlayID overlayID, const PointerEvent& event) {
             if (overlayID == getOverlayID()) {
                 handlePointerEvent(event);
             }
@@ -208,7 +208,7 @@ void Web3DOverlay::render(RenderArgs* args) {
         _mouseReleaseConnection = connect(&(qApp->getOverlays()), &Overlays::mouseReleaseOnOverlay, forwardPointerEvent);
         _mouseMoveConnection = connect(&(qApp->getOverlays()), &Overlays::mouseMoveOnOverlay, forwardPointerEvent);
         _hoverLeaveConnection = connect(&(qApp->getOverlays()), &Overlays::hoverLeaveOverlay,
-            [=](unsigned int overlayID, const PointerEvent& event) {
+            [=](OverlayID overlayID, const PointerEvent& event) {
             if (this->_pressed && this->getOverlayID() == overlayID) {
                 // If the user mouses off the overlay while the button is down, simulate a touch end.
                 QTouchEvent::TouchPoint point;