Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-08 13:38:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Adding in functionality to include only specified Ids in ray picking

Browse source
This commit is contained in:
ericrius1 2015-10-12 14:40:11 -07:00
parent 8dddf0e17a
commit d01dda9c81
9 changed files with 23 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
examples/controllers/handControllerGrab.js
View file

@ -67,7 +67,7 @@ var MSEC_PER_SEC = 1000.0;
var startTime = Date.now(); var startTime = Date.now();
var LIFETIME = 10; var LIFETIME = 10;
var ACTION_LIFETIME = 10; // seconds var ACTION_LIFETIME = 10; // seconds
var PICKS_PER_SECOND_PER_HAND = 5; var PICKS_PER_SECOND_PER_HAND = 60;
var MSECS_PER_SEC = 1000.0; var MSECS_PER_SEC = 1000.0;
// states for the state machine // states for the state machine

10
libraries/entities/src/EntityScriptingInterface.cpp
View file

@ -279,16 +279,16 @@ QVector<QUuid> EntityScriptingInterface::findEntitiesInBox(const glm::vec3& corn
return result; return result;
} }
RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersection(const PickRay& ray, bool precisionPicking) { RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersection(const PickRay& ray, const QVector<QUuid>& entityIdsToIgnore, bool precisionPicking) {
return findRayIntersectionWorker(ray, Octree::TryLock, precisionPicking); return findRayIntersectionWorker(ray, Octree::TryLock, entityIdsToIgnore, precisionPicking);
} }
RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionBlocking(const PickRay& ray, bool precisionPicking) { RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionBlocking(const PickRay& ray, const QVector<QUuid>& entityIdsToIgnore, bool precisionPicking) {
return findRayIntersectionWorker(ray, Octree::Lock, precisionPicking); return findRayIntersectionWorker(ray, Octree::Lock, entityIdsToIgnore, precisionPicking);
} }
RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionWorker(const PickRay& ray, RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionWorker(const PickRay& ray,
Octree::lockType lockType, Octree::lockType lockType, const QVector<QUuid>& entityIdsToIgnore,
bool precisionPicking) { bool precisionPicking) {

6
libraries/entities/src/EntityScriptingInterface.h
View file

@ -111,11 +111,11 @@ public slots:
/// If the scripting context has visible entities, this will determine a ray intersection, the results /// If the scripting context has visible entities, this will determine a ray intersection, the results
/// may be inaccurate if the engine is unable to access the visible entities, in which case result.accurate /// may be inaccurate if the engine is unable to access the visible entities, in which case result.accurate
/// will be false. /// will be false.
Q_INVOKABLE RayToEntityIntersectionResult findRayIntersection(const PickRay& ray, bool precisionPicking = false); Q_INVOKABLE RayToEntityIntersectionResult findRayIntersection(const PickRay& ray, const QVector<QUuid>& entityIdsToInclude, bool precisionPicking = false);
/// If the scripting context has visible entities, this will determine a ray intersection, and will block in /// If the scripting context has visible entities, this will determine a ray intersection, and will block in
/// order to return an accurate result /// order to return an accurate result
Q_INVOKABLE RayToEntityIntersectionResult findRayIntersectionBlocking(const PickRay& ray, bool precisionPicking = false); Q_INVOKABLE RayToEntityIntersectionResult findRayIntersectionBlocking(const PickRay& ray, const QVector<QUuid>& entityIdsToInclude, bool precisionPicking = false);
Q_INVOKABLE void setLightsArePickable(bool value); Q_INVOKABLE void setLightsArePickable(bool value);
Q_INVOKABLE bool getLightsArePickable() const; Q_INVOKABLE bool getLightsArePickable() const;
@ -185,7 +185,7 @@ private:
/// actually does the work of finding the ray intersection, can be called in locking mode or tryLock mode /// 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, RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType, const QVector<QUuid>& entityIdsToInclude,
bool precisionPicking); bool precisionPicking);
EntityTreePointer _entityTree; EntityTreePointer _entityTree;

4
libraries/entities/src/EntityTreeElement.cpp
View file

@ -495,12 +495,14 @@ bool EntityTreeElement::bestFitBounds(const glm::vec3& minPoint, const glm::vec3
bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool& keepSearching, bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool& keepSearching,
OctreeElementPointer& element, float& distance, BoxFace& face, glm::vec3& surfaceNormal, OctreeElementPointer& element, float& distance, BoxFace& face, glm::vec3& surfaceNormal,
void** intersectedObject, bool precisionPicking, float distanceToElementCube) { const QVector<QUuid>& entityIdsToInclude, void** intersectedObject, bool precisionPicking, float distanceToElementCube) {
// only called if we do intersect our bounding cube, but find if we actually intersect with entities... // only called if we do intersect our bounding cube, but find if we actually intersect with entities...
int entityNumber = 0; int entityNumber = 0;
bool somethingIntersected = false; bool somethingIntersected = false;
forEachEntity([&](EntityItemPointer entity) { forEachEntity([&](EntityItemPointer entity) {
qDebug() << "entity Ids to ignore:************* " << entityIdsToInclude;
AABox entityBox = entity->getAABox(); AABox entityBox = entity->getAABox();
float localDistance; float localDistance;
BoxFace localFace; BoxFace localFace;

2
libraries/entities/src/EntityTreeElement.h
View file

@ -144,7 +144,7 @@ public:
virtual bool canRayIntersect() const { return hasEntities(); } virtual bool canRayIntersect() const { return hasEntities(); }
virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction, virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
bool& keepSearching, OctreeElementPointer& element, float& distance, bool& keepSearching, OctreeElementPointer& element, float& distance,
BoxFace& face, glm::vec3& surfaceNormal, BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
void** intersectedObject, bool precisionPicking, float distanceToElementCube); void** intersectedObject, bool precisionPicking, float distanceToElementCube);
virtual bool findSpherePenetration(const glm::vec3& center, float radius, virtual bool findSpherePenetration(const glm::vec3& center, float radius,

7
libraries/octree/src/Octree.cpp
View file

@ -703,6 +703,7 @@ public:
float& distance; float& distance;
BoxFace& face; BoxFace& face;
glm::vec3& surfaceNormal; glm::vec3& surfaceNormal;
const QVector<QUuid>& entityIdsToInclude;
void** intersectedObject; void** intersectedObject;
bool found; bool found;
bool precisionPicking; bool precisionPicking;
@ -712,7 +713,7 @@ bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) {
RayArgs* args = static_cast<RayArgs*>(extraData); RayArgs* args = static_cast<RayArgs*>(extraData);
bool keepSearching = true; bool keepSearching = true;
if (element->findRayIntersection(args->origin, args->direction, keepSearching, if (element->findRayIntersection(args->origin, args->direction, keepSearching,
args->element, args->distance, args->face, args->surfaceNormal, args->element, args->distance, args->face, args->surfaceNormal, args->entityIdsToInclude,
args->intersectedObject, args->precisionPicking)) { args->intersectedObject, args->precisionPicking)) {
args->found = true; args->found = true;
} }
@ -721,9 +722,9 @@ bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) {
bool Octree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool Octree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
OctreeElementPointer& element, float& distance, OctreeElementPointer& element, float& distance,
BoxFace& face, glm::vec3& surfaceNormal, void** intersectedObject, BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude, void** intersectedObject,
Octree::lockType lockType, bool* accurateResult, bool precisionPicking) { Octree::lockType lockType, bool* accurateResult, bool precisionPicking) {
RayArgs args = { origin, direction, element, distance, face, surfaceNormal, intersectedObject, false, precisionPicking}; RayArgs args = { origin, direction, element, distance, face, surfaceNormal, entityIdsToInclude, intersectedObject, false, precisionPicking};
distance = FLT_MAX; distance = FLT_MAX;
bool requireLock = lockType == Octree::Lock; bool requireLock = lockType == Octree::Lock;

1
libraries/octree/src/Octree.h
View file

@ -300,6 +300,7 @@ public:
bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
OctreeElementPointer& node, float& distance, BoxFace& face, glm::vec3& surfaceNormal, OctreeElementPointer& node, float& distance, BoxFace& face, glm::vec3& surfaceNormal,
const QVector<QUuid>& entityIdsToInclude,
void** intersectedObject = NULL, void** intersectedObject = NULL,
Octree::lockType lockType = Octree::TryLock, Octree::lockType lockType = Octree::TryLock,
bool* accurateResult = NULL, bool* accurateResult = NULL,

6
libraries/octree/src/OctreeElement.cpp
View file

@ -575,7 +575,7 @@ void OctreeElement::notifyUpdateHooks() {
bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
bool& keepSearching, OctreeElementPointer& element, float& distance, bool& keepSearching, OctreeElementPointer& element, float& distance,
BoxFace& face, glm::vec3& surfaceNormal, BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
void** intersectedObject, bool precisionPicking) { void** intersectedObject, bool precisionPicking) {
keepSearching = true; // assume that we will continue searching after this. keepSearching = true; // assume that we will continue searching after this.
@ -601,7 +601,7 @@ bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3
if (_cube.contains(origin) || distanceToElementCube < distance) { if (_cube.contains(origin) || distanceToElementCube < distance) {
if (findDetailedRayIntersection(origin, direction, keepSearching, element, distanceToElementDetails, if (findDetailedRayIntersection(origin, direction, keepSearching, element, distanceToElementDetails,
face, localSurfaceNormal, intersectedObject, precisionPicking, distanceToElementCube)) { face, localSurfaceNormal, entityIdsToInclude, intersectedObject, precisionPicking, distanceToElementCube)) {
if (distanceToElementDetails < distance) { if (distanceToElementDetails < distance) {
distance = distanceToElementDetails; distance = distanceToElementDetails;
@ -616,7 +616,7 @@ bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3
bool OctreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool OctreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
bool& keepSearching, OctreeElementPointer& element, float& distance, bool& keepSearching, OctreeElementPointer& element, float& distance,
BoxFace& face, glm::vec3& surfaceNormal, BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
void** intersectedObject, bool precisionPicking, float distanceToElementCube) { void** intersectedObject, bool precisionPicking, float distanceToElementCube) {
// we did hit this element, so calculate appropriate distances // we did hit this element, so calculate appropriate distances

4
libraries/octree/src/OctreeElement.h
View file

@ -120,12 +120,12 @@ public:
virtual bool canRayIntersect() const { return isLeaf(); } virtual bool canRayIntersect() const { return isLeaf(); }
virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
bool& keepSearching, OctreeElementPointer& node, float& distance, bool& keepSearching, OctreeElementPointer& node, float& distance,
BoxFace& face, glm::vec3& surfaceNormal, BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
void** intersectedObject = NULL, bool precisionPicking = false); void** intersectedObject = NULL, bool precisionPicking = false);
virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction, virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
bool& keepSearching, OctreeElementPointer& element, float& distance, bool& keepSearching, OctreeElementPointer& element, float& distance,
BoxFace& face, glm::vec3& surfaceNormal, BoxFace& face, glm::vec3& surfaceNormal, const QVector<QUuid>& entityIdsToInclude,
void** intersectedObject, bool precisionPicking, float distanceToElementCube); void** intersectedObject, bool precisionPicking, float distanceToElementCube);
/// \param center center of sphere in meters /// \param center center of sphere in meters