| /* |
| * Copyright 2015 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "include/core/SkScalar.h" |
| #include "src/base/SkTime.h" |
| |
| #ifndef AnimTimer_DEFINED |
| #define AnimTimer_DEFINED |
| |
| /** |
| * Class to track a "timer". It supports 3 states: stopped, paused, and running. |
| * Playback speed is variable. |
| * |
| * The caller must call updateTime() to resync with the clock (typically just before |
| * using the timer). Forcing the caller to do this ensures that the timer's return values |
| * are consistent if called repeatedly, as they only reflect the time since the last |
| * calle to updateTimer(). |
| */ |
| class AnimTimer { |
| public: |
| /** |
| * Class begins in the "stopped" state. |
| */ |
| AnimTimer() {} |
| |
| enum State { kStopped_State, kPaused_State, kRunning_State }; |
| |
| State state() const { return fState; } |
| |
| double nanos() const { return fElapsedNanos; } |
| |
| /** |
| * Control the rate at which time advances. |
| */ |
| float getSpeed() const { return fSpeed; } |
| void setSpeed(float speed) { fSpeed = speed; } |
| |
| /** |
| * If the timer is paused or stopped, it will resume (or start if it was stopped). |
| */ |
| void run() { |
| switch (this->state()) { |
| case kStopped_State: |
| fPreviousNanos = SkTime::GetNSecs(); |
| fElapsedNanos = 0; |
| break; |
| case kPaused_State: // they want "resume" |
| fPreviousNanos = SkTime::GetNSecs(); |
| break; |
| case kRunning_State: break; |
| } |
| fState = kRunning_State; |
| } |
| |
| void pause() { |
| if (kRunning_State == this->state()) { |
| fState = kPaused_State; |
| } // else stay stopped or paused |
| } |
| |
| /** |
| * If the timer is stopped, start running, else it toggles between paused and running. |
| */ |
| void togglePauseResume() { |
| if (kRunning_State == this->state()) { |
| this->pause(); |
| } else { |
| this->run(); |
| } |
| } |
| |
| /** |
| * Call this each time you want to sample the clock for the timer. This is NOT done |
| * automatically, so that repeated calls to msec() or secs() will always return the |
| * same value. |
| * |
| * This may safely be called with the timer in any state. |
| */ |
| void updateTime() { |
| if (kRunning_State == this->state()) { |
| double now = SkTime::GetNSecs(); |
| fElapsedNanos += (now - fPreviousNanos) * fSpeed; |
| fPreviousNanos = now; |
| } |
| } |
| |
| private: |
| double fPreviousNanos = 0; |
| double fElapsedNanos = 0; |
| float fSpeed = 1; |
| State fState = kStopped_State; |
| }; |
| |
| #endif |