Added true boneSets to AnimOverlay.

interface/src/avatar/MyAvatar.cpp

@@ -53,6 +53,7 @@
 #include "AnimSkeleton.h"
 #include "AnimClip.h"
 #include "AnimBlendLinear.h"
+#include "AnimOverlay.h"
 
 using namespace std;
 
@@ -152,10 +153,12 @@ void MyAvatar::update(float deltaTime) {
 
     if (_animNode) {
         static float t = 0.0f;
+        /*
         auto blend = std::static_pointer_cast<AnimBlendLinear>(_animNode);
         blend->setAlpha(0.5f * sin(t) + 0.5f);
+        */
         t += deltaTime;
-          _animNode->evaluate(deltaTime);
+        _animNode->evaluate(deltaTime);
     }
 
     if (_referential) {
@@ -1220,13 +1223,13 @@ void MyAvatar::setupNewAnimationSystem() {
     AnimPose xform(_skeletonModel.getScale(), glm::quat(), _skeletonModel.getOffset());
     AnimDebugDraw::getInstance().addSkeleton("my-avatar", skeleton, xform);
 
-    // create a blend node
+    // create a overlay node
-    auto blend = make_shared<AnimBlendLinear>("blend", 0.5f);
+    auto overlay = make_shared<AnimOverlay>("overlay", AnimOverlay::UpperBodyBoneSet);
     auto idle = make_shared<AnimClip>("clip", "https://hifi-public.s3.amazonaws.com/ozan/support/FightClubBotTest1/Animations/standard_idle.fbx", 0.0f, 90.0f, 1.0f, true);
     auto walk = make_shared<AnimClip>("clip", "https://hifi-public.s3.amazonaws.com/ozan/support/FightClubBotTest1/Animations/standard_walk.fbx", 0.0f, 28.0f, 1.0f, true);
-    blend->addChild(idle);
+    overlay->addChild(idle);
-    blend->addChild(walk);
+    overlay->addChild(walk);
-    _animNode = blend;
+    _animNode = overlay;
     _animNode->setSkeleton(skeleton);
     xform.trans.z += 1.0f;
     AnimDebugDraw::getInstance().addAnimNode("blend", _animNode, xform);

libraries/animation/src/AnimNode.h

@@ -61,14 +61,14 @@ public:
     }
     int getChildCount() const { return (int)_children.size(); }
 
-    void setSkeleton(AnimSkeleton::Pointer skeleton) {
+    void setSkeleton(const AnimSkeleton::Pointer skeleton) {
         setSkeletonInternal(skeleton);
         for (auto&& child : _children) {
             child->setSkeletonInternal(skeleton);
         }
     }
 
-    AnimSkeleton::Pointer getSkeleton() const { return _skeleton; }
+    AnimSkeleton::ConstPointer getSkeleton() const { return _skeleton; }
 
     virtual ~AnimNode() {}
 
@@ -79,7 +79,7 @@ public:
 
 protected:
 
-    virtual void setSkeletonInternal(AnimSkeleton::Pointer skeleton) {
+    virtual void setSkeletonInternal(AnimSkeleton::ConstPointer skeleton) {
         _skeleton = skeleton;
     }
 
@@ -89,7 +89,7 @@ protected:
     Type _type;
     std::string _id;
     std::vector<AnimNode::Pointer> _children;
-    AnimSkeleton::Pointer _skeleton;
+    AnimSkeleton::ConstPointer _skeleton;
 
     // no copies
     AnimNode(const AnimNode&) = delete;

libraries/animation/src/AnimNodeLoader.cpp

@@ -176,7 +176,7 @@ static AnimNode::Pointer loadOverlayNode(const QJsonObject& jsonObj, const QStri
     auto boneSetEnum = stringToBoneSetEnum(boneSet);
     if (boneSetEnum == AnimOverlay::NumBoneSets) {
         qCCritical(animation) << "AnimNodeLoader, unknown bone set =" << boneSet << ", defaulting to \"fullBody\", url =" << jsonUrl;
-        boneSetEnum = AnimOverlay::FullBody;
+        boneSetEnum = AnimOverlay::FullBodyBoneSet;
     }
 
     return std::make_shared<AnimBlendLinear>(id.toStdString(), boneSetEnum);

libraries/animation/src/AnimOverlay.cpp

@@ -9,13 +9,32 @@
 
 #include "AnimOverlay.h"
 #include "AnimUtil.h"
+#include <queue>
 
 AnimOverlay::AnimOverlay(const std::string& id, BoneSet boneSet) :
-    AnimNode(AnimNode::OverlayType, id),
+    AnimNode(AnimNode::OverlayType, id), _boneSet(boneSet) {
-    _boneSet(boneSet) {
 }
 
 AnimOverlay::~AnimOverlay() {
+
+}
+
+void AnimOverlay::setBoneSet(BoneSet boneSet) {
+    _boneSet = boneSet;
+    assert(_skeleton);
+    switch (boneSet) {
+    case FullBodyBoneSet: buildFullBodyBoneSet(); break;
+    case UpperBodyBoneSet: buildUpperBodyBoneSet(); break;
+    case LowerBodyBoneSet: buildLowerBodyBoneSet(); break;
+    case RightArmBoneSet: buildRightArmBoneSet(); break;
+    case LeftArmBoneSet: buildLeftArmBoneSet(); break;
+    case AboveTheHeadBoneSet: buildAboveTheHeadBoneSet(); break;
+    case BelowTheHeadBoneSet: buildBelowTheHeadBoneSet(); break;
+    case HeadOnlyBoneSet: buildHeadOnlyBoneSet(); break;
+    case SpineOnlyBoneSet: buildSpineOnlyBoneSet(); break;
+    default:
+    case EmptyBoneSet: buildEmptyBoneSet(); break;
+    }
 }
 
 const std::vector<AnimPose>& AnimOverlay::evaluate(float dt) {
@@ -25,12 +44,128 @@ const std::vector<AnimPose>& AnimOverlay::evaluate(float dt) {
 
         if (underPoses.size() > 0 && underPoses.size() == overPoses.size()) {
             _poses.resize(underPoses.size());
+            assert(_boneSetVec.size() == _poses.size());
 
             for (size_t i = 0; i < _poses.size(); i++) {
-                float alpha = 1.0f;  // TODO: PULL from boneSet
+                float alpha = _boneSetVec[i];  // TODO: PULL from boneSet
                 blend(1, &underPoses[i], &overPoses[i], alpha, &_poses[i]);
             }
         }
     }
     return _poses;
 }
+
+template <typename Func>
+void for_each_child_joint(AnimSkeleton::ConstPointer skeleton, int startJoint, Func f) {
+    std::queue<int> q;
+    q.push(startJoint);
+    while(q.size() > 0) {
+        int jointIndex = q.front();
+        for (int i = 0; i < skeleton->getNumJoints(); i++) {
+            if (jointIndex == skeleton->getParentIndex(i)) {
+                f(i);
+                q.push(i);
+            }
+        }
+        q.pop();
+    }
+}
+
+void AnimOverlay::buildFullBodyBoneSet() {
+    assert(_skeleton);
+    _boneSetVec.resize(_skeleton->getNumJoints());
+    for (int i = 0; i < _skeleton->getNumJoints(); i++) {
+        _boneSetVec[i] = 1.0f;
+    }
+}
+
+void AnimOverlay::buildUpperBodyBoneSet() {
+    assert(_skeleton);
+    buildEmptyBoneSet();
+    int spineJoint = _skeleton->nameToJointIndex("Spine");
+    for_each_child_joint(_skeleton, spineJoint, [&](int i) {
+        _boneSetVec[i] = 1.0f;
+    });
+}
+
+void AnimOverlay::buildLowerBodyBoneSet() {
+    assert(_skeleton);
+    buildFullBodyBoneSet();
+    int hipsJoint = _skeleton->nameToJointIndex("Hips");
+    int spineJoint = _skeleton->nameToJointIndex("Spine");
+    _boneSetVec.resize(_skeleton->getNumJoints());
+    for_each_child_joint(_skeleton, spineJoint, [&](int i) {
+        _boneSetVec[i] = 0.0f;
+    });
+    _boneSetVec[hipsJoint] = 0.0f;
+}
+
+void AnimOverlay::buildRightArmBoneSet() {
+    assert(_skeleton);
+    buildEmptyBoneSet();
+    int rightShoulderJoint = _skeleton->nameToJointIndex("RightShoulder");
+    for_each_child_joint(_skeleton, rightShoulderJoint, [&](int i) {
+        _boneSetVec[i] = 1.0f;
+    });
+}
+
+void AnimOverlay::buildLeftArmBoneSet() {
+    assert(_skeleton);
+    buildEmptyBoneSet();
+    int leftShoulderJoint = _skeleton->nameToJointIndex("LeftShoulder");
+    for_each_child_joint(_skeleton, leftShoulderJoint, [&](int i) {
+        _boneSetVec[i] = 1.0f;
+    });
+}
+
+void AnimOverlay::buildAboveTheHeadBoneSet() {
+    assert(_skeleton);
+    buildEmptyBoneSet();
+    int headJoint = _skeleton->nameToJointIndex("Head");
+    for_each_child_joint(_skeleton, headJoint, [&](int i) {
+        _boneSetVec[i] = 1.0f;
+    });
+}
+
+void AnimOverlay::buildBelowTheHeadBoneSet() {
+    assert(_skeleton);
+    buildFullBodyBoneSet();
+    int headJoint = _skeleton->nameToJointIndex("Head");
+    for_each_child_joint(_skeleton, headJoint, [&](int i) {
+        _boneSetVec[i] = 0.0f;
+    });
+}
+
+void AnimOverlay::buildHeadOnlyBoneSet() {
+    assert(_skeleton);
+    buildEmptyBoneSet();
+    int headJoint = _skeleton->nameToJointIndex("Head");
+    _boneSetVec[headJoint] = 1.0f;
+}
+
+void AnimOverlay::buildSpineOnlyBoneSet() {
+    assert(_skeleton);
+    buildEmptyBoneSet();
+    int spineJoint = _skeleton->nameToJointIndex("Spine");
+    _boneSetVec[spineJoint] = 1.0f;
+}
+
+void AnimOverlay::buildEmptyBoneSet() {
+    assert(_skeleton);
+    _boneSetVec.resize(_skeleton->getNumJoints());
+    for (int i = 0; i < _skeleton->getNumJoints(); i++) {
+        _boneSetVec[i] = 0.0f;
+    }
+}
+
+// for AnimDebugDraw rendering
+const std::vector<AnimPose>& AnimOverlay::getPosesInternal() const {
+    return _poses;
+}
+
+void AnimOverlay::setSkeletonInternal(AnimSkeleton::ConstPointer skeleton) {
+    _skeleton = skeleton;
+
+    // we have to re-build the bone set when the skeleton changes.
+    setBoneSet(_boneSet);
+}

libraries/animation/src/AnimOverlay.h

@@ -22,7 +22,7 @@ class AnimOverlay : public AnimNode {
 public:
 
     enum BoneSet {
-        FullBody = 0,
+        FullBodyBoneSet = 0,
         UpperBodyBoneSet,
         LowerBodyBoneSet,
         RightArmBoneSet,
@@ -38,7 +38,7 @@ public:
     AnimOverlay(const std::string& id, BoneSet boneSet);
     virtual ~AnimOverlay() override;
 
-    void setBoneSet(BoneSet boneSet) { _boneSet = boneSet; }
+    void setBoneSet(BoneSet boneSet);
     BoneSet getBoneSet() const { return _boneSet; }
 
     virtual const std::vector<AnimPose>& evaluate(float dt) override;
@@ -46,9 +46,22 @@ public:
 protected:
     // for AnimDebugDraw rendering
     virtual const std::vector<AnimPose>& getPosesInternal() const override;
+    virtual void setSkeletonInternal(AnimSkeleton::ConstPointer skeleton) override;
 
     std::vector<AnimPose> _poses;
     BoneSet _boneSet;
+    std::vector<float> _boneSetVec;
+
+    void buildFullBodyBoneSet();
+    void buildUpperBodyBoneSet();
+    void buildLowerBodyBoneSet();
+    void buildRightArmBoneSet();
+    void buildLeftArmBoneSet();
+    void buildAboveTheHeadBoneSet();
+    void buildBelowTheHeadBoneSet();
+    void buildHeadOnlyBoneSet();
+    void buildSpineOnlyBoneSet();
+    void buildEmptyBoneSet();
 
     // no copies
     AnimOverlay(const AnimOverlay&) = delete;

libraries/animation/src/AnimSkeleton.h

@@ -38,6 +38,7 @@ inline QDebug operator<<(QDebug debug, const AnimPose& pose) {
 class AnimSkeleton {
 public:
     typedef std::shared_ptr<AnimSkeleton> Pointer;
+    typedef std::shared_ptr<const AnimSkeleton> ConstPointer;
 
     AnimSkeleton(const std::vector<FBXJoint>& joints);
     int nameToJointIndex(const QString& jointName) const;