From 930d9957f3289f0cb7c13aa1213a88d5be8b88e1 Mon Sep 17 00:00:00 2001 From: Andrew Meadows Date: Thu, 2 Jan 2014 16:09:41 -0800 Subject: [PATCH 1/7] Changed argument names in collision methods for improved readability. --- libraries/shared/src/GeometryUtil.cpp | 100 +++++++++++++------------- libraries/shared/src/GeometryUtil.h | 38 +++++----- 2 files changed, 69 insertions(+), 69 deletions(-) diff --git a/libraries/shared/src/GeometryUtil.cpp b/libraries/shared/src/GeometryUtil.cpp index 1da05f9fae..6f48401ce7 100644 --- a/libraries/shared/src/GeometryUtil.cpp +++ b/libraries/shared/src/GeometryUtil.cpp @@ -31,105 +31,105 @@ glm::vec3 computeVectorFromPointToSegment(const glm::vec3& point, const glm::vec } } -bool findSpherePenetration(const glm::vec3& penetratorToPenetratee, const glm::vec3& direction, +bool findSpherePenetration(const glm::vec3& localPoint, const glm::vec3& direction, float combinedRadius, glm::vec3& penetration) { - float vectorLength = glm::length(penetratorToPenetratee); + float vectorLength = glm::length(localPoint); if (vectorLength < EPSILON) { penetration = direction * combinedRadius; return true; } float distance = vectorLength - combinedRadius; if (distance < 0.0f) { - penetration = penetratorToPenetratee * (-distance / vectorLength); + penetration = localPoint * (-distance / vectorLength); return true; } return false; } -bool findSpherePointPenetration(const glm::vec3& penetratorCenter, float penetratorRadius, - const glm::vec3& penetrateeLocation, glm::vec3& penetration) { - return findSpherePenetration(penetrateeLocation - penetratorCenter, glm::vec3(0.0f, -1.0f, 0.0f), - penetratorRadius, penetration); +bool findSpherePointPenetration(const glm::vec3& sphereCenter, float sphereRadius, + const glm::vec3& point, glm::vec3& penetration) { + return findSpherePenetration(point - sphereCenter, glm::vec3(0.0f, -1.0f, 0.0f), + sphereRadius, penetration); } -bool findPointSpherePenetration(const glm::vec3& penetratorLocation, const glm::vec3& penetrateeCenter, - float penetrateeRadius, glm::vec3& penetration) { - return findSpherePenetration(penetrateeCenter - penetratorLocation, glm::vec3(0.0f, -1.0f, 0.0f), - penetrateeRadius, penetration); +bool findPointSpherePenetration(const glm::vec3& point, const glm::vec3& sphereCenter, + float sphereRadius, glm::vec3& penetration) { + return findSpherePenetration(sphereCenter - point, glm::vec3(0.0f, -1.0f, 0.0f), + sphereRadius, penetration); } -bool findSphereSpherePenetration(const glm::vec3& penetratorCenter, float penetratorRadius, - const glm::vec3& penetrateeCenter, float penetrateeRadius, glm::vec3& penetration) { - return findSpherePointPenetration(penetratorCenter, penetratorRadius + penetrateeRadius, penetrateeCenter, penetration); +bool findSphereSpherePenetration(const glm::vec3& firstCenter, float firstRadius, + const glm::vec3& secondCenter, float secondRadius, glm::vec3& penetration) { + return findSpherePointPenetration(firstCenter, firstRadius + secondRadius, secondCenter, penetration); } -bool findSphereSegmentPenetration(const glm::vec3& penetratorCenter, float penetratorRadius, - const glm::vec3& penetrateeStart, const glm::vec3& penetrateeEnd, glm::vec3& penetration) { - return findSpherePenetration(computeVectorFromPointToSegment(penetratorCenter, penetrateeStart, penetrateeEnd), - glm::vec3(0.0f, -1.0f, 0.0f), penetratorRadius, penetration); +bool findSphereSegmentPenetration(const glm::vec3& sphereCenter, float sphereRadius, + const glm::vec3& segmentStart, const glm::vec3& segmentEnd, glm::vec3& penetration) { + return findSpherePenetration(computeVectorFromPointToSegment(sphereCenter, segmentStart, segmentEnd), + glm::vec3(0.0f, -1.0f, 0.0f), sphereRadius, penetration); } -bool findSphereCapsulePenetration(const glm::vec3& penetratorCenter, float penetratorRadius, const glm::vec3& penetrateeStart, - const glm::vec3& penetrateeEnd, float penetrateeRadius, glm::vec3& penetration) { - return findSphereSegmentPenetration(penetratorCenter, penetratorRadius + penetrateeRadius, - penetrateeStart, penetrateeEnd, penetration); +bool findSphereCapsulePenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& capsuleStart, + const glm::vec3& capsuleEnd, float capsuleRadius, glm::vec3& penetration) { + return findSphereSegmentPenetration(sphereCenter, sphereRadius + capsuleRadius, + capsuleStart, capsuleEnd, penetration); } -bool findPointCapsuleConePenetration(const glm::vec3& penetratorLocation, const glm::vec3& penetrateeStart, - const glm::vec3& penetrateeEnd, float penetrateeStartRadius, float penetrateeEndRadius, glm::vec3& penetration) { +bool findPointCapsuleConePenetration(const glm::vec3& point, const glm::vec3& segmentStart, + const glm::vec3& segmentEnd, float startRadius, float endRadius, glm::vec3& penetration) { // compute the projection of the point vector onto the segment vector - glm::vec3 segmentVector = penetrateeEnd - penetrateeStart; + glm::vec3 segmentVector = segmentEnd - segmentStart; float lengthSquared = glm::dot(segmentVector, segmentVector); if (lengthSquared < EPSILON) { // start and end the same - return findPointSpherePenetration(penetratorLocation, penetrateeStart, - glm::max(penetrateeStartRadius, penetrateeEndRadius), penetration); + return findPointSpherePenetration(point, segmentStart, + glm::max(startRadius, endRadius), penetration); } - float proj = glm::dot(penetratorLocation - penetrateeStart, segmentVector) / lengthSquared; + float proj = glm::dot(point - segmentStart, segmentVector) / lengthSquared; if (proj <= 0.0f) { // closest to the start - return findPointSpherePenetration(penetratorLocation, penetrateeStart, penetrateeStartRadius, penetration); + return findPointSpherePenetration(point, segmentStart, startRadius, penetration); } else if (proj >= 1.0f) { // closest to the end - return findPointSpherePenetration(penetratorLocation, penetrateeEnd, penetrateeEndRadius, penetration); + return findPointSpherePenetration(point, segmentEnd, endRadius, penetration); } else { // closest to the middle - return findPointSpherePenetration(penetratorLocation, penetrateeStart + segmentVector * proj, - glm::mix(penetrateeStartRadius, penetrateeEndRadius, proj), penetration); + return findPointSpherePenetration(point, segmentStart + segmentVector * proj, + glm::mix(startRadius, endRadius, proj), penetration); } } -bool findSphereCapsuleConePenetration(const glm::vec3& penetratorCenter, - float penetratorRadius, const glm::vec3& penetrateeStart, const glm::vec3& penetrateeEnd, - float penetrateeStartRadius, float penetrateeEndRadius, glm::vec3& penetration) { - return findPointCapsuleConePenetration(penetratorCenter, penetrateeStart, penetrateeEnd, - penetrateeStartRadius + penetratorRadius, penetrateeEndRadius + penetratorRadius, penetration); +bool findSphereCapsuleConePenetration(const glm::vec3& sphereCenter, + float sphereRadius, const glm::vec3& segmentStart, const glm::vec3& segmentEnd, + float startRadius, float endRadius, glm::vec3& penetration) { + return findPointCapsuleConePenetration(sphereCenter, segmentStart, segmentEnd, + startRadius + sphereRadius, endRadius + sphereRadius, penetration); } -bool findSpherePlanePenetration(const glm::vec3& penetratorCenter, float penetratorRadius, - const glm::vec4& penetrateePlane, glm::vec3& penetration) { - float distance = glm::dot(penetrateePlane, glm::vec4(penetratorCenter, 1.0f)) - penetratorRadius; +bool findSpherePlanePenetration(const glm::vec3& sphereCenter, float sphereRadius, + const glm::vec4& plane, glm::vec3& penetration) { + float distance = glm::dot(plane, glm::vec4(sphereCenter, 1.0f)) - sphereRadius; if (distance < 0.0f) { - penetration = glm::vec3(penetrateePlane) * distance; + penetration = glm::vec3(plane) * distance; return true; } return false; } -bool findCapsuleSpherePenetration(const glm::vec3& penetratorStart, const glm::vec3& penetratorEnd, float penetratorRadius, - const glm::vec3& penetrateeCenter, float penetrateeRadius, glm::vec3& penetration) { - if (findSphereCapsulePenetration(penetrateeCenter, penetrateeRadius, - penetratorStart, penetratorEnd, penetratorRadius, penetration)) { +bool findCapsuleSpherePenetration(const glm::vec3& capsuleStart, const glm::vec3& capsuleEnd, float capsuleRadius, + const glm::vec3& sphereCenter, float sphereRadius, glm::vec3& penetration) { + if (findSphereCapsulePenetration(sphereCenter, sphereRadius, + capsuleStart, capsuleEnd, capsuleRadius, penetration)) { penetration = -penetration; return true; } return false; } -bool findCapsulePlanePenetration(const glm::vec3& penetratorStart, const glm::vec3& penetratorEnd, float penetratorRadius, - const glm::vec4& penetrateePlane, glm::vec3& penetration) { - float distance = glm::min(glm::dot(penetrateePlane, glm::vec4(penetratorStart, 1.0f)), - glm::dot(penetrateePlane, glm::vec4(penetratorEnd, 1.0f))) - penetratorRadius; +bool findCapsulePlanePenetration(const glm::vec3& capsuleStart, const glm::vec3& capsuleEnd, float capsuleRadius, + const glm::vec4& plane, glm::vec3& penetration) { + float distance = glm::min(glm::dot(plane, glm::vec4(capsuleStart, 1.0f)), + glm::dot(plane, glm::vec4(capsuleEnd, 1.0f))) - capsuleRadius; if (distance < 0.0f) { - penetration = glm::vec3(penetrateePlane) * distance; + penetration = glm::vec3(plane) * distance; return true; } return false; diff --git a/libraries/shared/src/GeometryUtil.h b/libraries/shared/src/GeometryUtil.h index 8cbb29580a..4bba48fe08 100644 --- a/libraries/shared/src/GeometryUtil.h +++ b/libraries/shared/src/GeometryUtil.h @@ -13,39 +13,39 @@ glm::vec3 computeVectorFromPointToSegment(const glm::vec3& point, const glm::vec3& start, const glm::vec3& end); -bool findSpherePenetration(const glm::vec3& penetratorToPenetratee, const glm::vec3& direction, +bool findSpherePenetration(const glm::vec3& localPoint, const glm::vec3& direction, float combinedRadius, glm::vec3& penetration); -bool findSpherePointPenetration(const glm::vec3& penetratorCenter, float penetratorRadius, +bool findSpherePointPenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& penetrateeLocation, glm::vec3& penetration); -bool findPointSpherePenetration(const glm::vec3& penetratorLocation, const glm::vec3& penetrateeCenter, - float penetrateeRadius, glm::vec3& penetration); +bool findPointSpherePenetration(const glm::vec3& point, const glm::vec3& sphereCenter, + float sphereRadius, glm::vec3& penetration); -bool findSphereSpherePenetration(const glm::vec3& penetratorCenter, float penetratorRadius, - const glm::vec3& penetrateeCenter, float penetrateeRadius, glm::vec3& penetration); +bool findSphereSpherePenetration(const glm::vec3& firstCenter, float firstRadius, + const glm::vec3& secondCenter, float secondRadius, glm::vec3& penetration); -bool findSphereSegmentPenetration(const glm::vec3& penetratorCenter, float penetratorRadius, +bool findSphereSegmentPenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& penetrateeStart, const glm::vec3& penetrateeEnd, glm::vec3& penetration); -bool findSphereCapsulePenetration(const glm::vec3& penetratorCenter, float penetratorRadius, const glm::vec3& penetrateeStart, - const glm::vec3& penetrateeEnd, float penetrateeRadius, glm::vec3& penetration); +bool findSphereCapsulePenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& penetrateeStart, + const glm::vec3& penetrateeEnd, float capsuleRadius, glm::vec3& penetration); -bool findPointCapsuleConePenetration(const glm::vec3& penetratorLocation, const glm::vec3& penetrateeStart, - const glm::vec3& penetrateeEnd, float penetrateeStartRadius, float penetrateeEndRadius, glm::vec3& penetration); +bool findPointCapsuleConePenetration(const glm::vec3& point, const glm::vec3& segmentStart, + const glm::vec3& segmentEnd, float startRadius, float endRadius, glm::vec3& penetration); -bool findSphereCapsuleConePenetration(const glm::vec3& penetratorCenter, - float penetratorRadius, const glm::vec3& penetrateeStart, const glm::vec3& penetrateeEnd, +bool findSphereCapsuleConePenetration(const glm::vec3& sphereCenter, float sphereRadius, + const glm::vec3& penetrateeStart, const glm::vec3& penetrateeEnd, float penetrateeStartRadius, float penetrateeEndRadius, glm::vec3& penetration); -bool findSpherePlanePenetration(const glm::vec3& penetratorCenter, float penetratorRadius, - const glm::vec4& penetrateePlane, glm::vec3& penetration); +bool findSpherePlanePenetration(const glm::vec3& sphereCenter, float sphereRadius, + const glm::vec4& plane, glm::vec3& penetration); -bool findCapsuleSpherePenetration(const glm::vec3& penetratorStart, const glm::vec3& penetratorEnd, float penetratorRadius, - const glm::vec3& penetrateeCenter, float penetrateeRadius, glm::vec3& penetration); +bool findCapsuleSpherePenetration(const glm::vec3& capsuleStart, const glm::vec3& capsuleEnd, float capsuleRadius, + const glm::vec3& sphereCenter, float sphereRadius, glm::vec3& penetration); -bool findCapsulePlanePenetration(const glm::vec3& penetratorStart, const glm::vec3& penetratorEnd, float penetratorRadius, - const glm::vec4& penetrateePlane, glm::vec3& penetration); +bool findCapsulePlanePenetration(const glm::vec3& capsuleStart, const glm::vec3& capsuleEnd, float capsuleRadius, + const glm::vec4& plane, glm::vec3& penetration); glm::vec3 addPenetrations(const glm::vec3& currentPenetration, const glm::vec3& newPenetration); From ea88f00ce527a40b25bdee0326516990e1af7d71 Mon Sep 17 00:00:00 2001 From: Andrew Meadows Date: Fri, 3 Jan 2014 16:01:31 -0800 Subject: [PATCH 2/7] Name changes, formatting, and comments for readability. --- libraries/shared/src/GeometryUtil.cpp | 46 ++++++++++++++------------- libraries/shared/src/GeometryUtil.h | 26 +++++++++------ 2 files changed, 40 insertions(+), 32 deletions(-) diff --git a/libraries/shared/src/GeometryUtil.cpp b/libraries/shared/src/GeometryUtil.cpp index 6f48401ce7..4536c962e5 100644 --- a/libraries/shared/src/GeometryUtil.cpp +++ b/libraries/shared/src/GeometryUtil.cpp @@ -31,16 +31,20 @@ glm::vec3 computeVectorFromPointToSegment(const glm::vec3& point, const glm::vec } } -bool findSpherePenetration(const glm::vec3& localPoint, const glm::vec3& direction, - float combinedRadius, glm::vec3& penetration) { - float vectorLength = glm::length(localPoint); +// Computes the penetration between a point and a sphere (centered at the origin) +// if point is inside sphere: returns true and stores the result in 'penetration' +// (the vector that would move the point outside the sphere) +// otherwise returns false +bool findSpherePenetration(const glm::vec3& point, const glm::vec3& defaultDirection, float sphereRadius, + glm::vec3& penetration) { + float vectorLength = glm::length(point); if (vectorLength < EPSILON) { - penetration = direction * combinedRadius; + penetration = defaultDirection * sphereRadius; return true; } - float distance = vectorLength - combinedRadius; + float distance = vectorLength - sphereRadius; if (distance < 0.0f) { - penetration = localPoint * (-distance / vectorLength); + penetration = point * (-distance / vectorLength); return true; } return false; @@ -48,14 +52,12 @@ bool findSpherePenetration(const glm::vec3& localPoint, const glm::vec3& directi bool findSpherePointPenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& point, glm::vec3& penetration) { - return findSpherePenetration(point - sphereCenter, glm::vec3(0.0f, -1.0f, 0.0f), - sphereRadius, penetration); + return findSpherePenetration(point - sphereCenter, glm::vec3(0.0f, -1.0f, 0.0f), sphereRadius, penetration); } bool findPointSpherePenetration(const glm::vec3& point, const glm::vec3& sphereCenter, float sphereRadius, glm::vec3& penetration) { - return findSpherePenetration(sphereCenter - point, glm::vec3(0.0f, -1.0f, 0.0f), - sphereRadius, penetration); + return findSpherePenetration(sphereCenter - point, glm::vec3(0.0f, -1.0f, 0.0f), sphereRadius, penetration); } bool findSphereSpherePenetration(const glm::vec3& firstCenter, float firstRadius, @@ -65,8 +67,8 @@ bool findSphereSpherePenetration(const glm::vec3& firstCenter, float firstRadius bool findSphereSegmentPenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& segmentStart, const glm::vec3& segmentEnd, glm::vec3& penetration) { - return findSpherePenetration(computeVectorFromPointToSegment(sphereCenter, segmentStart, segmentEnd), - glm::vec3(0.0f, -1.0f, 0.0f), sphereRadius, penetration); + return findSpherePenetration(computeVectorFromPointToSegment(sphereCenter, segmentStart, segmentEnd), + glm::vec3(0.0f, -1.0f, 0.0f), sphereRadius, penetration); } bool findSphereCapsulePenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& capsuleStart, @@ -75,32 +77,32 @@ bool findSphereCapsulePenetration(const glm::vec3& sphereCenter, float sphereRad capsuleStart, capsuleEnd, penetration); } -bool findPointCapsuleConePenetration(const glm::vec3& point, const glm::vec3& segmentStart, - const glm::vec3& segmentEnd, float startRadius, float endRadius, glm::vec3& penetration) { +bool findPointCapsuleConePenetration(const glm::vec3& point, const glm::vec3& capsuleStart, + const glm::vec3& capsuleEnd, float startRadius, float endRadius, glm::vec3& penetration) { // compute the projection of the point vector onto the segment vector - glm::vec3 segmentVector = segmentEnd - segmentStart; + glm::vec3 segmentVector = capsuleEnd - capsuleStart; float lengthSquared = glm::dot(segmentVector, segmentVector); if (lengthSquared < EPSILON) { // start and end the same - return findPointSpherePenetration(point, segmentStart, + return findPointSpherePenetration(point, capsuleStart, glm::max(startRadius, endRadius), penetration); } - float proj = glm::dot(point - segmentStart, segmentVector) / lengthSquared; + float proj = glm::dot(point - capsuleStart, segmentVector) / lengthSquared; if (proj <= 0.0f) { // closest to the start - return findPointSpherePenetration(point, segmentStart, startRadius, penetration); + return findPointSpherePenetration(point, capsuleStart, startRadius, penetration); } else if (proj >= 1.0f) { // closest to the end - return findPointSpherePenetration(point, segmentEnd, endRadius, penetration); + return findPointSpherePenetration(point, capsuleEnd, endRadius, penetration); } else { // closest to the middle - return findPointSpherePenetration(point, segmentStart + segmentVector * proj, + return findPointSpherePenetration(point, capsuleStart + segmentVector * proj, glm::mix(startRadius, endRadius, proj), penetration); } } bool findSphereCapsuleConePenetration(const glm::vec3& sphereCenter, - float sphereRadius, const glm::vec3& segmentStart, const glm::vec3& segmentEnd, + float sphereRadius, const glm::vec3& capsuleStart, const glm::vec3& capsuleEnd, float startRadius, float endRadius, glm::vec3& penetration) { - return findPointCapsuleConePenetration(sphereCenter, segmentStart, segmentEnd, + return findPointCapsuleConePenetration(sphereCenter, capsuleStart, capsuleEnd, startRadius + sphereRadius, endRadius + sphereRadius, penetration); } diff --git a/libraries/shared/src/GeometryUtil.h b/libraries/shared/src/GeometryUtil.h index 4bba48fe08..9d064aef9c 100644 --- a/libraries/shared/src/GeometryUtil.h +++ b/libraries/shared/src/GeometryUtil.h @@ -13,11 +13,17 @@ glm::vec3 computeVectorFromPointToSegment(const glm::vec3& point, const glm::vec3& start, const glm::vec3& end); -bool findSpherePenetration(const glm::vec3& localPoint, const glm::vec3& direction, - float combinedRadius, glm::vec3& penetration); +/// Computes the penetration between a point and a sphere (centered at the origin) +/// \param point the point location relative to sphere center (origin) +/// \param defaultDirection the direction of the pentration when the point is near the origin +/// \param sphereRadius the radius of the sphere +/// \param penetration the displacement that would move the point out of penetration with the sphere +/// \return true if point is inside sphere, otherwise false +bool findSpherePenetration(const glm::vec3& point, const glm::vec3& defaultDirection, + float sphereRadius, glm::vec3& penetration); bool findSpherePointPenetration(const glm::vec3& sphereCenter, float sphereRadius, - const glm::vec3& penetrateeLocation, glm::vec3& penetration); + const glm::vec3& point, glm::vec3& penetration); bool findPointSpherePenetration(const glm::vec3& point, const glm::vec3& sphereCenter, float sphereRadius, glm::vec3& penetration); @@ -26,17 +32,17 @@ bool findSphereSpherePenetration(const glm::vec3& firstCenter, float firstRadius const glm::vec3& secondCenter, float secondRadius, glm::vec3& penetration); bool findSphereSegmentPenetration(const glm::vec3& sphereCenter, float sphereRadius, - const glm::vec3& penetrateeStart, const glm::vec3& penetrateeEnd, glm::vec3& penetration); + const glm::vec3& segmentStart, const glm::vec3& segmentEnd, glm::vec3& penetration); -bool findSphereCapsulePenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& penetrateeStart, - const glm::vec3& penetrateeEnd, float capsuleRadius, glm::vec3& penetration); +bool findSphereCapsulePenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec3& capsuleStart, + const glm::vec3& capsuleEnd, float capsuleRadius, glm::vec3& penetration); -bool findPointCapsuleConePenetration(const glm::vec3& point, const glm::vec3& segmentStart, - const glm::vec3& segmentEnd, float startRadius, float endRadius, glm::vec3& penetration); +bool findPointCapsuleConePenetration(const glm::vec3& point, const glm::vec3& capsuleStart, + const glm::vec3& capsuleEnd, float startRadius, float endRadius, glm::vec3& penetration); bool findSphereCapsuleConePenetration(const glm::vec3& sphereCenter, float sphereRadius, - const glm::vec3& penetrateeStart, const glm::vec3& penetrateeEnd, - float penetrateeStartRadius, float penetrateeEndRadius, glm::vec3& penetration); + const glm::vec3& capsuleStart, const glm::vec3& capsuleEnd, + float startRadius, float endRadius, glm::vec3& penetration); bool findSpherePlanePenetration(const glm::vec3& sphereCenter, float sphereRadius, const glm::vec4& plane, glm::vec3& penetration); From 74392a88359ff732a4bb619f5efe5e64213c1d17 Mon Sep 17 00:00:00 2001 From: Andrew Meadows Date: Fri, 3 Jan 2014 16:03:42 -0800 Subject: [PATCH 3/7] Moved ParticleTreeUpdateArgs into ParticleTreeElement.h --- libraries/particles/src/ParticleTree.h | 5 ----- libraries/particles/src/ParticleTreeElement.h | 8 ++++++-- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/libraries/particles/src/ParticleTree.h b/libraries/particles/src/ParticleTree.h index 3f8b7fda09..7c8d724a17 100644 --- a/libraries/particles/src/ParticleTree.h +++ b/libraries/particles/src/ParticleTree.h @@ -12,11 +12,6 @@ #include #include "ParticleTreeElement.h" -class ParticleTreeUpdateArgs { -public: - std::vector _movingParticles; -}; - class NewlyCreatedParticleHook { public: virtual void particleCreated(const Particle& newParticle, Node* senderNode) = 0; diff --git a/libraries/particles/src/ParticleTreeElement.h b/libraries/particles/src/ParticleTreeElement.h index 34d4054d98..971f5f5481 100644 --- a/libraries/particles/src/ParticleTreeElement.h +++ b/libraries/particles/src/ParticleTreeElement.h @@ -19,7 +19,11 @@ class ParticleTree; class ParticleTreeElement; -class ParticleTreeUpdateArgs; + +class ParticleTreeUpdateArgs { +public: + std::vector _movingParticles; +}; class ParticleTreeElement : public OctreeElement { friend class ParticleTree; // to allow createElement to new us... @@ -95,4 +99,4 @@ protected: std::vector _particles; }; -#endif /* defined(__hifi__ParticleTreeElement__) */ \ No newline at end of file +#endif /* defined(__hifi__ParticleTreeElement__) */ From 71e5de8420c7164b5d911255318372654c096650 Mon Sep 17 00:00:00 2001 From: Andrew Meadows Date: Fri, 10 Jan 2014 11:37:01 -0800 Subject: [PATCH 4/7] Adding Particle::_mass and correct elastic collisions between particles --- libraries/particles/src/Particle.cpp | 6 ++ libraries/particles/src/Particle.h | 3 + .../particles/src/ParticleCollisionSystem.cpp | 67 +++++++++++-------- 3 files changed, 47 insertions(+), 29 deletions(-) diff --git a/libraries/particles/src/Particle.cpp b/libraries/particles/src/Particle.cpp index edca3a1fc0..346760b115 100644 --- a/libraries/particles/src/Particle.cpp +++ b/libraries/particles/src/Particle.cpp @@ -54,6 +54,7 @@ void Particle::init(glm::vec3 position, float radius, rgbColor color, glm::vec3 _position = position; _radius = radius; + _mass = 1.0f; memcpy(_color, color, sizeof(_color)); _velocity = velocity; _damping = damping; @@ -63,6 +64,11 @@ void Particle::init(glm::vec3 position, float radius, rgbColor color, glm::vec3 _shouldDie = false; } +void Particle::setMass(float value) { + if (value > 0.0f) { + _mass = value; + } +} bool Particle::appendParticleData(OctreePacketData* packetData) const { diff --git a/libraries/particles/src/Particle.h b/libraries/particles/src/Particle.h index 9c92d0ec48..5e80234660 100644 --- a/libraries/particles/src/Particle.h +++ b/libraries/particles/src/Particle.h @@ -67,6 +67,7 @@ public: const rgbColor& getColor() const { return _color; } xColor getXColor() const { xColor color = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] }; return color; } float getRadius() const { return _radius; } + float getMass() const { return _mass; } const glm::vec3& getVelocity() const { return _velocity; } const glm::vec3& getGravity() const { return _gravity; } bool getInHand() const { return _inHand; } @@ -96,6 +97,7 @@ public: _color[BLUE_INDEX] = value.blue; } void setRadius(float value) { _radius = value; } + void setMass(float value); void setGravity(const glm::vec3& value) { _gravity = value; } void setInHand(bool inHand) { _inHand = inHand; } void setDamping(float value) { _damping = value; } @@ -146,6 +148,7 @@ protected: glm::vec3 _position; rgbColor _color; float _radius; + float _mass; glm::vec3 _velocity; uint32_t _id; static uint32_t _nextID; diff --git a/libraries/particles/src/ParticleCollisionSystem.cpp b/libraries/particles/src/ParticleCollisionSystem.cpp index 1e1f3955fe..0389dddb66 100644 --- a/libraries/particles/src/ParticleCollisionSystem.cpp +++ b/libraries/particles/src/ParticleCollisionSystem.cpp @@ -87,41 +87,50 @@ void ParticleCollisionSystem::updateCollisionWithVoxels(Particle* particle) { } } -void ParticleCollisionSystem::updateCollisionWithParticles(Particle* particle) { - glm::vec3 center = particle->getPosition() * static_cast(TREE_SCALE); - float radius = particle->getRadius() * static_cast(TREE_SCALE); - const float ELASTICITY = 1.4f; +void ParticleCollisionSystem::updateCollisionWithParticles(Particle* particleA) { + glm::vec3 center = particleA->getPosition() * (float)TREE_SCALE; + float radius = particleA->getRadius() * (float)TREE_SCALE; + const float ELASTICITY = 0.4f; const float DAMPING = 0.0f; const float COLLISION_FREQUENCY = 0.5f; glm::vec3 penetration; - Particle* penetratedParticle; - if (_particles->findSpherePenetration(center, radius, penetration, (void**)&penetratedParticle)) { + Particle* particleB; + if (_particles->findSpherePenetration(center, radius, penetration, (void**)&particleB)) { + // NOTE: 'penetration' is the depth that 'particleA' overlaps 'particleB'. + // That is, it points from A into B. - // let the particles run their collision scripts if they have them - particle->collisionWithParticle(penetratedParticle); - penetratedParticle->collisionWithParticle(particle); + // Even if the particles overlap... when the particles are already moving appart + // we don't want to count this as a collision. + glm::vec3 relativeVelocity = particleA->getVelocity() - particleB->getVelocity(); + if (glm::dot(relativeVelocity, penetration) > 0.0f) { + particleA->collisionWithParticle(particleB); + particleB->collisionWithParticle(particleA); - penetration /= static_cast(TREE_SCALE); - updateCollisionSound(particle, penetration, COLLISION_FREQUENCY); - - // apply a hard collision to both particles of half the penetration each - - float particleShare, penetratedParticleShare; - if (particle->getInHand() && penetratedParticle->getInHand()) { - particleShare = 0.5f; - penetratedParticleShare = -0.5f; - } else if (particle->getInHand()) { - particleShare = 0.f; - penetratedParticleShare = -1.f; - } else if (penetratedParticle->getInHand()) { - particleShare = -1.f; - penetratedParticleShare = 0.f; - } else { - particleShare = 0.5f; - penetratedParticleShare = -0.5f; + glm::vec3 axis = glm::normalize(penetration); + glm::vec3 axialVelocity = glm::dot(relativeVelocity, axis) * axis; + + // particles that are in hand are assigned an ureasonably large mass for collisions + // which effectively makes them immovable but allows the other ball to reflect correctly. + const float MAX_MASS = 1.0e6f; + float massA = (particleA->getInHand()) ? MAX_MASS : particleA->getMass(); + float massB = (particleB->getInHand()) ? MAX_MASS : particleB->getMass(); + float totalMass = massA + massB; + + particleA->setVelocity(particleA->getVelocity() - axialVelocity * (2.0f * massB / totalMass)); + + ParticleEditHandle particleEditHandle(_packetSender, _particles, particleA->getID()); + particleEditHandle.updateParticle(particleA->getPosition(), particleA->getRadius(), particleA->getXColor(), particleA->getVelocity(), + particleA->getGravity(), particleA->getDamping(), particleA->getInHand(), particleA->getScript()); + + particleB->setVelocity(particleB->getVelocity() + axialVelocity * (2.0f * massA / totalMass)); + + ParticleEditHandle penetratedparticleEditHandle(_packetSender, _particles, particleB->getID()); + penetratedparticleEditHandle.updateParticle(particleB->getPosition(), particleB->getRadius(), particleB->getXColor(), particleB->getVelocity(), + particleB->getGravity(), particleB->getDamping(), particleB->getInHand(), particleB->getScript()); + + penetration /= (float)TREE_SCALE; + updateCollisionSound(particleA, penetration, COLLISION_FREQUENCY); } - applyHardCollision(particle, penetration * particleShare, ELASTICITY, DAMPING); - applyHardCollision(penetratedParticle, penetration * penetratedParticleShare, ELASTICITY, DAMPING); } } From c4c0c389ae105edea3218011ad97c24eff217a27 Mon Sep 17 00:00:00 2001 From: Andrew Meadows Date: Fri, 10 Jan 2014 11:42:23 -0800 Subject: [PATCH 5/7] Temporarily disabling DAMPING and non-unity ELASTICITY during particle-particle collisions --- libraries/particles/src/ParticleCollisionSystem.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libraries/particles/src/ParticleCollisionSystem.cpp b/libraries/particles/src/ParticleCollisionSystem.cpp index 0389dddb66..0d3f9dcaff 100644 --- a/libraries/particles/src/ParticleCollisionSystem.cpp +++ b/libraries/particles/src/ParticleCollisionSystem.cpp @@ -90,8 +90,8 @@ void ParticleCollisionSystem::updateCollisionWithVoxels(Particle* particle) { void ParticleCollisionSystem::updateCollisionWithParticles(Particle* particleA) { glm::vec3 center = particleA->getPosition() * (float)TREE_SCALE; float radius = particleA->getRadius() * (float)TREE_SCALE; - const float ELASTICITY = 0.4f; - const float DAMPING = 0.0f; + //const float ELASTICITY = 0.4f; + //const float DAMPING = 0.0f; const float COLLISION_FREQUENCY = 0.5f; glm::vec3 penetration; Particle* particleB; From ceb8ca7a23170f901f5257b7ce8d369e9f50d197 Mon Sep 17 00:00:00 2001 From: Stephen Birarda Date: Fri, 10 Jan 2014 16:59:01 -0800 Subject: [PATCH 6/7] changes to AssignmentClient architecture to fix fork behaviour --- assignment-client/src/AssignmentClient.cpp | 51 +++++- assignment-client/src/AssignmentClient.h | 5 +- .../src/AssignmentClientMonitor.cpp | 52 ++++++ .../src/AssignmentClientMonitor.h | 31 ++++ assignment-client/src/main.cpp | 155 +----------------- 5 files changed, 136 insertions(+), 158 deletions(-) create mode 100644 assignment-client/src/AssignmentClientMonitor.cpp create mode 100644 assignment-client/src/AssignmentClientMonitor.h diff --git a/assignment-client/src/AssignmentClient.cpp b/assignment-client/src/AssignmentClient.cpp index cc4292ad15..f3458c8afb 100644 --- a/assignment-client/src/AssignmentClient.cpp +++ b/assignment-client/src/AssignmentClient.cpp @@ -24,12 +24,8 @@ const long long ASSIGNMENT_REQUEST_INTERVAL_MSECS = 1 * 1000; int hifiSockAddrMeta = qRegisterMetaType("HifiSockAddr"); -AssignmentClient::AssignmentClient(int &argc, char **argv, - Assignment::Type requestAssignmentType, - const HifiSockAddr& customAssignmentServerSocket, - const char* requestAssignmentPool) : +AssignmentClient::AssignmentClient(int &argc, char **argv) : QCoreApplication(argc, argv), - _requestAssignment(Assignment::RequestCommand, requestAssignmentType, requestAssignmentPool), _currentAssignment(NULL) { // register meta type is required for queued invoke method on Assignment subclasses @@ -37,12 +33,53 @@ AssignmentClient::AssignmentClient(int &argc, char **argv, // set the logging target to the the CHILD_TARGET_NAME Logging::setTargetName(ASSIGNMENT_CLIENT_TARGET_NAME); + const char ASSIGNMENT_TYPE_OVVERIDE_OPTION[] = "-t"; + const char* assignmentTypeString = getCmdOption(argc, (const char**)argv, ASSIGNMENT_TYPE_OVVERIDE_OPTION); + + Assignment::Type requestAssignmentType = Assignment::AllTypes; + + if (assignmentTypeString) { + // the user is asking to only be assigned to a particular type of assignment + // so set that as the ::overridenAssignmentType to be used in requests + requestAssignmentType = (Assignment::Type) atoi(assignmentTypeString); + } + + const char ASSIGNMENT_POOL_OPTION[] = "--pool"; + const char* requestAssignmentPool = getCmdOption(argc, (const char**) argv, ASSIGNMENT_POOL_OPTION); + + + // setup our _requestAssignment member variable from the passed arguments + _requestAssignment = Assignment(Assignment::RequestCommand, requestAssignmentType, requestAssignmentPool); + // create a NodeList as an unassigned client NodeList* nodeList = NodeList::createInstance(NODE_TYPE_UNASSIGNED); + const char CUSTOM_ASSIGNMENT_SERVER_HOSTNAME_OPTION[] = "-a"; + const char CUSTOM_ASSIGNMENT_SERVER_PORT_OPTION[] = "-p"; + + // grab the overriden assignment-server hostname from argv, if it exists + const char* customAssignmentServerHostname = getCmdOption(argc, (const char**)argv, CUSTOM_ASSIGNMENT_SERVER_HOSTNAME_OPTION); + const char* customAssignmentServerPortString = getCmdOption(argc,(const char**)argv, CUSTOM_ASSIGNMENT_SERVER_PORT_OPTION); + + HifiSockAddr customAssignmentSocket; + + if (customAssignmentServerHostname || customAssignmentServerPortString) { + + // set the custom port or default if it wasn't passed + unsigned short assignmentServerPort = customAssignmentServerPortString + ? atoi(customAssignmentServerPortString) : DEFAULT_DOMAIN_SERVER_PORT; + + // set the custom hostname or default if it wasn't passed + if (!customAssignmentServerHostname) { + customAssignmentServerHostname = DEFAULT_ASSIGNMENT_SERVER_HOSTNAME; + } + + customAssignmentSocket = HifiSockAddr(customAssignmentServerHostname, assignmentServerPort); + } + // set the custom assignment socket if we have it - if (!customAssignmentServerSocket.isNull()) { - nodeList->setAssignmentServerSocket(customAssignmentServerSocket); + if (!customAssignmentSocket.isNull()) { + nodeList->setAssignmentServerSocket(customAssignmentSocket); } // call a timer function every ASSIGNMENT_REQUEST_INTERVAL_MSECS to ask for assignment, if required diff --git a/assignment-client/src/AssignmentClient.h b/assignment-client/src/AssignmentClient.h index 48311b0275..f19c8015b3 100644 --- a/assignment-client/src/AssignmentClient.h +++ b/assignment-client/src/AssignmentClient.h @@ -16,10 +16,7 @@ class AssignmentClient : public QCoreApplication { Q_OBJECT public: - AssignmentClient(int &argc, char **argv, - Assignment::Type requestAssignmentType = Assignment::AllTypes, - const HifiSockAddr& customAssignmentServerSocket = HifiSockAddr(), - const char* requestAssignmentPool = NULL); + AssignmentClient(int &argc, char **argv); private slots: void sendAssignmentRequest(); void readPendingDatagrams(); diff --git a/assignment-client/src/AssignmentClientMonitor.cpp b/assignment-client/src/AssignmentClientMonitor.cpp new file mode 100644 index 0000000000..d6a6c9b060 --- /dev/null +++ b/assignment-client/src/AssignmentClientMonitor.cpp @@ -0,0 +1,52 @@ +// +// AssignmentClientMonitor.cpp +// hifi +// +// Created by Stephen Birarda on 1/10/2014. +// Copyright (c) 2014 HighFidelity, Inc. All rights reserved. +// + +#include + +#include "AssignmentClientMonitor.h" + +const char* NUM_FORKS_PARAMETER = "-n"; + +const char ASSIGNMENT_CLIENT_MONITOR_TARGET_NAME[] = "assignment-client-monitor"; + +AssignmentClientMonitor::AssignmentClientMonitor(int &argc, char **argv, int numAssignmentClientForks) : + QCoreApplication(argc, argv) +{ + // start the Logging class with the parent's target name + Logging::setTargetName(ASSIGNMENT_CLIENT_MONITOR_TARGET_NAME); + + _childArguments = arguments(); + + // remove the parameter for the number of forks so it isn't passed to the child forked processes + int forksParameterIndex = _childArguments.indexOf(NUM_FORKS_PARAMETER); + + // this removes both the "-n" parameter and the number of forks passed + _childArguments.removeAt(forksParameterIndex); + _childArguments.removeAt(forksParameterIndex); + + // use QProcess to fork off a process for each of the child assignment clients + for (int i = 0; i < numAssignmentClientForks; i++) { + spawnChildClient(); + } +} + +void AssignmentClientMonitor::spawnChildClient() { + QProcess *assignmentClient = new QProcess(this); + assignmentClient->start(applicationFilePath(), _childArguments); + + // link the child processes' finished slot to our childProcessFinished slot + connect(assignmentClient, SIGNAL(finished(int, QProcess::ExitStatus)), this, + SLOT(childProcessFinished(int, QProcess::ExitStatus))); + + qDebug() << "Spawned a child client with PID" << assignmentClient->pid() << "\n"; +} + +void AssignmentClientMonitor::childProcessFinished(int exitCode, QProcess::ExitStatus exitStatus) { + qDebug() << "Replacing dead child assignment client with a new one.\n"; + spawnChildClient(); +} \ No newline at end of file diff --git a/assignment-client/src/AssignmentClientMonitor.h b/assignment-client/src/AssignmentClientMonitor.h new file mode 100644 index 0000000000..259a6d6db7 --- /dev/null +++ b/assignment-client/src/AssignmentClientMonitor.h @@ -0,0 +1,31 @@ +// +// AssignmentClientMonitor.h +// hifi +// +// Created by Stephen Birarda on 1/10/2014. +// Copyright (c) 2014 HighFidelity, Inc. All rights reserved. +// + +#ifndef __hifi__AssignmentClientMonitor__ +#define __hifi__AssignmentClientMonitor__ + +#include +#include + +#include + +extern const char* NUM_FORKS_PARAMETER; + +class AssignmentClientMonitor : public QCoreApplication { + Q_OBJECT +public: + AssignmentClientMonitor(int &argc, char **argv, int numAssignmentClientForks); +private slots: + void childProcessFinished(int exitCode, QProcess::ExitStatus exitStatus); +private: + void spawnChildClient(); + + QStringList _childArguments; +}; + +#endif /* defined(__hifi__AssignmentClientMonitor__) */ diff --git a/assignment-client/src/main.cpp b/assignment-client/src/main.cpp index 28516b37b8..7ee0ea9e14 100644 --- a/assignment-client/src/main.cpp +++ b/assignment-client/src/main.cpp @@ -6,172 +6,33 @@ // Copyright (c) 2013 High Fidelity, Inc. All rights reserved. // -#include -#include -#include -#include -#include - #include -#include -#include #include -#include -#include "Agent.h" #include "Assignment.h" #include "AssignmentClient.h" -#include "audio/AudioMixer.h" -#include "avatars/AvatarMixer.h" - -const char PARENT_TARGET_NAME[] = "assignment-client-monitor"; - -pid_t* childForks = NULL; -HifiSockAddr customAssignmentSocket; -int numForks = 0; -Assignment::Type overiddenAssignmentType = Assignment::AllTypes; -const char* assignmentPool = NULL; - -int argc = 0; -char** argv = NULL; - -int childClient() { - AssignmentClient client(::argc, ::argv, ::overiddenAssignmentType, customAssignmentSocket, ::assignmentPool); - return client.exec(); -} - -void sigchldHandler(int sig) { - pid_t processID; - int status; - - while ((processID = waitpid(-1, &status, WNOHANG)) != -1) { - if (processID == 0) { - // there are no more children to process, break out of here - break; - } - - int newForkProcessID = 0; - - // find the dead process in the array of child forks - for (int i = 0; i < ::numForks; i++) { - if (::childForks[i] == processID) { - - newForkProcessID = fork(); - if (newForkProcessID == 0) { - // this is the child, call childClient - childClient(); - - // break out so we don't fork bomb - break; - } else { - // this is the parent, replace the dead process with the new one - ::childForks[i] = newForkProcessID; - - qDebug("Replaced dead %d with new fork %d\n", processID, newForkProcessID); - - break; - } - } - } - } - -} - -void parentMonitor() { - - struct sigaction sa; - - memset(&sa, 0, sizeof(sa)); - sa.sa_handler = sigchldHandler; - - sigaction(SIGCHLD, &sa, NULL); - - pid_t childID = 0; - - // don't bail until all children have finished - while ((childID = waitpid(-1, NULL, 0))) { - if (errno == ECHILD) { - break; - } - } - - // delete the array of pid_t holding the forked process IDs - delete[] ::childForks; -} +#include "AssignmentClientMonitor.h" int main(int argc, char* argv[]) { - ::argc = argc; - ::argv = argv; setvbuf(stdout, NULL, _IOLBF, 0); // use the verbose message handler in Logging qInstallMessageHandler(Logging::verboseMessageHandler); - // start the Logging class with the parent's target name - Logging::setTargetName(PARENT_TARGET_NAME); - - const char CUSTOM_ASSIGNMENT_SERVER_HOSTNAME_OPTION[] = "-a"; - const char CUSTOM_ASSIGNMENT_SERVER_PORT_OPTION[] = "-p"; - - // grab the overriden assignment-server hostname from argv, if it exists - const char* customAssignmentServerHostname = getCmdOption(argc, (const char**)argv, CUSTOM_ASSIGNMENT_SERVER_HOSTNAME_OPTION); - const char* customAssignmentServerPortString = getCmdOption(argc,(const char**)argv, CUSTOM_ASSIGNMENT_SERVER_PORT_OPTION); - - if (customAssignmentServerHostname || customAssignmentServerPortString) { - - // set the custom port or default if it wasn't passed - unsigned short assignmentServerPort = customAssignmentServerPortString - ? atoi(customAssignmentServerPortString) : DEFAULT_DOMAIN_SERVER_PORT; - - // set the custom hostname or default if it wasn't passed - if (!customAssignmentServerHostname) { - customAssignmentServerHostname = DEFAULT_ASSIGNMENT_SERVER_HOSTNAME; - } - - ::customAssignmentSocket = HifiSockAddr(customAssignmentServerHostname, assignmentServerPort); - } - - const char ASSIGNMENT_TYPE_OVVERIDE_OPTION[] = "-t"; - const char* assignmentTypeString = getCmdOption(argc, (const char**)argv, ASSIGNMENT_TYPE_OVVERIDE_OPTION); - - if (assignmentTypeString) { - // the user is asking to only be assigned to a particular type of assignment - // so set that as the ::overridenAssignmentType to be used in requests - ::overiddenAssignmentType = (Assignment::Type) atoi(assignmentTypeString); - } - - const char ASSIGNMENT_POOL_OPTION[] = "--pool"; - ::assignmentPool = getCmdOption(argc, (const char**) argv, ASSIGNMENT_POOL_OPTION); - - const char* NUM_FORKS_PARAMETER = "-n"; const char* numForksString = getCmdOption(argc, (const char**)argv, NUM_FORKS_PARAMETER); - int processID = 0; + int numForks = 0; if (numForksString) { - ::numForks = atoi(numForksString); - qDebug("Starting %d assignment clients\n", ::numForks); - - ::childForks = new pid_t[::numForks]; - - // fire off as many children as we need (this is one less than the parent since the parent will run as well) - for (int i = 0; i < ::numForks; i++) { - processID = fork(); - - if (processID == 0) { - // this is in one of the children, break so we don't start a fork bomb - break; - } else { - // this is in the parent, save the ID of the forked process - childForks[i] = processID; - } - } + numForks = atoi(numForksString); } - if (processID == 0 || ::numForks == 0) { - return childClient(); + if (numForks) { + AssignmentClientMonitor monitor(argc, argv, numForks); + return monitor.exec(); } else { - parentMonitor(); + AssignmentClient client(argc, argv); + return client.exec(); } } \ No newline at end of file From 248754e63ec630d5741f86d1b67d88241a04271a Mon Sep 17 00:00:00 2001 From: Stephen Birarda Date: Fri, 10 Jan 2014 17:03:13 -0800 Subject: [PATCH 7/7] make sure STDOUT from child assignment-client bubbles up to parent --- assignment-client/src/AssignmentClientMonitor.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/assignment-client/src/AssignmentClientMonitor.cpp b/assignment-client/src/AssignmentClientMonitor.cpp index d6a6c9b060..fa050a0dac 100644 --- a/assignment-client/src/AssignmentClientMonitor.cpp +++ b/assignment-client/src/AssignmentClientMonitor.cpp @@ -37,6 +37,10 @@ AssignmentClientMonitor::AssignmentClientMonitor(int &argc, char **argv, int num void AssignmentClientMonitor::spawnChildClient() { QProcess *assignmentClient = new QProcess(this); + + // make sure that the output from the child process appears in our output + assignmentClient->setProcessChannelMode(QProcess::ForwardedChannels); + assignmentClient->start(applicationFilePath(), _childArguments); // link the child processes' finished slot to our childProcessFinished slot