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

double bits in collision groups

Browse source
This commit is contained in:
Andrew Meadows 2018-05-04 17:11:14 -07:00
parent 1112609ae7
commit 31dd59d212
16 changed files with 55 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
interface/src/avatar/AvatarMotionState.cpp
View file

@ -160,7 +160,7 @@ QUuid AvatarMotionState::getSimulatorID() const {
} }
// virtual // virtual
void AvatarMotionState::computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const { void AvatarMotionState::computeCollisionGroupAndMask(int32_t& group, int32_t& mask) const {
group = BULLET_COLLISION_GROUP_OTHER_AVATAR; group = BULLET_COLLISION_GROUP_OTHER_AVATAR;
mask = Physics::getDefaultCollisionMask(group); mask = Physics::getDefaultCollisionMask(group);
} }

2
interface/src/avatar/AvatarMotionState.h
View file

@ -65,7 +65,7 @@ public:
void addDirtyFlags(uint32_t flags) { _dirtyFlags |= flags; } void addDirtyFlags(uint32_t flags) { _dirtyFlags |= flags; }
virtual void computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const override; virtual void computeCollisionGroupAndMask(int32_t& group, int32_t& mask) const override;
virtual float getMass() const override; virtual float getMass() const override;

2
interface/src/avatar/MyAvatar.h
View file

@ -1402,7 +1402,7 @@ private:
SharedSoundPointer _collisionSound; SharedSoundPointer _collisionSound;
MyCharacterController _characterController; MyCharacterController _characterController;
int16_t _previousCollisionGroup { BULLET_COLLISION_GROUP_MY_AVATAR }; int32_t _previousCollisionGroup { BULLET_COLLISION_GROUP_MY_AVATAR };
AvatarWeakPointer _lookAtTargetAvatar; AvatarWeakPointer _lookAtTargetAvatar;
glm::vec3 _targetAvatarPosition; glm::vec3 _targetAvatarPosition;

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

@ -1914,7 +1914,7 @@ void EntityItem::setCreated(quint64 value) {
}); });
} }
void EntityItem::computeCollisionGroupAndFinalMask(int16_t& group, int16_t& mask) const { void EntityItem::computeCollisionGroupAndFinalMask(int32_t& group, int32_t& mask) const {
if (_collisionless) { if (_collisionless) {
group = BULLET_COLLISION_GROUP_COLLISIONLESS; group = BULLET_COLLISION_GROUP_COLLISIONLESS;
mask = 0; mask = 0;
@ -1927,7 +1927,7 @@ void EntityItem::computeCollisionGroupAndFinalMask(int16_t& group, int16_t& mask
group = BULLET_COLLISION_GROUP_STATIC; group = BULLET_COLLISION_GROUP_STATIC;
} }
uint8_t userMask = getCollisionMask(); uint16_t userMask = getCollisionMask();
if ((bool)(userMask & USER_COLLISION_GROUP_MY_AVATAR) != if ((bool)(userMask & USER_COLLISION_GROUP_MY_AVATAR) !=
(bool)(userMask & USER_COLLISION_GROUP_OTHER_AVATAR)) { (bool)(userMask & USER_COLLISION_GROUP_OTHER_AVATAR)) {
@ -1941,7 +1941,7 @@ void EntityItem::computeCollisionGroupAndFinalMask(int16_t& group, int16_t& mask
if ((bool)(_flags & Simulation::SPECIAL_FLAGS_NO_BOOTSTRAPPING)) { if ((bool)(_flags & Simulation::SPECIAL_FLAGS_NO_BOOTSTRAPPING)) {
userMask &= ~USER_COLLISION_GROUP_MY_AVATAR; userMask &= ~USER_COLLISION_GROUP_MY_AVATAR;
} }
mask = Physics::getDefaultCollisionMask(group) & (int16_t)(userMask); mask = Physics::getDefaultCollisionMask(group) & (int32_t)(userMask);
} }
} }
@ -2795,8 +2795,8 @@ bool EntityItem::getCollisionless() const {
return result; return result;
} }
uint8_t EntityItem::getCollisionMask() const { uint16_t EntityItem::getCollisionMask() const {
uint8_t result; uint16_t result;
withReadLock([&] { withReadLock([&] {
result = _collisionMask; result = _collisionMask;
}); });

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

@ -288,10 +288,10 @@ public:
bool getCollisionless() const; bool getCollisionless() const;
void setCollisionless(bool value); void setCollisionless(bool value);
uint8_t getCollisionMask() const; uint16_t getCollisionMask() const;
void setCollisionMask(uint8_t value); void setCollisionMask(uint8_t value);
void computeCollisionGroupAndFinalMask(int16_t& group, int16_t& mask) const; void computeCollisionGroupAndFinalMask(int32_t& group, int32_t& mask) const;
bool getDynamic() const; bool getDynamic() const;
void setDynamic(bool value); void setDynamic(bool value);
@ -580,7 +580,7 @@ protected:
bool _visible { ENTITY_ITEM_DEFAULT_VISIBLE }; bool _visible { ENTITY_ITEM_DEFAULT_VISIBLE };
bool _canCastShadow{ ENTITY_ITEM_DEFAULT_CAN_CAST_SHADOW }; bool _canCastShadow{ ENTITY_ITEM_DEFAULT_CAN_CAST_SHADOW };
bool _collisionless { ENTITY_ITEM_DEFAULT_COLLISIONLESS }; bool _collisionless { ENTITY_ITEM_DEFAULT_COLLISIONLESS };
uint8_t _collisionMask { ENTITY_COLLISION_MASK_DEFAULT }; uint16_t _collisionMask { ENTITY_COLLISION_MASK_DEFAULT };
bool _dynamic { ENTITY_ITEM_DEFAULT_DYNAMIC }; bool _dynamic { ENTITY_ITEM_DEFAULT_DYNAMIC };
bool _locked { ENTITY_ITEM_DEFAULT_LOCKED }; bool _locked { ENTITY_ITEM_DEFAULT_LOCKED };
QString _userData { ENTITY_ITEM_DEFAULT_USER_DATA }; QString _userData { ENTITY_ITEM_DEFAULT_USER_DATA };

14
libraries/physics/src/CharacterController.cpp
View file

@ -109,7 +109,7 @@ void CharacterController::setDynamicsWorld(btDynamicsWorld* world) {
} }
_dynamicsWorld = nullptr; _dynamicsWorld = nullptr;
} }
int16_t collisionGroup = computeCollisionGroup(); int32_t collisionGroup = computeCollisionGroup();
if (_rigidBody) { if (_rigidBody) {
updateMassProperties(); updateMassProperties();
} }
@ -325,7 +325,7 @@ void CharacterController::playerStep(btCollisionWorld* collisionWorld, btScalar
_ghost.setWorldTransform(_rigidBody->getWorldTransform()); _ghost.setWorldTransform(_rigidBody->getWorldTransform());
} }
void CharacterController::jump() { void CharacterController::jump(const btVector3& dir) {
_pendingFlags |= PENDING_FLAG_JUMP; _pendingFlags |= PENDING_FLAG_JUMP;
} }
@ -352,7 +352,7 @@ static const char* stateToStr(CharacterController::State state) {
#endif // #ifdef DEBUG_STATE_CHANGE #endif // #ifdef DEBUG_STATE_CHANGE
void CharacterController::updateCurrentGravity() { void CharacterController::updateCurrentGravity() {
int16_t collisionGroup = computeCollisionGroup(); int32_t collisionGroup = computeCollisionGroup();
if (_state == State::Hover || collisionGroup == BULLET_COLLISION_GROUP_COLLISIONLESS) { if (_state == State::Hover || collisionGroup == BULLET_COLLISION_GROUP_COLLISIONLESS) {
_currentGravity = 0.0f; _currentGravity = 0.0f;
} else { } else {
@ -433,7 +433,7 @@ void CharacterController::setCollisionless(bool collisionless) {
} }
} }
int16_t CharacterController::computeCollisionGroup() const { int32_t CharacterController::computeCollisionGroup() const {
if (_collisionless) { if (_collisionless) {
return _collisionlessAllowed ? BULLET_COLLISION_GROUP_COLLISIONLESS : BULLET_COLLISION_GROUP_MY_AVATAR; return _collisionlessAllowed ? BULLET_COLLISION_GROUP_COLLISIONLESS : BULLET_COLLISION_GROUP_MY_AVATAR;
} else { } else {
@ -446,7 +446,7 @@ void CharacterController::handleChangedCollisionGroup() {
// ATM the easiest way to update collision groups is to remove/re-add the RigidBody // ATM the easiest way to update collision groups is to remove/re-add the RigidBody
if (_dynamicsWorld) { if (_dynamicsWorld) {
_dynamicsWorld->removeRigidBody(_rigidBody); _dynamicsWorld->removeRigidBody(_rigidBody);
int16_t collisionGroup = computeCollisionGroup(); int32_t collisionGroup = computeCollisionGroup();
_dynamicsWorld->addRigidBody(_rigidBody, collisionGroup, BULLET_COLLISION_MASK_MY_AVATAR); _dynamicsWorld->addRigidBody(_rigidBody, collisionGroup, BULLET_COLLISION_MASK_MY_AVATAR);
} }
_pendingFlags &= ~PENDING_FLAG_UPDATE_COLLISION_GROUP; _pendingFlags &= ~PENDING_FLAG_UPDATE_COLLISION_GROUP;
@ -538,7 +538,7 @@ void CharacterController::applyMotor(int index, btScalar dt, btVector3& worldVel
btScalar angle = motor.rotation.getAngle(); btScalar angle = motor.rotation.getAngle();
btVector3 velocity = worldVelocity.rotate(axis, -angle); btVector3 velocity = worldVelocity.rotate(axis, -angle);
int16_t collisionGroup = computeCollisionGroup(); int32_t collisionGroup = computeCollisionGroup();
if (collisionGroup == BULLET_COLLISION_GROUP_COLLISIONLESS || if (collisionGroup == BULLET_COLLISION_GROUP_COLLISIONLESS ||
_state == State::Hover || motor.hTimescale == motor.vTimescale) { _state == State::Hover || motor.hTimescale == motor.vTimescale) {
// modify velocity // modify velocity
@ -679,7 +679,7 @@ void CharacterController::updateState() {
btVector3 rayStart = _position; btVector3 rayStart = _position;
btScalar rayLength = _radius; btScalar rayLength = _radius;
int16_t collisionGroup = computeCollisionGroup(); int32_t collisionGroup = computeCollisionGroup();
if (collisionGroup == BULLET_COLLISION_GROUP_MY_AVATAR) { if (collisionGroup == BULLET_COLLISION_GROUP_MY_AVATAR) {
rayLength += _scaleFactor * DEFAULT_AVATAR_FALL_HEIGHT; rayLength += _scaleFactor * DEFAULT_AVATAR_FALL_HEIGHT;
} else { } else {

4
libraries/physics/src/CharacterController.h
View file

@ -70,7 +70,7 @@ public:
virtual void preStep(btCollisionWorld *collisionWorld) override; virtual void preStep(btCollisionWorld *collisionWorld) override;
virtual void playerStep(btCollisionWorld *collisionWorld, btScalar dt) override; virtual void playerStep(btCollisionWorld *collisionWorld, btScalar dt) override;
virtual bool canJump() const override { assert(false); return false; } // never call this virtual bool canJump() const override { assert(false); return false; } // never call this
virtual void jump() override; virtual void jump(const btVector3& dir = btVector3(0.0f, 0.0f, 0.0f)) override;
virtual bool onGround() const override; virtual bool onGround() const override;
void clearMotors(); void clearMotors();
@ -120,7 +120,7 @@ public:
bool isStuck() const { return _isStuck; } bool isStuck() const { return _isStuck; }
void setCollisionless(bool collisionless); void setCollisionless(bool collisionless);
int16_t computeCollisionGroup() const; int32_t computeCollisionGroup() const;
void handleChangedCollisionGroup(); void handleChangedCollisionGroup();
bool getRigidBodyLocation(glm::vec3& avatarRigidBodyPosition, glm::quat& avatarRigidBodyRotation); bool getRigidBodyLocation(glm::vec3& avatarRigidBodyPosition, glm::quat& avatarRigidBodyRotation);

4
libraries/physics/src/CharacterGhostObject.cpp
View file

@ -29,13 +29,13 @@ CharacterGhostObject::~CharacterGhostObject() {
} }
} }
void CharacterGhostObject::setCollisionGroupAndMask(int16_t group, int16_t mask) { void CharacterGhostObject::setCollisionGroupAndMask(int32_t group, int32_t mask) {
_collisionFilterGroup = group; _collisionFilterGroup = group;
_collisionFilterMask = mask; _collisionFilterMask = mask;
// TODO: if this probe is in the world reset ghostObject overlap cache // TODO: if this probe is in the world reset ghostObject overlap cache
} }
void CharacterGhostObject::getCollisionGroupAndMask(int16_t& group, int16_t& mask) const { void CharacterGhostObject::getCollisionGroupAndMask(int32_t& group, int32_t& mask) const {
group = _collisionFilterGroup; group = _collisionFilterGroup;
mask = _collisionFilterMask; mask = _collisionFilterMask;
} }

8
libraries/physics/src/CharacterGhostObject.h
View file

@ -28,8 +28,8 @@ public:
CharacterGhostObject() { } CharacterGhostObject() { }
~CharacterGhostObject(); ~CharacterGhostObject();
void setCollisionGroupAndMask(int16_t group, int16_t mask); void setCollisionGroupAndMask(int32_t group, int32_t mask);
void getCollisionGroupAndMask(int16_t& group, int16_t& mask) const; void getCollisionGroupAndMask(int32_t& group, int32_t& mask) const;
void setRadiusAndHalfHeight(btScalar radius, btScalar halfHeight); void setRadiusAndHalfHeight(btScalar radius, btScalar halfHeight);
void setUpDirection(const btVector3& up); void setUpDirection(const btVector3& up);
@ -54,8 +54,8 @@ protected:
btScalar _radius { 0.0f }; btScalar _radius { 0.0f };
btConvexHullShape* _characterShape { nullptr }; // input, shape of character btConvexHullShape* _characterShape { nullptr }; // input, shape of character
CharacterGhostShape* _ghostShape { nullptr }; // internal, shape whose Aabb is used for overlap cache CharacterGhostShape* _ghostShape { nullptr }; // internal, shape whose Aabb is used for overlap cache
int16_t _collisionFilterGroup { 0 }; int32_t _collisionFilterGroup { 0 };
int16_t _collisionFilterMask { 0 }; int32_t _collisionFilterMask { 0 };
bool _inWorld { false }; // internal, was added to world bool _inWorld { false }; // internal, was added to world
}; };

2
libraries/physics/src/EntityMotionState.cpp
View file

@ -779,7 +779,7 @@ QString EntityMotionState::getName() const {
} }
// virtual // virtual
void EntityMotionState::computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const { void EntityMotionState::computeCollisionGroupAndMask(int32_t& group, int32_t& mask) const {
_entity->computeCollisionGroupAndFinalMask(group, mask); _entity->computeCollisionGroupAndFinalMask(group, mask);
} }

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

@ -84,7 +84,7 @@ public:
virtual QString getName() const override; virtual QString getName() const override;
virtual void computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const override; virtual void computeCollisionGroupAndMask(int32_t& group, int32_t& mask) const override;
bool shouldSendBid(); bool shouldSendBid();
bool isLocallyOwned() const override; bool isLocallyOwned() const override;

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

@ -154,7 +154,7 @@ public:
virtual QString getName() const { return ""; } virtual QString getName() const { return ""; }
virtual void computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const = 0; virtual void computeCollisionGroupAndMask(int32_t& group, int32_t& mask) const = 0;
bool isActive() const { return _body ? _body->isActive() : false; } bool isActive() const { return _body ? _body->isActive() : false; }

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

@ -148,7 +148,7 @@ void PhysicsEngine::addObjectToDynamicsWorld(ObjectMotionState* motionState) {
body->setFlags(BT_DISABLE_WORLD_GRAVITY); body->setFlags(BT_DISABLE_WORLD_GRAVITY);
motionState->updateBodyMaterialProperties(); motionState->updateBodyMaterialProperties();
int16_t group, mask; int32_t group, mask;
motionState->computeCollisionGroupAndMask(group, mask); motionState->computeCollisionGroupAndMask(group, mask);
_dynamicsWorld->addRigidBody(body, group, mask); _dynamicsWorld->addRigidBody(body, group, mask);

46
libraries/shared/src/PhysicsCollisionGroups.h
View file

@ -34,13 +34,13 @@ enum CollisionFilterGroups {
* *
*/ */
const int16_t BULLET_COLLISION_GROUP_STATIC = 1 << 0; const int32_t BULLET_COLLISION_GROUP_STATIC = 1 << 0;
const int16_t BULLET_COLLISION_GROUP_DYNAMIC = 1 << 1; const int32_t BULLET_COLLISION_GROUP_DYNAMIC = 1 << 1;
const int16_t BULLET_COLLISION_GROUP_KINEMATIC = 1 << 2; const int32_t BULLET_COLLISION_GROUP_KINEMATIC = 1 << 2;
const int16_t BULLET_COLLISION_GROUP_MY_AVATAR = 1 << 3; const int32_t BULLET_COLLISION_GROUP_MY_AVATAR = 1 << 3;
const int16_t BULLET_COLLISION_GROUP_OTHER_AVATAR = 1 << 4; const int32_t BULLET_COLLISION_GROUP_OTHER_AVATAR = 1 << 4;
// ... // ...
const int16_t BULLET_COLLISION_GROUP_COLLISIONLESS = 1 << 14; const int32_t BULLET_COLLISION_GROUP_COLLISIONLESS = 1 << 31;
/* Note: In order for objectA to collide with objectB at the filter stage /* Note: In order for objectA to collide with objectB at the filter stage
@ -48,21 +48,21 @@ const int16_t BULLET_COLLISION_GROUP_COLLISIONLESS = 1 << 14;
*/ */
// the default collision mask is: collides with everything except collisionless // the default collision mask is: collides with everything except collisionless
const int16_t BULLET_COLLISION_MASK_DEFAULT = ~ BULLET_COLLISION_GROUP_COLLISIONLESS; const int32_t BULLET_COLLISION_MASK_DEFAULT = ~ BULLET_COLLISION_GROUP_COLLISIONLESS;
// STATIC does not collide with itself (as optimization of physics simulation) // STATIC does not collide with itself (as optimization of physics simulation)
const int16_t BULLET_COLLISION_MASK_STATIC = ~ (BULLET_COLLISION_GROUP_COLLISIONLESS | BULLET_COLLISION_GROUP_KINEMATIC | BULLET_COLLISION_GROUP_STATIC); const int32_t BULLET_COLLISION_MASK_STATIC = ~ (BULLET_COLLISION_GROUP_COLLISIONLESS | BULLET_COLLISION_GROUP_KINEMATIC | BULLET_COLLISION_GROUP_STATIC);
const int16_t BULLET_COLLISION_MASK_DYNAMIC = BULLET_COLLISION_MASK_DEFAULT; const int32_t BULLET_COLLISION_MASK_DYNAMIC = BULLET_COLLISION_MASK_DEFAULT;
const int16_t BULLET_COLLISION_MASK_KINEMATIC = BULLET_COLLISION_MASK_STATIC; const int32_t BULLET_COLLISION_MASK_KINEMATIC = BULLET_COLLISION_MASK_STATIC;
// MY_AVATAR does not collide with itself // MY_AVATAR does not collide with itself
const int16_t BULLET_COLLISION_MASK_MY_AVATAR = ~(BULLET_COLLISION_GROUP_COLLISIONLESS | BULLET_COLLISION_GROUP_MY_AVATAR); const int32_t BULLET_COLLISION_MASK_MY_AVATAR = ~(BULLET_COLLISION_GROUP_COLLISIONLESS | BULLET_COLLISION_GROUP_MY_AVATAR);
const int16_t BULLET_COLLISION_MASK_OTHER_AVATAR = BULLET_COLLISION_MASK_DEFAULT; const int32_t BULLET_COLLISION_MASK_OTHER_AVATAR = BULLET_COLLISION_MASK_DEFAULT;
// COLLISIONLESS gets an empty mask. // COLLISIONLESS gets an empty mask.
const int16_t BULLET_COLLISION_MASK_COLLISIONLESS = 0; const int32_t BULLET_COLLISION_MASK_COLLISIONLESS = 0;
/**jsdoc /**jsdoc
* <p>An entity may collide with the following types of items:</p> * <p>An entity may collide with the following types of items:</p>
@ -72,35 +72,35 @@ const int16_t BULLET_COLLISION_MASK_COLLISIONLESS = 0;
* </thead> * </thead>
* <tbody> * <tbody>
* <tr><td><code>1</code></td><td>Static entities &mdash; non-dynamic entities with no velocity.</td></tr> * <tr><td><code>1</code></td><td>Static entities &mdash; non-dynamic entities with no velocity.</td></tr>
* <tr><td><code>2</code></td><td>Dynamic entities &mdash; entities that have their <code>dynamic</code> property set to * <tr><td><code>2</code></td><td>Dynamic entities &mdash; entities that have their <code>dynamic</code> property set to
* <code>true</code>.</td></tr> * <code>true</code>.</td></tr>
* <tr><td><code>4</code></td><td>Kinematic entities &mdash; non-dynamic entities with velocity.</td></tr> * <tr><td><code>4</code></td><td>Kinematic entities &mdash; non-dynamic entities with velocity.</td></tr>
* <tr><td><code>8</code></td><td>My avatar.</td></tr> * <tr><td><code>8</code></td><td>My avatar.</td></tr>
* <tr><td><code>16</code></td><td>Other avatars.</td></tr> * <tr><td><code>16</code></td><td>Other avatars.</td></tr>
* </tbody> * </tbody>
* </table> * </table>
* <p>The values for the collision types that are enabled are added together to give the CollisionMask value. For example, a * <p>The values for the collision types that are enabled are added together to give the CollisionMask value. For example, a
* value of <code>31</code> means that an entity will collide with all item types.</p> * value of <code>31</code> means that an entity will collide with all item types.</p>
* @typedef {number} Entities.CollisionMask * @typedef {number} Entities.CollisionMask
*/ */
// The USER collision groups are exposed to script and can be used to generate per-object collision masks. // The USER collision groups are exposed to script and can be used to generate per-object collision masks.
// They are not necessarily the same as the BULLET_COLLISION_GROUPS, but we start them off with matching numbers. // They are not necessarily the same as the BULLET_COLLISION_GROUPS, but we start them off with matching numbers.
const uint8_t USER_COLLISION_GROUP_STATIC = 1 << 0; const uint16_t USER_COLLISION_GROUP_STATIC = 1 << 0;
const uint8_t USER_COLLISION_GROUP_DYNAMIC = 1 << 1; const uint16_t USER_COLLISION_GROUP_DYNAMIC = 1 << 1;
const uint8_t USER_COLLISION_GROUP_KINEMATIC = 1 << 2; const uint16_t USER_COLLISION_GROUP_KINEMATIC = 1 << 2;
const uint8_t USER_COLLISION_GROUP_MY_AVATAR = 1 << 3; const uint16_t USER_COLLISION_GROUP_MY_AVATAR = 1 << 3;
const uint8_t USER_COLLISION_GROUP_OTHER_AVATAR = 1 << 4; const uint16_t USER_COLLISION_GROUP_OTHER_AVATAR = 1 << 4;
const uint8_t ENTITY_COLLISION_MASK_DEFAULT = const uint16_t ENTITY_COLLISION_MASK_DEFAULT =
USER_COLLISION_GROUP_STATIC | USER_COLLISION_GROUP_STATIC |
USER_COLLISION_GROUP_DYNAMIC | USER_COLLISION_GROUP_DYNAMIC |
USER_COLLISION_GROUP_KINEMATIC | USER_COLLISION_GROUP_KINEMATIC |
USER_COLLISION_GROUP_MY_AVATAR | USER_COLLISION_GROUP_MY_AVATAR |
USER_COLLISION_GROUP_OTHER_AVATAR; USER_COLLISION_GROUP_OTHER_AVATAR;
const uint8_t USER_COLLISION_MASK_AVATARS = USER_COLLISION_GROUP_MY_AVATAR | USER_COLLISION_GROUP_OTHER_AVATAR; const uint16_t USER_COLLISION_MASK_AVATARS = USER_COLLISION_GROUP_MY_AVATAR | USER_COLLISION_GROUP_OTHER_AVATAR;
const int NUM_USER_COLLISION_GROUPS = 5; const int32_t NUM_USER_COLLISION_GROUPS = 5;
#endif // hifi_PhysicsCollisionGroups_h #endif // hifi_PhysicsCollisionGroups_h

2
libraries/shared/src/PhysicsHelpers.cpp
View file

@ -61,7 +61,7 @@ glm::quat computeBulletRotationStep(const glm::vec3& angularVelocity, float time
} }
/* end Bullet code derivation*/ /* end Bullet code derivation*/
int16_t Physics::getDefaultCollisionMask(int16_t group) { int32_t Physics::getDefaultCollisionMask(int32_t group) {
switch(group) { switch(group) {
case BULLET_COLLISION_GROUP_STATIC: case BULLET_COLLISION_GROUP_STATIC:
return BULLET_COLLISION_MASK_STATIC; return BULLET_COLLISION_MASK_STATIC;

2
libraries/shared/src/PhysicsHelpers.h
View file

@ -31,7 +31,7 @@ const float KINEMATIC_ANGULAR_SPEED_THRESHOLD = 0.008f; // ~0.5 deg/sec
glm::quat computeBulletRotationStep(const glm::vec3& angularVelocity, float timeStep); glm::quat computeBulletRotationStep(const glm::vec3& angularVelocity, float timeStep);
namespace Physics { namespace Physics {
int16_t getDefaultCollisionMask(int16_t group); int32_t getDefaultCollisionMask(int32_t group);
void setSessionUUID(const QUuid& sessionID); void setSessionUUID(const QUuid& sessionID);
const QUuid& getSessionUUID(); const QUuid& getSessionUUID();