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