1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CC_ANIMATION_ANIMATION_H_ 6 #define CC_ANIMATION_ANIMATION_H_ 7 8 #include "base/basictypes.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "cc/base/cc_export.h" 11 12 namespace cc { 13 14 class AnimationCurve; 15 16 // An Animation, contains all the state required to play an AnimationCurve. 17 // Specifically, the affected property, the run state (paused, finished, etc.), 18 // loop count, last pause time, and the total time spent paused. 19 class CC_EXPORT Animation { 20 public: 21 // Animations begin in one of the 'waiting' states. Animations waiting for the 22 // next tick will start the next time the controller animates. Animations 23 // waiting for target availibility will run as soon as their target property 24 // is free (and all the animations animating with it are also able to run). 25 // Animations waiting for their start time to come have be scheduled to run at 26 // a particular point in time. When this time arrives, the controller will 27 // move the animations into the Starting state, and then into the Running 28 // state. Running animations may toggle between Running and Paused, and may be 29 // stopped by moving into either the Aborted or Finished states. A Finished 30 // animation was allowed to run to completion, but an Aborted animation was 31 // not. 32 enum RunState { 33 WaitingForNextTick = 0, 34 WaitingForTargetAvailability, 35 WaitingForStartTime, 36 WaitingForDeletion, 37 Starting, 38 Running, 39 Paused, 40 Finished, 41 Aborted, 42 // This sentinel must be last. 43 RunStateEnumSize 44 }; 45 46 enum TargetProperty { 47 Transform = 0, 48 Opacity, 49 // This sentinel must be last. 50 TargetPropertyEnumSize 51 }; 52 53 static scoped_ptr<Animation> Create(scoped_ptr<AnimationCurve> curve, 54 int animation_id, 55 int group_id, 56 TargetProperty target_property); 57 58 virtual ~Animation(); 59 60 int id() const { return id_; } 61 int group() const { return group_; } 62 TargetProperty target_property() const { return target_property_; } 63 64 RunState run_state() const { return run_state_; } 65 void SetRunState(RunState run_state, double monotonic_time); 66 67 // This is the number of times that the animation will play. If this 68 // value is zero the animation will not play. If it is negative, then 69 // the animation will loop indefinitely. 70 int iterations() const { return iterations_; } 71 void set_iterations(int n) { iterations_ = n; } 72 73 double start_time() const { return start_time_; } 74 void set_start_time(double monotonic_time) { start_time_ = monotonic_time; } 75 bool has_set_start_time() const { return !!start_time_; } 76 77 double time_offset() const { return time_offset_; } 78 void set_time_offset(double monotonic_time) { time_offset_ = monotonic_time; } 79 80 void Suspend(double monotonic_time); 81 void Resume(double monotonic_time); 82 83 // If alternates_direction is true, on odd numbered iterations we reverse the 84 // curve. 85 bool alternates_direction() const { return alternates_direction_; } 86 void set_alternates_direction(bool alternates) { 87 alternates_direction_ = alternates; 88 } 89 90 bool IsFinishedAt(double monotonic_time) const; 91 bool is_finished() const { 92 return run_state_ == Finished || 93 run_state_ == Aborted || 94 run_state_ == WaitingForDeletion; 95 } 96 97 AnimationCurve* curve() { return curve_.get(); } 98 const AnimationCurve* curve() const { return curve_.get(); } 99 100 // If this is true, even if the animation is running, it will not be tickable 101 // until it is given a start time. This is true for animations running on the 102 // main thread. 103 bool needs_synchronized_start_time() const { 104 return needs_synchronized_start_time_; 105 } 106 void set_needs_synchronized_start_time(bool needs_synchronized_start_time) { 107 needs_synchronized_start_time_ = needs_synchronized_start_time; 108 } 109 110 // This is true for animations running on the main thread when the Finished 111 // event sent by the corresponding impl animation has been received. 112 bool received_finished_event() const { 113 return received_finished_event_; 114 } 115 void set_received_finished_event(bool received_finished_event) { 116 received_finished_event_ = received_finished_event; 117 } 118 119 // Takes the given absolute time, and using the start time and the number 120 // of iterations, returns the relative time in the current iteration. 121 double TrimTimeToCurrentIteration(double monotonic_time) const; 122 123 enum InstanceType { 124 ControllingInstance = 0, 125 NonControllingInstance 126 }; 127 128 scoped_ptr<Animation> Clone(InstanceType instance_type) const; 129 scoped_ptr<Animation> CloneAndInitialize(InstanceType instance_type, 130 RunState initial_run_state, 131 double start_time) const; 132 bool is_controlling_instance() const { return is_controlling_instance_; } 133 134 void PushPropertiesTo(Animation* other) const; 135 136 void set_is_impl_only(bool is_impl_only) { is_impl_only_ = is_impl_only; } 137 bool is_impl_only() const { return is_impl_only_; } 138 139 private: 140 Animation(scoped_ptr<AnimationCurve> curve, 141 int animation_id, 142 int group_id, 143 TargetProperty target_property); 144 145 scoped_ptr<AnimationCurve> curve_; 146 147 // IDs are not necessarily unique. 148 int id_; 149 150 // Animations that must be run together are called 'grouped' and have the same 151 // group id. Grouped animations are guaranteed to start at the same time and 152 // no other animations may animate any of the group's target properties until 153 // all animations in the group have finished animating. Note: an active 154 // animation's group id and target property uniquely identify that animation. 155 int group_; 156 157 TargetProperty target_property_; 158 RunState run_state_; 159 int iterations_; 160 double start_time_; 161 bool alternates_direction_; 162 163 // The time offset effectively pushes the start of the animation back in time. 164 // This is used for resuming paused animations -- an animation is added with a 165 // non-zero time offset, causing the animation to skip ahead to the desired 166 // point in time. 167 double time_offset_; 168 169 bool needs_synchronized_start_time_; 170 bool received_finished_event_; 171 172 // When an animation is suspended, it behaves as if it is paused and it also 173 // ignores all run state changes until it is resumed. This is used for testing 174 // purposes. 175 bool suspended_; 176 177 // These are used in TrimTimeToCurrentIteration to account for time 178 // spent while paused. This is not included in AnimationState since it 179 // there is absolutely no need for clients of this controller to know 180 // about these values. 181 double pause_time_; 182 double total_paused_time_; 183 184 // Animations lead dual lives. An active animation will be conceptually owned 185 // by two controllers, one on the impl thread and one on the main. In reality, 186 // there will be two separate Animation instances for the same animation. They 187 // will have the same group id and the same target property (these two values 188 // uniquely identify an animation). The instance on the impl thread is the 189 // instance that ultimately controls the values of the animating layer and so 190 // we will refer to it as the 'controlling instance'. 191 bool is_controlling_instance_; 192 193 bool is_impl_only_; 194 195 DISALLOW_COPY_AND_ASSIGN(Animation); 196 }; 197 198 } // namespace cc 199 200 #endif // CC_ANIMATION_ANIMATION_H_ 201