sepearate looping logic from AnimationHandle

libraries/animation/src/AnimationLoop.cpp

@@ -0,0 +1,95 @@
+//
+//  AnimationLoop.cpp
+//  libraries/animation
+//
+//  Created by Brad Hefta-Gaub on 11/12/14.
+//  Copyright (c) 2014 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 "AnimationCache.h"
+#include "AnimationLoop.h"
+
+AnimationLoop::AnimationLoop() :
+    _fps(30.0f),
+    _loop(false),
+    _hold(false),
+    _startAutomatically(false),
+    _firstFrame(0.0f),
+    _lastFrame(FLT_MAX),
+    _running(false),
+    _frameIndex(0.0f)
+{
+}
+
+AnimationLoop::AnimationLoop(const AnimationDetails& animationDetails) :
+    _fps(animationDetails.fps),
+    _loop(animationDetails.loop),
+    _hold(animationDetails.hold),
+    _startAutomatically(animationDetails.startAutomatically),
+    _firstFrame(animationDetails.firstFrame),
+    _lastFrame(animationDetails.lastFrame),
+    _running(animationDetails.running),
+    _frameIndex(animationDetails.frameIndex)
+{
+}
+
+AnimationLoop::AnimationLoop(float fps, bool loop, bool hold, bool startAutomatically, float firstFrame, 
+                    float lastFrame, bool running, float frameIndex) :
+    _fps(fps),
+    _loop(loop),
+    _hold(hold),
+    _startAutomatically(startAutomatically),
+    _firstFrame(firstFrame),
+    _lastFrame(lastFrame),
+    _running(running),
+    _frameIndex(frameIndex)
+{
+}
+
+void AnimationLoop::simulate(float deltaTime) {
+    _frameIndex += deltaTime * _fps;
+
+    
+    // If we knew the number of frames from the animation, we'd consider using it here 
+    // animationGeometry.animationFrames.size()
+    float maxFrame = _lastFrame; 
+    float endFrameIndex = qMin(_lastFrame, maxFrame - (_loop ? 0.0f : 1.0f));
+    float startFrameIndex = qMin(_firstFrame, endFrameIndex);
+    if ((!_loop && (_frameIndex < startFrameIndex || _frameIndex > endFrameIndex)) || startFrameIndex == endFrameIndex) {
+        // passed the end; apply the last frame
+        _frameIndex = glm::clamp(_frameIndex, startFrameIndex, endFrameIndex);
+        if (!_hold) {
+            stop();
+        }
+    } else {
+        // wrap within the the desired range
+        if (_frameIndex < startFrameIndex) {
+            _frameIndex = endFrameIndex - glm::mod(endFrameIndex - _frameIndex, endFrameIndex - startFrameIndex);
+    
+        } else if (_frameIndex > endFrameIndex) {
+            _frameIndex = startFrameIndex + glm::mod(_frameIndex - startFrameIndex, endFrameIndex - startFrameIndex);
+        }
+    }
+}
+
+void AnimationLoop::setStartAutomatically(bool startAutomatically) {
+    if ((_startAutomatically = startAutomatically) && !isRunning()) {
+        start();
+    }
+}
+    
+void AnimationLoop::setRunning(bool running) {
+    if (_running == running) {
+        if (running) {
+            // move back to the beginning
+            _frameIndex = _firstFrame;
+        }
+        return;
+    }
+    if ((_running = running)) {
+        _frameIndex = _firstFrame;
+    }
+}

libraries/animation/src/AnimationLoop.h

@@ -0,0 +1,63 @@
+//
+//  AnimationLoop.h
+//  libraries/script-engine/src/
+//
+//  Created by Brad Hefta-Gaub on 11/12/14.
+//  Copyright (c) 2014 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_AnimationLoop_h
+#define hifi_AnimationLoop_h
+
+class AnimationDetails;
+
+class AnimationLoop {
+public:
+    AnimationLoop();
+    AnimationLoop(const AnimationDetails& animationDetails);
+    AnimationLoop(float fps, bool loop, bool hold, bool startAutomatically, float firstFrame, 
+                    float lastFrame, bool running, float frameIndex);
+
+    void setFPS(float fps) { _fps = fps; }
+    float getFPS() const { return _fps; }
+
+    void setLoop(bool loop) { _loop = loop; }
+    bool getLoop() const { return _loop; }
+    
+    void setHold(bool hold) { _hold = hold; }
+    bool getHold() const { return _hold; }
+    
+    void setStartAutomatically(bool startAutomatically);
+    bool getStartAutomatically() const { return _startAutomatically; }
+    
+    void setFirstFrame(float firstFrame) { _firstFrame = firstFrame; }
+    float getFirstFrame() const { return _firstFrame; }
+    
+    void setLastFrame(float lastFrame) { _lastFrame = lastFrame; }
+    float getLastFrame() const { return _lastFrame; }
+    
+    void setRunning(bool running);
+    bool isRunning() const { return _running; }
+
+    void setFrameIndex(float frameIndex) { _frameIndex = glm::clamp(_frameIndex, _firstFrame, _lastFrame); }
+    float getFrameIndex() const { return _frameIndex; }
+    
+    void start() { setRunning(true); }
+    void stop() { setRunning(false); }
+    void simulate(float deltaTime);
+    
+private:
+    float _fps;
+    bool _loop;
+    bool _hold;
+    bool _startAutomatically;
+    float _firstFrame;
+    float _lastFrame;
+    bool _running;
+    float _frameIndex;
+};
+
+#endif // hifi_AnimationLoop_h