Merge pull request #13352 from AndrewMeadows/RC68-without-PR13162

Rc68 without pr13162

interface/src/avatar/AvatarMotionState.cpp

@@ -21,17 +21,6 @@ AvatarMotionState::AvatarMotionState(AvatarSharedPointer avatar, const btCollisi
     _type = MOTIONSTATE_TYPE_AVATAR;
 }
 
-void AvatarMotionState::handleEasyChanges(uint32_t& flags) {
-    ObjectMotionState::handleEasyChanges(flags);
-    if (flags & Simulation::DIRTY_PHYSICS_ACTIVATION && !_body->isActive()) {
-        _body->activate();
-    }
-}
-
-bool AvatarMotionState::handleHardAndEasyChanges(uint32_t& flags, PhysicsEngine* engine) {
-    return ObjectMotionState::handleHardAndEasyChanges(flags, engine);
-}
-
 AvatarMotionState::~AvatarMotionState() {
     assert(_avatar);
     _avatar = nullptr;
@@ -57,9 +46,6 @@ PhysicsMotionType AvatarMotionState::computePhysicsMotionType() const {
 const btCollisionShape* AvatarMotionState::computeNewShape() {
     ShapeInfo shapeInfo;
     std::static_pointer_cast<Avatar>(_avatar)->computeShapeInfo(shapeInfo);
-    glm::vec3 halfExtents = shapeInfo.getHalfExtents();
-    halfExtents.y = 0.0f;
-    _diameter = 2.0f * glm::length(halfExtents);
     return getShapeManager()->getShape(shapeInfo);
 }
 
@@ -74,31 +60,25 @@ void AvatarMotionState::getWorldTransform(btTransform& worldTrans) const {
     worldTrans.setRotation(glmToBullet(getObjectRotation()));
     if (_body) {
         _body->setLinearVelocity(glmToBullet(getObjectLinearVelocity()));
-        _body->setAngularVelocity(glmToBullet(getObjectAngularVelocity()));
+        _body->setAngularVelocity(glmToBullet(getObjectLinearVelocity()));
     }
 }
 
 // virtual
 void AvatarMotionState::setWorldTransform(const btTransform& worldTrans) {
+    // HACK: The PhysicsEngine does not actually move OTHER avatars -- instead it slaves their local RigidBody to the transform
+    // as specified by a remote simulation.  However, to give the remote simulation time to respond to our own objects we tie
+    // the other avatar's body to its true position with a simple spring. This is a HACK that will have to be improved later.
     const float SPRING_TIMESCALE = 0.5f;
     float tau = PHYSICS_ENGINE_FIXED_SUBSTEP / SPRING_TIMESCALE;
     btVector3 currentPosition = worldTrans.getOrigin();
-    btVector3 offsetToTarget = glmToBullet(getObjectPosition()) - currentPosition;
+    btVector3 targetPosition = glmToBullet(getObjectPosition());
-    float distance = offsetToTarget.length();
+    btTransform newTransform;
-    if ((1.0f - tau) * distance > _diameter) {
+    newTransform.setOrigin((1.0f - tau) * currentPosition + tau * targetPosition);
-        // the avatar body is far from its target --> slam position
+    newTransform.setRotation(glmToBullet(getObjectRotation()));
-        btTransform newTransform;
+    _body->setWorldTransform(newTransform);
-        newTransform.setOrigin(currentPosition + offsetToTarget);
+    _body->setLinearVelocity(glmToBullet(getObjectLinearVelocity()));
-        newTransform.setRotation(glmToBullet(getObjectRotation()));
+    _body->setAngularVelocity(glmToBullet(getObjectLinearVelocity()));
-        _body->setWorldTransform(newTransform);
-        _body->setLinearVelocity(glmToBullet(getObjectLinearVelocity()));
-        _body->setAngularVelocity(glmToBullet(getObjectAngularVelocity()));
-    } else {
-        // the avatar body is near its target --> slam velocity
-        btVector3 velocity = glmToBullet(getObjectLinearVelocity()) + (1.0f / SPRING_TIMESCALE) * offsetToTarget;
-        _body->setLinearVelocity(velocity);
-        _body->setAngularVelocity(glmToBullet(getObjectAngularVelocity()));
-    }
 }
 
 // These pure virtual methods must be implemented for each MotionState type
@@ -165,8 +145,3 @@ void AvatarMotionState::computeCollisionGroupAndMask(int16_t& group, int16_t& ma
     mask = Physics::getDefaultCollisionMask(group);
 }
 
-// virtual
-float AvatarMotionState::getMass() const {
-    return std::static_pointer_cast<Avatar>(_avatar)->computeMass();
-}
-

interface/src/avatar/AvatarMotionState.h

@@ -23,9 +23,6 @@ class AvatarMotionState : public ObjectMotionState {
 public:
     AvatarMotionState(AvatarSharedPointer avatar, const btCollisionShape* shape);
 
-    virtual void handleEasyChanges(uint32_t& flags) override;
-    virtual bool handleHardAndEasyChanges(uint32_t& flags, PhysicsEngine* engine) override;
-
     virtual PhysicsMotionType getMotionType() const override { return _motionType; }
 
     virtual uint32_t getIncomingDirtyFlags() override;
@@ -67,8 +64,6 @@ public:
 
     virtual void computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const override;
 
-    virtual float getMass() const override;
-
     friend class AvatarManager;
     friend class Avatar;
 
@@ -81,7 +76,6 @@ protected:
     virtual const btCollisionShape* computeNewShape() override;
 
     AvatarSharedPointer _avatar;
-    float _diameter { 0.0f };
 
     uint32_t _dirtyFlags;
 };

libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp

@@ -799,6 +799,7 @@ bool Avatar::shouldRenderHead(const RenderArgs* renderArgs) const {
     return true;
 }
 
+// virtual
 void Avatar::simulateAttachments(float deltaTime) {
     assert(_attachmentModels.size() == _attachmentModelsTexturesLoaded.size());
     PerformanceTimer perfTimer("attachments");
@@ -1481,14 +1482,12 @@ void Avatar::updateDisplayNameAlpha(bool showDisplayName) {
     }
 }
 
+// virtual
 void Avatar::computeShapeInfo(ShapeInfo& shapeInfo) {
     float uniformScale = getModelScale();
-    float radius = uniformScale * _skeletonModel->getBoundingCapsuleRadius();
+    shapeInfo.setCapsuleY(uniformScale * _skeletonModel->getBoundingCapsuleRadius(),
-    float height = uniformScale *  _skeletonModel->getBoundingCapsuleHeight();
+            0.5f * uniformScale *  _skeletonModel->getBoundingCapsuleHeight());
-    shapeInfo.setCapsuleY(radius, 0.5f * height);
+    shapeInfo.setOffset(uniformScale * _skeletonModel->getBoundingCapsuleOffset());
-
-    glm::vec3 offset = uniformScale * _skeletonModel->getBoundingCapsuleOffset();
-    shapeInfo.setOffset(offset);
 }
 
 void Avatar::getCapsule(glm::vec3& start, glm::vec3& end, float& radius) {
@@ -1511,8 +1510,9 @@ float Avatar::computeMass() {
     return _density * TWO_PI * radius * radius * (glm::length(end - start) + 2.0f * radius / 3.0f);
 }
 
+// virtual
 void Avatar::rebuildCollisionShape() {
-    addPhysicsFlags(Simulation::DIRTY_SHAPE | Simulation::DIRTY_MASS);
+    addPhysicsFlags(Simulation::DIRTY_SHAPE);
 }
 
 void Avatar::setPhysicsCallback(AvatarPhysicsCallback cb) {

libraries/physics/src/ObjectMotionState.h

@@ -111,7 +111,7 @@ public:
     virtual PhysicsMotionType getMotionType() const { return _motionType; }
 
     void setMass(float mass);
-    virtual float getMass() const;
+    float getMass() const;
 
     void setBodyLinearVelocity(const glm::vec3& velocity) const;
     void setBodyAngularVelocity(const glm::vec3& velocity) const;

libraries/physics/src/PhysicsEngine.cpp

@@ -105,6 +105,10 @@ void PhysicsEngine::addObjectToDynamicsWorld(ObjectMotionState* motionState) {
         }
         case MOTION_TYPE_DYNAMIC: {
             mass = motionState->getMass();
+            if (mass != mass || mass < 1.0f) {
+                qCDebug(physics) << "mass is too low, setting to 1.0 Kg --" << mass;
+                mass = 1.0f;
+            }
             btCollisionShape* shape = const_cast<btCollisionShape*>(motionState->getShape());
             assert(shape);
             shape->calculateLocalInertia(mass, inertia);