ui/gfx/animation/tween.cc

   1 // Copyright (c) 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 #include "ui/gfx/animation/tween.h"
   6
   7 #include <math.h>
   8
   9 #if defined(OS_WIN)
  10 #include <float.h>
  11 #endif
  12
  13 #include <algorithm>
  14
  15 #include "base/basictypes.h"
  16 #include "base/logging.h"
  17 #include "ui/gfx/geometry/cubic_bezier.h"
  18 #include "ui/gfx/safe_integer_conversions.h"
  19
  20 namespace gfx {
  21
  22 // static
  23 double Tween::CalculateValue(Tween::Type type, double state) {
  24   DCHECK_GE(state, 0);
  25   DCHECK_LE(state, 1);
  26
  27   switch (type) {
  28     case EASE_IN:
  29       return pow(state, 2);
  30
  31     case EASE_IN_2:
  32       return pow(state, 4);
  33
  34     case EASE_IN_OUT:
  35       if (state < 0.5)
  36         return pow(state * 2, 2) / 2.0;
  37       return 1.0 - (pow((state - 1.0) * 2, 2) / 2.0);
  38
  39     case FAST_IN_OUT:
  40       return (pow(state - 0.5, 3) + 0.125) / 0.25;
  41
  42     case LINEAR:
  43       return state;
  44
  45     case EASE_OUT_SNAP:
  46       state = 0.95 * (1.0 - pow(1.0 - state, 2));
  47       return state;
  48
  49     case EASE_OUT:
  50       return 1.0 - pow(1.0 - state, 2);
  51
  52     case SMOOTH_IN_OUT:
  53       return sin(state);
  54
  55     case FAST_OUT_SLOW_IN:
  56       return gfx::CubicBezier(0.4, 0, 0.2, 1).Solve(state);
  57
  58     case LINEAR_OUT_SLOW_IN:
  59       return gfx::CubicBezier(0, 0, .2, 1).Solve(state);
  60
  61     case FAST_OUT_LINEAR_IN:
  62       return gfx::CubicBezier(0.4, 0, 1, 1).Solve(state);
  63
  64     case ZERO:
  65       return 0;
  66   }
  67
  68   NOTREACHED();
  69   return state;
  70 }
  71
  72 namespace {
  73 uint8 FloatToColorByte(float f) {
  74   return std::min(std::max(ToRoundedInt(f * 255.f), 0), 255);
  75 }
  76
  77 uint8 BlendColorComponents(uint8 start,
  78                            uint8 target,
  79                            float start_alpha,
  80                            float target_alpha,
  81                            float blended_alpha,
  82                            double progress) {
  83   // Since progress can be outside [0, 1], blending can produce a value outside
  84   // [0, 255].
  85   float blended_premultiplied = Tween::FloatValueBetween(
  86       progress, start / 255.f * start_alpha, target / 255.f * target_alpha);
  87   return FloatToColorByte(blended_premultiplied / blended_alpha);
  88 }
  89
  90 }  // namespace
  91
  92 // static
  93 SkColor Tween::ColorValueBetween(double value, SkColor start, SkColor target) {
  94   float start_a = SkColorGetA(start) / 255.f;
  95   float target_a = SkColorGetA(target) / 255.f;
  96   float blended_a = FloatValueBetween(value, start_a, target_a);
  97   if (blended_a <= 0.f)
  98     return SkColorSetARGB(0, 0, 0, 0);
  99   blended_a = std::min(blended_a, 1.f);
 100
 101   uint8 blended_r = BlendColorComponents(SkColorGetR(start),
 102                                          SkColorGetR(target),
 103                                          start_a,
 104                                          target_a,
 105                                          blended_a,
 106                                          value);
 107   uint8 blended_g = BlendColorComponents(SkColorGetG(start),
 108                                          SkColorGetG(target),
 109                                          start_a,
 110                                          target_a,
 111                                          blended_a,
 112                                          value);
 113   uint8 blended_b = BlendColorComponents(SkColorGetB(start),
 114                                          SkColorGetB(target),
 115                                          start_a,
 116                                          target_a,
 117                                          blended_a,
 118                                          value);
 119
 120   return SkColorSetARGB(
 121       FloatToColorByte(blended_a), blended_r, blended_g, blended_b);
 122 }
 123
 124 // static
 125 double Tween::DoubleValueBetween(double value, double start, double target) {
 126   return start + (target - start) * value;
 127 }
 128
 129 // static
 130 float Tween::FloatValueBetween(double value, float start, float target) {
 131   return static_cast<float>(start + (target - start) * value);
 132 }
 133
 134 // static
 135 int Tween::IntValueBetween(double value, int start, int target) {
 136   if (start == target)
 137     return start;
 138   double delta = static_cast<double>(target - start);
 139   if (delta < 0)
 140     delta--;
 141   else
 142     delta++;
 143 #if defined(OS_WIN)
 144   return start + static_cast<int>(value * _nextafter(delta, 0));
 145 #else
 146   return start + static_cast<int>(value * nextafter(delta, 0));
 147 #endif
 148 }
 149
 150 //static
 151 int Tween::LinearIntValueBetween(double value, int start, int target) {
 152   return std::floor(0.5 + DoubleValueBetween(value, start, target));
 153 }
 154
 155 // static
 156 gfx::Rect Tween::RectValueBetween(double value,
 157                                   const gfx::Rect& start_bounds,
 158                                   const gfx::Rect& target_bounds) {
 159   return gfx::Rect(
 160       LinearIntValueBetween(value, start_bounds.x(), target_bounds.x()),
 161       LinearIntValueBetween(value, start_bounds.y(), target_bounds.y()),
 162       LinearIntValueBetween(value, start_bounds.width(), target_bounds.width()),
 163       LinearIntValueBetween(
 164           value, start_bounds.height(), target_bounds.height()));
 165 }
 166
 167 // static
 168 gfx::Transform Tween::TransformValueBetween(
 169     double value,
 170     const gfx::Transform& start_transform,
 171     const gfx::Transform& end_transform) {
 172   if (value >= 1.0)
 173     return end_transform;
 174   if (value <= 0.0)
 175     return start_transform;
 176
 177   gfx::Transform to_return = end_transform;
 178   to_return.Blend(start_transform, value);
 179
 180   return to_return;
 181 }
 182
 183 }  // namespace gfx