Merge branch 'master' of https://github.com/highfidelity/hifi into controllers

cmake/externals/sixense/CMakeLists.txt

@@ -4,10 +4,22 @@ set(EXTERNAL_NAME sixense)
 
 string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER)
 
+#set(SIXENSE_URL "https://hifi-public.s3.amazonaws.com/dependencies/SixenseSDK_062612.zip")
+#set(SIXENSE_URL_MD5 "10cc8dc470d2ac1244a88cf04bc549cc")
+#set(SIXENSE_NEW_LAYOUT 0)
+
+#set(SIXENSE_URL "https://public.s3.amazonaws.com/dependencies/SixenseSDK_071615.zip")
+#set(SIXENSE_URL_MD5 "752a3901f334124e9cffc2ba4136ef7d")
+#set(SIXENSE_NEW_LAYOUT 1)
+
+set(SIXENSE_URL "https://hifi-public.s3.amazonaws.com/dependencies/SixenseSDK_102215.zip")
+set(SIXENSE_URL_MD5 "93c3a6795cce777a0f472b09532935f1")
+set(SIXENSE_NEW_LAYOUT 1)
+
 ExternalProject_Add(
   ${EXTERNAL_NAME}
-  URL https://hifi-public.s3.amazonaws.com/dependencies/SixenseSDK_102215.zip
-  URL_MD5 93c3a6795cce777a0f472b09532935f1
+  URL ${SIXENSE_URL}
+  URL_MD5 ${SIXENSE_URL_MD5}
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
@@ -30,8 +42,18 @@ if (WIN32)
         set(ARCH_SUFFIX "")
     endif()
     
-    set(${EXTERNAL_NAME_UPPER}_LIBRARY_RELEASE "${SOURCE_DIR}/lib/${ARCH_DIR}/VS2013/release_dll/sixense${ARCH_SUFFIX}.lib" CACHE TYPE INTERNAL)
-    add_paths_to_fixup_libs("${SOURCE_DIR}/bin/${ARCH_DIR}/VS2013/release_dll")
+    if (${SIXENSE_NEW_LAYOUT})
+        # for 2015 SDKs (using the 2013 versions may be causing the crash)
+        set(${EXTERNAL_NAME_UPPER}_DLL_PATH "${SOURCE_DIR}/bin/${ARCH_DIR}/VS2010/release_dll")
+        set(${EXTERNAL_NAME_UPPER}_LIB_PATH "${SOURCE_DIR}/lib/${ARCH_DIR}/VS2010/release_dll")
+    else()
+        # for the 2012 SDK
+        set(${EXTERNAL_NAME_UPPER}_DLL_PATH "${SOURCE_DIR}/bin/${ARCH_DIR}/release_dll")
+        set(${EXTERNAL_NAME_UPPER}_LIB_PATH "${SOURCE_DIR}/lib/${ARCH_DIR}/release_dll")
+    endif()
+
+    set(${EXTERNAL_NAME_UPPER}_LIBRARY_RELEASE "${${EXTERNAL_NAME_UPPER}_LIB_PATH}/sixense${ARCH_SUFFIX}.lib" CACHE TYPE INTERNAL)
+    add_paths_to_fixup_libs("${${EXTERNAL_NAME_UPPER}_DLL_PATH}")
 
 elseif(APPLE)
 

examples/libraries/fjs.js

@@ -0,0 +1,341 @@
+/*
+
+http://functionaljs.com/
+
+https://github.com/leecrossley/functional-js/
+
+The MIT License (MIT)
+Copyright © 2015 Lee Crossley <leee@hotmail.co.uk>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+ loadFJS = function(){
+    return fjs();
+}
+
+var fjs = function() {
+    "use strict";
+
+    var fjs = {},
+        hardReturn = "hardReturn;";
+
+    var lambda = function(exp) {
+        if (!fjs.isString(exp)) {
+            return;
+        }
+
+        var parts = exp.match(/(.*)\s*[=-]>\s*(.*)/);
+        parts.shift();
+
+        var params = parts.shift()
+            .replace(/^\s*|\s(?=\s)|\s*$|,/g, "").split(" ");
+        var body = parts.shift();
+
+        parts = ((!/\s*return\s+/.test(body)) ? "return " : "") + body;
+        params.push(parts);
+
+        return Function.apply({}, params);
+    };
+
+    var sliceArgs = function(args) {
+        return args.length > 0 ? [].slice.call(args, 0) : [];
+    };
+
+    fjs.isFunction = function(obj) {
+        return !!(obj && obj.constructor && obj.call && obj.apply);
+    };
+
+    fjs.isObject = function(obj) {
+        return fjs.isFunction(obj) || (!!obj && typeof(obj) === "object");
+    };
+
+    fjs.isArray = function(obj) {
+        return Object.prototype.toString.call(obj) === "[object Array]";
+    };
+
+    var checkFunction = function(func) {
+        if (!fjs.isFunction(func)) {
+            func = lambda(func);
+            if (!fjs.isFunction(func)) {
+                throw "fjs Error: Invalid function";
+            }
+        }
+        return func;
+    };
+
+    fjs.curry = function(func) {
+        func = checkFunction(func);
+        return function inner() {
+            var _args = sliceArgs(arguments);
+            if (_args.length === func.length) {
+                return func.apply(null, _args);
+            } else if (_args.length > func.length) {
+                var initial = func.apply(null, _args);
+                return fjs.fold(func, initial, _args.slice(func.length));
+            } else {
+                return function() {
+                    var args = sliceArgs(arguments);
+                    return inner.apply(null, _args.concat(args));
+                };
+            }
+        };
+    };
+
+    fjs.each = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        if (!fjs.exists(items) || !fjs.isArray(items)) {
+            return;
+        }
+        for (var i = 0; i < items.length; i += 1) {
+            if (iterator.call(null, items[i], i) === hardReturn) {
+                return;
+            }
+        }
+    });
+
+    fjs.map = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var mapped = [];
+        fjs.each(function() {
+            mapped.push(iterator.apply(null, arguments));
+        }, items);
+        return mapped;
+    });
+
+    fjs.fold = fjs.foldl = fjs.curry(function(iterator, cumulate, items) {
+        iterator = checkFunction(iterator);
+        fjs.each(function(item, i) {
+            cumulate = iterator.call(null, cumulate, item, i);
+        }, items);
+        return cumulate;
+    });
+
+    fjs.reduce = fjs.reducel = fjs.foldll = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var cumulate = items[0];
+        items.shift();
+        return fjs.fold(iterator, cumulate, items);
+    });
+
+    fjs.clone = function(items) {
+        var clone = [];
+        fjs.each(function(item) {
+            clone.push(item);
+        }, items);
+        return clone;
+    };
+
+    fjs.first = fjs.head = fjs.take = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var first;
+        fjs.each(function(item) {
+            if (iterator.call(null, item)) {
+                first = item;
+                return hardReturn;
+            }
+        }, items);
+        return first;
+    });
+
+    fjs.rest = fjs.tail = fjs.drop = fjs.curry(function(iterator, items) {
+        var result = fjs.select(iterator, items);
+        result.shift();
+        return result;
+    });
+
+    fjs.last = fjs.curry(function(iterator, items) {
+        var itemsClone = fjs.clone(items);
+        return fjs.first(iterator, itemsClone.reverse());
+    });
+
+    fjs.every = fjs.all = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var isEvery = true;
+        fjs.each(function(item) {
+            if (!iterator.call(null, item)) {
+                isEvery = false;
+                return hardReturn;
+            }
+        }, items);
+        return isEvery;
+    });
+
+    fjs.any = fjs.contains = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var isAny = false;
+        fjs.each(function(item) {
+            if (iterator.call(null, item)) {
+                isAny = true;
+                return hardReturn;
+            }
+        }, items);
+        return isAny;
+    });
+
+    fjs.select = fjs.filter = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var filtered = [];
+        fjs.each(function(item) {
+            if (iterator.call(null, item)) {
+                filtered.push(item);
+            }
+        }, items);
+        return filtered;
+    });
+
+    fjs.best = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var compare = function(arg1, arg2) {
+            return iterator.call(this, arg1, arg2) ?
+                arg1 : arg2;
+        };
+        return fjs.reduce(compare, items);
+    });
+
+    fjs._while = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var result = [];
+        fjs.each(function(item) {
+            if (iterator.call(null, item)) {
+                result.push(item);
+            } else {
+                return hardReturn;
+            }
+        }, items);
+        return result;
+    });
+
+    fjs.compose = function(funcs) {
+        var anyInvalid = fjs.any(function(func) {
+            return !fjs.isFunction(func);
+        });
+        funcs = sliceArgs(arguments).reverse();
+        if (anyInvalid(funcs)) {
+            throw "fjs Error: Invalid function to compose";
+        }
+        return function() {
+            var args = arguments;
+            var applyEach = fjs.each(function(func) {
+                args = [func.apply(null, args)];
+            });
+            applyEach(funcs);
+            return args[0];
+        };
+    };
+
+    fjs.partition = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var truthy = [],
+            falsy = [];
+        fjs.each(function(item) {
+            (iterator.call(null, item) ? truthy : falsy).push(item);
+        }, items);
+        return [truthy, falsy];
+    });
+
+    fjs.group = fjs.curry(function(iterator, items) {
+        iterator = checkFunction(iterator);
+        var result = {};
+        var group;
+        fjs.each(function(item) {
+            group = iterator.call(null, item);
+            result[group] = result[group] || [];
+            result[group].push(item);
+        }, items);
+        return result;
+    });
+
+    fjs.shuffle = function(items) {
+        var j, t;
+        fjs.each(function(item, i) {
+            j = Math.floor(Math.random() * (i + 1));
+            t = items[i];
+            items[i] = items[j];
+            items[j] = t;
+        }, items);
+        return items;
+    };
+
+    fjs.toArray = function(obj) {
+        return fjs.map(function(key) {
+            return [key, obj[key]];
+        }, Object.keys(obj));
+    };
+
+    fjs.apply = fjs.curry(function(func, items) {
+        var args = [];
+        if (fjs.isArray(func)) {
+            args = [].slice.call(func, 1);
+            func = func[0];
+        }
+        return fjs.map(function(item) {
+            return item[func].apply(item, args);
+        }, items);
+    });
+
+    fjs.assign = fjs.extend = fjs.curry(function(obj1, obj2) {
+        fjs.each(function(key) {
+            obj2[key] = obj1[key];
+        }, Object.keys(obj1));
+        return obj2;
+    });
+
+    fjs.prop = function(prop) {
+        return function(obj) {
+            return obj[prop];
+        };
+    };
+
+    fjs.pluck = fjs.curry(function(prop, items) {
+        return fjs.map(fjs.prop(prop), items);
+    });
+
+    fjs.nub = fjs.unique = fjs.distinct = fjs.curry(function(comparator, items) {
+        var unique = items.length > 0 ? [items[0]] : [];
+
+        fjs.each(function(item) {
+            if (!fjs.any(fjs.curry(comparator)(item), unique)) {
+                unique[unique.length] = item;
+            }
+        }, items);
+
+        return unique;
+    });
+
+    fjs.exists = function(obj) {
+        return obj != null; // jshint ignore:line
+    };
+
+    fjs.truthy = function(obj) {
+        return fjs.exists(obj) && obj !== false;
+    };
+
+    fjs.falsy = function(obj) {
+        return !fjs.truthy(obj);
+    };
+
+    fjs.each(function(type) {
+        fjs["is" + type] = function(obj) {
+            return Object.prototype.toString.call(obj) === "[object " + type + "]";
+        };
+    }, ["Arguments", "Date", "Number", "RegExp", "String"]);
+
+    return fjs;
+}

examples/libraries/fjsExample.js

@@ -0,0 +1,9 @@
+Script.include('fjs.js');
+var fjs = loadFJS();
+
+var concatenate = fjs.curry(function(word1, word2) {
+    return word1 + " " + word2;
+});
+var concatenateHello = concatenate("Hello");
+var hi = concatenateHello("World");
+print('anyone listening? ' + hi)

interface/resources/meshes/defaultAvatar_full/avatar-animation.json

@@ -523,29 +523,89 @@
                                             },
                                             {
                                                 "id": "walkFwd",
-                                                "type": "clip",
+                                                "type": "blendLinearMove",
                                                 "data": {
-                                                    "url": "https://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/walk_fwd.fbx",
-                                                    "startFrame": 0.0,
-                                                    "endFrame": 35.0,
-                                                    "timeScale": 1.0,
-                                                    "loopFlag": true,
-                                                    "timeScaleVar": "walkTimeScale"
+                                                    "alpha": 0.0,
+                                                    "desiredSpeed": 1.4,
+                                                    "characteristicSpeeds": [0.5, 1.4, 4.5],
+                                                    "alphaVar": "moveForwardAlpha",
+                                                    "desiredSpeedVar": "moveForwardSpeed"
                                                 },
-                                                "children": []
+                                                "children": [
+                                                    {
+                                                        "id": "walkFwdShort",
+                                                        "type": "clip",
+                                                        "data": {
+                                                            "url": "https://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/walk_short_fwd.fbx",
+                                                            "startFrame": 0.0,
+                                                            "endFrame": 39.0,
+                                                            "timeScale": 1.0,
+                                                            "loopFlag": true
+                                                        },
+                                                        "children": []
+                                                    },
+                                                    {
+                                                        "id": "walkFwdNormal",
+                                                        "type": "clip",
+                                                        "data": {
+                                                            "url": "https://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/walk_fwd.fbx",
+                                                            "startFrame": 0.0,
+                                                            "endFrame": 35.0,
+                                                            "timeScale": 1.0,
+                                                            "loopFlag": true
+                                                        },
+                                                        "children": []
+                                                    },
+                                                    {
+                                                        "id": "walkFwdRun",
+                                                        "type": "clip",
+                                                        "data": {
+                                                            "url": "https://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/run_fwd.fbx",
+                                                            "startFrame": 0.0,
+                                                            "endFrame": 21.0,
+                                                            "timeScale": 1.0,
+                                                            "loopFlag": true
+                                                        },
+                                                        "children": []
+                                                    }
+                                                ]
                                             },
                                             {
                                                 "id": "walkBwd",
-                                                "type": "clip",
+                                                "type": "blendLinearMove",
                                                 "data": {
-                                                    "url": "https://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/walk_bwd.fbx",
-                                                    "startFrame": 0.0,
-                                                    "endFrame": 37.0,
-                                                    "timeScale": 1.0,
-                                                    "loopFlag": true,
-                                                    "timeScaleVar": "walkTimeScale"
+                                                    "alpha": 0.0,
+                                                    "desiredSpeed": 1.4,
+                                                    "characteristicSpeeds": [0.6, 1.45],
+                                                    "alphaVar": "moveBackwardAlpha",
+                                                    "desiredSpeedVar": "moveBackwardSpeed"
                                                 },
-                                                "children": []
+                                                "children": [
+                                                    {
+                                                        "id": "walkBwdShort",
+                                                        "type": "clip",
+                                                        "data": {
+                                                            "url": "https://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/walk_short_bwd.fbx",
+                                                            "startFrame": 0.0,
+                                                            "endFrame": 38.0,
+                                                            "timeScale": 1.0,
+                                                            "loopFlag": true
+                                                        },
+                                                        "children": []
+                                                    },
+                                                    {
+                                                        "id": "walkBwdNormal",
+                                                        "type": "clip",
+                                                        "data": {
+                                                            "url": "https://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/walk_bwd.fbx",
+                                                            "startFrame": 0.0,
+                                                            "endFrame": 36.0,
+                                                            "timeScale": 1.0,
+                                                            "loopFlag": true
+                                                        },
+                                                        "children": []
+                                                    }
+                                                ]
                                             },
                                             {
                                                 "id": "turnLeft",
@@ -573,27 +633,77 @@
                                             },
                                             {
                                                 "id": "strafeLeft",
-                                                "type": "clip",
+                                                "type": "blendLinearMove",
                                                 "data": {
-                                                    "url": "http://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/side_step_left.fbx",
-                                                    "startFrame": 0.0,
-                                                    "endFrame": 31.0,
-                                                    "timeScale": 1.0,
-                                                    "loopFlag": true
+                                                    "alpha": 0.0,
+                                                    "desiredSpeed": 1.4,
+                                                    "characteristicSpeeds": [0.2, 0.65],
+                                                    "alphaVar": "moveLateralAlpha",
+                                                    "desiredSpeedVar": "moveLateralSpeed"
                                                 },
-                                                "children": []
+                                                "children": [
+                                                    {
+                                                        "id": "strafeLeftShort",
+                                                        "type": "clip",
+                                                        "data": {
+                                                            "url": "https://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/side_step_short_left.fbx",
+                                                            "startFrame": 0.0,
+                                                            "endFrame": 28.0,
+                                                            "timeScale": 1.0,
+                                                            "loopFlag": true
+                                                        },
+                                                        "children": []
+                                                    },
+                                                    {
+                                                        "id": "strafeLeftNormal",
+                                                        "type": "clip",
+                                                        "data": {
+                                                            "url": "http://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/side_step_left.fbx",
+                                                            "startFrame": 0.0,
+                                                            "endFrame": 30.0,
+                                                            "timeScale": 1.0,
+                                                            "loopFlag": true
+                                                        },
+                                                        "children": []
+                                                    }
+                                                ]
                                             },
                                             {
                                                 "id": "strafeRight",
-                                                "type": "clip",
+                                                "type": "blendLinearMove",
                                                 "data": {
-                                                    "url": "http://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/side_step_right.fbx",
-                                                    "startFrame": 0.0,
-                                                    "endFrame": 31.0,
-                                                    "timeScale": 1.0,
-                                                    "loopFlag": true
+                                                    "alpha": 0.0,
+                                                    "desiredSpeed": 1.4,
+                                                    "characteristicSpeeds": [0.2, 0.65],
+                                                    "alphaVar": "moveLateralAlpha",
+                                                    "desiredSpeedVar": "moveLateralSpeed"
                                                 },
-                                                "children": []
+                                                "children": [
+                                                    {
+                                                        "id": "strafeRightShort",
+                                                        "type": "clip",
+                                                        "data": {
+                                                            "url": "http://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/side_step_short_right.fbx",
+                                                            "startFrame": 0.0,
+                                                            "endFrame": 28.0,
+                                                            "timeScale": 1.0,
+                                                            "loopFlag": true
+                                                        },
+                                                        "children": []
+                                                    },
+                                                    {
+                                                        "id": "strafeRightNormal",
+                                                        "type": "clip",
+                                                        "data": {
+                                                            "url": "http://hifi-public.s3.amazonaws.com/ozan/anim/standard_anims/side_step_right.fbx",
+                                                            "startFrame": 0.0,
+                                                            "endFrame": 30.0,
+                                                            "timeScale": 1.0,
+                                                            "loopFlag": true
+                                                        },
+                                                        "children": []
+                                                    }
+                                                ]
                                             }
                                         ]
                                     }

interface/src/avatar/MyAvatar.cpp

@@ -157,6 +157,8 @@ void MyAvatar::reset(bool andReload) {
     // Reset dynamic state.
     _wasPushing = _isPushing = _isBraking = _billboardValid = false;
     _isFollowingHMD = false;
+    _hmdFollowVelocity = Vectors::ZERO;
+    _hmdFollowSpeed = 0.0f;
     _skeletonModel.reset();
     getHead()->reset();
     _targetVelocity = glm::vec3(0.0f);
@@ -248,7 +250,7 @@ void MyAvatar::simulate(float deltaTime) {
     {
         PerformanceTimer perfTimer("transform");
         bool stepAction = false;
-        // When there are no step values, we zero out the last step pulse. 
+        // When there are no step values, we zero out the last step pulse.
         // This allows a user to do faster snapping by tapping a control
         for (int i = STEP_TRANSLATE_X; !stepAction && i <= STEP_YAW; ++i) {
             if (_driveKeys[i] != 0.0f) {
@@ -332,25 +334,6 @@ glm::mat4 MyAvatar::getSensorToWorldMatrix() const {
     return _sensorToWorldMatrix;
 }
 
-// returns true if pos is OUTSIDE of the vertical capsule
-// where the middle cylinder length is defined by capsuleLen and the radius by capsuleRad.
-static bool pointIsOutsideCapsule(const glm::vec3& pos, float capsuleLen, float capsuleRad) {
-    const float halfCapsuleLen = capsuleLen / 2.0f;
-    if (fabs(pos.y) <= halfCapsuleLen) {
-        // cylinder check for middle capsule
-        glm::vec2 horizPos(pos.x, pos.z);
-        return glm::length(horizPos) > capsuleRad;
-    } else if (pos.y > halfCapsuleLen) {
-        glm::vec3 center(0.0f, halfCapsuleLen, 0.0f);
-        return glm::length(center - pos) > capsuleRad;
-    } else if (pos.y < halfCapsuleLen) {
-        glm::vec3 center(0.0f, -halfCapsuleLen, 0.0f);
-        return glm::length(center - pos) > capsuleRad;
-    } else {
-        return false;
-    }
-}
-
 // Pass a recent sample of the HMD to the avatar.
 // This can also update the avatar's position to follow the HMD
 // as it moves through the world.
@@ -359,102 +342,59 @@ void MyAvatar::updateFromHMDSensorMatrix(const glm::mat4& hmdSensorMatrix) {
     _hmdSensorMatrix = hmdSensorMatrix;
     _hmdSensorPosition = extractTranslation(hmdSensorMatrix);
     _hmdSensorOrientation = glm::quat_cast(hmdSensorMatrix);
+}
 
-    // calc deltaTime
-    auto now = usecTimestampNow();
-    auto deltaUsecs = now - _lastUpdateFromHMDTime;
-    _lastUpdateFromHMDTime = now;
-    double actualDeltaTime = (double)deltaUsecs / (double)USECS_PER_SECOND;
-    const float BIGGEST_DELTA_TIME_SECS = 0.25f;
-    float deltaTime = glm::clamp((float)actualDeltaTime, 0.0f, BIGGEST_DELTA_TIME_SECS);
-
-    bool hmdIsAtRest = _hmdAtRestDetector.update(deltaTime, _hmdSensorPosition, _hmdSensorOrientation);
-
-    // It can be more accurate/smooth to use velocity rather than position,
-    // but some modes (e.g., hmd standing) update position without updating velocity.
-    // So, let's create our own workingVelocity from the worldPosition...
-    glm::vec3 positionDelta = getPosition() - _lastPosition;
-    glm::vec3 workingVelocity = positionDelta / deltaTime;
-    _lastPosition = getPosition();
-
-    const float MOVE_ENTER_SPEED_THRESHOLD = 0.2f; // m/sec
-    const float MOVE_EXIT_SPEED_THRESHOLD = 0.07f;  // m/sec
+void MyAvatar::updateHMDFollowVelocity() {
     bool isMoving;
     if (_lastIsMoving) {
-        isMoving = glm::length(workingVelocity) >= MOVE_EXIT_SPEED_THRESHOLD;
+        const float MOVE_EXIT_SPEED_THRESHOLD = 0.07f;  // m/sec
+        isMoving = glm::length(_velocity) >= MOVE_EXIT_SPEED_THRESHOLD;
     } else {
-        isMoving = glm::length(workingVelocity) > MOVE_ENTER_SPEED_THRESHOLD;
+        const float MOVE_ENTER_SPEED_THRESHOLD = 0.2f; // m/sec
+        isMoving = glm::length(_velocity) > MOVE_ENTER_SPEED_THRESHOLD;
     }
 
     bool justStartedMoving = (_lastIsMoving != isMoving) && isMoving;
     _lastIsMoving = isMoving;
 
-    if (shouldFollowHMD() || hmdIsAtRest || justStartedMoving) {
-        beginFollowingHMD();
-    }
-
-    followHMD(deltaTime);
-}
-
-glm::vec3 MyAvatar::getHMDCorrectionVelocity() const {
-    // TODO: impelement this
-    return Vectors::ZERO;
-}
-
-void MyAvatar::beginFollowingHMD() {
-    // begin homing toward derived body position.
-    if (!_isFollowingHMD) {
+    bool hmdIsAtRest = _hmdAtRestDetector.update(_hmdSensorPosition, _hmdSensorOrientation);
+    if (hmdIsAtRest || justStartedMoving) {
         _isFollowingHMD = true;
-        _followHMDAlpha = 0.0f;
     }
-}
 
-bool MyAvatar::shouldFollowHMD() const {
-    if (!_isFollowingHMD) {
-        // define a vertical capsule
-        const float FOLLOW_HMD_CAPSULE_RADIUS = 0.2f;  // meters
-        const float FOLLOW_HMD_CAPSULE_LENGTH = 0.05f;  // length of the cylinder part of the capsule in meters.
-    
-        // detect if the derived body position is outside of a capsule around the _bodySensorMatrix
-        auto newBodySensorMatrix = deriveBodyFromHMDSensor();
-        glm::vec3 localPoint = extractTranslation(newBodySensorMatrix) - extractTranslation(_bodySensorMatrix);
-        return pointIsOutsideCapsule(localPoint, FOLLOW_HMD_CAPSULE_LENGTH, FOLLOW_HMD_CAPSULE_RADIUS);
+    // compute offset to body's target position (in sensor-frame)
+    auto sensorBodyMatrix = deriveBodyFromHMDSensor();
+    _hmdFollowOffset = extractTranslation(sensorBodyMatrix) - extractTranslation(_bodySensorMatrix);
+    glm::vec3 truncatedOffset = _hmdFollowOffset;
+    if (truncatedOffset.y < 0.0f) {
+        // don't pull the body DOWN to match the target (allow animation system to squat)
+        truncatedOffset.y = 0.0f;
     }
-    return false;
-}
 
-void MyAvatar::followHMD(float deltaTime) {
-    if (_isFollowingHMD) {
-
-        const float FOLLOW_HMD_DURATION = 0.5f;  // seconds
-
-        auto newBodySensorMatrix = deriveBodyFromHMDSensor();
-        auto worldBodyMatrix = _sensorToWorldMatrix * newBodySensorMatrix;
-        glm::vec3 worldBodyPos = extractTranslation(worldBodyMatrix);
-        glm::quat worldBodyRot = glm::normalize(glm::quat_cast(worldBodyMatrix));
-
-        _followHMDAlpha += (1.0f / FOLLOW_HMD_DURATION) * deltaTime;
-
-        if (_followHMDAlpha >= 1.0f) {
-            _isFollowingHMD = false;
-            nextAttitude(worldBodyPos, worldBodyRot);
-            _bodySensorMatrix = newBodySensorMatrix;
-        } else {
-            // interp position toward the desired pos
-            glm::vec3 pos = lerp(getPosition(), worldBodyPos, _followHMDAlpha);
-            glm::quat rot = glm::normalize(safeMix(getOrientation(), worldBodyRot, _followHMDAlpha));
-            nextAttitude(pos, rot);
-
-            // interp sensor matrix toward desired
-            glm::vec3 nextBodyPos = extractTranslation(newBodySensorMatrix);
-            glm::quat nextBodyRot = glm::normalize(glm::quat_cast(newBodySensorMatrix));
-            glm::vec3 prevBodyPos = extractTranslation(_bodySensorMatrix);
-            glm::quat prevBodyRot = glm::normalize(glm::quat_cast(_bodySensorMatrix));
-            pos = lerp(prevBodyPos, nextBodyPos, _followHMDAlpha);
-            rot = glm::normalize(safeMix(prevBodyRot, nextBodyRot, _followHMDAlpha));
-            _bodySensorMatrix = createMatFromQuatAndPos(rot, pos);
+    bool needNewFollowSpeed = (_isFollowingHMD && _hmdFollowSpeed == 0.0f);
+    if (!needNewFollowSpeed) {
+        // check to see if offset has exceeded its threshold
+        float distance = glm::length(truncatedOffset);
+        const float MAX_HMD_HIP_SHIFT = 0.2f;
+        if (distance > MAX_HMD_HIP_SHIFT) {
+            _isFollowingHMD = true;
+            needNewFollowSpeed = true;
         }
     }
+    if (_isFollowingHMD) {
+        // only bother to rotate into world frame if we're following
+        glm::quat sensorToWorldRotation = extractRotation(_sensorToWorldMatrix);
+        _hmdFollowOffset = sensorToWorldRotation * _hmdFollowOffset;
+    }
+    if (needNewFollowSpeed) {
+        // compute new velocity that will be used to resolve offset of hips from body
+        const float FOLLOW_HMD_DURATION = 0.5f;  // seconds
+        _hmdFollowVelocity = (_hmdFollowOffset / FOLLOW_HMD_DURATION);
+        _hmdFollowSpeed = glm::length(_hmdFollowVelocity);
+    } else if (_isFollowingHMD) {
+        // compute new velocity (but not new speed)
+        _hmdFollowVelocity = _hmdFollowSpeed * glm::normalize(_hmdFollowOffset);
+    }
 }
 
 // best called at end of main loop, just before rendering.
@@ -1356,17 +1296,68 @@ void MyAvatar::prepareForPhysicsSimulation() {
     relayDriveKeysToCharacterController();
     _characterController.setTargetVelocity(getTargetVelocity());
     _characterController.setAvatarPositionAndOrientation(getPosition(), getOrientation());
-    _characterController.setHMDVelocity(getHMDCorrectionVelocity());
-}   
+    if (qApp->isHMDMode()) {
+        updateHMDFollowVelocity();
+        _characterController.setHMDVelocity(_hmdFollowVelocity);
+    } else {
+        _characterController.setHMDVelocity(Vectors::ZERO);
+        _isFollowingHMD = false;
+    }
+}
 
 void MyAvatar::harvestResultsFromPhysicsSimulation() {
     glm::vec3 position = getPosition();
     glm::quat orientation = getOrientation();
     _characterController.getAvatarPositionAndOrientation(position, orientation);
     nextAttitude(position, orientation);
-    setVelocity(_characterController.getLinearVelocity());
-    // TODO: harvest HMD shift here
-    //glm::vec3 hmdShift = _characterController.getHMDShift();
+    if (_isFollowingHMD) {
+        setVelocity(_characterController.getLinearVelocity() + _hmdFollowVelocity);
+        glm::vec3 hmdShift = _characterController.getHMDShift();
+        adjustSensorTransform(hmdShift);
+    } else {
+        setVelocity(_characterController.getLinearVelocity());
+    }
+}
+
+void MyAvatar::adjustSensorTransform(glm::vec3 hmdShift) {
+    // compute blendFactor of latest hmdShift
+    // which we'll use to blend the rotation part
+    float blendFactor = 1.0f;
+    float shiftLength = glm::length(hmdShift);
+    if (shiftLength > 1.0e-5f) {
+        float offsetLength = glm::length(_hmdFollowOffset);
+        if (offsetLength > shiftLength) {
+            blendFactor = shiftLength / offsetLength;
+        }
+    }
+
+    auto newBodySensorMatrix = deriveBodyFromHMDSensor();
+    auto worldBodyMatrix = _sensorToWorldMatrix * newBodySensorMatrix;
+    glm::quat finalBodyRotation = glm::normalize(glm::quat_cast(worldBodyMatrix));
+    if (blendFactor >= 0.99f) {
+        // the "adjustment" is more or less complete so stop following
+        _isFollowingHMD = false;
+        _hmdFollowSpeed = 0.0f;
+        // and slam the body's transform anyway to eliminate any slight errors
+        glm::vec3 finalBodyPosition = extractTranslation(worldBodyMatrix);
+        nextAttitude(finalBodyPosition, finalBodyRotation);
+        _bodySensorMatrix = newBodySensorMatrix;
+    } else {
+        // physics already did the positional blending for us
+        glm::vec3 newBodyPosition = getPosition();
+        // but the rotational part must be done manually
+        glm::quat newBodyRotation = glm::normalize(safeMix(getOrientation(), finalBodyRotation, blendFactor));
+        nextAttitude(newBodyPosition, newBodyRotation);
+
+        // interp sensor matrix toward the desired
+        glm::vec3 prevPosition = extractTranslation(_bodySensorMatrix);
+        glm::quat prevRotation = glm::normalize(glm::quat_cast(_bodySensorMatrix));
+        glm::vec3 nextPosition = extractTranslation(newBodySensorMatrix);
+        glm::quat nextRotation = glm::normalize(glm::quat_cast(newBodySensorMatrix));
+        _bodySensorMatrix = createMatFromQuatAndPos(
+                glm::normalize(safeMix(prevRotation, nextRotation, blendFactor)),
+                lerp(prevPosition, nextPosition, blendFactor));
+    }
 }
 
 QString MyAvatar::getScriptedMotorFrame() const {
@@ -1468,7 +1459,7 @@ void MyAvatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, fl
         getHead()->renderLookAts(renderArgs);
     }
 
-    if (renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE && 
+    if (renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE &&
             Menu::getInstance()->isOptionChecked(MenuOption::DisplayHandTargets)) {
         getHand()->renderHandTargets(renderArgs, true);
     }
@@ -1947,7 +1938,7 @@ void MyAvatar::updateMotionBehaviorFromMenu() {
         QMetaObject::invokeMethod(this, "updateMotionBehaviorFromMenu");
         return;
     }
-    
+
     Menu* menu = Menu::getInstance();
     if (menu->isOptionChecked(MenuOption::KeyboardMotorControl)) {
         _motionBehaviors |= AVATAR_MOTION_KEYBOARD_MOTOR_ENABLED;

interface/src/avatar/MyAvatar.h

@@ -101,8 +101,6 @@ public:
     // as it moves through the world.
     void updateFromHMDSensorMatrix(const glm::mat4& hmdSensorMatrix);
 
-    glm::vec3 getHMDCorrectionVelocity() const;
-
     // best called at end of main loop, just before rendering.
     // update sensor to world matrix from current body position and hmd sensor.
     // This is so the correct camera can be used for rendering.
@@ -211,6 +209,7 @@ public:
 
     void prepareForPhysicsSimulation();
     void harvestResultsFromPhysicsSimulation();
+    void adjustSensorTransform(glm::vec3 hmdShift);
 
     const QString& getCollisionSoundURL() { return _collisionSoundURL; }
     void setCollisionSoundURL(const QString& url);
@@ -316,9 +315,10 @@ private:
     const RecorderPointer getRecorder() const { return _recorder; }
     const PlayerPointer getPlayer() const { return _player; }
 
-    void beginFollowingHMD();
-    bool shouldFollowHMD() const;
-    void followHMD(float deltaTime);
+    //void beginFollowingHMD();
+    //bool shouldFollowHMD() const;
+    //void followHMD(float deltaTime);
+    void updateHMDFollowVelocity();
 
     bool cameraInsideHead() const;
 
@@ -395,6 +395,9 @@ private:
 
     // used to transform any sensor into world space, including the _hmdSensorMat, or hand controllers.
     glm::mat4 _sensorToWorldMatrix;
+    glm::vec3 _hmdFollowOffset { Vectors::ZERO };
+    glm::vec3 _hmdFollowVelocity { Vectors::ZERO };
+    float _hmdFollowSpeed { 0.0f };
 
     bool _goToPending;
     glm::vec3 _goToPosition;
@@ -415,9 +418,7 @@ private:
     bool _isFollowingHMD { false };
     float _followHMDAlpha { 0.0f };
 
-    quint64 _lastUpdateFromHMDTime { usecTimestampNow() };
     AtRestDetector _hmdAtRestDetector;
-    glm::vec3 _lastPosition;
     bool _lastIsMoving { false };
     quint64 _lastStepPulse { 0 };
     bool _pulseUpdate { false };

interface/src/devices/EyeTracker.cpp

@@ -118,18 +118,6 @@ void EyeTracker::init() {
         qCWarning(interfaceapp) << "Eye Tracker: Already initialized";
         return;
     }
-
-#ifdef HAVE_IVIEWHMD
-    int result = smi_setCallback(eyeTrackerCallback);
-    if (result != SMI_RET_SUCCESS) {
-        qCWarning(interfaceapp) << "Eye Tracker: Error setting callback:" << smiReturnValueToString(result);
-        QMessageBox::warning(nullptr, "Eye Tracker Error", smiReturnValueToString(result));
-    } else {
-        _isInitialized = true;
-    }
-
-    connect(&_startStreamingWatcher, SIGNAL(finished()), this, SLOT(onStreamStarted()));
-#endif
 }
 
 #ifdef HAVE_IVIEWHMD
@@ -140,6 +128,10 @@ int EyeTracker::startStreaming(bool simulate) {
 
 #ifdef HAVE_IVIEWHMD
 void EyeTracker::onStreamStarted() {
+    if (!_isInitialized) {
+        return;
+    }
+
     int result = _startStreamingWatcher.result();
     _isStreaming = (result == SMI_RET_SUCCESS);
 
@@ -171,6 +163,20 @@ void EyeTracker::onStreamStarted() {
 #endif
 
 void EyeTracker::setEnabled(bool enabled, bool simulate) {
+    if (enabled && !_isInitialized) {
+#ifdef HAVE_IVIEWHMD
+        int result = smi_setCallback(eyeTrackerCallback);
+        if (result != SMI_RET_SUCCESS) {
+            qCWarning(interfaceapp) << "Eye Tracker: Error setting callback:" << smiReturnValueToString(result);
+            QMessageBox::warning(nullptr, "Eye Tracker Error", smiReturnValueToString(result));
+        } else {
+            _isInitialized = true;
+        }
+
+        connect(&_startStreamingWatcher, SIGNAL(finished()), this, SLOT(onStreamStarted()));
+#endif
+    }
+
     if (!_isInitialized) {
         return;
     }

libraries/animation/src/AnimBlendLinear.cpp

@@ -12,6 +12,7 @@
 #include "GLMHelpers.h"
 #include "AnimationLogging.h"
 #include "AnimUtil.h"
+#include "AnimClip.h"
 
 AnimBlendLinear::AnimBlendLinear(const QString& id, float alpha) :
     AnimNode(AnimNode::Type::BlendLinear, id),
@@ -34,24 +35,13 @@ const AnimPoseVec& AnimBlendLinear::evaluate(const AnimVariantMap& animVars, flo
     } else if (_children.size() == 1) {
         _poses = _children[0]->evaluate(animVars, dt, triggersOut);
     } else {
+
         float clampedAlpha = glm::clamp(_alpha, 0.0f, (float)(_children.size() - 1));
         size_t prevPoseIndex = glm::floor(clampedAlpha);
         size_t nextPoseIndex = glm::ceil(clampedAlpha);
         float alpha = glm::fract(clampedAlpha);
-        if (prevPoseIndex == nextPoseIndex) {
-            // this can happen if alpha is on an integer boundary
-            _poses = _children[prevPoseIndex]->evaluate(animVars, dt, triggersOut);
-        } else {
-            // need to eval and blend between two children.
-            auto prevPoses = _children[prevPoseIndex]->evaluate(animVars, dt, triggersOut);
-            auto nextPoses = _children[nextPoseIndex]->evaluate(animVars, dt, triggersOut);
 
-            if (prevPoses.size() > 0 && prevPoses.size() == nextPoses.size()) {
-                _poses.resize(prevPoses.size());
-
-                ::blend(_poses.size(), &prevPoses[0], &nextPoses[0], alpha, &_poses[0]);
-            }
-        }
+        evaluateAndBlendChildren(animVars, triggersOut, alpha, prevPoseIndex, nextPoseIndex, dt);
     }
     return _poses;
 }
@@ -60,3 +50,21 @@ const AnimPoseVec& AnimBlendLinear::evaluate(const AnimVariantMap& animVars, flo
 const AnimPoseVec& AnimBlendLinear::getPosesInternal() const {
     return _poses;
 }
+
+void AnimBlendLinear::evaluateAndBlendChildren(const AnimVariantMap& animVars, Triggers& triggersOut, float alpha,
+                                               size_t prevPoseIndex, size_t nextPoseIndex, float dt) {
+    if (prevPoseIndex == nextPoseIndex) {
+        // this can happen if alpha is on an integer boundary
+        _poses = _children[prevPoseIndex]->evaluate(animVars, dt, triggersOut);
+    } else {
+        // need to eval and blend between two children.
+        auto prevPoses = _children[prevPoseIndex]->evaluate(animVars, dt, triggersOut);
+        auto nextPoses = _children[nextPoseIndex]->evaluate(animVars, dt, triggersOut);
+
+        if (prevPoses.size() > 0 && prevPoses.size() == nextPoses.size()) {
+            _poses.resize(prevPoses.size());
+
+            ::blend(_poses.size(), &prevPoses[0], &nextPoses[0], alpha, &_poses[0]);
+        }
+    }
+}

libraries/animation/src/AnimBlendLinear.h

@@ -38,6 +38,9 @@ protected:
     // for AnimDebugDraw rendering
     virtual const AnimPoseVec& getPosesInternal() const override;
 
+    void evaluateAndBlendChildren(const AnimVariantMap& animVars, Triggers& triggersOut, float alpha,
+                                  size_t prevPoseIndex, size_t nextPoseIndex, float dt);
+
     AnimPoseVec _poses;
 
     float _alpha;

libraries/animation/src/AnimBlendLinearMove.cpp

@@ -0,0 +1,126 @@
+//
+//  AnimBlendLinearMove.cpp
+//
+//  Created by Anthony J. Thibault on 10/22/15.
+//  Copyright (c) 2015 High Fidelity, Inc. All rights reserved.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "AnimBlendLinearMove.h"
+#include <GLMHelpers.h>
+#include "AnimationLogging.h"
+#include "AnimUtil.h"
+#include "AnimClip.h"
+
+AnimBlendLinearMove::AnimBlendLinearMove(const QString& id, float alpha, float desiredSpeed, const std::vector<float>& characteristicSpeeds) :
+    AnimNode(AnimNode::Type::BlendLinearMove, id),
+    _alpha(alpha),
+    _desiredSpeed(desiredSpeed),
+    _characteristicSpeeds(characteristicSpeeds) {
+
+}
+
+AnimBlendLinearMove::~AnimBlendLinearMove() {
+
+}
+
+const AnimPoseVec& AnimBlendLinearMove::evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) {
+
+    assert(_children.size() == _characteristicSpeeds.size());
+
+    _alpha = animVars.lookup(_alphaVar, _alpha);
+    _desiredSpeed = animVars.lookup(_desiredSpeedVar, _desiredSpeed);
+
+    if (_children.size() == 0) {
+        for (auto&& pose : _poses) {
+            pose = AnimPose::identity;
+        }
+    } else if (_children.size() == 1) {
+        const float alpha = 0.0f;
+        const int prevPoseIndex = 0;
+        const int nextPoseIndex = 0;
+        float prevDeltaTime, nextDeltaTime;
+        setFrameAndPhase(dt, alpha, prevPoseIndex, nextPoseIndex, &prevDeltaTime, &nextDeltaTime, triggersOut);
+        evaluateAndBlendChildren(animVars, triggersOut, alpha, prevPoseIndex, nextPoseIndex, prevDeltaTime, nextDeltaTime);
+    } else {
+
+        float clampedAlpha = glm::clamp(_alpha, 0.0f, (float)(_children.size() - 1));
+        size_t prevPoseIndex = glm::floor(clampedAlpha);
+        size_t nextPoseIndex = glm::ceil(clampedAlpha);
+        float alpha = glm::fract(clampedAlpha);
+        float prevDeltaTime, nextDeltaTime;
+        setFrameAndPhase(dt, alpha, prevPoseIndex, nextPoseIndex, &prevDeltaTime, &nextDeltaTime, triggersOut);
+        evaluateAndBlendChildren(animVars, triggersOut, alpha, prevPoseIndex, nextPoseIndex, prevDeltaTime, nextDeltaTime);
+    }
+    return _poses;
+}
+
+// for AnimDebugDraw rendering
+const AnimPoseVec& AnimBlendLinearMove::getPosesInternal() const {
+    return _poses;
+}
+
+void AnimBlendLinearMove::evaluateAndBlendChildren(const AnimVariantMap& animVars, Triggers& triggersOut, float alpha,
+                                                   size_t prevPoseIndex, size_t nextPoseIndex,
+                                                   float prevDeltaTime, float nextDeltaTime) {
+    if (prevPoseIndex == nextPoseIndex) {
+        // this can happen if alpha is on an integer boundary
+        _poses = _children[prevPoseIndex]->evaluate(animVars, prevDeltaTime, triggersOut);
+    } else {
+        // need to eval and blend between two children.
+        auto prevPoses = _children[prevPoseIndex]->evaluate(animVars, prevDeltaTime, triggersOut);
+        auto nextPoses = _children[nextPoseIndex]->evaluate(animVars, nextDeltaTime, triggersOut);
+
+        if (prevPoses.size() > 0 && prevPoses.size() == nextPoses.size()) {
+            _poses.resize(prevPoses.size());
+
+            ::blend(_poses.size(), &prevPoses[0], &nextPoses[0], alpha, &_poses[0]);
+        }
+    }
+}
+
+void AnimBlendLinearMove::setFrameAndPhase(float dt, float alpha, int prevPoseIndex, int nextPoseIndex,
+                                           float* prevDeltaTimeOut, float* nextDeltaTimeOut, Triggers& triggersOut) {
+
+    const float FRAMES_PER_SECOND = 30.0f;
+    auto prevClipNode = std::dynamic_pointer_cast<AnimClip>(_children[prevPoseIndex]);
+    assert(prevClipNode);
+    auto nextClipNode = std::dynamic_pointer_cast<AnimClip>(_children[nextPoseIndex]);
+    assert(nextClipNode);
+
+    float v0 = _characteristicSpeeds[prevPoseIndex];
+    float n0 = (prevClipNode->getEndFrame() - prevClipNode->getStartFrame()) + 1.0f;
+    float v1 = _characteristicSpeeds[nextPoseIndex];
+    float n1 = (nextClipNode->getEndFrame() - nextClipNode->getStartFrame()) + 1.0f;
+
+    // rate of change in phase space, necessary to achive desired speed.
+    float omega = (_desiredSpeed * FRAMES_PER_SECOND) / ((1.0f - alpha) * v0 * n0 + alpha * v1 * n1);
+
+    float f0 = prevClipNode->getStartFrame() + _phase * n0;
+    prevClipNode->setCurrentFrame(f0);
+
+    float f1 = nextClipNode->getStartFrame() + _phase * n1;
+    nextClipNode->setCurrentFrame(f1);
+
+    // integrate phase forward in time.
+    _phase += omega * dt;
+
+    // detect loop trigger events
+    if (_phase >= 1.0f) {
+        triggersOut.push_back(_id + "Loop");
+        _phase = glm::fract(_phase);
+    }
+
+    *prevDeltaTimeOut = omega * dt * (n0 / FRAMES_PER_SECOND);
+    *nextDeltaTimeOut = omega * dt * (n1 / FRAMES_PER_SECOND);
+}
+
+void AnimBlendLinearMove::setCurrentFrameInternal(float frame) {
+    assert(_children.size() > 0);
+    auto clipNode = std::dynamic_pointer_cast<AnimClip>(_children.front());
+    assert(clipNode);
+    const float NUM_FRAMES = (clipNode->getEndFrame() - clipNode->getStartFrame()) + 1.0f;
+    _phase = fmodf(frame, NUM_FRAMES);
+}

libraries/animation/src/AnimBlendLinearMove.h

@@ -0,0 +1,77 @@
+//
+//  AnimBlendLinearMove.h
+//
+//  Created by Anthony J. Thibault on 10/22/15.
+//  Copyright (c) 2015 High Fidelity, Inc. All rights reserved.
+//
+//  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_AnimBlendLinearMove_h
+#define hifi_AnimBlendLinearMove_h
+
+#include "AnimNode.h"
+
+// Synced linear blend between two AnimNodes, where the playback speed of
+// the animation is timeScaled to match movement speed.
+//
+// Each child animation is associated with a chracteristic speed.
+// This defines the speed of that animation when played at the normal playback rate, 30 frames per second.
+//
+// The user also specifies a desired speed.  This desired speed is used to timescale
+// the animation to achive the desired movement velocity.
+//
+// Blending is determined by the alpha parameter.
+// If the number of children is 2, then the alpha parameters should be between
+// 0 and 1.  The first animation will have a (1 - alpha) factor, and the second
+// will have factor of alpha.
+//
+// This node supports more then 2 children.  In this case the alpha should be
+// between 0 and n - 1.  This alpha can be used to linearly interpolate between
+// the closest two children poses.  This can be used to sweep through a series
+// of animation poses.
+
+class AnimBlendLinearMove : public AnimNode {
+public:
+    friend class AnimTests;
+
+    AnimBlendLinearMove(const QString& id, float alpha, float desiredSpeed, const std::vector<float>& characteristicSpeeds);
+    virtual ~AnimBlendLinearMove() override;
+
+    virtual const AnimPoseVec& evaluate(const AnimVariantMap& animVars, float dt, Triggers& triggersOut) override;
+
+    void setAlphaVar(const QString& alphaVar) { _alphaVar = alphaVar; }
+    void setDesiredSpeedVar(const QString& desiredSpeedVar) { _desiredSpeedVar = desiredSpeedVar; }
+
+protected:
+    // for AnimDebugDraw rendering
+    virtual const AnimPoseVec& getPosesInternal() const override;
+
+    void evaluateAndBlendChildren(const AnimVariantMap& animVars, Triggers& triggersOut, float alpha,
+                                  size_t prevPoseIndex, size_t nextPoseIndex,
+                                  float prevDeltaTime, float nextDeltaTime);
+
+    void setFrameAndPhase(float dt, float alpha, int prevPoseIndex, int nextPoseIndex,
+                          float* prevDeltaTimeOut, float* nextDeltaTimeOut, Triggers& triggersOut);
+
+    virtual void setCurrentFrameInternal(float frame) override;
+
+    AnimPoseVec _poses;
+
+    float _alpha;
+    float _desiredSpeed;
+
+    float _phase = 0.0f;
+
+    QString _alphaVar;
+    QString _desiredSpeedVar;
+
+    std::vector<float> _characteristicSpeeds;
+
+    // no copies
+    AnimBlendLinearMove(const AnimBlendLinearMove&) = delete;
+    AnimBlendLinearMove& operator=(const AnimBlendLinearMove&) = delete;
+};
+
+#endif // hifi_AnimBlendLinearMove_h

libraries/animation/src/AnimClip.cpp

@@ -35,7 +35,9 @@ const AnimPoseVec& AnimClip::evaluate(const AnimVariantMap& animVars, float dt,
     _endFrame = animVars.lookup(_endFrameVar, _endFrame);
     _timeScale = animVars.lookup(_timeScaleVar, _timeScale);
     _loopFlag = animVars.lookup(_loopFlagVar, _loopFlag);
-    _frame = accumulateTime(animVars.lookup(_frameVar, _frame), dt, triggersOut);
+    float frame = animVars.lookup(_frameVar, _frame);
+
+    _frame = ::accumulateTime(_startFrame, _endFrame, _timeScale, frame, dt, _loopFlag, _id, triggersOut);
 
     // poll network anim to see if it's finished loading yet.
     if (_networkAnim && _networkAnim->isLoaded() && _skeleton) {
@@ -45,16 +47,17 @@ const AnimPoseVec& AnimClip::evaluate(const AnimVariantMap& animVars, float dt,
     }
 
     if (_anim.size()) {
-        int frameCount = _anim.size();
-
         int prevIndex = (int)glm::floor(_frame);
-        int nextIndex = (int)glm::ceil(_frame);
-        if (_loopFlag && nextIndex >= frameCount) {
-            nextIndex = 0;
+        int nextIndex;
+        if (_loopFlag && _frame >= _endFrame) {
+            nextIndex = (int)glm::ceil(_startFrame);
+        } else {
+            nextIndex = (int)glm::ceil(_frame);
         }
 
         // It can be quite possible for the user to set _startFrame and _endFrame to
         // values before or past valid ranges.  We clamp the frames here.
+        int frameCount = _anim.size();
         prevIndex = std::min(std::max(0, prevIndex), frameCount - 1);
         nextIndex = std::min(std::max(0, nextIndex), frameCount - 1);
 
@@ -78,39 +81,7 @@ void AnimClip::setCurrentFrameInternal(float frame) {
     // because dt is 0, we should not encounter any triggers
     const float dt = 0.0f;
     Triggers triggers;
-    _frame = accumulateTime(frame * _timeScale, dt, triggers);
-}
-
-float AnimClip::accumulateTime(float frame, float dt, Triggers& triggersOut) const {
-    const float startFrame = std::min(_startFrame, _endFrame);
-    if (startFrame == _endFrame) {
-        // when startFrame >= endFrame
-        frame = _endFrame;
-    } else if (_timeScale > 0.0f) {
-        // accumulate time, keeping track of loops and end of animation events.
-        const float FRAMES_PER_SECOND = 30.0f;
-        float framesRemaining = (dt * _timeScale) * FRAMES_PER_SECOND;
-        while (framesRemaining > 0.0f) {
-            float framesTillEnd = _endFrame - _frame;
-            if (framesRemaining >= framesTillEnd) {
-                if (_loopFlag) {
-                    // anim loop
-                    triggersOut.push_back(_id + "OnLoop");
-                    framesRemaining -= framesTillEnd;
-                    frame = startFrame;
-                } else {
-                    // anim end
-                    triggersOut.push_back(_id + "OnDone");
-                    frame = _endFrame;
-                    framesRemaining = 0.0f;
-                }
-            } else {
-                frame += framesRemaining;
-                framesRemaining = 0.0f;
-            }
-        }
-    }
-    return frame;
+    _frame = ::accumulateTime(_startFrame, _endFrame, _timeScale, frame, dt, _loopFlag, _id, triggers);
 }
 
 void AnimClip::copyFromNetworkAnim() {

libraries/animation/src/AnimClip.h

@@ -36,12 +36,17 @@ public:
     void setLoopFlagVar(const QString& loopFlagVar) { _loopFlagVar = loopFlagVar; }
     void setFrameVar(const QString& frameVar) { _frameVar = frameVar; }
 
+    float getStartFrame() const { return _startFrame; }
+    float getEndFrame() const { return _endFrame; }
+
+    void setTimeScale(float timeScale) { _timeScale = timeScale; }
+    float getTimeScale() const { return _timeScale; }
+
 protected:
     void loadURL(const QString& url);
 
     virtual void setCurrentFrameInternal(float frame) override;
 
-    float accumulateTime(float frame, float dt, Triggers& triggersOut) const;
     void copyFromNetworkAnim();
 
     // for AnimDebugDraw rendering

libraries/animation/src/AnimNode.h

@@ -38,6 +38,7 @@ public:
     enum class Type {
         Clip = 0,
         BlendLinear,
+        BlendLinearMove,
         Overlay,
         StateMachine,
         Manipulator,
@@ -75,10 +76,10 @@ public:
         return evaluate(animVars, dt, triggersOut);
     }
 
-protected:
-
     void setCurrentFrame(float frame);
 
+protected:
+
     virtual void setCurrentFrameInternal(float frame) {}
     virtual void setSkeletonInternal(AnimSkeleton::ConstPointer skeleton) { _skeleton = skeleton; }
 

libraries/animation/src/AnimNodeLoader.cpp

@@ -16,6 +16,7 @@
 #include "AnimNode.h"
 #include "AnimClip.h"
 #include "AnimBlendLinear.h"
+#include "AnimBlendLinearMove.h"
 #include "AnimationLogging.h"
 #include "AnimOverlay.h"
 #include "AnimNodeLoader.h"
@@ -29,6 +30,7 @@ using NodeProcessFunc = bool (*)(AnimNode::Pointer node, const QJsonObject& json
 // factory functions
 static AnimNode::Pointer loadClipNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl);
 static AnimNode::Pointer loadBlendLinearNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl);
+static AnimNode::Pointer loadBlendLinearMoveNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl);
 static AnimNode::Pointer loadOverlayNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl);
 static AnimNode::Pointer loadStateMachineNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl);
 static AnimNode::Pointer loadManipulatorNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl);
@@ -36,17 +38,14 @@ static AnimNode::Pointer loadInverseKinematicsNode(const QJsonObject& jsonObj, c
 
 // called after children have been loaded
 // returns node on success, nullptr on failure.
-static bool processClipNode(AnimNode::Pointer node, const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) { return true; }
-static bool processBlendLinearNode(AnimNode::Pointer node, const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) { return true; }
-static bool processOverlayNode(AnimNode::Pointer node, const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) { return true; }
+static bool processDoNothing(AnimNode::Pointer node, const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) { return true; }
 bool processStateMachineNode(AnimNode::Pointer node, const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl);
-static bool processManipulatorNode(AnimNode::Pointer node, const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) { return true; }
-static bool processInverseKinematicsNode(AnimNode::Pointer node, const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) { return true; }
 
 static const char* animNodeTypeToString(AnimNode::Type type) {
     switch (type) {
     case AnimNode::Type::Clip: return "clip";
     case AnimNode::Type::BlendLinear: return "blendLinear";
+    case AnimNode::Type::BlendLinearMove: return "blendLinearMove";
     case AnimNode::Type::Overlay: return "overlay";
     case AnimNode::Type::StateMachine: return "stateMachine";
     case AnimNode::Type::Manipulator: return "manipulator";
@@ -60,6 +59,7 @@ static NodeLoaderFunc animNodeTypeToLoaderFunc(AnimNode::Type type) {
     switch (type) {
     case AnimNode::Type::Clip: return loadClipNode;
     case AnimNode::Type::BlendLinear: return loadBlendLinearNode;
+    case AnimNode::Type::BlendLinearMove: return loadBlendLinearMoveNode;
     case AnimNode::Type::Overlay: return loadOverlayNode;
     case AnimNode::Type::StateMachine: return loadStateMachineNode;
     case AnimNode::Type::Manipulator: return loadManipulatorNode;
@@ -71,12 +71,13 @@ static NodeLoaderFunc animNodeTypeToLoaderFunc(AnimNode::Type type) {
 
 static NodeProcessFunc animNodeTypeToProcessFunc(AnimNode::Type type) {
     switch (type) {
-    case AnimNode::Type::Clip: return processClipNode;
-    case AnimNode::Type::BlendLinear: return processBlendLinearNode;
-    case AnimNode::Type::Overlay: return processOverlayNode;
+    case AnimNode::Type::Clip: return processDoNothing;
+    case AnimNode::Type::BlendLinear: return processDoNothing;
+    case AnimNode::Type::BlendLinearMove: return processDoNothing;
+    case AnimNode::Type::Overlay: return processDoNothing;
     case AnimNode::Type::StateMachine: return processStateMachineNode;
-    case AnimNode::Type::Manipulator: return processManipulatorNode;
-    case AnimNode::Type::InverseKinematics: return processInverseKinematicsNode;
+    case AnimNode::Type::Manipulator: return processDoNothing;
+    case AnimNode::Type::InverseKinematics: return processDoNothing;
     case AnimNode::Type::NumTypes: return nullptr;
     };
     return nullptr;
@@ -160,6 +161,9 @@ static AnimNode::Pointer loadNode(const QJsonObject& jsonObj, const QUrl& jsonUr
 
     assert((int)type >= 0 && type < AnimNode::Type::NumTypes);
     auto node = (animNodeTypeToLoaderFunc(type))(dataObj, id, jsonUrl);
+    if (!node) {
+        return nullptr;
+    }
 
     auto childrenValue = jsonObj.value("children");
     if (!childrenValue.isArray()) {
@@ -233,6 +237,45 @@ static AnimNode::Pointer loadBlendLinearNode(const QJsonObject& jsonObj, const Q
     return node;
 }
 
+static AnimNode::Pointer loadBlendLinearMoveNode(const QJsonObject& jsonObj, const QString& id, const QUrl& jsonUrl) {
+
+    READ_FLOAT(alpha, jsonObj, id, jsonUrl, nullptr);
+    READ_FLOAT(desiredSpeed, jsonObj, id, jsonUrl, nullptr);
+
+    std::vector<float> characteristicSpeeds;
+    auto speedsValue = jsonObj.value("characteristicSpeeds");
+    if (!speedsValue.isArray()) {
+        qCCritical(animation) << "AnimNodeLoader, bad array \"characteristicSpeeds\" in blendLinearMove node, id =" << id << ", url =" << jsonUrl.toDisplayString();
+        return nullptr;
+    }
+
+    auto speedsArray = speedsValue.toArray();
+    for (const auto& speedValue : speedsArray) {
+        if (!speedValue.isDouble()) {
+            qCCritical(animation) << "AnimNodeLoader, bad number in \"characteristicSpeeds\", id =" << id << ", url =" << jsonUrl.toDisplayString();
+            return nullptr;
+        }
+        float speedVal = (float)speedValue.toDouble();
+        characteristicSpeeds.push_back(speedVal);
+    };
+
+    READ_OPTIONAL_STRING(alphaVar, jsonObj);
+    READ_OPTIONAL_STRING(desiredSpeedVar, jsonObj);
+
+    auto node = std::make_shared<AnimBlendLinearMove>(id, alpha, desiredSpeed, characteristicSpeeds);
+
+    if (!alphaVar.isEmpty()) {
+        node->setAlphaVar(alphaVar);
+    }
+
+    if (!desiredSpeedVar.isEmpty()) {
+        node->setDesiredSpeedVar(desiredSpeedVar);
+    }
+
+    return node;
+}
+
+
 static const char* boneSetStrings[AnimOverlay::NumBoneSets] = {
     "fullBody",
     "upperBody",

libraries/animation/src/AnimPose.cpp

@@ -0,0 +1,56 @@
+//
+//  AnimPose.cpp
+//
+//  Created by Anthony J. Thibault on 10/14/15.
+//  Copyright (c) 2015 High Fidelity, Inc. All rights reserved.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "AnimPose.h"
+#include "GLMHelpers.h"
+
+const AnimPose AnimPose::identity = AnimPose(glm::vec3(1.0f),
+                                             glm::quat(),
+                                             glm::vec3(0.0f));
+
+AnimPose::AnimPose(const glm::mat4& mat) {
+    scale = extractScale(mat);
+    rot = glm::normalize(glm::quat_cast(mat));
+    trans = extractTranslation(mat);
+}
+
+glm::vec3 AnimPose::operator*(const glm::vec3& rhs) const {
+    return trans + (rot * (scale * rhs));
+}
+
+glm::vec3 AnimPose::xformPoint(const glm::vec3& rhs) const {
+    return *this * rhs;
+}
+
+// really slow
+glm::vec3 AnimPose::xformVector(const glm::vec3& rhs) const {
+    glm::vec3 xAxis = rot * glm::vec3(scale.x, 0.0f, 0.0f);
+    glm::vec3 yAxis = rot * glm::vec3(0.0f, scale.y, 0.0f);
+    glm::vec3 zAxis = rot * glm::vec3(0.0f, 0.0f, scale.z);
+    glm::mat3 mat(xAxis, yAxis, zAxis);
+    glm::mat3 transInvMat = glm::inverse(glm::transpose(mat));
+    return transInvMat * rhs;
+}
+
+AnimPose AnimPose::operator*(const AnimPose& rhs) const {
+    return AnimPose(static_cast<glm::mat4>(*this) * static_cast<glm::mat4>(rhs));
+}
+
+AnimPose AnimPose::inverse() const {
+    return AnimPose(glm::inverse(static_cast<glm::mat4>(*this)));
+}
+
+AnimPose::operator glm::mat4() const {
+    glm::vec3 xAxis = rot * glm::vec3(scale.x, 0.0f, 0.0f);
+    glm::vec3 yAxis = rot * glm::vec3(0.0f, scale.y, 0.0f);
+    glm::vec3 zAxis = rot * glm::vec3(0.0f, 0.0f, scale.z);
+    return glm::mat4(glm::vec4(xAxis, 0.0f), glm::vec4(yAxis, 0.0f),
+                     glm::vec4(zAxis, 0.0f), glm::vec4(trans, 1.0f));
+}

libraries/animation/src/AnimPose.h

@@ -0,0 +1,47 @@
+//
+//  AnimPose.h
+//
+//  Created by Anthony J. Thibault on 10/14/15.
+//  Copyright (c) 2015 High Fidelity, Inc. All rights reserved.
+//
+//  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_AnimPose
+#define hifi_AnimPose
+
+#include <QtGlobal>
+#include <QDebug>
+#include <vector>
+#include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
+
+struct AnimPose {
+    AnimPose() {}
+    explicit AnimPose(const glm::mat4& mat);
+    AnimPose(const glm::vec3& scaleIn, const glm::quat& rotIn, const glm::vec3& transIn) : scale(scaleIn), rot(rotIn), trans(transIn) {}
+    static const AnimPose identity;
+
+    glm::vec3 xformPoint(const glm::vec3& rhs) const;
+    glm::vec3 xformVector(const glm::vec3& rhs) const;  // really slow
+
+    glm::vec3 operator*(const glm::vec3& rhs) const; // same as xformPoint
+    AnimPose operator*(const AnimPose& rhs) const;
+
+    AnimPose inverse() const;
+    operator glm::mat4() const;
+
+    glm::vec3 scale;
+    glm::quat rot;
+    glm::vec3 trans;
+};
+
+inline QDebug operator<<(QDebug debug, const AnimPose& pose) {
+    debug << "AnimPose, trans = (" << pose.trans.x << pose.trans.y << pose.trans.z << "), rot = (" << pose.rot.x << pose.rot.y << pose.rot.z << pose.rot.w << "), scale = (" << pose.scale.x << pose.scale.y << pose.scale.z << ")";
+    return debug;
+}
+
+using AnimPoseVec = std::vector<AnimPose>;
+
+#endif

libraries/animation/src/AnimSkeleton.cpp

@@ -16,50 +16,6 @@
 
 #include "AnimationLogging.h"
 
-const AnimPose AnimPose::identity = AnimPose(glm::vec3(1.0f),
-                                             glm::quat(),
-                                             glm::vec3(0.0f));
-
-AnimPose::AnimPose(const glm::mat4& mat) {
-    scale = extractScale(mat);
-    rot = glm::normalize(glm::quat_cast(mat));
-    trans = extractTranslation(mat);
-}
-
-glm::vec3 AnimPose::operator*(const glm::vec3& rhs) const {
-    return trans + (rot * (scale * rhs));
-}
-
-glm::vec3 AnimPose::xformPoint(const glm::vec3& rhs) const {
-    return *this * rhs;
-}
-
-// really slow
-glm::vec3 AnimPose::xformVector(const glm::vec3& rhs) const {
-    glm::vec3 xAxis = rot * glm::vec3(scale.x, 0.0f, 0.0f);
-    glm::vec3 yAxis = rot * glm::vec3(0.0f, scale.y, 0.0f);
-    glm::vec3 zAxis = rot * glm::vec3(0.0f, 0.0f, scale.z);
-    glm::mat3 mat(xAxis, yAxis, zAxis);
-    glm::mat3 transInvMat = glm::inverse(glm::transpose(mat));
-    return transInvMat * rhs;
-}
-
-AnimPose AnimPose::operator*(const AnimPose& rhs) const {
-    return AnimPose(static_cast<glm::mat4>(*this) * static_cast<glm::mat4>(rhs));
-}
-
-AnimPose AnimPose::inverse() const {
-    return AnimPose(glm::inverse(static_cast<glm::mat4>(*this)));
-}
-
-AnimPose::operator glm::mat4() const {
-    glm::vec3 xAxis = rot * glm::vec3(scale.x, 0.0f, 0.0f);
-    glm::vec3 yAxis = rot * glm::vec3(0.0f, scale.y, 0.0f);
-    glm::vec3 zAxis = rot * glm::vec3(0.0f, 0.0f, scale.z);
-    return glm::mat4(glm::vec4(xAxis, 0.0f), glm::vec4(yAxis, 0.0f),
-                     glm::vec4(zAxis, 0.0f), glm::vec4(trans, 1.0f));
-}
-
 AnimSkeleton::AnimSkeleton(const FBXGeometry& fbxGeometry) {
     // convert to std::vector of joints
     std::vector<FBXJoint> joints;

libraries/animation/src/AnimSkeleton.h

@@ -16,33 +16,7 @@
 #include <glm/gtc/quaternion.hpp>
 
 #include <FBXReader.h>
-
-struct AnimPose {
-    AnimPose() {}
-    explicit AnimPose(const glm::mat4& mat);
-    AnimPose(const glm::vec3& scaleIn, const glm::quat& rotIn, const glm::vec3& transIn) : scale(scaleIn), rot(rotIn), trans(transIn) {}
-    static const AnimPose identity;
-
-    glm::vec3 xformPoint(const glm::vec3& rhs) const;
-    glm::vec3 xformVector(const glm::vec3& rhs) const;  // really slow
-
-    glm::vec3 operator*(const glm::vec3& rhs) const; // same as xformPoint
-    AnimPose operator*(const AnimPose& rhs) const;
-
-    AnimPose inverse() const;
-    operator glm::mat4() const;
-
-    glm::vec3 scale;
-    glm::quat rot;
-    glm::vec3 trans;
-};
-
-inline QDebug operator<<(QDebug debug, const AnimPose& pose) {
-    debug << "AnimPose, trans = (" << pose.trans.x << pose.trans.y << pose.trans.z << "), rot = (" << pose.rot.x << pose.rot.y << pose.rot.z << pose.rot.w << "), scale = (" << pose.scale.x << pose.scale.y << pose.scale.z << ")";
-    return debug;
-}
-
-using AnimPoseVec = std::vector<AnimPose>;
+#include "AnimPose.h"
 
 class AnimSkeleton {
 public:

libraries/animation/src/AnimUtil.cpp

@@ -11,6 +11,9 @@
 #include "AnimUtil.h"
 #include "GLMHelpers.h"
 
+// TODO: use restrict keyword
+// TODO: excellent candidate for simd vectorization.
+
 void blend(size_t numPoses, const AnimPose* a, const AnimPose* b, float alpha, AnimPose* result) {
     for (size_t i = 0; i < numPoses; i++) {
         const AnimPose& aPose = a[i];
@@ -20,3 +23,42 @@ void blend(size_t numPoses, const AnimPose* a, const AnimPose* b, float alpha, A
         result[i].trans = lerp(aPose.trans, bPose.trans, alpha);
     }
 }
+
+float accumulateTime(float startFrame, float endFrame, float timeScale, float currentFrame, float dt, bool loopFlag,
+                     const QString& id, AnimNode::Triggers& triggersOut) {
+
+    float frame = currentFrame;
+    const float clampedStartFrame = std::min(startFrame, endFrame);
+    if (fabsf(clampedStartFrame - endFrame) < 1.0f) {
+        frame = endFrame;
+    } else if (timeScale > 0.0f) {
+        // accumulate time, keeping track of loops and end of animation events.
+        const float FRAMES_PER_SECOND = 30.0f;
+        float framesRemaining = (dt * timeScale) * FRAMES_PER_SECOND;
+        while (framesRemaining > 0.0f) {
+            float framesTillEnd = endFrame - frame;
+            // when looping, add one frame between start and end.
+            if (loopFlag) {
+                framesTillEnd += 1.0f;
+            }
+            if (framesRemaining >= framesTillEnd) {
+                if (loopFlag) {
+                    // anim loop
+                    triggersOut.push_back(id + "OnLoop");
+                    framesRemaining -= framesTillEnd;
+                    frame = clampedStartFrame;
+                } else {
+                    // anim end
+                    triggersOut.push_back(id + "OnDone");
+                    frame = endFrame;
+                    framesRemaining = 0.0f;
+                }
+            } else {
+                frame += framesRemaining;
+                framesRemaining = 0.0f;
+            }
+        }
+    }
+    return frame;
+}
+

libraries/animation/src/AnimUtil.h

@@ -13,12 +13,12 @@
 
 #include "AnimNode.h"
 
-// TODO: use restrict keyword
-// TODO: excellent candidate for simd vectorization.
-
 // this is where the magic happens
 void blend(size_t numPoses, const AnimPose* a, const AnimPose* b, float alpha, AnimPose* result);
 
+float accumulateTime(float startFrame, float endFrame, float timeScale, float currentFrame, float dt, bool loopFlag,
+                     const QString& id, AnimNode::Triggers& triggersOut);
+
 #endif
 
 

libraries/animation/src/Rig.cpp

@@ -381,6 +381,33 @@ glm::mat4 Rig::getJointTransform(int jointIndex) const {
     return _jointStates[jointIndex].getTransform();
 }
 
+void Rig::calcAnimAlpha(float speed, const std::vector<float>& referenceSpeeds, float* alphaOut) const {
+
+    assert(referenceSpeeds.size() > 0);
+
+    // calculate alpha from linear combination of referenceSpeeds.
+    float alpha = 0.0f;
+    if (speed <= referenceSpeeds.front()) {
+        alpha = 0.0f;
+    } else if (speed > referenceSpeeds.back()) {
+        alpha = (float)(referenceSpeeds.size() - 1);
+    } else {
+        for (size_t i = 0; i < referenceSpeeds.size() - 1; i++) {
+            if (referenceSpeeds[i] < speed && speed < referenceSpeeds[i + 1]) {
+                alpha = (float)i + ((speed - referenceSpeeds[i]) / (referenceSpeeds[i + 1] - referenceSpeeds[i]));
+                break;
+            }
+        }
+    }
+
+    *alphaOut = alpha;
+}
+
+// animation reference speeds.
+static const std::vector<float> FORWARD_SPEEDS = { 0.4f, 1.4f, 4.5f }; // m/s
+static const std::vector<float> BACKWARD_SPEEDS = { 0.6f, 1.45f }; // m/s
+static const std::vector<float> LATERAL_SPEEDS = { 0.2f, 0.65f }; // m/s
+
 void Rig::computeMotionAnimationState(float deltaTime, const glm::vec3& worldPosition, const glm::vec3& worldVelocity, const glm::quat& worldRotation) {
 
     glm::vec3 front = worldRotation * IDENTITY_FRONT;
@@ -389,8 +416,16 @@ void Rig::computeMotionAnimationState(float deltaTime, const glm::vec3& worldPos
     // but some modes (e.g., hmd standing) update position without updating velocity.
     // It's very hard to debug hmd standing. (Look down at yourself, or have a second person observe. HMD third person is a bit undefined...)
     // So, let's create our own workingVelocity from the worldPosition...
+    glm::vec3 workingVelocity = _lastVelocity;
     glm::vec3 positionDelta = worldPosition - _lastPosition;
-    glm::vec3 workingVelocity = positionDelta / deltaTime;
+
+    // Don't trust position delta if deltaTime is 'small'.
+    // NOTE: This is mostly just a work around for an issue in oculus 0.7 runtime, where
+    // Application::idle() is being called more frequently and with smaller dt's then expected.
+    const float SMALL_DELTA_TIME = 0.006f;  // 6 ms
+    if (deltaTime > SMALL_DELTA_TIME) {
+        workingVelocity = positionDelta / deltaTime;
+    }
 
 #if !WANT_DEBUG
     // But for smoothest (non-hmd standing) results, go ahead and use velocity:
@@ -399,19 +434,43 @@ void Rig::computeMotionAnimationState(float deltaTime, const glm::vec3& worldPos
     }
 #endif
 
+    if (deltaTime > SMALL_DELTA_TIME) {
+        _lastVelocity = workingVelocity;
+    }
+
     if (_enableAnimGraph) {
 
         glm::vec3 localVel = glm::inverse(worldRotation) * workingVelocity;
+
         float forwardSpeed = glm::dot(localVel, IDENTITY_FRONT);
         float lateralSpeed = glm::dot(localVel, IDENTITY_RIGHT);
         float turningSpeed = glm::orientedAngle(front, _lastFront, IDENTITY_UP) / deltaTime;
 
+        // filter speeds using a simple moving average.
+        _averageForwardSpeed.updateAverage(forwardSpeed);
+        _averageLateralSpeed.updateAverage(lateralSpeed);
+
         // sine wave LFO var for testing.
         static float t = 0.0f;
-        _animVars.set("sine", static_cast<float>(0.5 * sin(t) + 0.5));
+        _animVars.set("sine", 2.0f * static_cast<float>(0.5 * sin(t) + 0.5));
 
-        const float ANIM_WALK_SPEED = 1.4f; // m/s
-        _animVars.set("walkTimeScale", glm::clamp(0.5f, 2.0f, glm::length(localVel) / ANIM_WALK_SPEED));
+        float moveForwardAlpha = 0.0f;
+        float moveBackwardAlpha = 0.0f;
+        float moveLateralAlpha = 0.0f;
+
+        // calcuate the animation alpha and timeScale values based on current speeds and animation reference speeds.
+        calcAnimAlpha(_averageForwardSpeed.getAverage(), FORWARD_SPEEDS, &moveForwardAlpha);
+        calcAnimAlpha(-_averageForwardSpeed.getAverage(), BACKWARD_SPEEDS, &moveBackwardAlpha);
+        calcAnimAlpha(fabsf(_averageLateralSpeed.getAverage()), LATERAL_SPEEDS, &moveLateralAlpha);
+
+        _animVars.set("moveForwardSpeed", _averageForwardSpeed.getAverage());
+        _animVars.set("moveForwardAlpha", moveForwardAlpha);
+
+        _animVars.set("moveBackwardSpeed", -_averageForwardSpeed.getAverage());
+        _animVars.set("moveBackwardAlpha", moveBackwardAlpha);
+
+        _animVars.set("moveLateralSpeed", fabsf(_averageLateralSpeed.getAverage()));
+        _animVars.set("moveLateralAlpha", moveLateralAlpha);
 
         const float MOVE_ENTER_SPEED_THRESHOLD = 0.2f; // m/sec
         const float MOVE_EXIT_SPEED_THRESHOLD = 0.07f;  // m/sec

libraries/animation/src/Rig.h

@@ -44,6 +44,7 @@
 
 #include "AnimNode.h"
 #include "AnimNodeLoader.h"
+#include "SimpleMovingAverage.h"
 
 class AnimationHandle;
 typedef std::shared_ptr<AnimationHandle> AnimationHandlePointer;
@@ -219,6 +220,7 @@ public:
     void updateLeanJoint(int index, float leanSideways, float leanForward, float torsoTwist);
     void updateNeckJoint(int index, const HeadParameters& params);
     void updateEyeJoint(int index, const glm::vec3& modelTranslation, const glm::quat& modelRotation, const glm::quat& worldHeadOrientation, const glm::vec3& lookAt, const glm::vec3& saccade);
+    void calcAnimAlpha(float speed, const std::vector<float>& referenceSpeeds, float* alphaOut) const;
 
     QVector<JointState> _jointStates;
     int _rootJointIndex = -1;
@@ -238,6 +240,7 @@ public:
     bool _enableAnimGraph = false;
     glm::vec3 _lastFront;
     glm::vec3 _lastPosition;
+    glm::vec3 _lastVelocity;
 
     std::shared_ptr<AnimNode> _animNode;
     std::shared_ptr<AnimSkeleton> _animSkeleton;
@@ -254,6 +257,9 @@ public:
     float _leftHandOverlayAlpha = 0.0f;
     float _rightHandOverlayAlpha = 0.0f;
 
+    SimpleMovingAverage _averageForwardSpeed{ 10 };
+    SimpleMovingAverage _averageLateralSpeed{ 10 };
+
 private:
     QMap<int, StateHandler> _stateHandlers;
     int _nextStateHandlerId {0};

libraries/gl/src/gl/GlWindow.h

@@ -11,7 +11,7 @@
 #define hifi_GlWindow_h
 
 #include <mutex>
-#include <QWindow>
+#include <QtGui/QWindow>
 
 class QOpenGLContext;
 class QOpenGLDebugLogger;

libraries/shared/src/AtRestDetector.cpp

@@ -1,5 +1,19 @@
+//
+//  AtRestDetector.cpp
+//  libraries/shared/src
+//
+//  Created by Anthony Thibault on 10/6/2015
+//  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 "AtRestDetector.h"
+
+#include "NumericalConstants.h"
 #include "SharedLogging.h"
+#include "SharedUtil.h"
 
 AtRestDetector::AtRestDetector(const glm::vec3& startPosition, const glm::quat& startRotation) {
     reset(startPosition, startRotation);
@@ -12,9 +26,14 @@ void AtRestDetector::reset(const glm::vec3& startPosition, const glm::quat& star
     glm::quat ql = glm::log(startRotation);
     _quatLogAverage = glm::vec3(ql.x, ql.y, ql.z);
     _quatLogVariance = 0.0f;
+    _lastUpdateTime = usecTimestampNow();
+    _isAtRest = false;
 }
 
-bool AtRestDetector::update(float dt, const glm::vec3& position, const glm::quat& rotation) {
+bool AtRestDetector::update(const glm::vec3& position, const glm::quat& rotation) {
+    uint64_t now = usecTimestampNow();
+    float dt = (float)(_lastUpdateTime - now) / (float)USECS_PER_SECOND;
+    _lastUpdateTime = now;
     const float TAU = 1.0f;
     float delta = glm::min(dt / TAU, 1.0f);
 
@@ -37,5 +56,6 @@ bool AtRestDetector::update(float dt, const glm::vec3& position, const glm::quat
     const float POSITION_VARIANCE_THRESHOLD = 0.001f;
     const float QUAT_LOG_VARIANCE_THRESHOLD = 0.00002f;
 
-    return _positionVariance < POSITION_VARIANCE_THRESHOLD && _quatLogVariance < QUAT_LOG_VARIANCE_THRESHOLD;
+    _isAtRest = _positionVariance < POSITION_VARIANCE_THRESHOLD && _quatLogVariance < QUAT_LOG_VARIANCE_THRESHOLD;
+    return _isAtRest;
 }

libraries/shared/src/AtRestDetector.h

@@ -21,14 +21,17 @@ public:
     void reset(const glm::vec3& startPosition, const glm::quat& startRotation);
 
     // returns true if object is at rest, dt in assumed to be seconds.
-    bool update(float dt, const glm::vec3& position, const glm::quat& startRotation);
+    bool update(const glm::vec3& position, const glm::quat& startRotation);
+
+    bool isAtRest() const { return _isAtRest; }
 
 protected:
     glm::vec3 _positionAverage;
-    float _positionVariance;
-
     glm::vec3 _quatLogAverage;
-    float _quatLogVariance;
+    uint64_t _lastUpdateTime { 0 };
+    float _positionVariance { 0.0f };
+    float _quatLogVariance { 0.0f };
+    bool _isAtRest { false };
 };
 
 #endif

libraries/shared/src/GLMHelpers.h

@@ -183,6 +183,11 @@ T toNormalizedDeviceScale(const T& value, const T& size) {
 #define PITCH(euler) euler.x
 #define ROLL(euler) euler.z
 
+// float - linear interpolate
+inline float lerp(float x, float y, float a) {
+    return x * (1.0f - a) + (y * a);
+}
+
 // vec2 lerp - linear interpolate
 template<typename T, glm::precision P>
 glm::detail::tvec2<T, P> lerp(const glm::detail::tvec2<T, P>& x, const glm::detail::tvec2<T, P>& y, T a) {

plugins/oculusLegacy/src/OculusLegacyDisplayPlugin.cpp

@@ -9,15 +9,15 @@
 
 #include <memory>
 
-#include <QMainWindow>
-#include <QGLWidget>
+#include <QtWidgets/QMainWindow>
+#include <QtOpenGL/QGLWidget>
 #include <GLMHelpers.h>
 #include <gl/GlWindow.h>
 #include <QEvent>
-#include <QResizeEvent>
-#include <QOpenGLContext>
-#include <QGuiApplication>
-#include <QScreen>
+#include <QtGui/QResizeEvent>
+#include <QtGui/QOpenGLContext>
+#include <QtGui/QGuiApplication>
+#include <QtGui/QScreen>
 
 #include <PerfStat.h>
 #include <gl/OglplusHelpers.h>

tests/animation/src/AnimTests.cpp

@@ -13,6 +13,7 @@
 #include "AnimBlendLinear.h"
 #include "AnimationLogging.h"
 #include "AnimVariant.h"
+#include "AnimUtil.h"
 
 #include <../QTestExtensions.h>
 
@@ -30,8 +31,8 @@ void AnimTests::cleanupTestCase() {
 }
 
 void AnimTests::testClipInternalState() {
-    std::string id = "my anim clip";
-    std::string url = "https://hifi-public.s3.amazonaws.com/ozan/support/FightClubBotTest1/Animations/standard_idle.fbx";
+    QString id = "my anim clip";
+    QString url = "https://hifi-public.s3.amazonaws.com/ozan/support/FightClubBotTest1/Animations/standard_idle.fbx";
     float startFrame = 2.0f;
     float endFrame = 20.0f;
     float timeScale = 1.1f;
@@ -55,8 +56,8 @@ static float framesToSec(float secs) {
 }
 
 void AnimTests::testClipEvaulate() {
-    std::string id = "myClipNode";
-    std::string url = "https://hifi-public.s3.amazonaws.com/ozan/support/FightClubBotTest1/Animations/standard_idle.fbx";
+    QString id = "myClipNode";
+    QString url = "https://hifi-public.s3.amazonaws.com/ozan/support/FightClubBotTest1/Animations/standard_idle.fbx";
     float startFrame = 2.0f;
     float endFrame = 22.0f;
     float timeScale = 1.0f;
@@ -73,8 +74,8 @@ void AnimTests::testClipEvaulate() {
 
     // does it loop?
     triggers.clear();
-    clip.evaluate(vars, framesToSec(11.0f), triggers);
-    QCOMPARE_WITH_ABS_ERROR(clip._frame, 3.0f, EPSILON);
+    clip.evaluate(vars, framesToSec(12.0f), triggers);
+    QCOMPARE_WITH_ABS_ERROR(clip._frame, 3.0f, EPSILON);  // Note: frame 3 and not 4, because extra frame between start and end.
 
     // did we receive a loop trigger?
     QVERIFY(std::find(triggers.begin(), triggers.end(), "myClipNodeOnLoop") != triggers.end());
@@ -90,8 +91,8 @@ void AnimTests::testClipEvaulate() {
 }
 
 void AnimTests::testClipEvaulateWithVars() {
-    std::string id = "myClipNode";
-    std::string url = "https://hifi-public.s3.amazonaws.com/ozan/support/FightClubBotTest1/Animations/standard_idle.fbx";
+    QString id = "myClipNode";
+    QString url = "https://hifi-public.s3.amazonaws.com/ozan/support/FightClubBotTest1/Animations/standard_idle.fbx";
     float startFrame = 2.0f;
     float endFrame = 22.0f;
     float timeScale = 1.0f;
@@ -126,9 +127,9 @@ void AnimTests::testClipEvaulateWithVars() {
 }
 
 void AnimTests::testLoader() {
-    auto url = QUrl("https://gist.githubusercontent.com/hyperlogic/857129fe04567cbe670f/raw/8ba57a8f0a76f88b39a11f77f8d9df04af9cec95/test.json");
+    auto url = QUrl("https://gist.githubusercontent.com/hyperlogic/857129fe04567cbe670f/raw/0c54500f480fd7314a5aeb147c45a8a707edcc2e/test.json");
     // NOTE: This will warn about missing "test01.fbx", "test02.fbx", etc. if the resource loading code doesn't handle relative pathnames!
-    // However, the test will proceed.
+    // However, the test will proceed.
     AnimNodeLoader loader(url);
 
     const int timeout = 1000;
@@ -238,3 +239,87 @@ void AnimTests::testVariant() {
     QVERIFY(m[1].z == -7.0f);
     QVERIFY(m[3].w == 16.0f);
 }
+
+void AnimTests::testAccumulateTime() {
+
+    float startFrame = 0.0f;
+    float endFrame = 10.0f;
+    float timeScale = 1.0f;
+    testAccumulateTimeWithParameters(startFrame, endFrame, timeScale);
+
+    startFrame = 5.0f;
+    endFrame = 15.0f;
+    timeScale = 1.0f;
+    testAccumulateTimeWithParameters(startFrame, endFrame, timeScale);
+
+    startFrame = 0.0f;
+    endFrame = 10.0f;
+    timeScale = 0.5f;
+    testAccumulateTimeWithParameters(startFrame, endFrame, timeScale);
+
+    startFrame = 5.0f;
+    endFrame = 15.0f;
+    timeScale = 2.0f;
+    testAccumulateTimeWithParameters(startFrame, endFrame, timeScale);
+}
+
+void AnimTests::testAccumulateTimeWithParameters(float startFrame, float endFrame, float timeScale) const {
+
+    float dt = (1.0f / 30.0f) / timeScale;  // sec
+    QString id = "testNode";
+    AnimNode::Triggers triggers;
+    bool loopFlag = false;
+
+    float resultFrame = accumulateTime(startFrame, endFrame, timeScale, startFrame, dt, loopFlag, id, triggers);
+    QVERIFY(resultFrame == startFrame + 1.0f);
+    QVERIFY(triggers.empty());
+    triggers.clear();
+
+    resultFrame = accumulateTime(startFrame, endFrame, timeScale, resultFrame, dt, loopFlag, id, triggers);
+    QVERIFY(resultFrame == startFrame + 2.0f);
+    QVERIFY(triggers.empty());
+    triggers.clear();
+
+    resultFrame = accumulateTime(startFrame, endFrame, timeScale, resultFrame, dt, loopFlag, id, triggers);
+    QVERIFY(resultFrame == startFrame + 3.0f);
+    QVERIFY(triggers.empty());
+    triggers.clear();
+
+    // test onDone trigger and frame clamping.
+    resultFrame = accumulateTime(startFrame, endFrame, timeScale, endFrame - 1.0f, dt, loopFlag, id, triggers);
+    QVERIFY(resultFrame == endFrame);
+    QVERIFY(!triggers.empty() && triggers[0] == "testNodeOnDone");
+    triggers.clear();
+
+    resultFrame = accumulateTime(startFrame, endFrame, timeScale, endFrame - 0.5f, dt, loopFlag, id, triggers);
+    QVERIFY(resultFrame == endFrame);
+    QVERIFY(!triggers.empty() && triggers[0] == "testNodeOnDone");
+    triggers.clear();
+
+    // test onLoop trigger and looping frame logic
+    loopFlag = true;
+
+    // should NOT trigger loop even though we stop at last frame, because there is an extra frame between end and start frames.
+    resultFrame = accumulateTime(startFrame, endFrame, timeScale, endFrame - 1.0f, dt, loopFlag, id, triggers);
+    QVERIFY(resultFrame == endFrame);
+    QVERIFY(triggers.empty());
+    triggers.clear();
+
+    // now we should hit loop trigger
+    resultFrame = accumulateTime(startFrame, endFrame, timeScale, resultFrame, dt, loopFlag, id, triggers);
+    QVERIFY(resultFrame == startFrame);
+    QVERIFY(!triggers.empty() && triggers[0] == "testNodeOnLoop");
+    triggers.clear();
+
+    // should NOT trigger loop, even though we move past the end frame, because of extra frame between end and start.
+    resultFrame = accumulateTime(startFrame, endFrame, timeScale, endFrame - 0.5f, dt, loopFlag, id, triggers);
+    QVERIFY(resultFrame == endFrame + 0.5f);
+    QVERIFY(triggers.empty());
+    triggers.clear();
+
+    // now we should hit loop trigger
+    resultFrame = accumulateTime(startFrame, endFrame, timeScale, resultFrame, dt, loopFlag, id, triggers);
+    QVERIFY(resultFrame == startFrame + 0.5f);
+    QVERIFY(!triggers.empty() && triggers[0] == "testNodeOnLoop");
+    triggers.clear();
+}

tests/animation/src/AnimTests.h

@@ -15,6 +15,8 @@
 
 class AnimTests : public QObject {
     Q_OBJECT
+public:
+    void testAccumulateTimeWithParameters(float startFrame, float endFrame, float timeScale) const;
 private slots:
     void initTestCase();
     void cleanupTestCase();
@@ -23,6 +25,7 @@ private slots:
     void testClipEvaulateWithVars();
     void testLoader();
     void testVariant();
+    void testAccumulateTime();
 };
 
 #endif // hifi_AnimTests_h