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

Merge pull request #5831 from hyperlogic/tony/anim-qstring

Browse source 
AnimGraph: prefer QString over std::string
This commit is contained in:
Howard Stearns 2015-09-17 14:36:39 -07:00
commit fb71a85bb8
15 changed files with 122 additions and 125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
libraries/animation/src/AnimBlendLinear.cpp
View file

@ -13,7 +13,7 @@
#include "AnimationLogging.h" #include "AnimationLogging.h"
#include "AnimUtil.h" #include "AnimUtil.h"
AnimBlendLinear::AnimBlendLinear(const std::string& id, float alpha) : AnimBlendLinear::AnimBlendLinear(const QString& id, float alpha) :
AnimNode(AnimNode::Type::BlendLinear, id), AnimNode(AnimNode::Type::BlendLinear, id),
_alpha(alpha) { _alpha(alpha) {

6
libraries/animation/src/AnimBlendLinear.h
View file

@ -27,12 +27,12 @@ class AnimBlendLinear : public AnimNode {
public: public:
friend class AnimTests; friend class AnimTests;
AnimBlendLinear(const std::string& id, float alpha); AnimBlendLinear(const QString& id, float alpha);
virtual ~AnimBlendLinear() override; virtual ~AnimBlendLinear() override;
virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override; virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override;
void setAlphaVar(const std::string& alphaVar) { _alphaVar = alphaVar; } void setAlphaVar(const QString& alphaVar) { _alphaVar = alphaVar; }
protected: protected:
// for AnimDebugDraw rendering // for AnimDebugDraw rendering
@ -42,7 +42,7 @@ protected:
float _alpha; float _alpha;
std::string _alphaVar; QString _alphaVar;
// no copies // no copies
AnimBlendLinear(const AnimBlendLinear&) = delete; AnimBlendLinear(const AnimBlendLinear&) = delete;

8
libraries/animation/src/AnimClip.cpp
View file

@ -13,7 +13,7 @@
#include "AnimationLogging.h" #include "AnimationLogging.h"
#include "AnimUtil.h" #include "AnimUtil.h"
AnimClip::AnimClip(const std::string& id, const std::string& url, float startFrame, float endFrame, float timeScale, bool loopFlag) : AnimClip::AnimClip(const QString& id, const QString& url, float startFrame, float endFrame, float timeScale, bool loopFlag) :
AnimNode(AnimNode::Type::Clip, id), AnimNode(AnimNode::Type::Clip, id),
_startFrame(startFrame), _startFrame(startFrame),
_endFrame(endFrame), _endFrame(endFrame),
@ -68,9 +68,9 @@ const AnimPoseVec& AnimClip::evaluate(const AnimVariantMap& animVars, float dt,
return _poses; return _poses;
} }
void AnimClip::loadURL(const std::string& url) { void AnimClip::loadURL(const QString& url) {
auto animCache = DependencyManager::get<AnimationCache>(); auto animCache = DependencyManager::get<AnimationCache>();
_networkAnim = animCache->getAnimation(QString::fromStdString(url)); _networkAnim = animCache->getAnimation(url);
_url = url; _url = url;
} }
@ -127,7 +127,7 @@ void AnimClip::copyFromNetworkAnim() {
for (int i = 0; i < animJointCount; i++) { for (int i = 0; i < animJointCount; i++) {
int skeletonJoint = _skeleton->nameToJointIndex(animJoints.at(i).name); int skeletonJoint = _skeleton->nameToJointIndex(animJoints.at(i).name);
if (skeletonJoint == -1) { if (skeletonJoint == -1) {
qCWarning(animation) << "animation contains joint =" << animJoints.at(i).name << " which is not in the skeleton, url =" << _url.c_str(); qCWarning(animation) << "animation contains joint =" << animJoints.at(i).name << " which is not in the skeleton, url =" << _url;
} }
jointMap.push_back(skeletonJoint); jointMap.push_back(skeletonJoint);
} }

26
libraries/animation/src/AnimClip.h
View file

@ -25,19 +25,19 @@ class AnimClip : public AnimNode {
public: public:
friend class AnimTests; friend class AnimTests;
AnimClip(const std::string& id, const std::string& url, float startFrame, float endFrame, float timeScale, bool loopFlag); AnimClip(const QString& id, const QString& url, float startFrame, float endFrame, float timeScale, bool loopFlag);
virtual ~AnimClip() override; virtual ~AnimClip() override;
virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override; virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override;
void setStartFrameVar(const std::string& startFrameVar) { _startFrameVar = startFrameVar; } void setStartFrameVar(const QString& startFrameVar) { _startFrameVar = startFrameVar; }
void setEndFrameVar(const std::string& endFrameVar) { _endFrameVar = endFrameVar; } void setEndFrameVar(const QString& endFrameVar) { _endFrameVar = endFrameVar; }
void setTimeScaleVar(const std::string& timeScaleVar) { _timeScaleVar = timeScaleVar; } void setTimeScaleVar(const QString& timeScaleVar) { _timeScaleVar = timeScaleVar; }
void setLoopFlagVar(const std::string& loopFlagVar) { _loopFlagVar = loopFlagVar; } void setLoopFlagVar(const QString& loopFlagVar) { _loopFlagVar = loopFlagVar; }
void setFrameVar(const std::string& frameVar) { _frameVar = frameVar; } void setFrameVar(const QString& frameVar) { _frameVar = frameVar; }
protected: protected:
void loadURL(const std::string& url); void loadURL(const QString& url);
virtual void setCurrentFrameInternal(float frame) override; virtual void setCurrentFrameInternal(float frame) override;
@ -53,18 +53,18 @@ protected:
// _anim[frame][joint] // _anim[frame][joint]
std::vector<AnimPoseVec> _anim; std::vector<AnimPoseVec> _anim;
std::string _url; QString _url;
float _startFrame; float _startFrame;
float _endFrame; float _endFrame;
float _timeScale; float _timeScale;
bool _loopFlag; bool _loopFlag;
float _frame; float _frame;
std::string _startFrameVar; QString _startFrameVar;
std::string _endFrameVar; QString _endFrameVar;
std::string _timeScaleVar; QString _timeScaleVar;
std::string _loopFlagVar; QString _loopFlagVar;
std::string _frameVar; QString _frameVar;
// no copies // no copies
AnimClip(const AnimClip&) = delete; AnimClip(const AnimClip&) = delete;

8
libraries/animation/src/AnimInverseKinematics.cpp
View file

@ -17,7 +17,7 @@
#include "SwingTwistConstraint.h" #include "SwingTwistConstraint.h"
#include "AnimationLogging.h" #include "AnimationLogging.h"
AnimInverseKinematics::AnimInverseKinematics(const std::string& id) : AnimNode(AnimNode::Type::InverseKinematics, id) { AnimInverseKinematics::AnimInverseKinematics(const QString& id) : AnimNode(AnimNode::Type::InverseKinematics, id) {
} }
AnimInverseKinematics::~AnimInverseKinematics() { AnimInverseKinematics::~AnimInverseKinematics() {
@ -59,15 +59,15 @@ void AnimInverseKinematics::setTargetVars(const QString& jointName, const QStrin
for (auto& targetVar: _targetVarVec) { for (auto& targetVar: _targetVarVec) {
if (targetVar.jointName == jointName) { if (targetVar.jointName == jointName) {
// update existing targetVar // update existing targetVar
targetVar.positionVar = positionVar.toStdString(); targetVar.positionVar = positionVar;
targetVar.rotationVar = rotationVar.toStdString(); targetVar.rotationVar = rotationVar;
found = true; found = true;
break; break;
} }
} }
if (!found) { if (!found) {
// create a new entry // create a new entry
_targetVarVec.push_back(IKTargetVar(jointName, positionVar.toStdString(), rotationVar.toStdString())); _targetVarVec.push_back(IKTargetVar(jointName, positionVar, rotationVar));
} }
} }

8
libraries/animation/src/AnimInverseKinematics.h
View file

@ -19,7 +19,7 @@ class RotationConstraint;
class AnimInverseKinematics : public AnimNode { class AnimInverseKinematics : public AnimNode {
public: public:
AnimInverseKinematics(const std::string& id); AnimInverseKinematics(const QString& id);
virtual ~AnimInverseKinematics() override; virtual ~AnimInverseKinematics() override;
void loadDefaultPoses(const AnimPoseVec& poses); void loadDefaultPoses(const AnimPoseVec& poses);
@ -45,15 +45,15 @@ protected:
void initConstraints(); void initConstraints();
struct IKTargetVar { struct IKTargetVar {
IKTargetVar(const QString& jointNameIn, const std::string& positionVarIn, const std::string& rotationVarIn) : IKTargetVar(const QString& jointNameIn, const QString& positionVarIn, const QString& rotationVarIn) :
positionVar(positionVarIn), positionVar(positionVarIn),
rotationVar(rotationVarIn), rotationVar(rotationVarIn),
jointName(jointNameIn), jointName(jointNameIn),
jointIndex(-1), jointIndex(-1),
rootIndex(-1) {} rootIndex(-1) {}
std::string positionVar; QString positionVar;
std::string rotationVar; QString rotationVar;
QString jointName; QString jointName;
int jointIndex; // cached joint index int jointIndex; // cached joint index
int rootIndex; // cached root index int rootIndex; // cached root index

7
libraries/animation/src/AnimManipulator.cpp
View file

@ -12,7 +12,7 @@
#include "AnimUtil.h" #include "AnimUtil.h"
#include "AnimationLogging.h" #include "AnimationLogging.h"
AnimManipulator::AnimManipulator(const std::string& id, float alpha) : AnimManipulator::AnimManipulator(const QString& id, float alpha) :
AnimNode(AnimNode::Type::Manipulator, id), AnimNode(AnimNode::Type::Manipulator, id),
_alpha(alpha) { _alpha(alpha) {
@ -31,10 +31,9 @@ const AnimPoseVec& AnimManipulator::overlay(const AnimVariantMap& animVars, floa
for (auto& jointVar : _jointVars) { for (auto& jointVar : _jointVars) {
if (!jointVar.hasPerformedJointLookup) { if (!jointVar.hasPerformedJointLookup) {
QString qJointName = QString::fromStdString(jointVar.jointName); jointVar.jointIndex = _skeleton->nameToJointIndex(jointVar.jointName);
jointVar.jointIndex = _skeleton->nameToJointIndex(qJointName);
if (jointVar.jointIndex < 0) { if (jointVar.jointIndex < 0) {
qCWarning(animation) << "AnimManipulator could not find jointName" << qJointName << "in skeleton"; qCWarning(animation) << "AnimManipulator could not find jointName" << jointVar.jointName << "in skeleton";
} }
jointVar.hasPerformedJointLookup = true; jointVar.hasPerformedJointLookup = true;
} }

12
libraries/animation/src/AnimManipulator.h
View file

@ -19,20 +19,20 @@ class AnimManipulator : public AnimNode {
public: public:
friend class AnimTests; friend class AnimTests;
AnimManipulator(const std::string& id, float alpha); AnimManipulator(const QString& id, float alpha);
virtual ~AnimManipulator() override; virtual ~AnimManipulator() override;
virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override; virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override;
virtual const AnimPoseVec& overlay(const AnimVariantMap& animVars, float dt, Triggers& triggersOut, const AnimPoseVec& underPoses) override; virtual const AnimPoseVec& overlay(const AnimVariantMap& animVars, float dt, Triggers& triggersOut, const AnimPoseVec& underPoses) override;
void setAlphaVar(const std::string& alphaVar) { _alphaVar = alphaVar; } void setAlphaVar(const QString& alphaVar) { _alphaVar = alphaVar; }
virtual void setSkeletonInternal(AnimSkeleton::ConstPointer skeleton) override; virtual void setSkeletonInternal(AnimSkeleton::ConstPointer skeleton) override;
struct JointVar { struct JointVar {
JointVar(const std::string& varIn, const std::string& jointNameIn) : var(varIn), jointName(jointNameIn), jointIndex(-1), hasPerformedJointLookup(false) {} JointVar(const QString& varIn, const QString& jointNameIn) : var(varIn), jointName(jointNameIn), jointIndex(-1), hasPerformedJointLookup(false) {}
std::string var = ""; QString var = "";
std::string jointName = ""; QString jointName = "";
int jointIndex = -1; int jointIndex = -1;
bool hasPerformedJointLookup = false; bool hasPerformedJointLookup = false;
}; };
@ -45,7 +45,7 @@ protected:
AnimPoseVec _poses; AnimPoseVec _poses;
float _alpha; float _alpha;
std::string _alphaVar; QString _alphaVar;
std::vector<JointVar> _jointVars; std::vector<JointVar> _jointVars;

10
libraries/animation/src/AnimNode.h
View file

@ -46,16 +46,16 @@ public:
}; };
using Pointer = std::shared_ptr<AnimNode>; using Pointer = std::shared_ptr<AnimNode>;
using ConstPointer = std::shared_ptr<const AnimNode>; using ConstPointer = std::shared_ptr<const AnimNode>;
using Triggers = std::vector<std::string>; using Triggers = std::vector<QString>;
friend class AnimDebugDraw; friend class AnimDebugDraw;
friend void buildChildMap(std::map<std::string, Pointer>& map, Pointer node); friend void buildChildMap(std::map<QString, Pointer>& map, Pointer node);
friend class AnimStateMachine; friend class AnimStateMachine;
AnimNode(Type type, const std::string& id) : _type(type), _id(id) {} AnimNode(Type type, const QString& id) : _type(type), _id(id) {}
virtual ~AnimNode() {} virtual ~AnimNode() {}
const std::string& getID() const { return _id; } const QString& getID() const { return _id; }
Type getType() const { return _type; } Type getType() const { return _type; }
// hierarchy accessors // hierarchy accessors
@ -105,7 +105,7 @@ protected:
virtual const AnimPoseVec& getPosesInternal() const = 0; virtual const AnimPoseVec& getPosesInternal() const = 0;
Type _type; Type _type;
std::string _id; QString _id;
std::vector<AnimNode::Pointer> _children; std::vector<AnimNode::Pointer> _children;
AnimSkeleton::ConstPointer _skeleton; AnimSkeleton::ConstPointer _skeleton;

56
libraries/animation/src/AnimNodeLoader.cpp
View file

@ -200,19 +200,19 @@ static AnimNode::Pointer loadClipNode(const QJsonObject& jsonObj, const QString&
READ_OPTIONAL_STRING(timeScaleVar, jsonObj); READ_OPTIONAL_STRING(timeScaleVar, jsonObj);
READ_OPTIONAL_STRING(loopFlagVar, jsonObj); READ_OPTIONAL_STRING(loopFlagVar, jsonObj);
auto node = std::make_shared<AnimClip>(id.toStdString(), url.toStdString(), startFrame, endFrame, timeScale, loopFlag); auto node = std::make_shared<AnimClip>(id, url, startFrame, endFrame, timeScale, loopFlag);
if (!startFrameVar.isEmpty()) { if (!startFrameVar.isEmpty()) {
node->setStartFrameVar(startFrameVar.toStdString()); node->setStartFrameVar(startFrameVar);
} }
if (!endFrameVar.isEmpty()) { if (!endFrameVar.isEmpty()) {
node->setEndFrameVar(endFrameVar.toStdString()); node->setEndFrameVar(endFrameVar);
} }
if (!timeScaleVar.isEmpty()) { if (!timeScaleVar.isEmpty()) {
node->setTimeScaleVar(timeScaleVar.toStdString()); node->setTimeScaleVar(timeScaleVar);
} }
if (!loopFlagVar.isEmpty()) { if (!loopFlagVar.isEmpty()) {
node->setLoopFlagVar(loopFlagVar.toStdString()); node->setLoopFlagVar(loopFlagVar);
} }
return node; return node;
@ -224,10 +224,10 @@ static AnimNode::Pointer loadBlendLinearNode(const QJsonObject& jsonObj, const Q
READ_OPTIONAL_STRING(alphaVar, jsonObj); READ_OPTIONAL_STRING(alphaVar, jsonObj);
auto node = std::make_shared<AnimBlendLinear>(id.toStdString(), alpha); auto node = std::make_shared<AnimBlendLinear>(id, alpha);
if (!alphaVar.isEmpty()) { if (!alphaVar.isEmpty()) {
node->setAlphaVar(alphaVar.toStdString()); node->setAlphaVar(alphaVar);
} }
return node; return node;
@ -271,31 +271,31 @@ static AnimNode::Pointer loadOverlayNode(const QJsonObject& jsonObj, const QStri
READ_OPTIONAL_STRING(boneSetVar, jsonObj); READ_OPTIONAL_STRING(boneSetVar, jsonObj);
READ_OPTIONAL_STRING(alphaVar, jsonObj); READ_OPTIONAL_STRING(alphaVar, jsonObj);
auto node = std::make_shared<AnimOverlay>(id.toStdString(), boneSetEnum, alpha); auto node = std::make_shared<AnimOverlay>(id, boneSetEnum, alpha);
if (!boneSetVar.isEmpty()) { if (!boneSetVar.isEmpty()) {
node->setBoneSetVar(boneSetVar.toStdString()); node->setBoneSetVar(boneSetVar);
} }
if (!alphaVar.isEmpty()) { if (!alphaVar.isEmpty()) {
node->setAlphaVar(alphaVar.toStdString()); node->setAlphaVar(alphaVar);
} }
return node; return node;
} }
static AnimNode::Pointer loadStateMachineNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) { static AnimNode::Pointer loadStateMachineNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) {
auto node = std::make_shared<AnimStateMachine>(id.toStdString()); auto node = std::make_shared<AnimStateMachine>(id);
return node; return node;
} }
static AnimNode::Pointer loadManipulatorNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) { static AnimNode::Pointer loadManipulatorNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) {
READ_FLOAT(alpha, jsonObj, id, jsonUrl, nullptr); READ_FLOAT(alpha, jsonObj, id, jsonUrl, nullptr);
auto node = std::make_shared<AnimManipulator>(id.toStdString(), alpha); auto node = std::make_shared<AnimManipulator>(id, alpha);
READ_OPTIONAL_STRING(alphaVar, jsonObj); READ_OPTIONAL_STRING(alphaVar, jsonObj);
if (!alphaVar.isEmpty()) { if (!alphaVar.isEmpty()) {
node->setAlphaVar(alphaVar.toStdString()); node->setAlphaVar(alphaVar);
} }
auto jointsValue = jsonObj.value("joints"); auto jointsValue = jsonObj.value("joints");
@ -315,7 +315,7 @@ static AnimNode::Pointer loadManipulatorNode(const QJsonObject& jsonObj, const Q
READ_STRING(var, jointObj, id, jsonUrl, nullptr); READ_STRING(var, jointObj, id, jsonUrl, nullptr);
READ_STRING(jointName, jointObj, id, jsonUrl, nullptr); READ_STRING(jointName, jointObj, id, jsonUrl, nullptr);
AnimManipulator::JointVar jointVar(var.toStdString(), jointName.toStdString()); AnimManipulator::JointVar jointVar(var, jointName);
node->addJointVar(jointVar); node->addJointVar(jointVar);
}; };
@ -323,7 +323,7 @@ static AnimNode::Pointer loadManipulatorNode(const QJsonObject& jsonObj, const Q
} }
AnimNode::Pointer loadInverseKinematicsNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) { AnimNode::Pointer loadInverseKinematicsNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) {
auto node = std::make_shared<AnimInverseKinematics>(id.toStdString()); auto node = std::make_shared<AnimInverseKinematics>(id);
auto targetsValue = jsonObj.value("targets"); auto targetsValue = jsonObj.value("targets");
if (!targetsValue.isArray()) { if (!targetsValue.isArray()) {
@ -349,9 +349,9 @@ AnimNode::Pointer loadInverseKinematicsNode(const QJsonObject& jsonObj, const QS
return node; return node;
} }
void buildChildMap(std::map<std::string, AnimNode::Pointer>& map, AnimNode::Pointer node) { void buildChildMap(std::map<QString, AnimNode::Pointer>& map, AnimNode::Pointer node) {
for ( auto child : node->_children ) { for ( auto child : node->_children ) {
map.insert(std::pair<std::string, AnimNode::Pointer>(child->_id, child)); map.insert(std::pair<QString, AnimNode::Pointer>(child->_id, child));
} }
} }
@ -368,15 +368,15 @@ bool processStateMachineNode(AnimNode::Pointer node, const QJsonObject& jsonObj,
} }
// build a map for all children by name. // build a map for all children by name.
std::map<std::string, AnimNode::Pointer> childMap; std::map<QString, AnimNode::Pointer> childMap;
buildChildMap(childMap, node); buildChildMap(childMap, node);
// first pass parse all the states and build up the state and transition map. // first pass parse all the states and build up the state and transition map.
using StringPair = std::pair<std::string, std::string>; using StringPair = std::pair<QString, QString>;
using TransitionMap = std::multimap<AnimStateMachine::State::Pointer, StringPair>; using TransitionMap = std::multimap<AnimStateMachine::State::Pointer, StringPair>;
TransitionMap transitionMap; TransitionMap transitionMap;
using StateMap = std::map<std::string, AnimStateMachine::State::Pointer>; using StateMap = std::map<QString, AnimStateMachine::State::Pointer>;
StateMap stateMap; StateMap stateMap;
auto statesArray = statesValue.toArray(); auto statesArray = statesValue.toArray();
@ -394,22 +394,20 @@ bool processStateMachineNode(AnimNode::Pointer node, const QJsonObject& jsonObj,
READ_OPTIONAL_STRING(interpTargetVar, stateObj); READ_OPTIONAL_STRING(interpTargetVar, stateObj);
READ_OPTIONAL_STRING(interpDurationVar, stateObj); READ_OPTIONAL_STRING(interpDurationVar, stateObj);
auto stdId = id.toStdString(); auto iter = childMap.find(id);
auto iter = childMap.find(stdId);
if (iter == childMap.end()) { if (iter == childMap.end()) {
qCCritical(animation) << "AnimNodeLoader, could not find stateMachine child (state) with nodeId =" << nodeId << "stateId =" << id << "url =" << jsonUrl.toDisplayString(); qCCritical(animation) << "AnimNodeLoader, could not find stateMachine child (state) with nodeId =" << nodeId << "stateId =" << id << "url =" << jsonUrl.toDisplayString();
return false; return false;
} }
auto statePtr = std::make_shared<AnimStateMachine::State>(stdId, iter->second, interpTarget, interpDuration); auto statePtr = std::make_shared<AnimStateMachine::State>(id, iter->second, interpTarget, interpDuration);
assert(statePtr); assert(statePtr);
if (!interpTargetVar.isEmpty()) { if (!interpTargetVar.isEmpty()) {
statePtr->setInterpTargetVar(interpTargetVar.toStdString()); statePtr->setInterpTargetVar(interpTargetVar);
} }
if (!interpDurationVar.isEmpty()) { if (!interpDurationVar.isEmpty()) {
statePtr->setInterpDurationVar(interpDurationVar.toStdString()); statePtr->setInterpDurationVar(interpDurationVar);
} }
smNode->addState(statePtr); smNode->addState(statePtr);
@ -432,7 +430,7 @@ bool processStateMachineNode(AnimNode::Pointer node, const QJsonObject& jsonObj,
READ_STRING(var, transitionObj, nodeId, jsonUrl, false); READ_STRING(var, transitionObj, nodeId, jsonUrl, false);
READ_STRING(state, transitionObj, nodeId, jsonUrl, false); READ_STRING(state, transitionObj, nodeId, jsonUrl, false);
transitionMap.insert(TransitionMap::value_type(statePtr, StringPair(var.toStdString(), state.toStdString()))); transitionMap.insert(TransitionMap::value_type(statePtr, StringPair(var, state)));
} }
} }
@ -443,12 +441,12 @@ bool processStateMachineNode(AnimNode::Pointer node, const QJsonObject& jsonObj,
if (iter != stateMap.end()) { if (iter != stateMap.end()) {
srcState->addTransition(AnimStateMachine::State::Transition(transition.second.first, iter->second)); srcState->addTransition(AnimStateMachine::State::Transition(transition.second.first, iter->second));
} else { } else {
qCCritical(animation) << "AnimNodeLoader, bad state machine transtion from srcState =" << srcState->_id.c_str() << "dstState =" << transition.second.second.c_str() << "nodeId =" << nodeId << "url = " << jsonUrl.toDisplayString(); qCCritical(animation) << "AnimNodeLoader, bad state machine transtion from srcState =" << srcState->_id << "dstState =" << transition.second.second << "nodeId =" << nodeId << "url = " << jsonUrl.toDisplayString();
return false; return false;
} }
} }
auto iter = stateMap.find(currentState.toStdString()); auto iter = stateMap.find(currentState);
if (iter == stateMap.end()) { if (iter == stateMap.end()) {
qCCritical(animation) << "AnimNodeLoader, bad currentState =" << currentState << "could not find child node" << "id =" << nodeId << "url = " << jsonUrl.toDisplayString(); qCCritical(animation) << "AnimNodeLoader, bad currentState =" << currentState << "could not find child node" << "id =" << nodeId << "url = " << jsonUrl.toDisplayString();
} }

2
libraries/animation/src/AnimOverlay.cpp
View file

@ -12,7 +12,7 @@
#include "AnimUtil.h" #include "AnimUtil.h"
#include <queue> #include <queue>
AnimOverlay::AnimOverlay(const std::string& id, BoneSet boneSet, float alpha) : AnimOverlay::AnimOverlay(const QString& id, BoneSet boneSet, float alpha) :
AnimNode(AnimNode::Type::Overlay, id), _boneSet(boneSet), _alpha(alpha) { AnimNode(AnimNode::Type::Overlay, id), _boneSet(boneSet), _alpha(alpha) {
} }

10
libraries/animation/src/AnimOverlay.h
View file

@ -40,13 +40,13 @@ public:
NumBoneSets NumBoneSets
}; };
AnimOverlay(const std::string& id, BoneSet boneSet, float alpha); AnimOverlay(const QString& id, BoneSet boneSet, float alpha);
virtual ~AnimOverlay() override; virtual ~AnimOverlay() override;
virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override; virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override;
void setBoneSetVar(const std::string& boneSetVar) { _boneSetVar = boneSetVar; } void setBoneSetVar(const QString& boneSetVar) { _boneSetVar = boneSetVar; }
void setAlphaVar(const std::string& alphaVar) { _alphaVar = alphaVar; } void setAlphaVar(const QString& alphaVar) { _alphaVar = alphaVar; }
protected: protected:
void buildBoneSet(BoneSet boneSet); void buildBoneSet(BoneSet boneSet);
@ -60,8 +60,8 @@ public:
float _alpha; float _alpha;
std::vector<float> _boneSetVec; std::vector<float> _boneSetVec;
std::string _boneSetVar; QString _boneSetVar;
std::string _alphaVar; QString _alphaVar;
void buildFullBodyBoneSet(); void buildFullBodyBoneSet();
void buildUpperBodyBoneSet(); void buildUpperBodyBoneSet();

8
libraries/animation/src/AnimStateMachine.cpp
View file

@ -12,7 +12,7 @@
#include "AnimUtil.h" #include "AnimUtil.h"
#include "AnimationLogging.h" #include "AnimationLogging.h"
AnimStateMachine::AnimStateMachine(const std::string& id) : AnimStateMachine::AnimStateMachine(const QString& id) :
AnimNode(AnimNode::Type::StateMachine, id) { AnimNode(AnimNode::Type::StateMachine, id) {
} }
@ -23,7 +23,7 @@ AnimStateMachine::~AnimStateMachine() {
const AnimPoseVec& AnimStateMachine::evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) { const AnimPoseVec& AnimStateMachine::evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) {
std::string desiredStateID = animVars.lookup(_currentStateVar, _currentState->getID()); QString desiredStateID = animVars.lookup(_currentStateVar, _currentState->getID());
if (_currentState->getID() != desiredStateID) { if (_currentState->getID() != desiredStateID) {
// switch states // switch states
bool foundState = false; bool foundState = false;
@ -35,7 +35,7 @@ const AnimPoseVec& AnimStateMachine::evaluate(const AnimVariantMap& animVars, fl
} }
} }
if (!foundState) { if (!foundState) {
qCCritical(animation) << "AnimStateMachine could not find state =" << desiredStateID.c_str() << ", referenced by _currentStateVar =" << _currentStateVar.c_str(); qCCritical(animation) << "AnimStateMachine could not find state =" << desiredStateID << ", referenced by _currentStateVar =" << _currentStateVar;
} }
} }
@ -77,7 +77,7 @@ void AnimStateMachine::addState(State::Pointer state) {
void AnimStateMachine::switchState(const AnimVariantMap& animVars, State::Pointer desiredState) { void AnimStateMachine::switchState(const AnimVariantMap& animVars, State::Pointer desiredState) {
qCDebug(animation) << "AnimStateMachine::switchState:" << _currentState->getID().c_str() << "->" << desiredState->getID().c_str(); qCDebug(animation) << "AnimStateMachine::switchState:" << _currentState->getID() << "->" << desiredState->getID();
const float FRAMES_PER_SECOND = 30.0f; const float FRAMES_PER_SECOND = 30.0f;

24
libraries/animation/src/AnimStateMachine.h
View file

@ -49,23 +49,23 @@ protected:
class Transition { class Transition {
public: public:
friend AnimStateMachine; friend AnimStateMachine;
Transition(const std::string& var, State::Pointer state) : _var(var), _state(state) {} Transition(const QString& var, State::Pointer state) : _var(var), _state(state) {}
protected: protected:
std::string _var; QString _var;
State::Pointer _state; State::Pointer _state;
}; };
State(const std::string& id, AnimNode::Pointer node, float interpTarget, float interpDuration) : State(const QString& id, AnimNode::Pointer node, float interpTarget, float interpDuration) :
_id(id), _id(id),
_node(node), _node(node),
_interpTarget(interpTarget), _interpTarget(interpTarget),
_interpDuration(interpDuration) {} _interpDuration(interpDuration) {}
void setInterpTargetVar(const std::string& interpTargetVar) { _interpTargetVar = interpTargetVar; } void setInterpTargetVar(const QString& interpTargetVar) { _interpTargetVar = interpTargetVar; }
void setInterpDurationVar(const std::string& interpDurationVar) { _interpDurationVar = interpDurationVar; } void setInterpDurationVar(const QString& interpDurationVar) { _interpDurationVar = interpDurationVar; }
AnimNode::Pointer getNode() const { return _node; } AnimNode::Pointer getNode() const { return _node; }
const std::string& getID() const { return _id; } const QString& getID() const { return _id; }
protected: protected:
@ -74,13 +74,13 @@ protected:
void addTransition(const Transition& transition) { _transitions.push_back(transition); } void addTransition(const Transition& transition) { _transitions.push_back(transition); }
std::string _id; QString _id;
AnimNode::Pointer _node; AnimNode::Pointer _node;
float _interpTarget; // frames float _interpTarget; // frames
float _interpDuration; // frames float _interpDuration; // frames
std::string _interpTargetVar; QString _interpTargetVar;
std::string _interpDurationVar; QString _interpDurationVar;
std::vector<Transition> _transitions; std::vector<Transition> _transitions;
@ -92,12 +92,12 @@ protected:
public: public:
AnimStateMachine(const std::string& id); AnimStateMachine(const QString& id);
virtual ~AnimStateMachine() override; virtual ~AnimStateMachine() override;
virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override; virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override;
void setCurrentStateVar(std::string& currentStateVar) { _currentStateVar = currentStateVar; } void setCurrentStateVar(QString& currentStateVar) { _currentStateVar = currentStateVar; }
protected: protected:
@ -123,7 +123,7 @@ protected:
State::Pointer _currentState; State::Pointer _currentState;
std::vector<State::Pointer> _states; std::vector<State::Pointer> _states;
std::string _currentStateVar; QString _currentStateVar;
private: private:
// no copies // no copies

60
libraries/animation/src/AnimVariant.h
View file

@ -37,7 +37,7 @@ public:
AnimVariant(const glm::vec3& value) : _type(Type::Vec3) { *reinterpret_cast<glm::vec3*>(&_val) = value; } AnimVariant(const glm::vec3& value) : _type(Type::Vec3) { *reinterpret_cast<glm::vec3*>(&_val) = value; }
AnimVariant(const glm::quat& value) : _type(Type::Quat) { *reinterpret_cast<glm::quat*>(&_val) = value; } AnimVariant(const glm::quat& value) : _type(Type::Quat) { *reinterpret_cast<glm::quat*>(&_val) = value; }
AnimVariant(const glm::mat4& value) : _type(Type::Mat4) { *reinterpret_cast<glm::mat4*>(&_val) = value; } AnimVariant(const glm::mat4& value) : _type(Type::Mat4) { *reinterpret_cast<glm::mat4*>(&_val) = value; }
AnimVariant(const std::string& value) : _type(Type::String) { _stringVal = value; } AnimVariant(const QString& value) : _type(Type::String) { _stringVal = value; }
bool isBool() const { return _type == Type::Bool; } bool isBool() const { return _type == Type::Bool; }
bool isInt() const { return _type == Type::Int; } bool isInt() const { return _type == Type::Int; }
@ -53,7 +53,7 @@ public:
void setVec3(const glm::vec3& value) { assert(_type == Type::Vec3); *reinterpret_cast<glm::vec3*>(&_val) = value; } void setVec3(const glm::vec3& value) { assert(_type == Type::Vec3); *reinterpret_cast<glm::vec3*>(&_val) = value; }
void setQuat(const glm::quat& value) { assert(_type == Type::Quat); *reinterpret_cast<glm::quat*>(&_val) = value; } void setQuat(const glm::quat& value) { assert(_type == Type::Quat); *reinterpret_cast<glm::quat*>(&_val) = value; }
void setMat4(const glm::mat4& value) { assert(_type == Type::Mat4); *reinterpret_cast<glm::mat4*>(&_val) = value; } void setMat4(const glm::mat4& value) { assert(_type == Type::Mat4); *reinterpret_cast<glm::mat4*>(&_val) = value; }
void setString(const std::string& value) { assert(_type == Type::String); _stringVal = value; } void setString(const QString& value) { assert(_type == Type::String); _stringVal = value; }
bool getBool() const { assert(_type == Type::Bool); return _val.boolVal; } bool getBool() const { assert(_type == Type::Bool); return _val.boolVal; }
int getInt() const { assert(_type == Type::Int); return _val.intVal; } int getInt() const { assert(_type == Type::Int); return _val.intVal; }
@ -61,11 +61,11 @@ public:
const glm::vec3& getVec3() const { assert(_type == Type::Vec3); return *reinterpret_cast<const glm::vec3*>(&_val); } const glm::vec3& getVec3() const { assert(_type == Type::Vec3); return *reinterpret_cast<const glm::vec3*>(&_val); }
const glm::quat& getQuat() const { assert(_type == Type::Quat); return *reinterpret_cast<const glm::quat*>(&_val); } const glm::quat& getQuat() const { assert(_type == Type::Quat); return *reinterpret_cast<const glm::quat*>(&_val); }
const glm::mat4& getMat4() const { assert(_type == Type::Mat4); return *reinterpret_cast<const glm::mat4*>(&_val); } const glm::mat4& getMat4() const { assert(_type == Type::Mat4); return *reinterpret_cast<const glm::mat4*>(&_val); }
const std::string& getString() const { assert(_type == Type::String); return _stringVal; } const QString& getString() const { assert(_type == Type::String); return _stringVal; }
protected: protected:
Type _type; Type _type;
std::string _stringVal; QString _stringVal;
union { union {
bool boolVal; bool boolVal;
int intVal; int intVal;
@ -76,9 +76,9 @@ protected:
class AnimVariantMap { class AnimVariantMap {
public: public:
bool lookup(const std::string& key, bool defaultValue) const { bool lookup(const QString& key, bool defaultValue) const {
// check triggers first, then map // check triggers first, then map
if (key.empty()) { if (key.isEmpty()) {
return defaultValue; return defaultValue;
} else if (_triggers.find(key) != _triggers.end()) { } else if (_triggers.find(key) != _triggers.end()) {
return true; return true;
@ -88,8 +88,8 @@ public:
} }
} }
int lookup(const std::string& key, int defaultValue) const { int lookup(const QString& key, int defaultValue) const {
if (key.empty()) { if (key.isEmpty()) {
return defaultValue; return defaultValue;
} else { } else {
auto iter = _map.find(key); auto iter = _map.find(key);
@ -97,8 +97,8 @@ public:
} }
} }
float lookup(const std::string& key, float defaultValue) const { float lookup(const QString& key, float defaultValue) const {
if (key.empty()) { if (key.isEmpty()) {
return defaultValue; return defaultValue;
} else { } else {
auto iter = _map.find(key); auto iter = _map.find(key);
@ -106,8 +106,8 @@ public:
} }
} }
const glm::vec3& lookup(const std::string& key, const glm::vec3& defaultValue) const { const glm::vec3& lookup(const QString& key, const glm::vec3& defaultValue) const {
if (key.empty()) { if (key.isEmpty()) {
return defaultValue; return defaultValue;
} else { } else {
auto iter = _map.find(key); auto iter = _map.find(key);
@ -115,8 +115,8 @@ public:
} }
} }
const glm::quat& lookup(const std::string& key, const glm::quat& defaultValue) const { const glm::quat& lookup(const QString& key, const glm::quat& defaultValue) const {
if (key.empty()) { if (key.isEmpty()) {
return defaultValue; return defaultValue;
} else { } else {
auto iter = _map.find(key); auto iter = _map.find(key);
@ -124,8 +124,8 @@ public:
} }
} }
const glm::mat4& lookup(const std::string& key, const glm::mat4& defaultValue) const { const glm::mat4& lookup(const QString& key, const glm::mat4& defaultValue) const {
if (key.empty()) { if (key.isEmpty()) {
return defaultValue; return defaultValue;
} else { } else {
auto iter = _map.find(key); auto iter = _map.find(key);
@ -133,8 +133,8 @@ public:
} }
} }
const std::string& lookup(const std::string& key, const std::string& defaultValue) const { const QString& lookup(const QString& key, const QString& defaultValue) const {
if (key.empty()) { if (key.isEmpty()) {
return defaultValue; return defaultValue;
} else { } else {
auto iter = _map.find(key); auto iter = _map.find(key);
@ -142,23 +142,23 @@ public:
} }
} }
void set(const std::string& key, bool value) { _map[key] = AnimVariant(value); } void set(const QString& key, bool value) { _map[key] = AnimVariant(value); }
void set(const std::string& key, int value) { _map[key] = AnimVariant(value); } void set(const QString& key, int value) { _map[key] = AnimVariant(value); }
void set(const std::string& key, float value) { _map[key] = AnimVariant(value); } void set(const QString& key, float value) { _map[key] = AnimVariant(value); }
void set(const std::string& key, const glm::vec3& value) { _map[key] = AnimVariant(value); } void set(const QString& key, const glm::vec3& value) { _map[key] = AnimVariant(value); }
void set(const std::string& key, const glm::quat& value) { _map[key] = AnimVariant(value); } void set(const QString& key, const glm::quat& value) { _map[key] = AnimVariant(value); }
void set(const std::string& key, const glm::mat4& value) { _map[key] = AnimVariant(value); } void set(const QString& key, const glm::mat4& value) { _map[key] = AnimVariant(value); }
void set(const std::string& key, const std::string& value) { _map[key] = AnimVariant(value); } void set(const QString& key, const QString& value) { _map[key] = AnimVariant(value); }
void unset(const std::string& key) { _map.erase(key); } void unset(const QString& key) { _map.erase(key); }
void setTrigger(const std::string& key) { _triggers.insert(key); } void setTrigger(const QString& key) { _triggers.insert(key); }
void clearTriggers() { _triggers.clear(); } void clearTriggers() { _triggers.clear(); }
bool hasKey(const std::string& key) const { return _map.find(key) != _map.end(); } bool hasKey(const QString& key) const { return _map.find(key) != _map.end(); }
protected: protected:
std::map<std::string, AnimVariant> _map; std::map<QString, AnimVariant> _map;
std::set<std::string> _triggers; std::set<QString> _triggers;
}; };
#endif // hifi_AnimVariant_h #endif // hifi_AnimVariant_h