try having all spring derived actions agree on a target

Seth Alves committed 10 years ago

Commit 44beca11 parent 5a866405 files · +112 −78Browse files

Showing the changes to libraries/physics/src/ObjectActionSpring.cpp (1 of 5 files). Show all

Unified · Split

libraries/physics/src/ObjectActionSpring.cpp+89−17

 ObjectActionSpring::ObjectActionSpring(const QUuid& id, EntityItemPointer ownerEntity) :
     ObjectAction(ACTION_TYPE_SPRING, id, ownerEntity),
     _positionalTarget(glm::vec3(0.0f)),
+    _desiredPositionalTarget(glm::vec3(0.0f)),
     _linearTimeScale(FLT_MAX),
     _positionalTargetSet(true),
     _rotationalTarget(glm::quat()),
+    _desiredRotationalTarget(glm::quat()),
     _angularTimeScale(FLT_MAX),
     _rotationalTargetSet(true) {
     #if WANT_DEBUG
     #endif
 }
+bool ObjectActionSpring::getTarget(float deltaTimeStep, glm::quat& rotation, glm::vec3& position,
+                                   glm::vec3& linearVelocity, glm::vec3& angularVelocity) {
+    rotation = _desiredRotationalTarget;
+    position = _desiredPositionalTarget;
+    linearVelocity = glm::vec3();
+    angularVelocity = glm::vec3();
+	return true;
+}
+bool ObjectActionSpring::prepareForSpringUpdate(btScalar deltaTimeStep) {
+    glm::quat rotation;
+    glm::vec3 position;
+    glm::vec3 linearVelocity;
+    glm::vec3 angularVelocity;
+    bool valid = false;
+    int springCount = 0;
+    auto ownerEntity = _ownerEntity.lock();
+    if (!ownerEntity) {
+        return false;
+    }
+	QList<EntityActionPointer> springDerivedActions;
+    springDerivedActions.append(ownerEntity->getActionsOfType(ACTION_TYPE_SPRING));
+    springDerivedActions.append(ownerEntity->getActionsOfType(ACTION_TYPE_HOLD));
+    foreach (EntityActionPointer action, springDerivedActions) {
+        std::shared_ptr<ObjectActionSpring> springAction = std::static_pointer_cast<ObjectActionSpring>(action);
+        glm::quat rotationForAction;
+        glm::vec3 positionForAction;
+        glm::vec3 linearVelocityForAction, angularVelocityForAction;
+        bool success = springAction->getTarget(deltaTimeStep, rotationForAction,
+                                               positionForAction,  linearVelocityForAction,
+                                               angularVelocityForAction);
+        if (success) {
+            springCount ++;
+            if (springAction.get() == this) {
+                // only use the rotation for this action
+                valid = true;
+                rotation = rotationForAction;
+            }
+            position += positionForAction;
+            linearVelocity += linearVelocityForAction;
+            angularVelocity += angularVelocityForAction;
+        }
+    }
+    if (valid && springCount > 0) {
+        position /= springCount;
+        linearVelocity /= springCount;
+        angularVelocity /= springCount;
+        withWriteLock([&]{
+            _positionalTarget = position;
+            _rotationalTarget = rotation;
+            _linearVelocityTarget = linearVelocity;
+            _angularVelocityTarget = angularVelocity;
+            _positionalTargetSet = true;
+            _rotationalTargetSet = true;
+            _active = true;
+        });
+    }
+    return valid;
+}
 void ObjectActionSpring::updateActionWorker(btScalar deltaTimeStep) {
-    // don't risk hanging the thread running the physics simulation
+    if (!prepareForSpringUpdate(deltaTimeStep)) {
-    auto lockResult = withTryReadLock([&]{
+        return;
+    }
+    withReadLock([&]{
         auto ownerEntity = _ownerEntity.lock();
         if (!ownerEntity) {
             return;
             rigidBody->setAngularVelocity(targetVelocity);
         }
     });
-    if (!lockResult) {
-        qDebug() << "ObjectActionSpring::updateActionWorker lock failed";
-    }
 }
 const float MIN_TIMESCALE = 0.1f;
         bool ok = true;
         positionalTarget = EntityActionInterface::extractVec3Argument("spring action", arguments, "targetPosition", ok, false);
         if (!ok) {
-            positionalTarget = _positionalTarget;
+            positionalTarget = _desiredPositionalTarget;
         }
         ok = true;
         linearTimeScale = EntityActionInterface::extractFloatArgument("spring action", arguments, "linearTimeScale", ok, false);
         ok = true;
         rotationalTarget = EntityActionInterface::extractQuatArgument("spring action", arguments, "targetRotation", ok, false);
         if (!ok) {
-            rotationalTarget = _rotationalTarget;
+            rotationalTarget = _desiredRotationalTarget;
         }
         ok = true;
         }
         if (somethingChanged ||
-            positionalTarget != _positionalTarget ||
+            positionalTarget != _desiredPositionalTarget ||
             linearTimeScale != _linearTimeScale ||
-            rotationalTarget != _rotationalTarget ||
+            rotationalTarget != _desiredRotationalTarget ||
             angularTimeScale != _angularTimeScale) {
             // something changed
             needUpdate = true;
     if (needUpdate) {
         withWriteLock([&] {
-            _positionalTarget = positionalTarget;
+            _desiredPositionalTarget = positionalTarget;
             _linearTimeScale = glm::max(MIN_TIMESCALE, glm::abs(linearTimeScale));
-            _rotationalTarget = rotationalTarget;
+            _desiredRotationalTarget = rotationalTarget;
             _angularTimeScale = glm::max(MIN_TIMESCALE, glm::abs(angularTimeScale));
             _active = true;
     QVariantMap arguments = ObjectAction::getArguments();
     withReadLock([&] {
         arguments["linearTimeScale"] = _linearTimeScale;
-        arguments["targetPosition"] = glmToQMap(_positionalTarget);
+        arguments["targetPosition"] = glmToQMap(_desiredPositionalTarget);
-        arguments["targetRotation"] = glmToQMap(_rotationalTarget);
+        arguments["targetRotation"] = glmToQMap(_desiredRotationalTarget);
         arguments["angularTimeScale"] = _angularTimeScale;
     });
     return arguments;
     dataStream << ObjectActionSpring::springVersion;
     withReadLock([&] {
-        dataStream << _positionalTarget;
+        dataStream << _desiredPositionalTarget;
         dataStream << _linearTimeScale;
         dataStream << _positionalTargetSet;
-        dataStream << _rotationalTarget;
+        dataStream << _desiredRotationalTarget;
         dataStream << _angularTimeScale;
         dataStream << _rotationalTargetSet;
         dataStream << localTimeToServerTime(_expires);
     }
     withWriteLock([&] {
-        dataStream >> _positionalTarget;
+        dataStream >> _desiredPositionalTarget;
         dataStream >> _linearTimeScale;
         dataStream >> _positionalTargetSet;
-        dataStream >> _rotationalTarget;
+        dataStream >> _desiredRotationalTarget;
         dataStream >> _angularTimeScale;
         dataStream >> _rotationalTargetSet;