From 8c229d88a8e30f5a9d0815d7aa3811b4ec5463a7 Mon Sep 17 00:00:00 2001 From: ericrius1 Date: Mon, 19 Oct 2015 11:59:44 -0700 Subject: [PATCH 01/10] moving whitelist code out of octree --- libraries/entities/src/EntityTree.cpp | 46 +++++++++++++++++++++++++++ libraries/entities/src/EntityTree.h | 8 +++++ libraries/octree/src/Octree.cpp | 24 +------------- libraries/octree/src/Octree.h | 2 +- 4 files changed, 56 insertions(+), 24 deletions(-) diff --git a/libraries/entities/src/EntityTree.cpp b/libraries/entities/src/EntityTree.cpp index 6e487cbfe3..d40e4e6e96 100644 --- a/libraries/entities/src/EntityTree.cpp +++ b/libraries/entities/src/EntityTree.cpp @@ -448,6 +448,52 @@ 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& entityIdsToInclude; + void** intersectedObject; + bool found; + bool precisionPicking; +}; + + +bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) { + RayArgs* args = static_cast(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 EntityTree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, + OctreeElementPointer& element, float& distance, + BoxFace& face, glm::vec3& surfaceNormal, const QVector& 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 }; diff --git a/libraries/entities/src/EntityTree.h b/libraries/entities/src/EntityTree.h index ff84a79088..17c7347b2e 100644 --- a/libraries/entities/src/EntityTree.h +++ b/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& entityIdsToInclude = QVector(), + 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 diff --git a/libraries/octree/src/Octree.cpp b/libraries/octree/src/Octree.cpp index 3b6467401c..f573161255 100644 --- a/libraries/octree/src/Octree.cpp +++ b/libraries/octree/src/Octree.cpp @@ -709,34 +709,12 @@ public: bool precisionPicking; }; -bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) { - RayArgs* args = static_cast(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& 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; + return false; } class SphereArgs { diff --git a/libraries/octree/src/Octree.h b/libraries/octree/src/Octree.h index f0a4d2c9c0..c785bf47fb 100644 --- a/libraries/octree/src/Octree.h +++ b/libraries/octree/src/Octree.h @@ -298,7 +298,7 @@ public: TryLock } lockType; - bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, + virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, OctreeElementPointer& node, float& distance, BoxFace& face, glm::vec3& surfaceNormal, const QVector& entityIdsToInclude = QVector(), void** intersectedObject = NULL, From dcb37ccd73c41aa85164500ee5dd94dd3e9d64a1 Mon Sep 17 00:00:00 2001 From: ericrius1 Date: Mon, 19 Oct 2015 13:14:19 -0700 Subject: [PATCH 02/10] Removed whitelist and raypicking code from octree, fixed a small bug with polylines --- libraries/entities/src/EntityTree.cpp | 3 +- libraries/entities/src/EntityTreeElement.cpp | 41 +++++++++++++ libraries/entities/src/EntityTreeElement.h | 5 +- libraries/entities/src/PolyLineEntityItem.cpp | 7 ++- libraries/octree/src/Octree.cpp | 21 ------- libraries/octree/src/Octree.h | 7 --- libraries/octree/src/OctreeElement.cpp | 58 ------------------- libraries/octree/src/OctreeElement.h | 10 ---- 8 files changed, 51 insertions(+), 101 deletions(-) diff --git a/libraries/entities/src/EntityTree.cpp b/libraries/entities/src/EntityTree.cpp index d40e4e6e96..e45e3e8a1e 100644 --- a/libraries/entities/src/EntityTree.cpp +++ b/libraries/entities/src/EntityTree.cpp @@ -467,7 +467,8 @@ public: bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) { RayArgs* args = static_cast(extraData); bool keepSearching = true; - if (element->findRayIntersection(args->origin, args->direction, keepSearching, + EntityTreeElementPointer entityTreeElementPointer = std::dynamic_pointer_cast(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; diff --git a/libraries/entities/src/EntityTreeElement.cpp b/libraries/entities/src/EntityTreeElement.cpp index 56ab27836c..b3571097b3 100644 --- a/libraries/entities/src/EntityTreeElement.cpp +++ b/libraries/entities/src/EntityTreeElement.cpp @@ -493,6 +493,47 @@ 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& entityIdsToInclude, + void** intersectedObject, bool precisionPicking) { + + keepSearching = true; // assume that we will continue searching after this. + + float distanceToElementCube = std::numeric_limits::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& entityIdsToInclude, void** intersectedObject, bool precisionPicking, float distanceToElementCube) { diff --git a/libraries/entities/src/EntityTreeElement.h b/libraries/entities/src/EntityTreeElement.h index 0a47542e65..78537dca3f 100644 --- a/libraries/entities/src/EntityTreeElement.h +++ b/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& 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& entityIdsToInclude, void** intersectedObject, bool precisionPicking, float distanceToElementCube); - virtual bool findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration, void** penetratedObject) const; diff --git a/libraries/entities/src/PolyLineEntityItem.cpp b/libraries/entities/src/PolyLineEntityItem.cpp index 352d0425bf..f1be431ce8 100644 --- a/libraries/entities/src/PolyLineEntityItem.cpp +++ b/libraries/entities/src/PolyLineEntityItem.cpp @@ -108,7 +108,7 @@ bool PolyLineEntityItem::setStrokeWidths(const QVector& strokeWidths) { bool PolyLineEntityItem::setNormals(const QVector& 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& 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& 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; diff --git a/libraries/octree/src/Octree.cpp b/libraries/octree/src/Octree.cpp index f573161255..cceb3ba706 100644 --- a/libraries/octree/src/Octree.cpp +++ b/libraries/octree/src/Octree.cpp @@ -694,29 +694,8 @@ 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& entityIdsToInclude; - void** intersectedObject; - bool found; - bool precisionPicking; -}; -bool Octree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, - OctreeElementPointer& element, float& distance, - BoxFace& face, glm::vec3& surfaceNormal, const QVector& entityIdsToInclude, void** intersectedObject, - Octree::lockType lockType, bool* accurateResult, bool precisionPicking) { - return false; -} - class SphereArgs { public: glm::vec3 center; diff --git a/libraries/octree/src/Octree.h b/libraries/octree/src/Octree.h index c785bf47fb..5ebb991d49 100644 --- a/libraries/octree/src/Octree.h +++ b/libraries/octree/src/Octree.h @@ -298,13 +298,6 @@ public: TryLock } lockType; - virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, - OctreeElementPointer& node, float& distance, BoxFace& face, glm::vec3& surfaceNormal, - const QVector& entityIdsToInclude = QVector(), - 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); diff --git a/libraries/octree/src/OctreeElement.cpp b/libraries/octree/src/OctreeElement.cpp index 9a48079338..17ebe492ce 100644 --- a/libraries/octree/src/OctreeElement.cpp +++ b/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& entityIdsToInclude, - void** intersectedObject, bool precisionPicking) { - - keepSearching = true; // assume that we will continue searching after this. - - float distanceToElementCube = std::numeric_limits::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& 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 { diff --git a/libraries/octree/src/OctreeElement.h b/libraries/octree/src/OctreeElement.h index c132d437cd..6ccef31d4f 100644 --- a/libraries/octree/src/OctreeElement.h +++ b/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& 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& 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 From 0373a481f8475f4948373fbefdba406b3ec75957 Mon Sep 17 00:00:00 2001 From: ericrius1 Date: Tue, 20 Oct 2015 09:22:16 -0700 Subject: [PATCH 03/10] Using EntityItemIDs instead of QUuids --- .../entities-renderer/src/EntityTreeRenderer.cpp | 2 +- .../entities-renderer/src/EntityTreeRenderer.h | 2 +- .../entities/src/EntityScriptingInterface.cpp | 6 +++--- .../entities/src/EntityScriptingInterface.h | 2 +- libraries/entities/src/EntityTree.cpp | 4 ++-- libraries/entities/src/EntityTree.h | 2 +- libraries/entities/src/EntityTreeElement.cpp | 4 ++-- libraries/entities/src/EntityTreeElement.h | 4 ++-- libraries/shared/src/RegisteredMetaTypes.cpp | 16 +++++++++++++++- libraries/shared/src/RegisteredMetaTypes.h | 2 ++ 10 files changed, 30 insertions(+), 14 deletions(-) diff --git a/libraries/entities-renderer/src/EntityTreeRenderer.cpp b/libraries/entities-renderer/src/EntityTreeRenderer.cpp index 8f316af276..d5bf0bde8a 100644 --- a/libraries/entities-renderer/src/EntityTreeRenderer.cpp +++ b/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& entityIdsToInclude) { + bool precisionPicking, const QVector& entityIdsToInclude) { RayToEntityIntersectionResult result; if (_tree) { EntityTreePointer entityTree = std::static_pointer_cast(_tree); diff --git a/libraries/entities-renderer/src/EntityTreeRenderer.h b/libraries/entities-renderer/src/EntityTreeRenderer.h index 15c030f77e..5cd86fba21 100644 --- a/libraries/entities-renderer/src/EntityTreeRenderer.h +++ b/libraries/entities-renderer/src/EntityTreeRenderer.h @@ -130,7 +130,7 @@ private: QList _releasedModels; RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType, - bool precisionPicking, const QVector& entityIdsToInclude = QVector()); + bool precisionPicking, const QVector& entityIdsToInclude = QVector()); EntityItemID _currentHoverOverEntityID; EntityItemID _currentClickingOnEntityID; diff --git a/libraries/entities/src/EntityScriptingInterface.cpp b/libraries/entities/src/EntityScriptingInterface.cpp index 07c932b34e..01d46e0a91 100644 --- a/libraries/entities/src/EntityScriptingInterface.cpp +++ b/libraries/entities/src/EntityScriptingInterface.cpp @@ -280,18 +280,18 @@ QVector EntityScriptingInterface::findEntitiesInBox(const glm::vec3& corn } RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersection(const PickRay& ray, bool precisionPicking, const QScriptValue& entityIdsToInclude) { - QVector entities = qVectorQUuidFromScriptValue(entityIdsToInclude); + QVector entities = qVectorEntityItemIDFromScriptValue(entityIdsToInclude); return findRayIntersectionWorker(ray, Octree::TryLock, precisionPicking, entities); } RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionBlocking(const PickRay& ray, bool precisionPicking, const QScriptValue& entityIdsToInclude) { - const QVector& entities = qVectorQUuidFromScriptValue(entityIdsToInclude); + const QVector& entities = qVectorEntityItemIDFromScriptValue(entityIdsToInclude); return findRayIntersectionWorker(ray, Octree::Lock, precisionPicking, entities); } RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType, - bool precisionPicking, const QVector& entityIdsToInclude) { + bool precisionPicking, const QVector& entityIdsToInclude) { RayToEntityIntersectionResult result; diff --git a/libraries/entities/src/EntityScriptingInterface.h b/libraries/entities/src/EntityScriptingInterface.h index 48f13e81bd..d764cd7bab 100644 --- a/libraries/entities/src/EntityScriptingInterface.h +++ b/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& entityIdsToInclude); + bool precisionPicking, const QVector& entityIdsToInclude); EntityTreePointer _entityTree; EntitiesScriptEngineProvider* _entitiesScriptEngine = nullptr; diff --git a/libraries/entities/src/EntityTree.cpp b/libraries/entities/src/EntityTree.cpp index e45e3e8a1e..24c13ae28e 100644 --- a/libraries/entities/src/EntityTree.cpp +++ b/libraries/entities/src/EntityTree.cpp @@ -457,7 +457,7 @@ public: float& distance; BoxFace& face; glm::vec3& surfaceNormal; - const QVector& entityIdsToInclude; + const QVector& entityIdsToInclude; void** intersectedObject; bool found; bool precisionPicking; @@ -478,7 +478,7 @@ bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) { bool EntityTree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, OctreeElementPointer& element, float& distance, - BoxFace& face, glm::vec3& surfaceNormal, const QVector& entityIdsToInclude, void** intersectedObject, + BoxFace& face, glm::vec3& surfaceNormal, const QVector& 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; diff --git a/libraries/entities/src/EntityTree.h b/libraries/entities/src/EntityTree.h index 17c7347b2e..1957787a60 100644 --- a/libraries/entities/src/EntityTree.h +++ b/libraries/entities/src/EntityTree.h @@ -82,7 +82,7 @@ public: virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, OctreeElementPointer& node, float& distance, BoxFace& face, glm::vec3& surfaceNormal, - const QVector& entityIdsToInclude = QVector(), + const QVector& entityIdsToInclude = QVector(), void** intersectedObject = NULL, Octree::lockType lockType = Octree::TryLock, bool* accurateResult = NULL, diff --git a/libraries/entities/src/EntityTreeElement.cpp b/libraries/entities/src/EntityTreeElement.cpp index b3571097b3..8b3721488c 100644 --- a/libraries/entities/src/EntityTreeElement.cpp +++ b/libraries/entities/src/EntityTreeElement.cpp @@ -495,7 +495,7 @@ bool EntityTreeElement::bestFitBounds(const glm::vec3& minPoint, const glm::vec3 bool EntityTreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool& keepSearching, OctreeElementPointer& element, float& distance, - BoxFace& face, glm::vec3& surfaceNormal, const QVector& entityIdsToInclude, + BoxFace& face, glm::vec3& surfaceNormal, const QVector& entityIdsToInclude, void** intersectedObject, bool precisionPicking) { keepSearching = true; // assume that we will continue searching after this. @@ -536,7 +536,7 @@ bool EntityTreeElement::findRayIntersection(const glm::vec3& origin, const glm:: bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool& keepSearching, OctreeElementPointer& element, float& distance, BoxFace& face, glm::vec3& surfaceNormal, - const QVector& entityIdsToInclude, void** intersectedObject, bool precisionPicking, float distanceToElementCube) { + const QVector& 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; diff --git a/libraries/entities/src/EntityTreeElement.h b/libraries/entities/src/EntityTreeElement.h index 78537dca3f..3be52a3740 100644 --- a/libraries/entities/src/EntityTreeElement.h +++ b/libraries/entities/src/EntityTreeElement.h @@ -144,11 +144,11 @@ public: 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& entityIdsToInclude, + BoxFace& face, glm::vec3& surfaceNormal, const QVector& 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& entityIdsToInclude, + BoxFace& face, glm::vec3& surfaceNormal, const QVector& entityIdsToInclude, void** intersectedObject, bool precisionPicking, float distanceToElementCube); virtual bool findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration, void** penetratedObject) const; diff --git a/libraries/shared/src/RegisteredMetaTypes.cpp b/libraries/shared/src/RegisteredMetaTypes.cpp index 9ab0eaecb4..016c99a8dc 100644 --- a/libraries/shared/src/RegisteredMetaTypes.cpp +++ b/libraries/shared/src/RegisteredMetaTypes.cpp @@ -13,7 +13,6 @@ #include #include #include - #include #include "RegisteredMetaTypes.h" @@ -119,6 +118,21 @@ QVector qVectorQUuidFromScriptValue(const QScriptValue& array) { return newVector; } +QVector qVectorEntityItemIDFromScriptValue(const QScriptValue& array) { + if (!array.isArray()) { + return QVector(); + } + QVector 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& vector) { QScriptValue array = engine->newArray(); for (int i = 0; i < vector.size(); i++) { diff --git a/libraries/shared/src/RegisteredMetaTypes.h b/libraries/shared/src/RegisteredMetaTypes.h index cd1e3b0d3e..8e53f0ee37 100644 --- a/libraries/shared/src/RegisteredMetaTypes.h +++ b/libraries/shared/src/RegisteredMetaTypes.h @@ -14,6 +14,7 @@ #include #include +#include "../../entities/src/EntityItemID.h" #include #include @@ -66,6 +67,7 @@ void qVectorFloatFromScriptValue(const QScriptValue& array, QVector& vect QVector qVectorFloatFromScriptValue(const QScriptValue& array); QVector qVectorQUuidFromScriptValue(const QScriptValue& array); +QVector qVectorEntityItemIDFromScriptValue(const QScriptValue& array); class PickRay { public: From af09871bed6858c3d4e43204b009b2d838d8fe56 Mon Sep 17 00:00:00 2001 From: "James B. Pollack" Date: Tue, 20 Oct 2015 11:08:28 -0700 Subject: [PATCH 04/10] fix basketball solidity in toybox --- examples/toys/basketball/createHoop.js | 8 +++-- examples/toys/basketball/createRack.js | 45 +++++++++++++------------ unpublishedScripts/hiddenEntityReset.js | 2 +- unpublishedScripts/masterReset.js | 2 +- 4 files changed, 31 insertions(+), 26 deletions(-) diff --git a/examples/toys/basketball/createHoop.js b/examples/toys/basketball/createHoop.js index 2beb7c9fca..792232b98f 100644 --- a/examples/toys/basketball/createHoop.js +++ b/examples/toys/basketball/createHoop.js @@ -36,6 +36,10 @@ var hoop = Entities.addEntity({ y: 3.99, z: 3.79 }, + userData: JSON.stringify({ + grabbableKey: { + grabbable: false + } + }) compoundShapeURL: hoopCollisionHullURL -}); - +}); \ No newline at end of file diff --git a/examples/toys/basketball/createRack.js b/examples/toys/basketball/createRack.js index f764b2ec03..cda1a115d4 100644 --- a/examples/toys/basketball/createRack.js +++ b/examples/toys/basketball/createRack.js @@ -22,8 +22,6 @@ var DIAMETER = 0.30; var RESET_DISTANCE = 1; var MINIMUM_MOVE_LENGTH = 0.05; -var GRABBABLE_DATA_KEY = "grabbableKey"; - var rackStartPosition = Vec3.sum(MyAvatar.position, Vec3.multiplyQbyV(MyAvatar.orientation, { @@ -53,19 +51,17 @@ var rack = Entities.addEntity({ ignoreForCollisions: false, collisionSoundURL: collisionSoundURL, compoundShapeURL: rackCollisionHullURL, - // scriptURL: rackScriptURL + userData: JSON.stringify({ + grabbableKey: { + grabbable: false + } + }) }); - -setEntityCustomData(GRABBABLE_DATA_KEY, rack, { - grabbable: false -}); - -var nonCollidingBalls = []; -var collidingBalls = []; +var balls = []; var originalBallPositions = []; -function createCollidingBalls() { +function createBalls() { var position = rackStartPosition; var i; @@ -76,9 +72,9 @@ function createCollidingBalls() { z: position.z + (DIAMETER) - (DIAMETER * i) }; - var collidingBall = Entities.addEntity({ + var ball = Entities.addEntity({ type: "Model", - name: 'Colliding Basketball', + name: 'Hifi-Basketball', shapeType: 'Sphere', position: ballPosition, dimensions: { @@ -96,16 +92,21 @@ function createCollidingBalls() { collisionsWillMove: true, ignoreForCollisions: false, modelURL: basketballURL, + userData: JSON.stringify({ + grabbableKey: { + invertSolidWhileHeld: true + } + }) }); - collidingBalls.push(collidingBall); + balls.push(ball); originalBallPositions.push(position); } } function testBallDistanceFromStart() { var resetCount = 0; - collidingBalls.forEach(function(ball, index) { + balls.forEach(function(ball, index) { var currentPosition = Entities.getEntityProperties(ball, "position").position; var originalPosition = originalBallPositions[index]; var distance = Vec3.subtract(originalPosition, currentPosition); @@ -117,8 +118,8 @@ function testBallDistanceFromStart() { if (moving < MINIMUM_MOVE_LENGTH) { resetCount++; if (resetCount === NUMBER_OF_BALLS) { - deleteCollidingBalls(); - createCollidingBalls(); + deleteBalls(); + createBalls(); } } }, 200) @@ -128,19 +129,19 @@ function testBallDistanceFromStart() { function deleteEntity(entityID) { if (entityID === rack) { - deleteCollidingBalls(); + deleteBalls(); Script.clearInterval(distanceCheckInterval); Entities.deletingEntity.disconnect(deleteEntity); } } -function deleteCollidingBalls() { - while (collidingBalls.length > 0) { - Entities.deleteEntity(collidingBalls.pop()); +function deleteBalls() { + while (balls.length > 0) { + Entities.deleteEntity(balls.pop()); } } -createCollidingBalls(); +createBalls(); Entities.deletingEntity.connect(deleteEntity); var distanceCheckInterval = Script.setInterval(testBallDistanceFromStart, 1000); diff --git a/unpublishedScripts/hiddenEntityReset.js b/unpublishedScripts/hiddenEntityReset.js index 42056f6c3b..fde97beeb5 100644 --- a/unpublishedScripts/hiddenEntityReset.js +++ b/unpublishedScripts/hiddenEntityReset.js @@ -321,7 +321,7 @@ resetMe: { resetMe: true }, - grabbable: { + grabbableKey: { invertSolidWhileHeld: true } }) diff --git a/unpublishedScripts/masterReset.js b/unpublishedScripts/masterReset.js index 2ecd52f344..7316da57d1 100644 --- a/unpublishedScripts/masterReset.js +++ b/unpublishedScripts/masterReset.js @@ -294,7 +294,7 @@ MasterReset = function() { resetMe: { resetMe: true }, - grabbable: { + grabbableKey: { invertSolidWhileHeld: true } }) From f16b62df83767642ee11f522b00ed1bdccb0317b Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 20 Oct 2015 17:34:35 -0700 Subject: [PATCH 05/10] - grab script: possible fix for line disappearing - grab script: go from 3 pickrays back to 1 - grab script: put "sphere" test back in, but with fixed distance test --- examples/controllers/handControllerGrab.js | 102 ++++++++++++--------- 1 file changed, 61 insertions(+), 41 deletions(-) diff --git a/examples/controllers/handControllerGrab.js b/examples/controllers/handControllerGrab.js index f912761b43..9f174bd3e6 100644 --- a/examples/controllers/handControllerGrab.js +++ b/examples/controllers/handControllerGrab.js @@ -19,7 +19,7 @@ Script.include("../libraries/utils.js"); // // add lines where the hand ray picking is happening // -var DEBUG_HAND_RAY_PICKING = false; +var WANT_DEBUG = false; ///////////////////////////////////////////////////////////////// // @@ -193,22 +193,23 @@ function MyController(hand, triggerAction) { }; this.setState = function(newState) { - // print("STATE: " + this.state + " --> " + newState); + if (WANT_DEBUG) { + print("STATE: " + this.state + " --> " + newState); + } this.state = newState; } - this.debugLine = function(closePoint, farPoint, color){ - Entities.addEntity({ - type: "Line", - name: "Debug Line", - dimensions: LINE_ENTITY_DIMENSIONS, - visible: true, - position: closePoint, - linePoints: [ZERO_VEC, farPoint], - color: color, - lifetime: 0.1 - }); + Entities.addEntity({ + type: "Line", + name: "Debug Line", + dimensions: LINE_ENTITY_DIMENSIONS, + visible: true, + position: closePoint, + linePoints: [ZERO_VEC, farPoint], + color: color, + lifetime: 0.1 + }); } this.lineOn = function(closePoint, farPoint, color) { @@ -226,14 +227,13 @@ function MyController(hand, triggerAction) { }); } else { var age = Entities.getEntityProperties(this.pointer, "age").age; - Entities.editEntity(this.pointer, { + this.pointer = Entities.editEntity(this.pointer, { position: closePoint, linePoints: [ZERO_VEC, farPoint], color: color, lifetime: age + LIFETIME }); } - }; this.lineOff = function() { @@ -282,7 +282,6 @@ function MyController(hand, triggerAction) { return; } - // the trigger is being pressed, do a ray test var handPosition = this.getHandPosition(); var distantPickRay = { @@ -290,29 +289,17 @@ function MyController(hand, triggerAction) { direction: Quat.getUp(this.getHandRotation()), length: PICK_MAX_DISTANCE }; - var palmPickRay = { - origin: handPosition, - direction: Quat.getFront(this.getHandRotation()), - length: NEAR_PICK_MAX_DISTANCE - }; - - var otherPickRay = { - origin: handPosition, - direction: Quat.getRight(this.getHandRotation()), - length: NEAR_PICK_MAX_DISTANCE - }; - this.lineOn(distantPickRay.origin, Vec3.multiply(distantPickRay.direction, LINE_LENGTH), NO_INTERSECT_COLOR); - // don't pick 60x per second. do this check after updating the line so it's not jumpy. + // don't pick 60x per second. + var pickRays = []; var now = Date.now(); - if (now - this.lastPickTime < MSECS_PER_SEC / PICKS_PER_SECOND_PER_HAND) { - return; + if (now - this.lastPickTime > MSECS_PER_SEC / PICKS_PER_SECOND_PER_HAND) { + pickRays = [distantPickRay]; + this.lastPickTime = now; } - this.lastPickTime = now; - var pickRays = [distantPickRay, palmPickRay, otherPickRay]; for (var index=0; index < pickRays.length; ++index) { var pickRay = pickRays[index]; var directionNormalized = Vec3.normalize(pickRay.direction); @@ -322,12 +309,13 @@ function MyController(hand, triggerAction) { direction: pickRay.direction }; - if (DEBUG_HAND_RAY_PICKING) + if (WANT_DEBUG) { this.debugLine(pickRayBacked.origin, Vec3.multiply(pickRayBacked.direction, NEAR_PICK_MAX_DISTANCE), { red: 0, green: 255, blue: 0 }) + } var intersection = Entities.findRayIntersection(pickRayBacked, true); @@ -336,7 +324,6 @@ function MyController(hand, triggerAction) { var intersectionDistance = Vec3.distance(pickRay.origin, intersection.intersection); this.grabbedEntity = intersection.entityID; - //this code will disabled the beam for the opposite hand of the one that grabbed it if the entity says so var grabbableData = getEntityCustomData(GRABBABLE_DATA_KEY, intersection.entityID, DEFAULT_GRABBABLE_DATA); if (grabbableData["turnOffOppositeBeam"] === true) { @@ -345,7 +332,6 @@ function MyController(hand, triggerAction) { } else { disabledHand = RIGHT_HAND; } - } else { disabledHand = 'none'; } @@ -380,6 +366,35 @@ function MyController(hand, triggerAction) { } } } + + if (this.grabbedEntity === null) { + // forward ray test failed, try sphere test. + var nearbyEntities = Entities.findEntities(handPosition, GRAB_RADIUS); + var minDistance = PICK_MAX_DISTANCE; + var i, props, distance; + for (i = 0; i < nearbyEntities.length; i++) { + var grabbableData = getEntityCustomData(GRABBABLE_DATA_KEY, nearbyEntities[i], DEFAULT_GRABBABLE_DATA); + if (grabbableData.grabbable === false) { + continue; + } + var propsForCandidate = + Entities.getEntityProperties(nearbyEntities[i], ["position", "name", "collisionsWillMove", "locked"]); + distance = Vec3.distance(propsForCandidate.position, handPosition); + if (distance < minDistance && props.name !== "pointer") { + this.grabbedEntity = nearbyEntities[i]; + minDistance = distance; + props = propsForCandidate; + } + } + if (this.grabbedEntity === null) { + return; + } else if (props.locked === 0 && props.collisionsWillMove === 1) { + this.setState(STATE_NEAR_GRABBING); + } else if (props.collisionsWillMove === 0) { + // We have grabbed a non-physical object, so we want to trigger a non-colliding event as opposed to a grab event + this.setState(STATE_NEAR_GRABBING_NON_COLLIDING); + } + } }; this.distanceHolding = function() { @@ -441,7 +456,8 @@ function MyController(hand, triggerAction) { this.lineOn(handPosition, Vec3.subtract(grabbedProperties.position, handPosition), INTERSECT_COLOR); // the action was set up on a previous call. update the targets. - var radius = Math.max(Vec3.distance(this.currentObjectPosition, handControllerPosition) * DISTANCE_HOLDING_RADIUS_FACTOR, DISTANCE_HOLDING_RADIUS_FACTOR); + var radius = Math.max(Vec3.distance(this.currentObjectPosition, handControllerPosition) * + DISTANCE_HOLDING_RADIUS_FACTOR, DISTANCE_HOLDING_RADIUS_FACTOR); // how far did avatar move this timestep? var currentPosition = MyAvatar.position; var avatarDeltaPosition = Vec3.subtract(currentPosition, this.currentAvatarPosition); @@ -491,7 +507,10 @@ function MyController(hand, triggerAction) { this.currentObjectTime = now; // this doubles hand rotation - var handChange = Quat.multiply(Quat.slerp(this.handPreviousRotation, handRotation, DISTANCE_HOLDING_ROTATION_EXAGGERATION_FACTOR), Quat.inverse(this.handPreviousRotation)); + var handChange = Quat.multiply(Quat.slerp(this.handPreviousRotation, + handRotation, + DISTANCE_HOLDING_ROTATION_EXAGGERATION_FACTOR), + Quat.inverse(this.handPreviousRotation)); this.handPreviousRotation = handRotation; this.currentObjectRotation = Quat.multiply(handChange, this.currentObjectRotation); @@ -526,7 +545,8 @@ function MyController(hand, triggerAction) { this.lineOff(); - var grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, ["position", "rotation", "gravity", "ignoreForCollisions"]); + var grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, + ["position", "rotation", "gravity", "ignoreForCollisions"]); this.activateEntity(this.grabbedEntity, grabbedProperties); var handRotation = this.getHandRotation(); @@ -764,9 +784,9 @@ function MyController(hand, triggerAction) { this.release = function() { - if(this.hand!==disabledHand){ + if(this.hand !== disabledHand){ //release the disabled hand when we let go with the main one - disabledHand='none'; + disabledHand = 'none'; } this.lineOff(); From ed480f651f06a916b40988a7494277c7b23e66be Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 20 Oct 2015 17:43:31 -0700 Subject: [PATCH 06/10] missed a line --- examples/controllers/handControllerGrab.js | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/controllers/handControllerGrab.js b/examples/controllers/handControllerGrab.js index 9f174bd3e6..1ed3406c61 100644 --- a/examples/controllers/handControllerGrab.js +++ b/examples/controllers/handControllerGrab.js @@ -49,6 +49,7 @@ var PICK_MAX_DISTANCE = 500; // max length of pick-ray // near grabbing // +var GRAB_RADIUS = 0.3; // if the ray misses but an object is this close, it will still be selected var NEAR_GRABBING_ACTION_TIMEFRAME = 0.05; // how quickly objects move to their new position var NEAR_GRABBING_VELOCITY_SMOOTH_RATIO = 1.0; // adjust time-averaging of held object's velocity. 1.0 to disable. var NEAR_PICK_MAX_DISTANCE = 0.3; // max length of pick-ray for close grabbing to be selected From 7dcbb5849ae0ccfe45db2b717aa88829f78840cc Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 20 Oct 2015 17:44:12 -0700 Subject: [PATCH 07/10] another bug --- examples/controllers/handControllerGrab.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/controllers/handControllerGrab.js b/examples/controllers/handControllerGrab.js index 1ed3406c61..9176394a95 100644 --- a/examples/controllers/handControllerGrab.js +++ b/examples/controllers/handControllerGrab.js @@ -381,7 +381,7 @@ function MyController(hand, triggerAction) { var propsForCandidate = Entities.getEntityProperties(nearbyEntities[i], ["position", "name", "collisionsWillMove", "locked"]); distance = Vec3.distance(propsForCandidate.position, handPosition); - if (distance < minDistance && props.name !== "pointer") { + if (distance < minDistance && propsForCandidate.name !== "pointer") { this.grabbedEntity = nearbyEntities[i]; minDistance = distance; props = propsForCandidate; From 311254c395d5db9dd11bb2999bac126b23feab79 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 20 Oct 2015 18:26:12 -0700 Subject: [PATCH 08/10] require user-data to have wantsTrigger in it before non-colliding calls will happen --- examples/controllers/handControllerGrab.js | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/examples/controllers/handControllerGrab.js b/examples/controllers/handControllerGrab.js index 9176394a95..a087236abd 100644 --- a/examples/controllers/handControllerGrab.js +++ b/examples/controllers/handControllerGrab.js @@ -372,10 +372,11 @@ function MyController(hand, triggerAction) { // forward ray test failed, try sphere test. var nearbyEntities = Entities.findEntities(handPosition, GRAB_RADIUS); var minDistance = PICK_MAX_DISTANCE; - var i, props, distance; + var i, props, distance, grabbableData; for (i = 0; i < nearbyEntities.length; i++) { - var grabbableData = getEntityCustomData(GRABBABLE_DATA_KEY, nearbyEntities[i], DEFAULT_GRABBABLE_DATA); - if (grabbableData.grabbable === false) { + var grabbableDataForCandidate = + getEntityCustomData(GRABBABLE_DATA_KEY, nearbyEntities[i], DEFAULT_GRABBABLE_DATA); + if (grabbableDataForCandidate.grabbable === false) { continue; } var propsForCandidate = @@ -385,13 +386,14 @@ function MyController(hand, triggerAction) { this.grabbedEntity = nearbyEntities[i]; minDistance = distance; props = propsForCandidate; + grabbableData = grabbableDataForCandidate; } } if (this.grabbedEntity === null) { return; } else if (props.locked === 0 && props.collisionsWillMove === 1) { this.setState(STATE_NEAR_GRABBING); - } else if (props.collisionsWillMove === 0) { + } else if (props.collisionsWillMove === 0 & grabbableData.wantsTrigger) { // We have grabbed a non-physical object, so we want to trigger a non-colliding event as opposed to a grab event this.setState(STATE_NEAR_GRABBING_NON_COLLIDING); } From f85ef9267baeebdf1dc8ca4e7b49a22ff9564948 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 20 Oct 2015 18:29:27 -0700 Subject: [PATCH 09/10] oops --- examples/controllers/handControllerGrab.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/controllers/handControllerGrab.js b/examples/controllers/handControllerGrab.js index a087236abd..80fb4c8e40 100644 --- a/examples/controllers/handControllerGrab.js +++ b/examples/controllers/handControllerGrab.js @@ -393,7 +393,7 @@ function MyController(hand, triggerAction) { return; } else if (props.locked === 0 && props.collisionsWillMove === 1) { this.setState(STATE_NEAR_GRABBING); - } else if (props.collisionsWillMove === 0 & grabbableData.wantsTrigger) { + } else if (props.collisionsWillMove === 0 && grabbableData.wantsTrigger) { // We have grabbed a non-physical object, so we want to trigger a non-colliding event as opposed to a grab event this.setState(STATE_NEAR_GRABBING_NON_COLLIDING); } From d34ad2af42854e38415d9b1debea048c3a741c05 Mon Sep 17 00:00:00 2001 From: Brad Hefta-Gaub Date: Tue, 20 Oct 2015 21:01:20 -0700 Subject: [PATCH 10/10] improved findEntities(sphere) to check against Non-AABBox of entities --- libraries/entities/src/EntityTreeElement.cpp | 84 +++++++++++++++++--- libraries/entities/src/EntityTreeElement.h | 7 +- 2 files changed, 77 insertions(+), 14 deletions(-) diff --git a/libraries/entities/src/EntityTreeElement.cpp b/libraries/entities/src/EntityTreeElement.cpp index 56ab27836c..34433cdbb1 100644 --- a/libraries/entities/src/EntityTreeElement.cpp +++ b/libraries/entities/src/EntityTreeElement.cpp @@ -609,25 +609,83 @@ EntityItemPointer EntityTreeElement::getClosestEntity(glm::vec3 position) const void EntityTreeElement::getEntities(const glm::vec3& searchPosition, float searchRadius, QVector& foundEntities) const { float compareRadius = searchRadius * searchRadius; forEachEntity([&](EntityItemPointer entity) { - // For iteration like this, avoid the use of square roots by comparing distances squared - float distanceSquared = glm::length2(entity->getPosition() - searchPosition); - float otherRadius = entity->getRadius(); - if (distanceSquared < (compareRadius + (otherRadius * otherRadius))) { + + AABox entityBox = entity->getAABox(); + + // if the sphere doesn't intersect with our world frame AABox, we don't need to consider the more complex case + glm::vec3 penetration; + if (entityBox.findSpherePenetration(searchPosition, searchRadius, penetration)) { + + // FIXME - handle entity->getShapeType() == SHAPE_TYPE_SPHERE case better + // FIXME - consider allowing the entity to determine penetration so that + // entities could presumably dull actuall hull testing if they wanted to + + // determine the worldToEntityMatrix that doesn't include scale because + // we're going to use the registration aware aa box in the entity frame + glm::mat4 rotation = glm::mat4_cast(entity->getRotation()); + glm::mat4 translation = glm::translate(entity->getPosition()); + glm::mat4 entityToWorldMatrix = translation * rotation; + glm::mat4 worldToEntityMatrix = glm::inverse(entityToWorldMatrix); + + glm::vec3 dimensions = entity->getDimensions(); + glm::vec3 registrationPoint = entity->getRegistrationPoint(); + glm::vec3 corner = -(dimensions * registrationPoint); + + AABox entityFrameBox(corner, dimensions); + + glm::vec3 entityFrameSearchPosition = glm::vec3(worldToEntityMatrix * glm::vec4(searchPosition, 1.0f)); + if (entityFrameBox.findSpherePenetration(entityFrameSearchPosition, searchRadius, penetration)) { + foundEntities.push_back(entity); + } + } + }); +} + +void EntityTreeElement::getEntities(const AACube& cube, QVector& foundEntities) { + forEachEntity([&](EntityItemPointer entity) { + AABox entityBox = entity->getAABox(); + // FIXME - handle entity->getShapeType() == SHAPE_TYPE_SPHERE case better + // FIXME - consider allowing the entity to determine penetration so that + // entities could presumably dull actuall hull testing if they wanted to + // FIXME - is there an easy way to translate the search cube into something in the + // entity frame that can be easily tested against? + // simple algorithm is probably: + // if target box is fully inside search box == yes + // if search box is fully inside target box == yes + // for each face of search box: + // translate the triangles of the face into the box frame + // test the triangles of the face against the box? + // if translated search face triangle intersect target box + // add to result + // + + // If the entities AABox touches the search cube then consider it to be found + if (entityBox.touches(cube)) { foundEntities.push_back(entity); } }); } -// TODO: change this to use better bounding shape for entity than sphere -void EntityTreeElement::getEntities(const AACube& box, QVector& foundEntities) { - AACube entityCube; +void EntityTreeElement::getEntities(const AABox& box, QVector& foundEntities) { forEachEntity([&](EntityItemPointer entity) { - float radius = entity->getRadius(); - // NOTE: we actually do cube-cube collision queries here, which is sloppy but good enough for now - // TODO: decide whether to replace entityCube-cube query with sphere-cube (requires a square root - // but will be slightly more accurate). - entityCube.setBox(entity->getPosition() - glm::vec3(radius), 2.0f * radius); - if (entityCube.touches(box)) { + AABox entityBox = entity->getAABox(); + // FIXME - handle entity->getShapeType() == SHAPE_TYPE_SPHERE case better + // FIXME - consider allowing the entity to determine penetration so that + // entities could presumably dull actuall hull testing if they wanted to + // FIXME - is there an easy way to translate the search cube into something in the + // entity frame that can be easily tested against? + // simple algorithm is probably: + // if target box is fully inside search box == yes + // if search box is fully inside target box == yes + // for each face of search box: + // translate the triangles of the face into the box frame + // test the triangles of the face against the box? + // if translated search face triangle intersect target box + // add to result + // + + // If the entities AABox touches the search cube then consider it to be found + if (entityBox.touches(box)) { foundEntities.push_back(entity); } }); diff --git a/libraries/entities/src/EntityTreeElement.h b/libraries/entities/src/EntityTreeElement.h index 0a47542e65..cb5e35945e 100644 --- a/libraries/entities/src/EntityTreeElement.h +++ b/libraries/entities/src/EntityTreeElement.h @@ -180,7 +180,12 @@ public: /// finds all entities that touch a box /// \param box the query box /// \param entities[out] vector of non-const EntityItemPointer - void getEntities(const AACube& box, QVector& foundEntities); + void getEntities(const AACube& cube, QVector& foundEntities); + + /// finds all entities that touch a box + /// \param box the query box + /// \param entities[out] vector of non-const EntityItemPointer + void getEntities(const AABox& box, QVector& foundEntities); EntityItemPointer getEntityWithID(uint32_t id) const; EntityItemPointer getEntityWithEntityItemID(const EntityItemID& id) const;