Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-07-18 21:07:32 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

rename: ParentFrame --> ConstrainedFrame

Browse source
This commit is contained in:
Andrew Meadows 2014-07-09 16:43:46 -07:00
parent af6704a83c
commit 8fa7bf4fa0
5 changed files with 41 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
interface/src/avatar/FaceModel.cpp
View file

@ -49,9 +49,9 @@ void FaceModel::simulate(float deltaTime, bool fullUpdate) {
void FaceModel::maybeUpdateNeckRotation(const JointState& parentState, const FBXJoint& joint, JointState& state) { void FaceModel::maybeUpdateNeckRotation(const JointState& parentState, const FBXJoint& joint, JointState& state) {
// get the rotation axes in joint space and use them to adjust the rotation // get the rotation axes in joint space and use them to adjust the rotation
glm::mat3 axes = glm::mat3_cast(glm::quat()); glm::mat3 axes = glm::mat3_cast(glm::quat());
glm::mat3 inverse = glm::mat3(glm::inverse(parentState.getTransform() * glm::translate(state.getDefaultTranslationInParentFrame()) * glm::mat3 inverse = glm::mat3(glm::inverse(parentState.getTransform() * glm::translate(state.getDefaultTranslationInConstrainedFrame()) *
joint.preTransform * glm::mat4_cast(joint.preRotation))); joint.preTransform * glm::mat4_cast(joint.preRotation)));
state.setRotationInParentFrame(glm::angleAxis(- RADIANS_PER_DEGREE * _owningHead->getFinalRoll(), glm::normalize(inverse * axes[2])) state.setRotationInConstrainedFrame(glm::angleAxis(- RADIANS_PER_DEGREE * _owningHead->getFinalRoll(), glm::normalize(inverse * axes[2]))
* glm::angleAxis(RADIANS_PER_DEGREE * _owningHead->getFinalYaw(), glm::normalize(inverse * axes[1])) * glm::angleAxis(RADIANS_PER_DEGREE * _owningHead->getFinalYaw(), glm::normalize(inverse * axes[1]))
* glm::angleAxis(- RADIANS_PER_DEGREE * _owningHead->getFinalPitch(), glm::normalize(inverse * axes[0])) * glm::angleAxis(- RADIANS_PER_DEGREE * _owningHead->getFinalPitch(), glm::normalize(inverse * axes[0]))
* joint.rotation); * joint.rotation);
@ -61,14 +61,14 @@ void FaceModel::maybeUpdateEyeRotation(const JointState& parentState, const FBXJ
// likewise with the eye joints // likewise with the eye joints
// NOTE: at the moment we do the math in the world-frame, hence the inverse transform is more complex than usual. // NOTE: at the moment we do the math in the world-frame, hence the inverse transform is more complex than usual.
glm::mat4 inverse = glm::inverse(glm::mat4_cast(_rotation) * parentState.getTransform() * glm::mat4 inverse = glm::inverse(glm::mat4_cast(_rotation) * parentState.getTransform() *
glm::translate(state.getDefaultTranslationInParentFrame()) * glm::translate(state.getDefaultTranslationInConstrainedFrame()) *
joint.preTransform * glm::mat4_cast(joint.preRotation * joint.rotation)); joint.preTransform * glm::mat4_cast(joint.preRotation * joint.rotation));
glm::vec3 front = glm::vec3(inverse * glm::vec4(_owningHead->getFinalOrientationInWorldFrame() * IDENTITY_FRONT, 0.0f)); glm::vec3 front = glm::vec3(inverse * glm::vec4(_owningHead->getFinalOrientationInWorldFrame() * IDENTITY_FRONT, 0.0f));
glm::vec3 lookAt = glm::vec3(inverse * glm::vec4(_owningHead->getLookAtPosition() + glm::vec3 lookAt = glm::vec3(inverse * glm::vec4(_owningHead->getLookAtPosition() +
_owningHead->getSaccade() - _translation, 1.0f)); _owningHead->getSaccade() - _translation, 1.0f));
glm::quat between = rotationBetween(front, lookAt); glm::quat between = rotationBetween(front, lookAt);
const float MAX_ANGLE = 30.0f * RADIANS_PER_DEGREE; const float MAX_ANGLE = 30.0f * RADIANS_PER_DEGREE;
state.setRotationInParentFrame(glm::angleAxis(glm::clamp(glm::angle(between), -MAX_ANGLE, MAX_ANGLE), glm::axis(between)) * state.setRotationInConstrainedFrame(glm::angleAxis(glm::clamp(glm::angle(between), -MAX_ANGLE, MAX_ANGLE), glm::axis(between)) *
joint.rotation); joint.rotation);
} }

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

@ -219,7 +219,7 @@ void SkeletonModel::applyPalmData(int jointIndex, PalmData& palm) {
JointState& parentState = _jointStates[parentJointIndex]; JointState& parentState = _jointStates[parentJointIndex];
parentState.setRotationFromBindFrame(palmRotation, PALM_PRIORITY); parentState.setRotationFromBindFrame(palmRotation, PALM_PRIORITY);
// lock hand to forearm by slamming its rotation (in parent-frame) to identity // lock hand to forearm by slamming its rotation (in parent-frame) to identity
_jointStates[jointIndex].setRotationInParentFrame(glm::quat()); _jointStates[jointIndex].setRotationInConstrainedFrame(glm::quat());
} else { } else {
inverseKinematics(jointIndex, palmPosition, palmRotation, PALM_PRIORITY); inverseKinematics(jointIndex, palmPosition, palmRotation, PALM_PRIORITY);
} }
@ -255,9 +255,9 @@ void SkeletonModel::maybeUpdateLeanRotation(const JointState& parentState, const
} }
// get the rotation axes in joint space and use them to adjust the rotation // get the rotation axes in joint space and use them to adjust the rotation
glm::mat3 axes = glm::mat3_cast(glm::quat()); glm::mat3 axes = glm::mat3_cast(glm::quat());
glm::mat3 inverse = glm::mat3(glm::inverse(parentState.getTransform() * glm::translate(state.getDefaultTranslationInParentFrame()) * glm::mat3 inverse = glm::mat3(glm::inverse(parentState.getTransform() * glm::translate(state.getDefaultTranslationInConstrainedFrame()) *
joint.preTransform * glm::mat4_cast(joint.preRotation * joint.rotation))); joint.preTransform * glm::mat4_cast(joint.preRotation * joint.rotation)));
state.setRotationInParentFrame(glm::angleAxis(- RADIANS_PER_DEGREE * _owningAvatar->getHead()->getFinalLeanSideways(), state.setRotationInConstrainedFrame(glm::angleAxis(- RADIANS_PER_DEGREE * _owningAvatar->getHead()->getFinalLeanSideways(),
glm::normalize(inverse * axes[2])) * glm::angleAxis(- RADIANS_PER_DEGREE * _owningAvatar->getHead()->getFinalLeanForward(), glm::normalize(inverse * axes[2])) * glm::angleAxis(- RADIANS_PER_DEGREE * _owningAvatar->getHead()->getFinalLeanForward(),
glm::normalize(inverse * axes[0])) * joint.rotation); glm::normalize(inverse * axes[0])) * joint.rotation);
} }

48
interface/src/renderer/JointState.cpp
View file

@ -26,7 +26,7 @@ JointState::JointState() :
JointState::JointState(const JointState& other) : _constraint(NULL) { JointState::JointState(const JointState& other) : _constraint(NULL) {
_transform = other._transform; _transform = other._transform;
_rotation = other._rotation; _rotation = other._rotation;
_rotationInParentFrame = other._rotationInParentFrame; _rotationInConstrainedFrame = other._rotationInConstrainedFrame;
_animationPriority = other._animationPriority; _animationPriority = other._animationPriority;
_fbxJoint = other._fbxJoint; _fbxJoint = other._fbxJoint;
// DO NOT copy _constraint // DO NOT copy _constraint
@ -43,7 +43,7 @@ JointState::~JointState() {
void JointState::setFBXJoint(const FBXJoint* joint) { void JointState::setFBXJoint(const FBXJoint* joint) {
assert(joint != NULL); assert(joint != NULL);
_rotationInParentFrame = joint->rotation; _rotationInConstrainedFrame = joint->rotation;
// NOTE: JointState does not own the FBXJoint to which it points. // NOTE: JointState does not own the FBXJoint to which it points.
_fbxJoint = joint; _fbxJoint = joint;
if (_constraint) { if (_constraint) {
@ -68,24 +68,24 @@ void JointState::copyState(const JointState& state) {
_animationPriority = state._animationPriority; _animationPriority = state._animationPriority;
_transform = state._transform; _transform = state._transform;
_rotation = extractRotation(_transform); _rotation = extractRotation(_transform);
_rotationInParentFrame = state._rotationInParentFrame; _rotationInConstrainedFrame = state._rotationInConstrainedFrame;
_visibleTransform = state._visibleTransform; _visibleTransform = state._visibleTransform;
_visibleRotation = extractRotation(_visibleTransform); _visibleRotation = extractRotation(_visibleTransform);
_visibleRotationInParentFrame = state._visibleRotationInParentFrame; _visibleRotationInConstrainedFrame = state._visibleRotationInConstrainedFrame;
// DO NOT copy _fbxJoint or _constraint // DO NOT copy _fbxJoint or _constraint
} }
void JointState::computeTransform(const glm::mat4& parentTransform) { void JointState::computeTransform(const glm::mat4& parentTransform) {
glm::quat modifiedRotation = _fbxJoint->preRotation * _rotationInParentFrame * _fbxJoint->postRotation; glm::quat rotationInConstrainedFrame = _fbxJoint->preRotation * _rotationInConstrainedFrame * _fbxJoint->postRotation;
glm::mat4 modifiedTransform = _fbxJoint->preTransform * glm::mat4_cast(modifiedRotation) * _fbxJoint->postTransform; glm::mat4 modifiedTransform = _fbxJoint->preTransform * glm::mat4_cast(rotationInConstrainedFrame) * _fbxJoint->postTransform;
_transform = parentTransform * glm::translate(_fbxJoint->translation) * modifiedTransform; _transform = parentTransform * glm::translate(_fbxJoint->translation) * modifiedTransform;
_rotation = extractRotation(_transform); _rotation = extractRotation(_transform);
} }
void JointState::computeVisibleTransform(const glm::mat4& parentTransform) { void JointState::computeVisibleTransform(const glm::mat4& parentTransform) {
glm::quat modifiedRotation = _fbxJoint->preRotation * _visibleRotationInParentFrame * _fbxJoint->postRotation; glm::quat rotationInConstrainedFrame = _fbxJoint->preRotation * _visibleRotationInConstrainedFrame * _fbxJoint->postRotation;
glm::mat4 modifiedTransform = _fbxJoint->preTransform * glm::mat4_cast(modifiedRotation) * _fbxJoint->postTransform; glm::mat4 modifiedTransform = _fbxJoint->preTransform * glm::mat4_cast(rotationInConstrainedFrame) * _fbxJoint->postTransform;
_visibleTransform = parentTransform * glm::translate(_fbxJoint->translation) * modifiedTransform; _visibleTransform = parentTransform * glm::translate(_fbxJoint->translation) * modifiedTransform;
_visibleRotation = extractRotation(_visibleTransform); _visibleRotation = extractRotation(_visibleTransform);
} }
@ -97,7 +97,7 @@ glm::quat JointState::getRotationFromBindToModelFrame() const {
void JointState::restoreRotation(float fraction, float priority) { void JointState::restoreRotation(float fraction, float priority) {
assert(_fbxJoint != NULL); assert(_fbxJoint != NULL);
if (priority == _animationPriority || _animationPriority == 0.0f) { if (priority == _animationPriority || _animationPriority == 0.0f) {
setRotationInParentFrame(safeMix(_rotationInParentFrame, _fbxJoint->rotation, fraction)); setRotationInConstrainedFrame(safeMix(_rotationInConstrainedFrame, _fbxJoint->rotation, fraction));
_animationPriority = 0.0f; _animationPriority = 0.0f;
} }
} }
@ -106,11 +106,11 @@ void JointState::setRotationFromBindFrame(const glm::quat& rotation, float prior
// rotation is from bind- to model-frame // rotation is from bind- to model-frame
assert(_fbxJoint != NULL); assert(_fbxJoint != NULL);
if (priority >= _animationPriority) { if (priority >= _animationPriority) {
glm::quat targetRotation = _rotationInParentFrame * glm::inverse(_rotation) * rotation * glm::inverse(_fbxJoint->inverseBindRotation); glm::quat targetRotation = _rotationInConstrainedFrame * glm::inverse(_rotation) * rotation * glm::inverse(_fbxJoint->inverseBindRotation);
if (constrain && _constraint) { if (constrain && _constraint) {
_constraint->softClamp(targetRotation, _rotationInParentFrame, 0.5f); _constraint->softClamp(targetRotation, _rotationInConstrainedFrame, 0.5f);
} }
setRotationInParentFrame(targetRotation); setRotationInConstrainedFrame(targetRotation);
_animationPriority = priority; _animationPriority = priority;
} }
} }
@ -137,12 +137,12 @@ void JointState::applyRotationDelta(const glm::quat& delta, bool constrain, floa
_animationPriority = priority; _animationPriority = priority;
if (!constrain || _constraint == NULL) { if (!constrain || _constraint == NULL) {
// no constraints // no constraints
_rotationInParentFrame = _rotationInParentFrame * glm::inverse(_rotation) * delta * _rotation; _rotationInConstrainedFrame = _rotationInConstrainedFrame * glm::inverse(_rotation) * delta * _rotation;
_rotation = delta * _rotation; _rotation = delta * _rotation;
return; return;
} }
glm::quat targetRotation = _rotationInParentFrame * glm::inverse(_rotation) * delta * _rotation; glm::quat targetRotation = _rotationInConstrainedFrame * glm::inverse(_rotation) * delta * _rotation;
setRotationInParentFrame(targetRotation); setRotationInConstrainedFrame(targetRotation);
} }
/// Applies delta rotation to joint but mixes a little bit of the default pose as well. /// Applies delta rotation to joint but mixes a little bit of the default pose as well.
@ -154,30 +154,30 @@ void JointState::mixRotationDelta(const glm::quat& delta, float mixFactor, float
return; return;
} }
_animationPriority = priority; _animationPriority = priority;
glm::quat targetRotation = _rotationInParentFrame * glm::inverse(_rotation) * delta * _rotation; glm::quat targetRotation = _rotationInConstrainedFrame * glm::inverse(_rotation) * delta * _rotation;
if (mixFactor > 0.0f && mixFactor <= 1.0f) { if (mixFactor > 0.0f && mixFactor <= 1.0f) {
targetRotation = safeMix(targetRotation, _fbxJoint->rotation, mixFactor); targetRotation = safeMix(targetRotation, _fbxJoint->rotation, mixFactor);
} }
if (_constraint) { if (_constraint) {
_constraint->softClamp(targetRotation, _rotationInParentFrame, 0.5f); _constraint->softClamp(targetRotation, _rotationInConstrainedFrame, 0.5f);
} }
setRotationInParentFrame(targetRotation); setRotationInConstrainedFrame(targetRotation);
} }
glm::quat JointState::computeParentRotation() const { glm::quat JointState::computeParentRotation() const {
// R = Rp * Rpre * r * Rpost // R = Rp * Rpre * r * Rpost
// Rp = R * (Rpre * r * Rpost)^ // Rp = R * (Rpre * r * Rpost)^
return _rotation * glm::inverse(_fbxJoint->preRotation * _rotationInParentFrame * _fbxJoint->postRotation); return _rotation * glm::inverse(_fbxJoint->preRotation * _rotationInConstrainedFrame * _fbxJoint->postRotation);
} }
void JointState::setRotationInParentFrame(const glm::quat& targetRotation) { void JointState::setRotationInConstrainedFrame(const glm::quat& targetRotation) {
glm::quat parentRotation = computeParentRotation(); glm::quat parentRotation = computeParentRotation();
_rotationInParentFrame = targetRotation; _rotationInConstrainedFrame = targetRotation;
// R' = Rp * Rpre * r' * Rpost // R' = Rp * Rpre * r' * Rpost
_rotation = parentRotation * _fbxJoint->preRotation * _rotationInParentFrame * _fbxJoint->postRotation; _rotation = parentRotation * _fbxJoint->preRotation * _rotationInConstrainedFrame * _fbxJoint->postRotation;
} }
const glm::vec3& JointState::getDefaultTranslationInParentFrame() const { const glm::vec3& JointState::getDefaultTranslationInConstrainedFrame() const {
assert(_fbxJoint != NULL); assert(_fbxJoint != NULL);
return _fbxJoint->translation; return _fbxJoint->translation;
} }
@ -185,5 +185,5 @@ const glm::vec3& JointState::getDefaultTranslationInParentFrame() const {
void JointState::slaveVisibleTransform() { void JointState::slaveVisibleTransform() {
_visibleTransform = _transform; _visibleTransform = _transform;
_visibleRotation = _rotation; _visibleRotation = _rotation;
_visibleRotationInParentFrame = _rotationInParentFrame; _visibleRotationInConstrainedFrame = _rotationInConstrainedFrame;
} }

12
interface/src/renderer/JointState.h
View file

@ -66,14 +66,14 @@ public:
void restoreRotation(float fraction, float priority); void restoreRotation(float fraction, float priority);
/// \param rotation is from bind- to model-frame /// \param rotation is from bind- to model-frame
/// computes and sets new _rotationInParentFrame /// computes and sets new _rotationInConstrainedFrame
/// NOTE: the JointState's model-frame transform/rotation are NOT updated! /// NOTE: the JointState's model-frame transform/rotation are NOT updated!
void setRotationFromBindFrame(const glm::quat& rotation, float priority, bool constrain = false); void setRotationFromBindFrame(const glm::quat& rotation, float priority, bool constrain = false);
void setRotationInParentFrame(const glm::quat& targetRotation); void setRotationInConstrainedFrame(const glm::quat& targetRotation);
const glm::quat& getRotationInParentFrame() const { return _rotationInParentFrame; } const glm::quat& getRotationInConstrainedFrame() const { return _rotationInConstrainedFrame; }
const glm::vec3& getDefaultTranslationInParentFrame() const; const glm::vec3& getDefaultTranslationInConstrainedFrame() const;
void clearTransformTranslation(); void clearTransformTranslation();
@ -92,11 +92,11 @@ private:
glm::mat4 _transform; // joint- to model-frame glm::mat4 _transform; // joint- to model-frame
glm::quat _rotation; // joint- to model-frame glm::quat _rotation; // joint- to model-frame
glm::quat _rotationInParentFrame; // joint- to parentJoint-frame glm::quat _rotationInConstrainedFrame; // rotation in frame where angular constraints would be applied
glm::mat4 _visibleTransform; glm::mat4 _visibleTransform;
glm::quat _visibleRotation; glm::quat _visibleRotation;
glm::quat _visibleRotationInParentFrame; glm::quat _visibleRotationInConstrainedFrame;
const FBXJoint* _fbxJoint; // JointState does NOT own its FBXJoint const FBXJoint* _fbxJoint; // JointState does NOT own its FBXJoint
AngularConstraint* _constraint; // JointState owns its AngularConstraint AngularConstraint* _constraint; // JointState owns its AngularConstraint

8
interface/src/renderer/Model.cpp
View file

@ -460,7 +460,7 @@ void Model::reset() {
} }
const FBXGeometry& geometry = _geometry->getFBXGeometry(); const FBXGeometry& geometry = _geometry->getFBXGeometry();
for (int i = 0; i < _jointStates.size(); i++) { for (int i = 0; i < _jointStates.size(); i++) {
_jointStates[i].setRotationInParentFrame(geometry.joints.at(i).rotation); _jointStates[i].setRotationInConstrainedFrame(geometry.joints.at(i).rotation);
} }
} }
@ -688,7 +688,7 @@ bool Model::getJointState(int index, glm::quat& rotation) const {
if (index == -1 || index >= _jointStates.size()) { if (index == -1 || index >= _jointStates.size()) {
return false; return false;
} }
rotation = _jointStates.at(index).getRotationInParentFrame(); rotation = _jointStates.at(index).getRotationInConstrainedFrame();
const glm::quat& defaultRotation = _geometry->getFBXGeometry().joints.at(index).rotation; const glm::quat& defaultRotation = _geometry->getFBXGeometry().joints.at(index).rotation;
return glm::abs(rotation.x - defaultRotation.x) >= EPSILON || return glm::abs(rotation.x - defaultRotation.x) >= EPSILON ||
glm::abs(rotation.y - defaultRotation.y) >= EPSILON || glm::abs(rotation.y - defaultRotation.y) >= EPSILON ||
@ -701,7 +701,7 @@ void Model::setJointState(int index, bool valid, const glm::quat& rotation, floa
JointState& state = _jointStates[index]; JointState& state = _jointStates[index];
if (priority >= state._animationPriority) { if (priority >= state._animationPriority) {
if (valid) { if (valid) {
state.setRotationInParentFrame(rotation); state.setRotationInConstrainedFrame(rotation);
state._animationPriority = priority; state._animationPriority = priority;
} else { } else {
state.restoreRotation(1.0f, priority); state.restoreRotation(1.0f, priority);
@ -1787,7 +1787,7 @@ void AnimationHandle::applyFrame(float frameIndex) {
if (mapping != -1) { if (mapping != -1) {
JointState& state = _model->_jointStates[mapping]; JointState& state = _model->_jointStates[mapping];
if (_priority >= state._animationPriority) { if (_priority >= state._animationPriority) {
state.setRotationInParentFrame(safeMix(floorFrame.rotations.at(i), ceilFrame.rotations.at(i), frameFraction)); state.setRotationInConstrainedFrame(safeMix(floorFrame.rotations.at(i), ceilFrame.rotations.at(i), frameFraction));
state._animationPriority = _priority; state._animationPriority = _priority;
} }
} }