Mirrors/overte-JulianGro
3
0
Fork 0
mirror of https://github.com/JulianGro/overte.git synced 2025-04-29 19:42:53 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Revert "Convert entityIntersections/avatarIntersections lists in"

Browse source 
This reverts commit aa4a6b2eae.
This commit is contained in:
sabrina-shanman 2018-08-20 10:15:28 -07:00
parent 2a182a0033
commit 74f482b361
4 changed files with 30 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
interface/src/raypick/CollisionPick.cpp
View file

@ -19,19 +19,19 @@
PickResultPointer CollisionPickResult::compareAndProcessNewResult(const PickResultPointer& newRes) { PickResultPointer CollisionPickResult::compareAndProcessNewResult(const PickResultPointer& newRes) {
const std::shared_ptr<CollisionPickResult> newCollisionResult = std::static_pointer_cast<CollisionPickResult>(newRes); const std::shared_ptr<CollisionPickResult> newCollisionResult = std::static_pointer_cast<CollisionPickResult>(newRes);
if (entityIntersections->size()) { if (entityIntersections.size()) {
entityIntersections->insert(entityIntersections->cend(), newCollisionResult->entityIntersections->begin(), newCollisionResult->entityIntersections->end()); entityIntersections.insert(entityIntersections.cend(), newCollisionResult->entityIntersections.begin(), newCollisionResult->entityIntersections.end());
} else { } else {
entityIntersections = newCollisionResult->entityIntersections; entityIntersections = newCollisionResult->entityIntersections;
} }
if (avatarIntersections->size()) { if (avatarIntersections.size()) {
avatarIntersections->insert(avatarIntersections->cend(), newCollisionResult->avatarIntersections->begin(), newCollisionResult->avatarIntersections->end()); avatarIntersections.insert(avatarIntersections.cend(), newCollisionResult->avatarIntersections.begin(), newCollisionResult->avatarIntersections.end());
} else { } else {
avatarIntersections = newCollisionResult->avatarIntersections; avatarIntersections = newCollisionResult->avatarIntersections;
} }
intersects = entityIntersections->size() || avatarIntersections->size(); intersects = entityIntersections.size() || avatarIntersections.size();
if (newCollisionResult->loadState == LOAD_STATE_NOT_LOADED || loadState == LOAD_STATE_UNKNOWN) { if (newCollisionResult->loadState == LOAD_STATE_NOT_LOADED || loadState == LOAD_STATE_UNKNOWN) {
loadState = (LoadState)newCollisionResult->loadState; loadState = (LoadState)newCollisionResult->loadState;
} }
@ -39,8 +39,8 @@ PickResultPointer CollisionPickResult::compareAndProcessNewResult(const PickResu
return std::make_shared<CollisionPickResult>(*this); return std::make_shared<CollisionPickResult>(*this);
} }
void buildObjectIntersectionsMap(IntersectionType intersectionType, const std::shared_ptr<std::vector<ContactTestResult>> objectIntersections, std::unordered_map<QUuid, QVariantMap>& intersections, std::unordered_map<QUuid, QVariantList>& collisionPointPairs) { void buildObjectIntersectionsMap(IntersectionType intersectionType, const std::vector<ContactTestResult>& objectIntersections, std::unordered_map<QUuid, QVariantMap>& intersections, std::unordered_map<QUuid, QVariantList>& collisionPointPairs) {
for (auto& objectIntersection : *objectIntersections) { for (auto& objectIntersection : objectIntersections) {
auto at = intersections.find(objectIntersection.foundID); auto at = intersections.find(objectIntersection.foundID);
if (at == intersections.end()) { if (at == intersections.end()) {
QVariantMap intersectingObject; QVariantMap intersectingObject;
@ -332,7 +332,7 @@ CollisionRegion CollisionPick::getMathematicalPick() const {
return _mathPick; return _mathPick;
} }
void CollisionPick::filterIntersections(std::shared_ptr<std::vector<ContactTestResult>> intersections) const { void CollisionPick::filterIntersections(std::vector<ContactTestResult>& intersections) const {
const QVector<QUuid>& ignoreItems = getIgnoreItems(); const QVector<QUuid>& ignoreItems = getIgnoreItems();
const QVector<QUuid>& includeItems = getIncludeItems(); const QVector<QUuid>& includeItems = getIncludeItems();
bool isWhitelist = !includeItems.empty(); bool isWhitelist = !includeItems.empty();
@ -341,13 +341,13 @@ void CollisionPick::filterIntersections(std::shared_ptr<std::vector<ContactTestR
return; return;
} }
int n = (int)intersections->size(); int n = (int)intersections.size();
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
auto& intersection = (*intersections)[i]; auto& intersection = intersections[i];
const QUuid& id = intersection.foundID; const QUuid& id = intersection.foundID;
if (ignoreItems.contains(id) || (isWhitelist && !includeItems.contains(id))) { if (ignoreItems.contains(id) || (isWhitelist && !includeItems.contains(id))) {
intersection = (*intersections)[--n]; intersections[i] = intersections[--n];
intersections->pop_back(); intersections.pop_back();
} }
} }
} }
@ -355,29 +355,29 @@ void CollisionPick::filterIntersections(std::shared_ptr<std::vector<ContactTestR
PickResultPointer CollisionPick::getEntityIntersection(const CollisionRegion& pick) { PickResultPointer CollisionPick::getEntityIntersection(const CollisionRegion& pick) {
if (!isShapeInfoReady()) { if (!isShapeInfoReady()) {
// Cannot compute result // Cannot compute result
return std::make_shared<CollisionPickResult>(pick.toVariantMap(), CollisionPickResult::LOAD_STATE_NOT_LOADED, std::make_shared<std::vector<ContactTestResult>>(), std::make_shared<std::vector<ContactTestResult>>()); return std::make_shared<CollisionPickResult>(pick.toVariantMap(), CollisionPickResult::LOAD_STATE_NOT_LOADED, std::vector<ContactTestResult>(), std::vector<ContactTestResult>());
} }
auto& entityIntersections = _physicsEngine->contactTest(USER_COLLISION_MASK_ENTITIES, *pick.shapeInfo, pick.transform); auto& entityIntersections = _physicsEngine->contactTest(USER_COLLISION_MASK_ENTITIES, *pick.shapeInfo, pick.transform);
filterIntersections(entityIntersections); filterIntersections(entityIntersections);
return std::make_shared<CollisionPickResult>(pick, CollisionPickResult::LOAD_STATE_LOADED, entityIntersections, std::make_shared<std::vector<ContactTestResult>>()); return std::make_shared<CollisionPickResult>(pick, CollisionPickResult::LOAD_STATE_LOADED, entityIntersections, std::vector<ContactTestResult>());
} }
PickResultPointer CollisionPick::getOverlayIntersection(const CollisionRegion& pick) { PickResultPointer CollisionPick::getOverlayIntersection(const CollisionRegion& pick) {
return std::make_shared<CollisionPickResult>(pick.toVariantMap(), isShapeInfoReady() ? CollisionPickResult::LOAD_STATE_LOADED : CollisionPickResult::LOAD_STATE_NOT_LOADED, std::make_shared<std::vector<ContactTestResult>>(), std::make_shared<std::vector<ContactTestResult>>()); return std::make_shared<CollisionPickResult>(pick.toVariantMap(), isShapeInfoReady() ? CollisionPickResult::LOAD_STATE_LOADED : CollisionPickResult::LOAD_STATE_NOT_LOADED, std::vector<ContactTestResult>(), std::vector<ContactTestResult>());
} }
PickResultPointer CollisionPick::getAvatarIntersection(const CollisionRegion& pick) { PickResultPointer CollisionPick::getAvatarIntersection(const CollisionRegion& pick) {
if (!isShapeInfoReady()) { if (!isShapeInfoReady()) {
// Cannot compute result // Cannot compute result
return std::make_shared<CollisionPickResult>(pick.toVariantMap(), CollisionPickResult::LOAD_STATE_NOT_LOADED, std::make_shared<std::vector<ContactTestResult>>(), std::make_shared<std::vector<ContactTestResult>>()); return std::make_shared<CollisionPickResult>(pick.toVariantMap(), CollisionPickResult::LOAD_STATE_NOT_LOADED, std::vector<ContactTestResult>(), std::vector<ContactTestResult>());
} }
auto &avatarIntersections = _physicsEngine->contactTest(USER_COLLISION_MASK_AVATARS, *pick.shapeInfo, pick.transform); auto &avatarIntersections = _physicsEngine->contactTest(USER_COLLISION_MASK_AVATARS, *pick.shapeInfo, pick.transform);
filterIntersections(avatarIntersections); filterIntersections(avatarIntersections);
return std::make_shared<CollisionPickResult>(pick, CollisionPickResult::LOAD_STATE_LOADED, std::make_shared<std::vector<ContactTestResult>>(), avatarIntersections); return std::make_shared<CollisionPickResult>(pick, CollisionPickResult::LOAD_STATE_LOADED, std::vector<ContactTestResult>(), avatarIntersections);
} }
PickResultPointer CollisionPick::getHUDIntersection(const CollisionRegion& pick) { PickResultPointer CollisionPick::getHUDIntersection(const CollisionRegion& pick) {
return std::make_shared<CollisionPickResult>(pick.toVariantMap(), isShapeInfoReady() ? CollisionPickResult::LOAD_STATE_LOADED : CollisionPickResult::LOAD_STATE_NOT_LOADED, std::make_shared<std::vector<ContactTestResult>>(), std::make_shared<std::vector<ContactTestResult>>()); return std::make_shared<CollisionPickResult>(pick.toVariantMap(), isShapeInfoReady() ? CollisionPickResult::LOAD_STATE_LOADED : CollisionPickResult::LOAD_STATE_NOT_LOADED, std::vector<ContactTestResult>(), std::vector<ContactTestResult>());
} }

16
interface/src/raypick/CollisionPick.h
View file

@ -24,14 +24,10 @@ public:
CollisionPickResult() {} CollisionPickResult() {}
CollisionPickResult(const QVariantMap& pickVariant) : PickResult(pickVariant) {} CollisionPickResult(const QVariantMap& pickVariant) : PickResult(pickVariant) {}
CollisionPickResult(const CollisionRegion& searchRegion, CollisionPickResult(const CollisionRegion& searchRegion, LoadState loadState, const std::vector<ContactTestResult>& entityIntersections, const std::vector<ContactTestResult>& avatarIntersections) :
LoadState loadState,
std::shared_ptr<std::vector<ContactTestResult>> entityIntersections = std::make_shared<std::vector<ContactTestResult>>(),
std::shared_ptr<std::vector<ContactTestResult>> avatarIntersections = std::make_shared<std::vector<ContactTestResult>>()
) :
PickResult(searchRegion.toVariantMap()), PickResult(searchRegion.toVariantMap()),
loadState(loadState), loadState(loadState),
intersects(entityIntersections->size() || avatarIntersections->size()), intersects(entityIntersections.size() || avatarIntersections.size()),
entityIntersections(entityIntersections), entityIntersections(entityIntersections),
avatarIntersections(avatarIntersections) { avatarIntersections(avatarIntersections) {
} }
@ -45,8 +41,8 @@ public:
LoadState loadState { LOAD_STATE_UNKNOWN }; LoadState loadState { LOAD_STATE_UNKNOWN };
bool intersects { false }; bool intersects { false };
std::shared_ptr<std::vector<ContactTestResult>> entityIntersections { std::make_shared<std::vector<ContactTestResult>>() }; std::vector<ContactTestResult> entityIntersections;
std::shared_ptr<std::vector<ContactTestResult>> avatarIntersections { std::make_shared<std::vector<ContactTestResult>>() }; std::vector<ContactTestResult> avatarIntersections;
QVariantMap toVariantMap() const override; QVariantMap toVariantMap() const override;
@ -69,7 +65,7 @@ public:
CollisionRegion getMathematicalPick() const override; CollisionRegion getMathematicalPick() const override;
PickResultPointer getDefaultResult(const QVariantMap& pickVariant) const override { PickResultPointer getDefaultResult(const QVariantMap& pickVariant) const override {
return std::make_shared<CollisionPickResult>(pickVariant, CollisionPickResult::LOAD_STATE_UNKNOWN, std::make_shared<std::vector<ContactTestResult>>(), std::make_shared<std::vector<ContactTestResult>>()); return std::make_shared<CollisionPickResult>(pickVariant, CollisionPickResult::LOAD_STATE_UNKNOWN, std::vector<ContactTestResult>(), std::vector<ContactTestResult>());
} }
PickResultPointer getEntityIntersection(const CollisionRegion& pick) override; PickResultPointer getEntityIntersection(const CollisionRegion& pick) override;
PickResultPointer getOverlayIntersection(const CollisionRegion& pick) override; PickResultPointer getOverlayIntersection(const CollisionRegion& pick) override;
@ -80,7 +76,7 @@ protected:
// Returns true if pick.shapeInfo is valid. Otherwise, attempts to get the shapeInfo ready for use. // Returns true if pick.shapeInfo is valid. Otherwise, attempts to get the shapeInfo ready for use.
bool isShapeInfoReady(); bool isShapeInfoReady();
void computeShapeInfo(CollisionRegion& pick, ShapeInfo& shapeInfo, QSharedPointer<GeometryResource> resource); void computeShapeInfo(CollisionRegion& pick, ShapeInfo& shapeInfo, QSharedPointer<GeometryResource> resource);
void filterIntersections(std::shared_ptr<std::vector<ContactTestResult>> intersections) const; void filterIntersections(std::vector<ContactTestResult>& intersections) const;
CollisionRegion _mathPick; CollisionRegion _mathPick;
PhysicsEnginePointer _physicsEngine; PhysicsEnginePointer _physicsEngine;

9
libraries/physics/src/PhysicsEngine.cpp
View file

@ -867,6 +867,7 @@ struct AllContactsCallback : public btCollisionWorld::ContactResultCallback {
AllContactsCallback(int32_t mask, int32_t group, const ShapeInfo& shapeInfo, const Transform& transform, btCollisionObject* myAvatarCollisionObject) : AllContactsCallback(int32_t mask, int32_t group, const ShapeInfo& shapeInfo, const Transform& transform, btCollisionObject* myAvatarCollisionObject) :
btCollisionWorld::ContactResultCallback(), btCollisionWorld::ContactResultCallback(),
collisionObject(), collisionObject(),
contacts(),
myAvatarCollisionObject(myAvatarCollisionObject) { myAvatarCollisionObject(myAvatarCollisionObject) {
const btCollisionShape* collisionShape = ObjectMotionState::getShapeManager()->getShape(shapeInfo); const btCollisionShape* collisionShape = ObjectMotionState::getShapeManager()->getShape(shapeInfo);
@ -887,7 +888,7 @@ struct AllContactsCallback : public btCollisionWorld::ContactResultCallback {
} }
btCollisionObject collisionObject; btCollisionObject collisionObject;
std::shared_ptr<std::vector<ContactTestResult>> contacts = std::make_shared<std::vector<ContactTestResult>>(); std::vector<ContactTestResult> contacts;
btCollisionObject* myAvatarCollisionObject; btCollisionObject* myAvatarCollisionObject;
btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0, int partId0, int index0, const btCollisionObjectWrapper* colObj1, int partId1, int index1) override { btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObjectWrapper* colObj0, int partId0, int index0, const btCollisionObjectWrapper* colObj1, int partId1, int index1) override {
@ -906,7 +907,7 @@ struct AllContactsCallback : public btCollisionWorld::ContactResultCallback {
// TODO: Give MyAvatar a motion state so we don't have to do this // TODO: Give MyAvatar a motion state so we don't have to do this
if ((m_collisionFilterMask & BULLET_COLLISION_GROUP_MY_AVATAR) && myAvatarCollisionObject && myAvatarCollisionObject == otherBody) { if ((m_collisionFilterMask & BULLET_COLLISION_GROUP_MY_AVATAR) && myAvatarCollisionObject && myAvatarCollisionObject == otherBody) {
contacts->emplace_back(Physics::getSessionUUID(), bulletToGLM(penetrationPoint), bulletToGLM(otherPenetrationPoint)); contacts.emplace_back(Physics::getSessionUUID(), bulletToGLM(penetrationPoint), bulletToGLM(otherPenetrationPoint));
return 0; return 0;
} }
@ -922,7 +923,7 @@ struct AllContactsCallback : public btCollisionWorld::ContactResultCallback {
} }
// This is the correct object type. Add it to the list. // This is the correct object type. Add it to the list.
contacts->emplace_back(candidate->getObjectID(), bulletToGLM(penetrationPoint), bulletToGLM(otherPenetrationPoint)); contacts.emplace_back(candidate->getObjectID(), bulletToGLM(penetrationPoint), bulletToGLM(otherPenetrationPoint));
return 0; return 0;
} }
@ -933,7 +934,7 @@ protected:
} }
}; };
std::shared_ptr<std::vector<ContactTestResult>> PhysicsEngine::contactTest(uint16_t mask, const ShapeInfo& regionShapeInfo, const Transform& regionTransform, uint16_t group) const { std::vector<ContactTestResult> PhysicsEngine::contactTest(uint16_t mask, const ShapeInfo& regionShapeInfo, const Transform& regionTransform, uint16_t group) const {
// TODO: Give MyAvatar a motion state so we don't have to do this // TODO: Give MyAvatar a motion state so we don't have to do this
btCollisionObject* myAvatarCollisionObject = nullptr; btCollisionObject* myAvatarCollisionObject = nullptr;
if ((mask & USER_COLLISION_GROUP_MY_AVATAR) && _myAvatarController) { if ((mask & USER_COLLISION_GROUP_MY_AVATAR) && _myAvatarController) {

2
libraries/physics/src/PhysicsEngine.h
View file

@ -127,7 +127,7 @@ public:
// Function for getting colliding objects in the world of specified type // Function for getting colliding objects in the world of specified type
// See PhysicsCollisionGroups.h for mask flags. // See PhysicsCollisionGroups.h for mask flags.
std::shared_ptr<std::vector<ContactTestResult>> contactTest(uint16_t mask, const ShapeInfo& regionShapeInfo, const Transform& regionTransform, uint16_t group = USER_COLLISION_GROUP_DYNAMIC) const; std::vector<ContactTestResult> contactTest(uint16_t mask, const ShapeInfo& regionShapeInfo, const Transform& regionTransform, uint16_t group = USER_COLLISION_GROUP_DYNAMIC) const;
private: private:
QList<EntityDynamicPointer> removeDynamicsForBody(btRigidBody* body); QList<EntityDynamicPointer> removeDynamicsForBody(btRigidBody* body);