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

Merge pull request #6565 from hyperlogic/tony/thread-safe-rig-joint-getters

Browse source 
Make Avatar::getJointRotation and getJointTranslation thread-safe
This commit is contained in:
Seth Alves 2015-12-04 16:45:56 -08:00
commit 7448d9f262
3 changed files with 87 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
interface/src/avatar/Avatar.cpp
View file

@ -857,18 +857,12 @@ QVector<glm::quat> Avatar::getJointRotations() const {
} }
glm::quat Avatar::getJointRotation(int index) const { glm::quat Avatar::getJointRotation(int index) const {
if (QThread::currentThread() != thread()) {
return AvatarData::getJointRotation(index);
}
glm::quat rotation; glm::quat rotation;
_skeletonModel.getJointRotation(index, rotation); _skeletonModel.getJointRotation(index, rotation);
return rotation; return rotation;
} }
glm::vec3 Avatar::getJointTranslation(int index) const { glm::vec3 Avatar::getJointTranslation(int index) const {
if (QThread::currentThread() != thread()) {
return AvatarData::getJointTranslation(index);
}
glm::vec3 translation; glm::vec3 translation;
_skeletonModel.getJointTranslation(index, translation); _skeletonModel.getJointTranslation(index, translation);
return translation; return translation;

126
libraries/animation/src/Rig.cpp
View file

@ -14,6 +14,8 @@
#include <glm/gtx/vector_angle.hpp> #include <glm/gtx/vector_angle.hpp>
#include <queue> #include <queue>
#include <QScriptValueIterator> #include <QScriptValueIterator>
#include <QWriteLocker>
#include <QReadLocker>
#include <NumericalConstants.h> #include <NumericalConstants.h>
#include <DebugDraw.h> #include <DebugDraw.h>
@ -158,10 +160,10 @@ void Rig::destroyAnimGraph() {
_animSkeleton.reset(); _animSkeleton.reset();
_animLoader.reset(); _animLoader.reset();
_animNode.reset(); _animNode.reset();
_relativePoses.clear(); _internalPoseSet._relativePoses.clear();
_absolutePoses.clear(); _internalPoseSet._absolutePoses.clear();
_overridePoses.clear(); _internalPoseSet._overridePoses.clear();
_overrideFlags.clear(); _internalPoseSet._overrideFlags.clear();
} }
void Rig::initJointStates(const FBXGeometry& geometry, const glm::mat4& modelOffset) { void Rig::initJointStates(const FBXGeometry& geometry, const glm::mat4& modelOffset) {
@ -173,16 +175,16 @@ void Rig::initJointStates(const FBXGeometry& geometry, const glm::mat4& modelOff
computeEyesInRootFrame(_animSkeleton->getRelativeDefaultPoses()); computeEyesInRootFrame(_animSkeleton->getRelativeDefaultPoses());
_relativePoses.clear(); _internalPoseSet._relativePoses.clear();
_relativePoses = _animSkeleton->getRelativeDefaultPoses(); _internalPoseSet._relativePoses = _animSkeleton->getRelativeDefaultPoses();
buildAbsoluteRigPoses(_relativePoses, _absolutePoses); buildAbsoluteRigPoses(_internalPoseSet._relativePoses, _internalPoseSet._absolutePoses);
_overridePoses.clear(); _internalPoseSet._overridePoses.clear();
_overridePoses = _animSkeleton->getRelativeDefaultPoses(); _internalPoseSet._overridePoses = _animSkeleton->getRelativeDefaultPoses();
_overrideFlags.clear(); _internalPoseSet._overrideFlags.clear();
_overrideFlags.resize(_animSkeleton->getNumJoints(), false); _internalPoseSet._overrideFlags.resize(_animSkeleton->getNumJoints(), false);
buildAbsoluteRigPoses(_animSkeleton->getRelativeDefaultPoses(), _absoluteDefaultPoses); buildAbsoluteRigPoses(_animSkeleton->getRelativeDefaultPoses(), _absoluteDefaultPoses);
@ -201,16 +203,16 @@ void Rig::reset(const FBXGeometry& geometry) {
computeEyesInRootFrame(_animSkeleton->getRelativeDefaultPoses()); computeEyesInRootFrame(_animSkeleton->getRelativeDefaultPoses());
_relativePoses.clear(); _internalPoseSet._relativePoses.clear();
_relativePoses = _animSkeleton->getRelativeDefaultPoses(); _internalPoseSet._relativePoses = _animSkeleton->getRelativeDefaultPoses();
buildAbsoluteRigPoses(_relativePoses, _absolutePoses); buildAbsoluteRigPoses(_internalPoseSet._relativePoses, _internalPoseSet._absolutePoses);
_overridePoses.clear(); _internalPoseSet._overridePoses.clear();
_overridePoses = _animSkeleton->getRelativeDefaultPoses(); _internalPoseSet._overridePoses = _animSkeleton->getRelativeDefaultPoses();
_overrideFlags.clear(); _internalPoseSet._overrideFlags.clear();
_overrideFlags.resize(_animSkeleton->getNumJoints(), false); _internalPoseSet._overrideFlags.resize(_animSkeleton->getNumJoints(), false);
buildAbsoluteRigPoses(_animSkeleton->getRelativeDefaultPoses(), _absoluteDefaultPoses); buildAbsoluteRigPoses(_animSkeleton->getRelativeDefaultPoses(), _absoluteDefaultPoses);
@ -228,11 +230,11 @@ void Rig::reset(const FBXGeometry& geometry) {
} }
bool Rig::jointStatesEmpty() { bool Rig::jointStatesEmpty() {
return _relativePoses.empty(); return _internalPoseSet._relativePoses.empty();
} }
int Rig::getJointStateCount() const { int Rig::getJointStateCount() const {
return _relativePoses.size(); return _internalPoseSet._relativePoses.size();
} }
int Rig::indexOfJoint(const QString& jointName) const { int Rig::indexOfJoint(const QString& jointName) const {
@ -262,7 +264,7 @@ void Rig::setModelOffset(const glm::mat4& modelOffsetMat) {
bool Rig::getJointStateRotation(int index, glm::quat& rotation) const { bool Rig::getJointStateRotation(int index, glm::quat& rotation) const {
if (isIndexValid(index)) { if (isIndexValid(index)) {
rotation = _relativePoses[index].rot; rotation = _internalPoseSet._relativePoses[index].rot;
return !isEqual(rotation, _animSkeleton->getRelativeDefaultPose(index).rot); return !isEqual(rotation, _animSkeleton->getRelativeDefaultPose(index).rot);
} else { } else {
return false; return false;
@ -271,7 +273,7 @@ bool Rig::getJointStateRotation(int index, glm::quat& rotation) const {
bool Rig::getJointStateTranslation(int index, glm::vec3& translation) const { bool Rig::getJointStateTranslation(int index, glm::vec3& translation) const {
if (isIndexValid(index)) { if (isIndexValid(index)) {
translation = _relativePoses[index].trans; translation = _internalPoseSet._relativePoses[index].trans;
return !isEqual(translation, _animSkeleton->getRelativeDefaultPose(index).trans); return !isEqual(translation, _animSkeleton->getRelativeDefaultPose(index).trans);
} else { } else {
return false; return false;
@ -280,46 +282,46 @@ bool Rig::getJointStateTranslation(int index, glm::vec3& translation) const {
void Rig::clearJointState(int index) { void Rig::clearJointState(int index) {
if (isIndexValid(index)) { if (isIndexValid(index)) {
_overrideFlags[index] = false; _internalPoseSet._overrideFlags[index] = false;
} }
} }
void Rig::clearJointStates() { void Rig::clearJointStates() {
_overrideFlags.clear(); _internalPoseSet._overrideFlags.clear();
_overrideFlags.resize(_animSkeleton->getNumJoints()); _internalPoseSet._overrideFlags.resize(_animSkeleton->getNumJoints());
} }
void Rig::clearJointAnimationPriority(int index) { void Rig::clearJointAnimationPriority(int index) {
if (isIndexValid(index)) { if (isIndexValid(index)) {
_overrideFlags[index] = false; _internalPoseSet._overrideFlags[index] = false;
} }
} }
void Rig::setJointTranslation(int index, bool valid, const glm::vec3& translation, float priority) { void Rig::setJointTranslation(int index, bool valid, const glm::vec3& translation, float priority) {
if (isIndexValid(index)) { if (isIndexValid(index)) {
if (valid) { if (valid) {
assert(_overrideFlags.size() == _overridePoses.size()); assert(_internalPoseSet._overrideFlags.size() == _internalPoseSet._overridePoses.size());
_overrideFlags[index] = true; _internalPoseSet._overrideFlags[index] = true;
_overridePoses[index].trans = translation; _internalPoseSet._overridePoses[index].trans = translation;
} }
} }
} }
void Rig::setJointState(int index, bool valid, const glm::quat& rotation, const glm::vec3& translation, float priority) { void Rig::setJointState(int index, bool valid, const glm::quat& rotation, const glm::vec3& translation, float priority) {
if (isIndexValid(index)) { if (isIndexValid(index)) {
assert(_overrideFlags.size() == _overridePoses.size()); assert(_internalPoseSet._overrideFlags.size() == _internalPoseSet._overridePoses.size());
_overrideFlags[index] = true; _internalPoseSet._overrideFlags[index] = true;
_overridePoses[index].rot = rotation; _internalPoseSet._overridePoses[index].rot = rotation;
_overridePoses[index].trans = translation; _internalPoseSet._overridePoses[index].trans = translation;
} }
} }
void Rig::setJointRotation(int index, bool valid, const glm::quat& rotation, float priority) { void Rig::setJointRotation(int index, bool valid, const glm::quat& rotation, float priority) {
if (isIndexValid(index)) { if (isIndexValid(index)) {
if (valid) { if (valid) {
ASSERT(_overrideFlags.size() == _overridePoses.size()); ASSERT(_internalPoseSet._overrideFlags.size() == _internalPoseSet._overridePoses.size());
_overrideFlags[index] = true; _internalPoseSet._overrideFlags[index] = true;
_overridePoses[index].rot = rotation; _internalPoseSet._overridePoses[index].rot = rotation;
} }
} }
} }
@ -336,7 +338,7 @@ void Rig::restoreJointTranslation(int index, float fraction, float priority) {
bool Rig::getJointPositionInWorldFrame(int jointIndex, glm::vec3& position, glm::vec3 translation, glm::quat rotation) const { bool Rig::getJointPositionInWorldFrame(int jointIndex, glm::vec3& position, glm::vec3 translation, glm::quat rotation) const {
if (isIndexValid(jointIndex)) { if (isIndexValid(jointIndex)) {
position = (rotation * _absolutePoses[jointIndex].trans) + translation; position = (rotation * _internalPoseSet._absolutePoses[jointIndex].trans) + translation;
return true; return true;
} else { } else {
return false; return false;
@ -345,7 +347,7 @@ bool Rig::getJointPositionInWorldFrame(int jointIndex, glm::vec3& position, glm:
bool Rig::getJointPosition(int jointIndex, glm::vec3& position) const { bool Rig::getJointPosition(int jointIndex, glm::vec3& position) const {
if (isIndexValid(jointIndex)) { if (isIndexValid(jointIndex)) {
position = _absolutePoses[jointIndex].trans; position = _internalPoseSet._absolutePoses[jointIndex].trans;
return true; return true;
} else { } else {
return false; return false;
@ -354,7 +356,7 @@ bool Rig::getJointPosition(int jointIndex, glm::vec3& position) const {
bool Rig::getJointRotationInWorldFrame(int jointIndex, glm::quat& result, const glm::quat& rotation) const { bool Rig::getJointRotationInWorldFrame(int jointIndex, glm::quat& result, const glm::quat& rotation) const {
if (isIndexValid(jointIndex)) { if (isIndexValid(jointIndex)) {
result = rotation * _absolutePoses[jointIndex].rot; result = rotation * _internalPoseSet._absolutePoses[jointIndex].rot;
return true; return true;
} else { } else {
return false; return false;
@ -362,8 +364,9 @@ bool Rig::getJointRotationInWorldFrame(int jointIndex, glm::quat& result, const
} }
bool Rig::getJointRotation(int jointIndex, glm::quat& rotation) const { bool Rig::getJointRotation(int jointIndex, glm::quat& rotation) const {
if (isIndexValid(jointIndex)) { QReadLocker readLock(&_externalPoseSetLock);
rotation = _relativePoses[jointIndex].rot; if (jointIndex >= 0 && jointIndex < (int)_externalPoseSet._relativePoses.size()) {
rotation = _externalPoseSet._relativePoses[jointIndex].rot;
return true; return true;
} else { } else {
return false; return false;
@ -371,8 +374,9 @@ bool Rig::getJointRotation(int jointIndex, glm::quat& rotation) const {
} }
bool Rig::getJointTranslation(int jointIndex, glm::vec3& translation) const { bool Rig::getJointTranslation(int jointIndex, glm::vec3& translation) const {
if (isIndexValid(jointIndex)) { QReadLocker readLock(&_externalPoseSetLock);
translation = _relativePoses[jointIndex].trans; if (jointIndex >= 0 && jointIndex < (int)_externalPoseSet._relativePoses.size()) {
translation = _externalPoseSet._relativePoses[jointIndex].trans;
return true; return true;
} else { } else {
return false; return false;
@ -708,21 +712,27 @@ void Rig::updateAnimations(float deltaTime, glm::mat4 rootTransform) {
// evaluate the animation // evaluate the animation
AnimNode::Triggers triggersOut; AnimNode::Triggers triggersOut;
_relativePoses = _animNode->evaluate(_animVars, deltaTime, triggersOut); _internalPoseSet._relativePoses = _animNode->evaluate(_animVars, deltaTime, triggersOut);
if ((int)_relativePoses.size() != _animSkeleton->getNumJoints()) { if ((int)_internalPoseSet._relativePoses.size() != _animSkeleton->getNumJoints()) {
// animations haven't fully loaded yet. // animations haven't fully loaded yet.
_relativePoses = _animSkeleton->getRelativeDefaultPoses(); _internalPoseSet._relativePoses = _animSkeleton->getRelativeDefaultPoses();
} }
_animVars.clearTriggers(); _animVars.clearTriggers();
for (auto& trigger : triggersOut) { for (auto& trigger : triggersOut) {
_animVars.setTrigger(trigger); _animVars.setTrigger(trigger);
} }
computeEyesInRootFrame(_relativePoses); computeEyesInRootFrame(_internalPoseSet._relativePoses);
} }
applyOverridePoses(); applyOverridePoses();
buildAbsoluteRigPoses(_relativePoses, _absolutePoses); buildAbsoluteRigPoses(_internalPoseSet._relativePoses, _internalPoseSet._absolutePoses);
// copy internal poses to external poses
{
QWriteLocker writeLock(&_externalPoseSetLock);
_externalPoseSet = _internalPoseSet;
}
} }
void Rig::inverseKinematics(int endIndex, glm::vec3 targetPosition, const glm::quat& targetRotation, float priority, void Rig::inverseKinematics(int endIndex, glm::vec3 targetPosition, const glm::quat& targetRotation, float priority,
@ -884,7 +894,7 @@ void Rig::updateEyeJoint(int index, const glm::vec3& modelTranslation, const glm
if (isIndexValid(index)) { if (isIndexValid(index)) {
glm::mat4 rigToWorld = createMatFromQuatAndPos(modelRotation, modelTranslation); glm::mat4 rigToWorld = createMatFromQuatAndPos(modelRotation, modelTranslation);
glm::mat4 worldToRig = glm::inverse(rigToWorld); glm::mat4 worldToRig = glm::inverse(rigToWorld);
glm::vec3 zAxis = glm::normalize(_absolutePoses[index].trans - transformPoint(worldToRig, lookAtSpot)); glm::vec3 zAxis = glm::normalize(_internalPoseSet._absolutePoses[index].trans - transformPoint(worldToRig, lookAtSpot));
glm::quat q = rotationBetween(IDENTITY_FRONT, zAxis); glm::quat q = rotationBetween(IDENTITY_FRONT, zAxis);
// limit rotation // limit rotation
@ -892,7 +902,7 @@ void Rig::updateEyeJoint(int index, const glm::vec3& modelTranslation, const glm
q = glm::angleAxis(glm::clamp(glm::angle(q), -MAX_ANGLE, MAX_ANGLE), glm::axis(q)); q = glm::angleAxis(glm::clamp(glm::angle(q), -MAX_ANGLE, MAX_ANGLE), glm::axis(q));
// directly set absolutePose rotation // directly set absolutePose rotation
_absolutePoses[index].rot = q; _internalPoseSet._absolutePoses[index].rot = q;
} }
} }
@ -989,13 +999,13 @@ void Rig::applyOverridePoses() {
return; return;
} }
ASSERT(_animSkeleton->getNumJoints() == (int)_relativePoses.size()); ASSERT(_animSkeleton->getNumJoints() == (int)_internalPoseSet._relativePoses.size());
ASSERT(_animSkeleton->getNumJoints() == (int)_overrideFlags.size()); ASSERT(_animSkeleton->getNumJoints() == (int)_internalPoseSet._overrideFlags.size());
ASSERT(_animSkeleton->getNumJoints() == (int)_overridePoses.size()); ASSERT(_animSkeleton->getNumJoints() == (int)_internalPoseSet._overridePoses.size());
for (size_t i = 0; i < _overrideFlags.size(); i++) { for (size_t i = 0; i < _internalPoseSet._overrideFlags.size(); i++) {
if (_overrideFlags[i]) { if (_internalPoseSet._overrideFlags[i]) {
_relativePoses[i] = _overridePoses[i]; _internalPoseSet._relativePoses[i] = _internalPoseSet._overridePoses[i];
} }
} }
} }
@ -1020,14 +1030,14 @@ void Rig::buildAbsoluteRigPoses(const AnimPoseVec& relativePoses, AnimPoseVec& a
// transform all absolute poses into rig space. // transform all absolute poses into rig space.
AnimPose geometryToRigTransform(_geometryToRigTransform); AnimPose geometryToRigTransform(_geometryToRigTransform);
for (int i = 0; i < (int)_absolutePoses.size(); i++) { for (int i = 0; i < (int)absolutePosesOut.size(); i++) {
absolutePosesOut[i] = geometryToRigTransform * absolutePosesOut[i]; absolutePosesOut[i] = geometryToRigTransform * absolutePosesOut[i];
} }
} }
glm::mat4 Rig::getJointTransform(int jointIndex) const { glm::mat4 Rig::getJointTransform(int jointIndex) const {
if (isIndexValid(jointIndex)) { if (isIndexValid(jointIndex)) {
return _absolutePoses[jointIndex]; return _internalPoseSet._absolutePoses[jointIndex];
} else { } else {
return glm::mat4(); return glm::mat4();
} }

17
libraries/animation/src/Rig.h
View file

@ -19,6 +19,7 @@
#include <QScriptValue> #include <QScriptValue>
#include <vector> #include <vector>
#include <JointData.h> #include <JointData.h>
#include <QReadWriteLock>
#include "AnimNode.h" #include "AnimNode.h"
#include "AnimNodeLoader.h" #include "AnimNodeLoader.h"
@ -27,6 +28,9 @@
class Rig; class Rig;
typedef std::shared_ptr<Rig> RigPointer; typedef std::shared_ptr<Rig> RigPointer;
// Rig instances are reentrant.
// However only specific methods thread-safe. Noted below.
class Rig : public QObject, public std::enable_shared_from_this<Rig> { class Rig : public QObject, public std::enable_shared_from_this<Rig> {
public: public:
struct StateHandler { struct StateHandler {
@ -123,10 +127,10 @@ public:
// if rotation is identity, result will be in rig space // if rotation is identity, result will be in rig space
bool getJointRotationInWorldFrame(int jointIndex, glm::quat& result, const glm::quat& rotation) const; bool getJointRotationInWorldFrame(int jointIndex, glm::quat& result, const glm::quat& rotation) const;
// geometry space // geometry space (thread-safe)
bool getJointRotation(int jointIndex, glm::quat& rotation) const; bool getJointRotation(int jointIndex, glm::quat& rotation) const;
// geometry space // geometry space (thread-safe)
bool getJointTranslation(int jointIndex, glm::vec3& translation) const; bool getJointTranslation(int jointIndex, glm::vec3& translation) const;
// legacy // legacy
@ -217,10 +221,19 @@ public:
AnimPose _modelOffset; // model to rig space AnimPose _modelOffset; // model to rig space
AnimPose _geometryOffset; // geometry to model space (includes unit offset & fst offsets) AnimPose _geometryOffset; // geometry to model space (includes unit offset & fst offsets)
struct PoseSet {
AnimPoseVec _relativePoses; // geometry space relative to parent. AnimPoseVec _relativePoses; // geometry space relative to parent.
AnimPoseVec _absolutePoses; // rig space, not relative to parent. AnimPoseVec _absolutePoses; // rig space, not relative to parent.
AnimPoseVec _overridePoses; // geometry space relative to parent. AnimPoseVec _overridePoses; // geometry space relative to parent.
std::vector<bool> _overrideFlags; std::vector<bool> _overrideFlags;
};
// Only accessed by the main thread
PoseSet _internalPoseSet;
// Copy of the _poseSet for external threads.
PoseSet _externalPoseSet;
mutable QReadWriteLock _externalPoseSetLock;
AnimPoseVec _absoluteDefaultPoses; // rig space, not relative to parent. AnimPoseVec _absoluteDefaultPoses; // rig space, not relative to parent.