From cf8955a8c5801dbf38f62926861030752b745dce Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Fri, 2 Oct 2015 15:27:01 -0700 Subject: [PATCH 01/12] kinematic grab --- interface/src/InterfaceActionFactory.cpp | 3 + .../src/avatar/AvatarActionKinematicHold.cpp | 162 ++++++++++++++++++ .../src/avatar/AvatarActionKinematicHold.h | 41 +++++ .../entities/src/EntityActionInterface.cpp | 5 + .../entities/src/EntityActionInterface.h | 3 +- 5 files changed, 213 insertions(+), 1 deletion(-) create mode 100644 interface/src/avatar/AvatarActionKinematicHold.cpp create mode 100644 interface/src/avatar/AvatarActionKinematicHold.h diff --git a/interface/src/InterfaceActionFactory.cpp b/interface/src/InterfaceActionFactory.cpp index 2879c19eaa..b4bd7c45ae 100644 --- a/interface/src/InterfaceActionFactory.cpp +++ b/interface/src/InterfaceActionFactory.cpp @@ -12,6 +12,7 @@ #include +#include #include #include @@ -28,6 +29,8 @@ EntityActionPointer interfaceActionFactory(EntityActionType type, const QUuid& i return (EntityActionPointer) new ObjectActionSpring(id, ownerEntity); case ACTION_TYPE_HOLD: return (EntityActionPointer) new AvatarActionHold(id, ownerEntity); + case ACTION_TYPE_KINEMATIC_HOLD: + return (EntityActionPointer) new AvatarActionKinematicHold(id, ownerEntity); } assert(false); diff --git a/interface/src/avatar/AvatarActionKinematicHold.cpp b/interface/src/avatar/AvatarActionKinematicHold.cpp new file mode 100644 index 0000000000..14b80efd64 --- /dev/null +++ b/interface/src/avatar/AvatarActionKinematicHold.cpp @@ -0,0 +1,162 @@ +// +// AvatarActionKinematicHold.cpp +// interface/src/avatar/ +// +// Created by Seth Alves 2015-6-9 +// Copyright 2015 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +#include "QVariantGLM.h" +#include "avatar/MyAvatar.h" +#include "avatar/AvatarManager.h" + +#include "AvatarActionKinematicHold.h" + +const uint16_t AvatarActionKinematicHold::holdVersion = 1; + +AvatarActionKinematicHold::AvatarActionKinematicHold(const QUuid& id, EntityItemPointer ownerEntity) : + ObjectActionSpring(id, ownerEntity), + _relativePosition(glm::vec3(0.0f)), + _relativeRotation(glm::quat()), + _hand("right"), + _mine(false) +{ + _type = ACTION_TYPE_HOLD; + #if WANT_DEBUG + qDebug() << "AvatarActionKinematicHold::AvatarActionKinematicHold"; + #endif +} + +AvatarActionKinematicHold::~AvatarActionKinematicHold() { + #if WANT_DEBUG + qDebug() << "AvatarActionKinematicHold::~AvatarActionKinematicHold"; + #endif +} + +void AvatarActionKinematicHold::updateActionWorker(float deltaTimeStep) { + if (!_mine) { + // if a local script isn't updating this, then we are just getting spring-action data over the wire. + // let the super-class handle it. + ObjectActionSpring::updateActionWorker(deltaTimeStep); + return; + } + + glm::quat rotation; + glm::vec3 position; + glm::vec3 offset; + bool gotLock = withTryReadLock([&]{ + auto myAvatar = DependencyManager::get()->getMyAvatar(); + glm::vec3 palmPosition; + glm::quat palmRotation; + if (_hand == "right") { + palmPosition = myAvatar->getRightPalmPosition(); + palmRotation = myAvatar->getRightPalmRotation(); + } else { + palmPosition = myAvatar->getLeftPalmPosition(); + palmRotation = myAvatar->getLeftPalmRotation(); + } + + rotation = palmRotation * _relativeRotation; + offset = rotation * _relativePosition; + position = palmPosition + offset; + }); + + if (gotLock) { + gotLock = withTryWriteLock([&]{ + if (_positionalTarget != position || _rotationalTarget != rotation) { + _positionalTarget = position; + _rotationalTarget = rotation; + auto ownerEntity = _ownerEntity.lock(); + if (ownerEntity) { + ownerEntity->setActionDataDirty(true); + void* physicsInfo = ownerEntity->getPhysicsInfo(); + if (physicsInfo) { + ObjectMotionState* motionState = static_cast(physicsInfo); + btRigidBody* rigidBody = motionState->getRigidBody(); + if (!rigidBody) { + qDebug() << "ObjectActionSpring::updateActionWorker no rigidBody"; + return; + } + + btTransform worldTrans; + worldTrans.setOrigin(glmToBullet(_positionalTarget)); + worldTrans.setRotation(glmToBullet(_rotationalTarget)); + rigidBody->setWorldTransform(worldTrans); + } + } + } + }); + } + + if (gotLock) { + ObjectActionSpring::updateActionWorker(deltaTimeStep); + } +} + + +bool AvatarActionKinematicHold::updateArguments(QVariantMap arguments) { + if (!ObjectAction::updateArguments(arguments)) { + return false; + } + bool ok = true; + glm::vec3 relativePosition = + EntityActionInterface::extractVec3Argument("hold", arguments, "relativePosition", ok, false); + if (!ok) { + relativePosition = _relativePosition; + } + + ok = true; + glm::quat relativeRotation = + EntityActionInterface::extractQuatArgument("hold", arguments, "relativeRotation", ok, false); + if (!ok) { + relativeRotation = _relativeRotation; + } + + ok = true; + QString hand = + EntityActionInterface::extractStringArgument("hold", arguments, "hand", ok, false); + if (!ok || !(hand == "left" || hand == "right")) { + hand = _hand; + } + + if (relativePosition != _relativePosition + || relativeRotation != _relativeRotation + || hand != _hand) { + withWriteLock([&] { + _relativePosition = relativePosition; + _relativeRotation = relativeRotation; + _hand = hand; + + _mine = true; + _active = true; + activateBody(); + }); + } + return true; +} + + +QVariantMap AvatarActionKinematicHold::getArguments() { + QVariantMap arguments = ObjectAction::getArguments(); + withReadLock([&]{ + if (!_mine) { + arguments = ObjectActionSpring::getArguments(); + return; + } + + arguments["relativePosition"] = glmToQMap(_relativePosition); + arguments["relativeRotation"] = glmToQMap(_relativeRotation); + arguments["hand"] = _hand; + }); + return arguments; +} + + +void AvatarActionKinematicHold::deserialize(QByteArray serializedArguments) { + if (!_mine) { + ObjectActionSpring::deserialize(serializedArguments); + } +} diff --git a/interface/src/avatar/AvatarActionKinematicHold.h b/interface/src/avatar/AvatarActionKinematicHold.h new file mode 100644 index 0000000000..6bd7dca01a --- /dev/null +++ b/interface/src/avatar/AvatarActionKinematicHold.h @@ -0,0 +1,41 @@ +// +// AvatarActionKinematicHold.h +// interface/src/avatar/ +// +// Created by Seth Alves 2015-10-2 +// Copyright 2015 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +#ifndef hifi_AvatarActionKinematicHold_h +#define hifi_AvatarActionKinematicHold_h + +#include + +#include +#include + +class AvatarActionKinematicHold : public ObjectActionSpring { +public: + AvatarActionKinematicHold(const QUuid& id, EntityItemPointer ownerEntity); + virtual ~AvatarActionKinematicHold(); + + virtual bool updateArguments(QVariantMap arguments); + virtual QVariantMap getArguments(); + + virtual void updateActionWorker(float deltaTimeStep); + + virtual void deserialize(QByteArray serializedArguments); + +private: + static const uint16_t holdVersion; + + glm::vec3 _relativePosition; + glm::quat _relativeRotation; + QString _hand; + bool _mine = false; +}; + +#endif // hifi_AvatarActionKinematicHold_h diff --git a/libraries/entities/src/EntityActionInterface.cpp b/libraries/entities/src/EntityActionInterface.cpp index ba7f3afea4..d821dcdc2f 100644 --- a/libraries/entities/src/EntityActionInterface.cpp +++ b/libraries/entities/src/EntityActionInterface.cpp @@ -100,6 +100,9 @@ EntityActionType EntityActionInterface::actionTypeFromString(QString actionTypeS if (normalizedActionTypeString == "hold") { return ACTION_TYPE_HOLD; } + if (normalizedActionTypeString == "kinematic-hold") { + return ACTION_TYPE_KINEMATIC_HOLD; + } qDebug() << "Warning -- EntityActionInterface::actionTypeFromString got unknown action-type name" << actionTypeString; return ACTION_TYPE_NONE; @@ -115,6 +118,8 @@ QString EntityActionInterface::actionTypeToString(EntityActionType actionType) { return "spring"; case ACTION_TYPE_HOLD: return "hold"; + case ACTION_TYPE_KINEMATIC_HOLD: + return "kinematic-hold"; } assert(false); return "none"; diff --git a/libraries/entities/src/EntityActionInterface.h b/libraries/entities/src/EntityActionInterface.h index e61019c98c..567b88d4b0 100644 --- a/libraries/entities/src/EntityActionInterface.h +++ b/libraries/entities/src/EntityActionInterface.h @@ -23,7 +23,8 @@ enum EntityActionType { ACTION_TYPE_NONE = 0, ACTION_TYPE_OFFSET = 1000, ACTION_TYPE_SPRING = 2000, - ACTION_TYPE_HOLD = 3000 + ACTION_TYPE_HOLD = 3000, + ACTION_TYPE_KINEMATIC_HOLD = 4000 }; From 89c848d8c8c4351d656361f8a6c0fbdd2ba02be9 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Fri, 2 Oct 2015 17:14:53 -0700 Subject: [PATCH 02/12] fix up kinematic hold --- examples/controllers/handControllerGrab.js | 2 +- .../src/avatar/AvatarActionKinematicHold.cpp | 24 +++++++++++++++++-- .../src/avatar/AvatarActionKinematicHold.h | 4 ++++ .../entities/src/EntityActionInterface.cpp | 2 +- 4 files changed, 28 insertions(+), 4 deletions(-) diff --git a/examples/controllers/handControllerGrab.js b/examples/controllers/handControllerGrab.js index 5705bd4498..a8a95cb4ca 100644 --- a/examples/controllers/handControllerGrab.js +++ b/examples/controllers/handControllerGrab.js @@ -444,7 +444,7 @@ function MyController(hand, triggerAction) { var offsetPosition = Vec3.multiplyQbyV(Quat.inverse(Quat.multiply(handRotation, offsetRotation)), offset); this.actionID = NULL_ACTION_ID; - this.actionID = Entities.addAction("hold", this.grabbedEntity, { + this.actionID = Entities.addAction("kinematic-hold", this.grabbedEntity, { hand: this.hand === RIGHT_HAND ? "right" : "left", timeScale: NEAR_GRABBING_ACTION_TIMEFRAME, relativePosition: offsetPosition, diff --git a/interface/src/avatar/AvatarActionKinematicHold.cpp b/interface/src/avatar/AvatarActionKinematicHold.cpp index 14b80efd64..e890d8cbd8 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.cpp +++ b/interface/src/avatar/AvatarActionKinematicHold.cpp @@ -22,7 +22,9 @@ AvatarActionKinematicHold::AvatarActionKinematicHold(const QUuid& id, EntityItem _relativePosition(glm::vec3(0.0f)), _relativeRotation(glm::quat()), _hand("right"), - _mine(false) + _mine(false), + _previousPositionalTarget(Vectors::ZERO), + _previousRotationalTarget(Quaternions::IDENTITY) { _type = ACTION_TYPE_HOLD; #if WANT_DEBUG @@ -44,6 +46,10 @@ void AvatarActionKinematicHold::updateActionWorker(float deltaTimeStep) { return; } + if (deltaTimeStep <= 0.0f) { + return; + } + glm::quat rotation; glm::vec3 position; glm::vec3 offset; @@ -81,10 +87,24 @@ void AvatarActionKinematicHold::updateActionWorker(float deltaTimeStep) { return; } - btTransform worldTrans; + btTransform worldTrans = rigidBody->getWorldTransform(); worldTrans.setOrigin(glmToBullet(_positionalTarget)); worldTrans.setRotation(glmToBullet(_rotationalTarget)); rigidBody->setWorldTransform(worldTrans); + + if (_previousSet) { + glm::vec3 positionalVelocity = (_positionalTarget - _previousPositionalTarget) / deltaTimeStep; + rigidBody->setLinearVelocity(glmToBullet(positionalVelocity)); + + glm::quat rotationalDelta = glm::inverse(_previousRotationalTarget) * _rotationalTarget; + glm::vec3 rotationalDeltaAxis = glm::axis(rotationalDelta); + float rotationalDeltaAngle = glm::angle(rotationalDelta); + glm::vec3 rotationalVelocity = glm::normalize(rotationalDeltaAxis) * rotationalDeltaAngle / deltaTimeStep; + rigidBody->setAngularVelocity(glmToBullet(rotationalVelocity)); + } + _previousPositionalTarget = _positionalTarget; + _previousRotationalTarget = _rotationalTarget; + _previousSet = true; } } } diff --git a/interface/src/avatar/AvatarActionKinematicHold.h b/interface/src/avatar/AvatarActionKinematicHold.h index 6bd7dca01a..95e9605c2b 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.h +++ b/interface/src/avatar/AvatarActionKinematicHold.h @@ -36,6 +36,10 @@ private: glm::quat _relativeRotation; QString _hand; bool _mine = false; + + bool _previousSet = false; + glm::vec3 _previousPositionalTarget; + glm::quat _previousRotationalTarget; }; #endif // hifi_AvatarActionKinematicHold_h diff --git a/libraries/entities/src/EntityActionInterface.cpp b/libraries/entities/src/EntityActionInterface.cpp index d821dcdc2f..25f61fcf25 100644 --- a/libraries/entities/src/EntityActionInterface.cpp +++ b/libraries/entities/src/EntityActionInterface.cpp @@ -100,7 +100,7 @@ EntityActionType EntityActionInterface::actionTypeFromString(QString actionTypeS if (normalizedActionTypeString == "hold") { return ACTION_TYPE_HOLD; } - if (normalizedActionTypeString == "kinematic-hold") { + if (normalizedActionTypeString == "kinematichold") { return ACTION_TYPE_KINEMATIC_HOLD; } From 6a770a870b98be3d9120d50fcfcd3ad0fd7fc026 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Fri, 2 Oct 2015 17:31:45 -0700 Subject: [PATCH 03/12] set correct type in kinematic hold --- interface/src/avatar/AvatarActionKinematicHold.cpp | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-) diff --git a/interface/src/avatar/AvatarActionKinematicHold.cpp b/interface/src/avatar/AvatarActionKinematicHold.cpp index e890d8cbd8..21f2989299 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.cpp +++ b/interface/src/avatar/AvatarActionKinematicHold.cpp @@ -26,7 +26,7 @@ AvatarActionKinematicHold::AvatarActionKinematicHold(const QUuid& id, EntityItem _previousPositionalTarget(Vectors::ZERO), _previousRotationalTarget(Quaternions::IDENTITY) { - _type = ACTION_TYPE_HOLD; + _type = ACTION_TYPE_KINEMATIC_HOLD; #if WANT_DEBUG qDebug() << "AvatarActionKinematicHold::AvatarActionKinematicHold"; #endif @@ -95,12 +95,6 @@ void AvatarActionKinematicHold::updateActionWorker(float deltaTimeStep) { if (_previousSet) { glm::vec3 positionalVelocity = (_positionalTarget - _previousPositionalTarget) / deltaTimeStep; rigidBody->setLinearVelocity(glmToBullet(positionalVelocity)); - - glm::quat rotationalDelta = glm::inverse(_previousRotationalTarget) * _rotationalTarget; - glm::vec3 rotationalDeltaAxis = glm::axis(rotationalDelta); - float rotationalDeltaAngle = glm::angle(rotationalDelta); - glm::vec3 rotationalVelocity = glm::normalize(rotationalDeltaAxis) * rotationalDeltaAngle / deltaTimeStep; - rigidBody->setAngularVelocity(glmToBullet(rotationalVelocity)); } _previousPositionalTarget = _positionalTarget; _previousRotationalTarget = _rotationalTarget; @@ -123,21 +117,21 @@ bool AvatarActionKinematicHold::updateArguments(QVariantMap arguments) { } bool ok = true; glm::vec3 relativePosition = - EntityActionInterface::extractVec3Argument("hold", arguments, "relativePosition", ok, false); + EntityActionInterface::extractVec3Argument("kinematic-hold", arguments, "relativePosition", ok, false); if (!ok) { relativePosition = _relativePosition; } ok = true; glm::quat relativeRotation = - EntityActionInterface::extractQuatArgument("hold", arguments, "relativeRotation", ok, false); + EntityActionInterface::extractQuatArgument("kinematic-hold", arguments, "relativeRotation", ok, false); if (!ok) { relativeRotation = _relativeRotation; } ok = true; QString hand = - EntityActionInterface::extractStringArgument("hold", arguments, "hand", ok, false); + EntityActionInterface::extractStringArgument("kinematic-hold", arguments, "hand", ok, false); if (!ok || !(hand == "left" || hand == "right")) { hand = _hand; } From 26310d8ce421369193be808b451cf09d7418c787 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Fri, 2 Oct 2015 17:54:09 -0700 Subject: [PATCH 04/12] kill gravity in near-held objects --- examples/controllers/handControllerGrab.js | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/examples/controllers/handControllerGrab.js b/examples/controllers/handControllerGrab.js index a8a95cb4ca..d143df1e83 100644 --- a/examples/controllers/handControllerGrab.js +++ b/examples/controllers/handControllerGrab.js @@ -431,7 +431,7 @@ function MyController(hand, triggerAction) { this.activateEntity(this.grabbedEntity); - var grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, ["position", "rotation"]); + var grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, ["position", "rotation", "gravity"]); var handRotation = this.getHandRotation(); var handPosition = this.getHandPosition(); @@ -443,6 +443,9 @@ function MyController(hand, triggerAction) { var offset = Vec3.subtract(currentObjectPosition, handPosition); var offsetPosition = Vec3.multiplyQbyV(Quat.inverse(Quat.multiply(handRotation, offsetRotation)), offset); + this.saveGravity = grabbedProperties.gravity; + Entities.editEntity(this.grabbedEntity, {gravity: {x:0, y:0, z:0}}); + this.actionID = NULL_ACTION_ID; this.actionID = Entities.addAction("kinematic-hold", this.grabbedEntity, { hand: this.hand === RIGHT_HAND ? "right" : "left", @@ -472,6 +475,7 @@ function MyController(hand, triggerAction) { this.continueNearGrabbing = function() { if (this.triggerSmoothedReleased()) { this.state = STATE_RELEASE; + Entities.editEntity(this.grabbedEntity, {gravity: this.saveGravity}); return; } From 7f84e882c5537591184d897b9163bbe861a6a8c3 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Mon, 5 Oct 2015 13:06:39 -0700 Subject: [PATCH 05/12] attempt to keep ignoreForCollisions the same before and after grab --- examples/controllers/handControllerGrab.js | 23 ++++++++++++++++++---- examples/libraries/utils.js | 6 +++++- 2 files changed, 24 insertions(+), 5 deletions(-) diff --git a/examples/controllers/handControllerGrab.js b/examples/controllers/handControllerGrab.js index d143df1e83..eba69c2150 100644 --- a/examples/controllers/handControllerGrab.js +++ b/examples/controllers/handControllerGrab.js @@ -81,6 +81,8 @@ var STATE_RELEASE = 8; var GRAB_USER_DATA_KEY = "grabKey"; var GRABBABLE_DATA_KEY = "grabbableKey"; +var GRAVITY_USER_DATA_KEY = "preGrabGravity"; +var IGNORE_FOR_COLLISIONS_USER_DATA_KEY = "preGrabIgnoreForCollisions"; function getTag() { return "grab-" + MyAvatar.sessionUUID; @@ -431,7 +433,8 @@ function MyController(hand, triggerAction) { this.activateEntity(this.grabbedEntity); - var grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, ["position", "rotation", "gravity"]); + var grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, + ["position", "rotation", "gravity", "ignoreForCollisions"]); var handRotation = this.getHandRotation(); var handPosition = this.getHandPosition(); @@ -443,8 +446,17 @@ function MyController(hand, triggerAction) { var offset = Vec3.subtract(currentObjectPosition, handPosition); var offsetPosition = Vec3.multiplyQbyV(Quat.inverse(Quat.multiply(handRotation, offsetRotation)), offset); - this.saveGravity = grabbedProperties.gravity; - Entities.editEntity(this.grabbedEntity, {gravity: {x:0, y:0, z:0}}); + // zero gravity and set ignoreForCollisions to true, but in a way that lets us put them back, after all grabs are done + this.saveGravity = getEntityCustomData(GRAVITY_USER_DATA_KEY, this.grabbedEntity, grabbedProperties.gravity); + setEntityCustomData(GRAVITY_USER_DATA_KEY, this.grabbedEntity, this.saveGravity); + + this.saveIgnoreForCollisions = getEntityCustomData(IGNORE_FOR_COLLISIONS_USER_DATA_KEY, this.grabbedEntity, + grabbedProperties.ignoreForCollisions); + setEntityCustomData(IGNORE_FOR_COLLISIONS_USER_DATA_KEY, this.grabbedEntity, this.saveIgnoreForCollisions); + + print("this.ifc = " + this.saveIgnoreForCollisions + ", props.ifc = " + grabbedProperties.ignoreForCollisions); + + Entities.editEntity(this.grabbedEntity, {gravity: {x:0, y:0, z:0}, ignoreForCollisions: true}); this.actionID = NULL_ACTION_ID; this.actionID = Entities.addAction("kinematic-hold", this.grabbedEntity, { @@ -475,7 +487,10 @@ function MyController(hand, triggerAction) { this.continueNearGrabbing = function() { if (this.triggerSmoothedReleased()) { this.state = STATE_RELEASE; - Entities.editEntity(this.grabbedEntity, {gravity: this.saveGravity}); + Entities.editEntity(this.grabbedEntity, + {gravity: this.saveGravity, ignoreForCollisions: this.saveIgnoreForCollisions}); + setEntityCustomData(IGNORE_FOR_COLLISIONS_USER_DATA_KEY, this.grabbedEntity, null); + setEntityCustomData(GRAVITY_USER_DATA_KEY, this.grabbedEntity, null); return; } diff --git a/examples/libraries/utils.js b/examples/libraries/utils.js index fa0f36cbb1..f876d48777 100644 --- a/examples/libraries/utils.js +++ b/examples/libraries/utils.js @@ -79,7 +79,11 @@ getEntityUserData = function(id) { // Non-destructively modify the user data of an entity. setEntityCustomData = function(customKey, id, data) { var userData = getEntityUserData(id); - userData[customKey] = data; + if (data == null) { + delete userData[customKey]; + } else { + userData[customKey] = data; + } setEntityUserData(id, userData); } From 7f8411d947a714e11d7a3aceb04f8cb2b58d5fc8 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Mon, 5 Oct 2015 14:15:38 -0700 Subject: [PATCH 06/12] reference count grabs on an entity --- examples/controllers/handControllerGrab.js | 66 +++++++++++----------- examples/grab.js | 49 ++++++++++++---- 2 files changed, 70 insertions(+), 45 deletions(-) diff --git a/examples/controllers/handControllerGrab.js b/examples/controllers/handControllerGrab.js index 90b85b15da..cdcb15d9dc 100644 --- a/examples/controllers/handControllerGrab.js +++ b/examples/controllers/handControllerGrab.js @@ -79,10 +79,8 @@ var STATE_NEAR_GRABBING_NON_COLLIDING = 6; var STATE_CONTINUE_NEAR_GRABBING_NON_COLLIDING = 7; var STATE_RELEASE = 8; -var GRAB_USER_DATA_KEY = "grabKey"; -var GRABBABLE_DATA_KEY = "grabbableKey"; -var GRAVITY_USER_DATA_KEY = "preGrabGravity"; -var IGNORE_FOR_COLLISIONS_USER_DATA_KEY = "preGrabIgnoreForCollisions"; +var GRABBABLE_DATA_KEY = "grabbableKey"; // shared with grab.js +var GRAB_USER_DATA_KEY = "grabKey"; // shared with grab.js function getTag() { return "grab-" + MyAvatar.sessionUUID; @@ -314,7 +312,8 @@ function MyController(hand, triggerAction) { var handControllerPosition = Controller.getSpatialControlPosition(this.palm); var handRotation = Quat.multiply(MyAvatar.orientation, Controller.getSpatialControlRawRotation(this.palm)); - var grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, ["position", "rotation"]); + var grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, ["position", "rotation", + "gravity", "ignoreForCollisions"]); // add the action and initialize some variables this.currentObjectPosition = grabbedProperties.position; @@ -338,7 +337,7 @@ function MyController(hand, triggerAction) { if (this.actionID !== null) { this.setState(STATE_CONTINUE_DISTANCE_HOLDING); - this.activateEntity(this.grabbedEntity); + this.activateEntity(this.grabbedEntity, grabbedProperties); if (this.hand === RIGHT_HAND) { Entities.callEntityMethod(this.grabbedEntity, "setRightHand"); } else { @@ -441,10 +440,9 @@ function MyController(hand, triggerAction) { this.lineOff(); - this.activateEntity(this.grabbedEntity); - var grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, ["position", "rotation", "gravity", "ignoreForCollisions"]); + this.activateEntity(this.grabbedEntity, grabbedProperties); var handRotation = this.getHandRotation(); var handPosition = this.getHandPosition(); @@ -456,14 +454,6 @@ function MyController(hand, triggerAction) { var offset = Vec3.subtract(currentObjectPosition, handPosition); var offsetPosition = Vec3.multiplyQbyV(Quat.inverse(Quat.multiply(handRotation, offsetRotation)), offset); - // zero gravity and set ignoreForCollisions to true, but in a way that lets us put them back, after all grabs are done - this.saveGravity = getEntityCustomData(GRAVITY_USER_DATA_KEY, this.grabbedEntity, grabbedProperties.gravity); - setEntityCustomData(GRAVITY_USER_DATA_KEY, this.grabbedEntity, this.saveGravity); - this.saveIgnoreForCollisions = getEntityCustomData(IGNORE_FOR_COLLISIONS_USER_DATA_KEY, this.grabbedEntity, - grabbedProperties.ignoreForCollisions); - setEntityCustomData(IGNORE_FOR_COLLISIONS_USER_DATA_KEY, this.grabbedEntity, this.saveIgnoreForCollisions); - Entities.editEntity(this.grabbedEntity, {gravity: {x:0, y:0, z:0}, ignoreForCollisions: true}); - this.actionID = NULL_ACTION_ID; this.actionID = Entities.addAction("kinematic-hold", this.grabbedEntity, { hand: this.hand === RIGHT_HAND ? "right" : "left", @@ -492,12 +482,7 @@ function MyController(hand, triggerAction) { this.continueNearGrabbing = function() { if (this.triggerSmoothedReleased()) { - this.setState(STATE_RELEASE); - Entities.editEntity(this.grabbedEntity, - {gravity: this.saveGravity, ignoreForCollisions: this.saveIgnoreForCollisions}); - setEntityCustomData(IGNORE_FOR_COLLISIONS_USER_DATA_KEY, this.grabbedEntity, null); - setEntityCustomData(GRAVITY_USER_DATA_KEY, this.grabbedEntity, null); return; } @@ -656,20 +641,35 @@ function MyController(hand, triggerAction) { this.release(); }; - this.activateEntity = function() { - var data = { - activated: true, - avatarId: MyAvatar.sessionUUID - }; - setEntityCustomData(GRAB_USER_DATA_KEY, this.grabbedEntity, data); + this.activateEntity = function(entityID, grabbedProperties) { + var data = getEntityCustomData(GRAB_USER_DATA_KEY, entityID, {}); + data["activated"] = true; + data["avatarId"] = MyAvatar.sessionUUID; + data["refCount"] = data["refCount"] ? data["refCount"] + 1 : 1; + // zero gravity and set ignoreForCollisions to true, but in a way that lets us put them back, after all grabs are done + if (data["refCount"] == 1) { + data["gravity"] = grabbedProperties.gravity; + data["ignoreForCollisions"] = grabbedProperties.ignoreForCollisions; + Entities.editEntity(entityID, {gravity: {x:0, y:0, z:0}, ignoreForCollisions: true}); + } + setEntityCustomData(GRAB_USER_DATA_KEY, entityID, data); }; - this.deactivateEntity = function() { - var data = { - activated: false, - avatarId: null - }; - setEntityCustomData(GRAB_USER_DATA_KEY, this.grabbedEntity, data); + this.deactivateEntity = function(entityID) { + var data = getEntityCustomData(GRAB_USER_DATA_KEY, entityID, {}); + if (data && data["refCount"]) { + data["refCount"] = data["refCount"] - 1; + if (data["refCount"] < 1) { + Entities.editEntity(entityID, { + gravity: data["gravity"], + ignoreForCollisions: data["ignoreForCollisions"] + }); + data = null; + } + } else { + data = null; + } + setEntityCustomData(GRAB_USER_DATA_KEY, entityID, data); }; } diff --git a/examples/grab.js b/examples/grab.js index 1e0adf9f1b..1c49775a49 100644 --- a/examples/grab.js +++ b/examples/grab.js @@ -26,7 +26,8 @@ var IDENTITY_QUAT = { z: 0, w: 0 }; -var GRABBABLE_DATA_KEY = "grabbableKey"; +var GRABBABLE_DATA_KEY = "grabbableKey"; // shared with handControllerGrab.js +var GRAB_USER_DATA_KEY = "grabKey"; // shared with handControllerGrab.js var defaultGrabbableData = { grabbable: true @@ -247,7 +248,6 @@ Grabber = function() { this.currentPosition = ZERO_VEC3; this.planeNormal = ZERO_VEC3; - this.originalGravity = ZERO_VEC3; // maxDistance is a function of the size of the object. this.maxDistance; @@ -346,14 +346,11 @@ Grabber.prototype.pressEvent = function(event) { return; } - Entities.editEntity(clickedEntity, { - gravity: ZERO_VEC3 - }); + this.activateEntity(clickedEntity, entityProperties); this.isGrabbing = true; this.entityID = clickedEntity; this.currentPosition = entityProperties.position; - this.originalGravity = entityProperties.gravity; this.targetPosition = { x: this.startPosition.x, y: this.startPosition.y, @@ -379,12 +376,7 @@ Grabber.prototype.pressEvent = function(event) { Grabber.prototype.releaseEvent = function() { if (this.isGrabbing) { - if (Vec3.length(this.originalGravity) != 0) { - Entities.editEntity(this.entityID, { - gravity: this.originalGravity - }); - } - + this.deactivateEntity(this.entityID); this.isGrabbing = false Entities.deleteAction(this.entityID, this.actionID); this.actionID = null; @@ -503,6 +495,39 @@ Grabber.prototype.keyPressEvent = function(event) { this.computeNewGrabPlane(); } +Grabber.prototype.activateEntity = function(entityID, grabbedProperties) { + var data = getEntityCustomData(GRAB_USER_DATA_KEY, entityID, {}); + data["activated"] = true; + data["avatarId"] = MyAvatar.sessionUUID; + data["refCount"] = data["refCount"] ? data["refCount"] + 1 : 1; + // zero gravity and set ignoreForCollisions to true, but in a way that lets us put them back, after all grabs are done + if (data["refCount"] == 1) { + data["gravity"] = grabbedProperties.gravity; + data["ignoreForCollisions"] = grabbedProperties.ignoreForCollisions; + Entities.editEntity(entityID, {gravity: {x:0, y:0, z:0}, ignoreForCollisions: true}); + } + setEntityCustomData(GRAB_USER_DATA_KEY, entityID, data); +}; + +Grabber.prototype.deactivateEntity = function(entityID) { + var data = getEntityCustomData(GRAB_USER_DATA_KEY, entityID, {}); + if (data && data["refCount"]) { + data["refCount"] = data["refCount"] - 1; + if (data["refCount"] < 1) { + Entities.editEntity(entityID, { + gravity: data["gravity"], + ignoreForCollisions: data["ignoreForCollisions"] + }); + data = null; + } + } else { + data = null; + } + setEntityCustomData(GRAB_USER_DATA_KEY, entityID, data); +}; + + + var grabber = new Grabber(); function pressEvent(event) { From 99be44f92d77dfc18c4d1a7678bc2157c39534df Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Mon, 5 Oct 2015 14:58:42 -0700 Subject: [PATCH 07/12] smooth out vibrating appearance for kinematic hold --- interface/src/avatar/AvatarActionKinematicHold.cpp | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/interface/src/avatar/AvatarActionKinematicHold.cpp b/interface/src/avatar/AvatarActionKinematicHold.cpp index 21f2989299..84310cd35f 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.cpp +++ b/interface/src/avatar/AvatarActionKinematicHold.cpp @@ -87,15 +87,19 @@ void AvatarActionKinematicHold::updateActionWorker(float deltaTimeStep) { return; } + if (_previousSet) { + glm::vec3 positionalVelocity = (_positionalTarget - _previousPositionalTarget) / deltaTimeStep; + rigidBody->setLinearVelocity(glmToBullet(positionalVelocity)); + + // back up along velocity a bit in order to smooth out a "vibrating" appearance + _positionalTarget -= positionalVelocity * deltaTimeStep / 2.0f; + } + btTransform worldTrans = rigidBody->getWorldTransform(); worldTrans.setOrigin(glmToBullet(_positionalTarget)); worldTrans.setRotation(glmToBullet(_rotationalTarget)); rigidBody->setWorldTransform(worldTrans); - if (_previousSet) { - glm::vec3 positionalVelocity = (_positionalTarget - _previousPositionalTarget) / deltaTimeStep; - rigidBody->setLinearVelocity(glmToBullet(positionalVelocity)); - } _previousPositionalTarget = _positionalTarget; _previousRotationalTarget = _rotationalTarget; _previousSet = true; From 91f5a6fec6b79a43e2a1013a04b0e07dc9531057 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 6 Oct 2015 08:08:33 -0700 Subject: [PATCH 08/12] make setting of rigid-body velocity controlled by an action argument --- .../src/avatar/AvatarActionKinematicHold.cpp | 23 +++++++++++++------ .../src/avatar/AvatarActionKinematicHold.h | 2 ++ .../entities/src/EntityActionInterface.cpp | 22 ++++++++++++++++++ .../entities/src/EntityActionInterface.h | 2 ++ 4 files changed, 42 insertions(+), 7 deletions(-) diff --git a/interface/src/avatar/AvatarActionKinematicHold.cpp b/interface/src/avatar/AvatarActionKinematicHold.cpp index 84310cd35f..781d895a32 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.cpp +++ b/interface/src/avatar/AvatarActionKinematicHold.cpp @@ -81,18 +81,19 @@ void AvatarActionKinematicHold::updateActionWorker(float deltaTimeStep) { void* physicsInfo = ownerEntity->getPhysicsInfo(); if (physicsInfo) { ObjectMotionState* motionState = static_cast(physicsInfo); - btRigidBody* rigidBody = motionState->getRigidBody(); + btRigidBody* rigidBody = motionState ? motionState->getRigidBody() : nullptr; if (!rigidBody) { qDebug() << "ObjectActionSpring::updateActionWorker no rigidBody"; return; } - if (_previousSet) { - glm::vec3 positionalVelocity = (_positionalTarget - _previousPositionalTarget) / deltaTimeStep; - rigidBody->setLinearVelocity(glmToBullet(positionalVelocity)); - - // back up along velocity a bit in order to smooth out a "vibrating" appearance - _positionalTarget -= positionalVelocity * deltaTimeStep / 2.0f; + if (_setVelocity) { + if (_previousSet) { + glm::vec3 positionalVelocity = (_positionalTarget - _previousPositionalTarget) / deltaTimeStep; + rigidBody->setLinearVelocity(glmToBullet(positionalVelocity)); + // back up along velocity a bit in order to smooth out a "vibrating" appearance + _positionalTarget -= positionalVelocity * deltaTimeStep / 2.0f; + } } btTransform worldTrans = rigidBody->getWorldTransform(); @@ -140,6 +141,13 @@ bool AvatarActionKinematicHold::updateArguments(QVariantMap arguments) { hand = _hand; } + ok = true; + int setVelocity = + EntityActionInterface::extractIntegerArgument("kinematic-hold", arguments, "setVelocity", ok, false); + if (!ok) { + setVelocity = false; + } + if (relativePosition != _relativePosition || relativeRotation != _relativeRotation || hand != _hand) { @@ -147,6 +155,7 @@ bool AvatarActionKinematicHold::updateArguments(QVariantMap arguments) { _relativePosition = relativePosition; _relativeRotation = relativeRotation; _hand = hand; + _setVelocity = setVelocity; _mine = true; _active = true; diff --git a/interface/src/avatar/AvatarActionKinematicHold.h b/interface/src/avatar/AvatarActionKinematicHold.h index 95e9605c2b..b4fceab1e7 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.h +++ b/interface/src/avatar/AvatarActionKinematicHold.h @@ -40,6 +40,8 @@ private: bool _previousSet = false; glm::vec3 _previousPositionalTarget; glm::quat _previousRotationalTarget; + + bool _setVelocity = false; }; #endif // hifi_AvatarActionKinematicHold_h diff --git a/libraries/entities/src/EntityActionInterface.cpp b/libraries/entities/src/EntityActionInterface.cpp index 25f61fcf25..c34f072601 100644 --- a/libraries/entities/src/EntityActionInterface.cpp +++ b/libraries/entities/src/EntityActionInterface.cpp @@ -249,6 +249,28 @@ float EntityActionInterface::extractFloatArgument(QString objectName, QVariantMa return v; } +int EntityActionInterface::extractIntegerArgument(QString objectName, QVariantMap arguments, + QString argumentName, bool& ok, bool required) { + if (!arguments.contains(argumentName)) { + if (required) { + qDebug() << objectName << "requires argument:" << argumentName; + } + ok = false; + return 0.0f; + } + + QVariant vV = arguments[argumentName]; + bool vOk = true; + int v = vV.toInt(&vOk); + + if (!vOk || v != v) { + ok = false; + return 0; + } + + return v; +} + QString EntityActionInterface::extractStringArgument(QString objectName, QVariantMap arguments, QString argumentName, bool& ok, bool required) { if (!arguments.contains(argumentName)) { diff --git a/libraries/entities/src/EntityActionInterface.h b/libraries/entities/src/EntityActionInterface.h index b5d277587c..57f605c3e3 100644 --- a/libraries/entities/src/EntityActionInterface.h +++ b/libraries/entities/src/EntityActionInterface.h @@ -70,6 +70,8 @@ protected: QString argumentName, bool& ok, bool required = true); static float extractFloatArgument(QString objectName, QVariantMap arguments, QString argumentName, bool& ok, bool required = true); + static int extractIntegerArgument(QString objectName, QVariantMap arguments, + QString argumentName, bool& ok, bool required = true); static QString extractStringArgument(QString objectName, QVariantMap arguments, QString argumentName, bool& ok, bool required = true); From c3142ab90b2079615b4a34bb67eb4c40f732461d Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 6 Oct 2015 09:20:07 -0700 Subject: [PATCH 09/12] include setVelocity in returned arguments --- interface/src/avatar/AvatarActionKinematicHold.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/interface/src/avatar/AvatarActionKinematicHold.cpp b/interface/src/avatar/AvatarActionKinematicHold.cpp index 781d895a32..521230adc6 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.cpp +++ b/interface/src/avatar/AvatarActionKinematicHold.cpp @@ -176,6 +176,7 @@ QVariantMap AvatarActionKinematicHold::getArguments() { arguments["relativePosition"] = glmToQMap(_relativePosition); arguments["relativeRotation"] = glmToQMap(_relativeRotation); + arguments["setVelocity"] = glmToQMap((int)_setVelocity); arguments["hand"] = _hand; }); return arguments; From 18b5b994b4e41e8f8cfa1b43173320000560facb Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 6 Oct 2015 09:23:38 -0700 Subject: [PATCH 10/12] include setVelocity in returned arguments --- interface/src/avatar/AvatarActionKinematicHold.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interface/src/avatar/AvatarActionKinematicHold.cpp b/interface/src/avatar/AvatarActionKinematicHold.cpp index 521230adc6..b792058846 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.cpp +++ b/interface/src/avatar/AvatarActionKinematicHold.cpp @@ -176,7 +176,7 @@ QVariantMap AvatarActionKinematicHold::getArguments() { arguments["relativePosition"] = glmToQMap(_relativePosition); arguments["relativeRotation"] = glmToQMap(_relativeRotation); - arguments["setVelocity"] = glmToQMap((int)_setVelocity); + arguments["setVelocity"] = glmToQMap((quint8)_setVelocity); arguments["hand"] = _hand; }); return arguments; From 5abaf38efd6acb314dd29b78a953ab26cfaf7be7 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 6 Oct 2015 09:24:18 -0700 Subject: [PATCH 11/12] include setVelocity in returned arguments --- interface/src/avatar/AvatarActionKinematicHold.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interface/src/avatar/AvatarActionKinematicHold.cpp b/interface/src/avatar/AvatarActionKinematicHold.cpp index b792058846..9831fca47c 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.cpp +++ b/interface/src/avatar/AvatarActionKinematicHold.cpp @@ -176,7 +176,7 @@ QVariantMap AvatarActionKinematicHold::getArguments() { arguments["relativePosition"] = glmToQMap(_relativePosition); arguments["relativeRotation"] = glmToQMap(_relativeRotation); - arguments["setVelocity"] = glmToQMap((quint8)_setVelocity); + arguments["setVelocity"] = _setVelocity; arguments["hand"] = _hand; }); return arguments; From 8caa7abca67d7a15856ecffec1cdbd52cd37ee21 Mon Sep 17 00:00:00 2001 From: Seth Alves Date: Tue, 6 Oct 2015 09:35:54 -0700 Subject: [PATCH 12/12] assert that deltaTimeStep is always greater than zero --- interface/src/avatar/AvatarActionKinematicHold.cpp | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/interface/src/avatar/AvatarActionKinematicHold.cpp b/interface/src/avatar/AvatarActionKinematicHold.cpp index 9831fca47c..680363877f 100644 --- a/interface/src/avatar/AvatarActionKinematicHold.cpp +++ b/interface/src/avatar/AvatarActionKinematicHold.cpp @@ -46,9 +46,7 @@ void AvatarActionKinematicHold::updateActionWorker(float deltaTimeStep) { return; } - if (deltaTimeStep <= 0.0f) { - return; - } + assert(deltaTimeStep > 0.0f); glm::quat rotation; glm::vec3 position;