Merge pull request #6112 from ericrius1/rayPickAdditions

Moved whitelist and raypicking code out of octree, fixed small bug with polylines

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -482,7 +482,7 @@ void EntityTreeRenderer::deleteReleasedModels() {
 }
 
 RayToEntityIntersectionResult EntityTreeRenderer::findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType,
-                                                                                    bool precisionPicking, const QVector<QUuid>& entityIdsToInclude) {
+                                                                                    bool precisionPicking, const QVector<EntityItemID>& entityIdsToInclude) {
     RayToEntityIntersectionResult result;
     if (_tree) {
         EntityTreePointer entityTree = std::static_pointer_cast<EntityTree>(_tree);

libraries/entities-renderer/src/EntityTreeRenderer.h

@@ -130,7 +130,7 @@ private:
 
     QList<Model*> _releasedModels;
     RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType,
-                                                                bool precisionPicking, const QVector<QUuid>& entityIdsToInclude = QVector<QUuid>());
+                                                                bool precisionPicking, const QVector<EntityItemID>& entityIdsToInclude = QVector<EntityItemID>());
 
     EntityItemID _currentHoverOverEntityID;
     EntityItemID _currentClickingOnEntityID;

libraries/entities/src/EntityScriptingInterface.cpp

@@ -280,18 +280,18 @@ QVector<QUuid> EntityScriptingInterface::findEntitiesInBox(const glm::vec3& corn
 }
 
 RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersection(const PickRay& ray, bool precisionPicking, const QScriptValue& entityIdsToInclude) {
-    QVector<QUuid> entities = qVectorQUuidFromScriptValue(entityIdsToInclude);
+    QVector<EntityItemID> entities = qVectorEntityItemIDFromScriptValue(entityIdsToInclude);
     return findRayIntersectionWorker(ray, Octree::TryLock, precisionPicking, entities);
 }
 
 RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionBlocking(const PickRay& ray, bool precisionPicking, const QScriptValue& entityIdsToInclude) {
-    const QVector<QUuid>& entities = qVectorQUuidFromScriptValue(entityIdsToInclude);
+    const QVector<EntityItemID>& entities = qVectorEntityItemIDFromScriptValue(entityIdsToInclude);
     return findRayIntersectionWorker(ray, Octree::Lock, precisionPicking, entities);
 }
 
 RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionWorker(const PickRay& ray,
                                                                                     Octree::lockType lockType,
-                                                                                    bool precisionPicking, const QVector<QUuid>& entityIdsToInclude) {
+                                                                                    bool precisionPicking, const QVector<EntityItemID>& entityIdsToInclude) {
 
 
     RayToEntityIntersectionResult result;

libraries/entities/src/EntityScriptingInterface.h

@@ -186,7 +186,7 @@ private:
 
     /// actually does the work of finding the ray intersection, can be called in locking mode or tryLock mode
     RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType,
-                                                            bool precisionPicking, const QVector<QUuid>& entityIdsToInclude);
+                                                            bool precisionPicking, const QVector<EntityItemID>& entityIdsToInclude);
 
     EntityTreePointer _entityTree;
     EntitiesScriptEngineProvider* _entitiesScriptEngine = nullptr;

libraries/entities/src/EntityTree.cpp

@@ -448,6 +448,53 @@ bool EntityTree::findNearPointOperation(OctreeElementPointer element, void* extr
     // if this element doesn't contain the point, then none of its children can contain the point, so stop searching
     return false;
 }
+// combines the ray cast arguments into a single object
+class RayArgs {
+public:
+    glm::vec3 origin;
+    glm::vec3 direction;
+    OctreeElementPointer& element;
+    float& distance;
+    BoxFace& face;
+    glm::vec3& surfaceNormal;
+    const QVector<EntityItemID>& entityIdsToInclude;
+    void** intersectedObject;
+    bool found;
+    bool precisionPicking;
+};
+
+
+bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) {
+    RayArgs* args = static_cast<RayArgs*>(extraData);
+    bool keepSearching = true;
+    EntityTreeElementPointer entityTreeElementPointer = std::dynamic_pointer_cast<EntityTreeElement>(element);
+    if (entityTreeElementPointer ->findRayIntersection(args->origin, args->direction, keepSearching,
+        args->element, args->distance, args->face, args->surfaceNormal, args->entityIdsToInclude,
+        args->intersectedObject, args->precisionPicking)) {
+        args->found = true;
+    }
+    return keepSearching;
+}
+
+bool EntityTree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+                                    OctreeElementPointer& element, float& distance, 
+                                    BoxFace& face, glm::vec3& surfaceNormal, const QVector<EntityItemID>& entityIdsToInclude, void** intersectedObject,
+                                    Octree::lockType lockType, bool* accurateResult, bool precisionPicking) {
+    RayArgs args = { origin, direction, element, distance, face, surfaceNormal, entityIdsToInclude, intersectedObject, false, precisionPicking };
+    distance = FLT_MAX;
+
+    bool requireLock = lockType == Octree::Lock;
+    bool lockResult = withReadLock([&]{
+        recurseTreeWithOperation(findRayIntersectionOp, &args);
+    }, requireLock);
+
+    if (accurateResult) {
+        *accurateResult = lockResult; // if user asked to accuracy or result, let them know this is accurate
+    }
+
+    return args.found;
+}
+
 
 EntityItemPointer EntityTree::findClosestEntity(glm::vec3 position, float targetRadius) {
     FindNearPointArgs args = { position, targetRadius, false, NULL, FLT_MAX };

libraries/entities/src/EntityTree.h

@@ -80,6 +80,14 @@ public:
     virtual int processEditPacketData(NLPacket& packet, const unsigned char* editData, int maxLength,
                                       const SharedNodePointer& senderNode);
 
+    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+        OctreeElementPointer& node, float& distance, BoxFace& face, glm::vec3& surfaceNormal,
+        const QVector<EntityItemID>& entityIdsToInclude = QVector<EntityItemID>(),
+        void** intersectedObject = NULL,
+        Octree::lockType lockType = Octree::TryLock,
+        bool* accurateResult = NULL,
+        bool precisionPicking = false);
+
     virtual bool rootElementHasData() const { return true; }
 
     // the root at least needs to store the number of entities in the packet/buffer

libraries/entities/src/EntityTreeElement.cpp

@@ -493,9 +493,50 @@ bool EntityTreeElement::bestFitBounds(const glm::vec3& minPoint, const glm::vec3
     return false;
 }
 
+bool EntityTreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+    bool& keepSearching, OctreeElementPointer& element, float& distance,
+    BoxFace& face, glm::vec3& surfaceNormal, const QVector<EntityItemID>& entityIdsToInclude,
+    void** intersectedObject, bool precisionPicking) {
+
+    keepSearching = true; // assume that we will continue searching after this.
+
+    float distanceToElementCube = std::numeric_limits<float>::max();
+    float distanceToElementDetails = distance;
+    BoxFace localFace;
+    glm::vec3 localSurfaceNormal;
+
+    // if the ray doesn't intersect with our cube, we can stop searching!
+    if (!_cube.findRayIntersection(origin, direction, distanceToElementCube, localFace, localSurfaceNormal)) {
+        keepSearching = false; // no point in continuing to search
+        return false; // we did not intersect
+    }
+
+    // by default, we only allow intersections with leaves with content
+    if (!canRayIntersect()) {
+        return false; // we don't intersect with non-leaves, and we keep searching
+    }
+
+    // if the distance to the element cube is not less than the current best distance, then it's not possible
+    // for any details inside the cube to be closer so we don't need to consider them.
+    if (_cube.contains(origin) || distanceToElementCube < distance) {
+
+        if (findDetailedRayIntersection(origin, direction, keepSearching, element, distanceToElementDetails,
+            face, localSurfaceNormal, entityIdsToInclude, intersectedObject, precisionPicking, distanceToElementCube)) {
+
+            if (distanceToElementDetails < distance) {
+                distance = distanceToElementDetails;
+                face = localFace;
+                surfaceNormal = localSurfaceNormal;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
 bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool& keepSearching,
                                     OctreeElementPointer& element, float& distance, BoxFace& face, glm::vec3& surfaceNormal,
-                                    const QVector<QUuid>& entityIdsToInclude, void** intersectedObject, bool precisionPicking, float distanceToElementCube) {
+                                    const QVector<EntityItemID>& entityIdsToInclude, void** intersectedObject, bool precisionPicking, float distanceToElementCube) {
 
     // only called if we do intersect our bounding cube, but find if we actually intersect with entities...
     int entityNumber = 0;

libraries/entities/src/EntityTreeElement.h

@@ -142,11 +142,14 @@ public:
     virtual bool deleteApproved() const { return !hasEntities(); }
 
     virtual bool canRayIntersect() const { return hasEntities(); }
+    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+        bool& keepSearching, OctreeElementPointer& node, float& distance,
+        BoxFace& face, glm::vec3& surfaceNormal, const QVector<EntityItemID>& entityIdsToInclude,
+        void** intersectedObject = NULL, bool precisionPicking = false);
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElementPointer& element, float& distance, 
-                         BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
+                         BoxFace& face, glm::vec3& surfaceNormal, const QVector<EntityItemID>& entityIdsToInclude,
                          void** intersectedObject, bool precisionPicking, float distanceToElementCube);
-
     virtual bool findSpherePenetration(const glm::vec3& center, float radius,
                         glm::vec3& penetration, void** penetratedObject) const;
 

libraries/entities/src/PolyLineEntityItem.cpp

@@ -108,7 +108,7 @@ bool PolyLineEntityItem::setStrokeWidths(const QVector<float>& strokeWidths) {
 
 bool PolyLineEntityItem::setNormals(const QVector<glm::vec3>& normals) {
     _normals = normals;
-    if (_points.size() < 2 || _normals.size() < 2) {
+    if (_points.size() < 2 || _normals.size() < 2 || _strokeWidths.size() < 2) {
         return false;
     }
 
@@ -123,7 +123,8 @@ bool PolyLineEntityItem::setNormals(const QVector<glm::vec3>& normals) {
     _vertices.clear();
     glm::vec3 v1, v2, tangent, binormal, point;
 
-    for (int i = 0; i < minVectorSize - 1; i++) {
+    int finalIndex = minVectorSize -1;
+    for (int i = 0; i < finalIndex; i++) {
         float width = _strokeWidths.at(i);
         point = _points.at(i);
 
@@ -138,7 +139,7 @@ bool PolyLineEntityItem::setNormals(const QVector<glm::vec3>& normals) {
         _vertices << v1 << v2;
     }
     //for last point we can just assume binormals are same since it represents last two vertices of quad
-    point = _points.at(minVectorSize - 1);
+    point = _points.at(finalIndex);
     v1 = point + binormal;
     v2 = point - binormal;
     _vertices << v1 << v2;

libraries/octree/src/Octree.cpp

@@ -694,50 +694,7 @@ OctreeElementPointer Octree::getOrCreateChildElementContaining(const AACube& box
     return getRoot()->getOrCreateChildElementContaining(box);
 }
 
-// combines the ray cast arguments into a single object
-class RayArgs {
-public:
-    glm::vec3 origin;
-    glm::vec3 direction;
-    OctreeElementPointer& element;
-    float& distance;
-    BoxFace& face;
-    glm::vec3& surfaceNormal;
-    const QVector<QUuid>& entityIdsToInclude;
-    void** intersectedObject;
-    bool found;
-    bool precisionPicking;
-};
 
-bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) {
-    RayArgs* args = static_cast<RayArgs*>(extraData);
-    bool keepSearching = true;
-    if (element->findRayIntersection(args->origin, args->direction, keepSearching,
-                            args->element, args->distance, args->face, args->surfaceNormal, args->entityIdsToInclude, 
-                            args->intersectedObject, args->precisionPicking)) {
-        args->found = true;
-    }
-    return keepSearching;
-}
-
-bool Octree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                                    OctreeElementPointer& element, float& distance, 
-                                    BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude, void** intersectedObject,
-                                    Octree::lockType lockType, bool* accurateResult, bool precisionPicking) {
-    RayArgs args = { origin, direction, element, distance, face, surfaceNormal, entityIdsToInclude, intersectedObject, false, precisionPicking};
-    distance = FLT_MAX;
-
-    bool requireLock = lockType == Octree::Lock;
-    bool lockResult = withReadLock([&]{
-        recurseTreeWithOperation(findRayIntersectionOp, &args);
-    }, requireLock);
-
-    if (accurateResult) {
-        *accurateResult = lockResult; // if user asked to accuracy or result, let them know this is accurate
-    }
-
-    return args.found;
-}
 
 class SphereArgs {
 public:

libraries/octree/src/Octree.h

@@ -298,13 +298,6 @@ public:
         TryLock
     } lockType;
 
-    bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                             OctreeElementPointer& node, float& distance, BoxFace& face, glm::vec3& surfaceNormal,
-                             const QVector<QUuid>& entityIdsToInclude = QVector<QUuid>(),
-                             void** intersectedObject = NULL,
-                             Octree::lockType lockType = Octree::TryLock,
-                             bool* accurateResult = NULL,
-                             bool precisionPicking = false);
 
     bool findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration, void** penetratedObject = NULL,
                                     Octree::lockType lockType = Octree::TryLock, bool* accurateResult = NULL);

libraries/octree/src/OctreeElement.cpp

@@ -573,64 +573,6 @@ void OctreeElement::notifyUpdateHooks() {
     }
 }
 
-bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                         bool& keepSearching, OctreeElementPointer& element, float& distance, 
-                         BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
-                         void** intersectedObject, bool precisionPicking) {
-
-    keepSearching = true; // assume that we will continue searching after this.
-
-    float distanceToElementCube = std::numeric_limits<float>::max();
-    float distanceToElementDetails = distance;
-    BoxFace localFace;
-    glm::vec3 localSurfaceNormal;
-
-    // if the ray doesn't intersect with our cube, we can stop searching!
-    if (!_cube.findRayIntersection(origin, direction, distanceToElementCube, localFace, localSurfaceNormal)) {
-        keepSearching = false; // no point in continuing to search
-        return false; // we did not intersect
-    }
-
-    // by default, we only allow intersections with leaves with content
-    if (!canRayIntersect()) {
-        return false; // we don't intersect with non-leaves, and we keep searching
-    }
-
-    // if the distance to the element cube is not less than the current best distance, then it's not possible
-    // for any details inside the cube to be closer so we don't need to consider them.
-    if (_cube.contains(origin) || distanceToElementCube < distance) {
-
-        if (findDetailedRayIntersection(origin, direction, keepSearching, element, distanceToElementDetails,
-                                    face, localSurfaceNormal, entityIdsToInclude, intersectedObject, precisionPicking, distanceToElementCube)) {
-
-            if (distanceToElementDetails < distance) {
-                distance = distanceToElementDetails;
-                face = localFace;
-                surfaceNormal = localSurfaceNormal;
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-bool OctreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                         bool& keepSearching, OctreeElementPointer& element, float& distance, 
-                         BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
-                         void** intersectedObject, bool precisionPicking, float distanceToElementCube) {
-
-    // we did hit this element, so calculate appropriate distances
-    if (hasContent()) {
-        element = shared_from_this();
-        distance = distanceToElementCube;
-        if (intersectedObject) {
-            *intersectedObject = this;
-        }
-        keepSearching = false;
-        return true; // we did intersect
-    }
-    return false; // we did not intersect
-}
 
 bool OctreeElement::findSpherePenetration(const glm::vec3& center, float radius,
                         glm::vec3& penetration, void** penetratedObject) const {

libraries/octree/src/OctreeElement.h

@@ -118,16 +118,6 @@ public:
     virtual bool deleteApproved() const { return true; }
 
     virtual bool canRayIntersect() const { return isLeaf(); }
-    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                             bool& keepSearching, OctreeElementPointer& node, float& distance, 
-                             BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
-                             void** intersectedObject = NULL, bool precisionPicking = false);
-
-    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                         bool& keepSearching, OctreeElementPointer& element, float& distance, 
-                         BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
-                         void** intersectedObject, bool precisionPicking, float distanceToElementCube);
-
     /// \param center center of sphere in meters
     /// \param radius radius of sphere in meters
     /// \param[out] penetration pointing into cube from sphere

libraries/shared/src/RegisteredMetaTypes.cpp

@@ -13,7 +13,6 @@
 #include <QUrl>
 #include <QUuid>
 #include <QRect>
-
 #include <glm/gtc/quaternion.hpp>
 
 #include "RegisteredMetaTypes.h"
@@ -119,6 +118,21 @@ QVector<QUuid> qVectorQUuidFromScriptValue(const QScriptValue& array) {
     return newVector;
 }
 
+QVector<EntityItemID> qVectorEntityItemIDFromScriptValue(const QScriptValue& array) {
+    if (!array.isArray()) {
+        return QVector<EntityItemID>();
+    }
+    QVector<EntityItemID> newVector;
+    int length = array.property("length").toInteger();
+    newVector.reserve(length);
+    for (int i = 0; i < length; i++) {
+        QString uuidAsString = array.property(i).toString();
+        EntityItemID fromString(uuidAsString);
+        newVector << fromString;
+    }
+    return newVector;
+}
+
 QScriptValue qVectorFloatToScriptValue(QScriptEngine* engine, const QVector<float>& vector) {
     QScriptValue array = engine->newArray();
     for (int i = 0; i < vector.size(); i++) {

libraries/shared/src/RegisteredMetaTypes.h

@@ -14,6 +14,7 @@
 
 #include <QtScript/QScriptEngine>
 #include <QtCore/QUuid>
+#include "../../entities/src/EntityItemID.h"
 
 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
@@ -66,6 +67,7 @@ void qVectorFloatFromScriptValue(const QScriptValue& array, QVector<float>& vect
 QVector<float> qVectorFloatFromScriptValue(const QScriptValue& array);
 
 QVector<QUuid> qVectorQUuidFromScriptValue(const QScriptValue& array);
+QVector<EntityItemID> qVectorEntityItemIDFromScriptValue(const QScriptValue& array);
 
 class PickRay {
 public: