content/browser/android/edge_effect.cc

   1 // Copyright (c) 2013 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 "content/browser/android/edge_effect.h"
   6
   7 #include "cc/layers/layer.h"
   8 #include "ui/gfx/screen.h"
   9
  10 namespace content {
  11
  12 namespace {
  13
  14 enum State {
  15   STATE_IDLE = 0,
  16   STATE_PULL,
  17   STATE_ABSORB,
  18   STATE_RECEDE,
  19   STATE_PULL_DECAY
  20 };
  21
  22 // Time it will take the effect to fully recede in ms
  23 const int kRecedeTime = 1000;
  24
  25 // Time it will take before a pulled glow begins receding in ms
  26 const int kPullTime = 167;
  27
  28 // Time it will take in ms for a pulled glow to decay before release
  29 const int kPullDecayTime = 1000;
  30
  31 const float kMaxAlpha = 1.f;
  32 const float kHeldEdgeScaleY = .5f;
  33
  34 const float kMaxGlowHeight = 4.f;
  35
  36 const float kPullGlowBegin = 1.f;
  37 const float kPullEdgeBegin = 0.6f;
  38
  39 // Minimum velocity that will be absorbed
  40 const float kMinVelocity = 100.f;
  41
  42 const float kEpsilon = 0.001f;
  43
  44 // How much dragging should effect the height of the edge image.
  45 // Number determined by user testing.
  46 const int kPullDistanceEdgeFactor = 7;
  47
  48 // How much dragging should effect the height of the glow image.
  49 // Number determined by user testing.
  50 const int kPullDistanceGlowFactor = 7;
  51 const float kPullDistanceAlphaGlowFactor = 1.1f;
  52
  53 const int kVelocityEdgeFactor = 8;
  54 const int kVelocityGlowFactor = 16;
  55
  56 template <typename T>
  57 T Lerp(T a, T b, T t) {
  58   return a + (b - a) * t;
  59 }
  60
  61 template <typename T>
  62 T Clamp(T value, T low, T high) {
  63    return value < low ? low : (value > high ? high : value);
  64 }
  65
  66 template <typename T>
  67 T Damp(T input, T factor) {
  68   T result;
  69   if (factor == 1) {
  70     result = 1 - (1 - input) * (1 - input);
  71   } else {
  72     result = 1 - std::pow(1 - input, 2 * factor);
  73   }
  74   return result;
  75 }
  76
  77 gfx::Transform ComputeTransform(EdgeEffect::Edge edge,
  78                                 gfx::SizeF size, int height) {
  79   switch (edge) {
  80     default:
  81     case EdgeEffect::EDGE_TOP:
  82       return gfx::Transform(1, 0, 0, 1, 0, 0);
  83     case EdgeEffect::EDGE_LEFT:
  84       return gfx::Transform(0, 1, -1, 0,
  85                             (-size.width() + height) / 2 ,
  86                             (size.width() - height) / 2);
  87     case EdgeEffect::EDGE_BOTTOM:
  88       return gfx::Transform(-1, 0, 0, -1, 0, size.height() - height);
  89     case EdgeEffect::EDGE_RIGHT:
  90       return gfx::Transform(0, -1, 1, 0,
  91                             (-size.width() - height) / 2 + size.height(),
  92                             (size.width() - height) / 2);
  93   };
  94 }
  95
  96 void DisableLayer(cc::Layer* layer) {
  97   DCHECK(layer);
  98   layer->SetIsDrawable(false);
  99   layer->SetTransform(gfx::Transform());
 100   layer->SetOpacity(1.f);
 101 }
 102
 103 void UpdateLayer(cc::Layer* layer,
 104                  EdgeEffect::Edge edge,
 105                  gfx::SizeF size,
 106                  int height,
 107                  float opacity) {
 108   DCHECK(layer);
 109   layer->SetIsDrawable(true);
 110   layer->SetTransform(ComputeTransform(edge, size, height));
 111   layer->SetBounds(gfx::Size(size.width(), height));
 112   layer->SetOpacity(Clamp(opacity, 0.f, 1.f));
 113 }
 114
 115 } // namespace
 116
 117 EdgeEffect::EdgeEffect(scoped_refptr<cc::Layer> edge,
 118                        scoped_refptr<cc::Layer> glow)
 119   : edge_(edge)
 120   , glow_(glow)
 121   , edge_alpha_(0)
 122   , edge_scale_y_(0)
 123   , glow_alpha_(0)
 124   , glow_scale_y_(0)
 125   , edge_alpha_start_(0)
 126   , edge_alpha_finish_(0)
 127   , edge_scale_y_start_(0)
 128   , edge_scale_y_finish_(0)
 129   , glow_alpha_start_(0)
 130   , glow_alpha_finish_(0)
 131   , glow_scale_y_start_(0)
 132   , glow_scale_y_finish_(0)
 133   , state_(STATE_IDLE)
 134   , pull_distance_(0)
 135   , dpi_scale_(1) {
 136   // Prevent the provided layers from drawing until the effect is activated.
 137   DisableLayer(edge_.get());
 138   DisableLayer(glow_.get());
 139
 140   dpi_scale_ =
 141       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().device_scale_factor();
 142 }
 143
 144 EdgeEffect::~EdgeEffect() { }
 145
 146 bool EdgeEffect::IsFinished() const {
 147   return state_ == STATE_IDLE;
 148 }
 149
 150 void EdgeEffect::Finish() {
 151   DisableLayer(edge_.get());
 152   DisableLayer(glow_.get());
 153   pull_distance_ = 0;
 154   state_ = STATE_IDLE;
 155 }
 156
 157 void EdgeEffect::Pull(base::TimeTicks current_time, float delta_distance) {
 158   if (state_ == STATE_PULL_DECAY && current_time - start_time_ < duration_) {
 159     return;
 160   }
 161   if (state_ != STATE_PULL) {
 162     glow_scale_y_ = kPullGlowBegin;
 163   }
 164   state_ = STATE_PULL;
 165
 166   start_time_ = current_time;
 167   duration_ = base::TimeDelta::FromMilliseconds(kPullTime);
 168
 169   delta_distance *= dpi_scale_;
 170   float abs_delta_distance = std::abs(delta_distance);
 171   pull_distance_ += delta_distance;
 172   float distance = std::abs(pull_distance_);
 173
 174   edge_alpha_ = edge_alpha_start_ = Clamp(distance, kPullEdgeBegin, kMaxAlpha);
 175   edge_scale_y_ = edge_scale_y_start_
 176       = Clamp(distance * kPullDistanceEdgeFactor, kHeldEdgeScaleY, 1.f);
 177
 178   glow_alpha_ = glow_alpha_start_ =
 179       std::min(kMaxAlpha,
 180                glow_alpha_ + abs_delta_distance * kPullDistanceAlphaGlowFactor);
 181
 182   float glow_change = abs_delta_distance;
 183   if (delta_distance > 0 && pull_distance_ < 0)
 184     glow_change = -glow_change;
 185   if (pull_distance_ == 0)
 186     glow_scale_y_ = 0;
 187
 188   // Do not allow glow to get larger than kMaxGlowHeight.
 189   glow_scale_y_ = glow_scale_y_start_ =
 190       Clamp(glow_scale_y_ + glow_change * kPullDistanceGlowFactor,
 191             0.f, kMaxGlowHeight);
 192
 193   edge_alpha_finish_ = edge_alpha_;
 194   edge_scale_y_finish_ = edge_scale_y_;
 195   glow_alpha_finish_ = glow_alpha_;
 196   glow_scale_y_finish_ = glow_scale_y_;
 197 }
 198
 199 void EdgeEffect::Release(base::TimeTicks current_time) {
 200   pull_distance_ = 0;
 201
 202   if (state_ != STATE_PULL && state_ != STATE_PULL_DECAY)
 203     return;
 204
 205   state_ = STATE_RECEDE;
 206   edge_alpha_start_ = edge_alpha_;
 207   edge_scale_y_start_ = edge_scale_y_;
 208   glow_alpha_start_ = glow_alpha_;
 209   glow_scale_y_start_ = glow_scale_y_;
 210
 211   edge_alpha_finish_ = 0.f;
 212   edge_scale_y_finish_ = 0.f;
 213   glow_alpha_finish_ = 0.f;
 214   glow_scale_y_finish_ = 0.f;
 215
 216   start_time_ = current_time;
 217   duration_ = base::TimeDelta::FromMilliseconds(kRecedeTime);
 218 }
 219
 220 void EdgeEffect::Absorb(base::TimeTicks current_time, float velocity) {
 221   state_ = STATE_ABSORB;
 222   float scaled_velocity =
 223       dpi_scale_ * std::max(kMinVelocity, std::abs(velocity));
 224
 225   start_time_ = current_time;
 226   // This should never be less than 1 millisecond.
 227   duration_ = base::TimeDelta::FromMilliseconds(0.1f + (velocity * 0.03f));
 228
 229   // The edge should always be at least partially visible, regardless
 230   // of velocity.
 231   edge_alpha_start_ = 0.f;
 232   edge_scale_y_ = edge_scale_y_start_ = 0.f;
 233   // The glow depends more on the velocity, and therefore starts out
 234   // nearly invisible.
 235   glow_alpha_start_ = 0.5f;
 236   glow_scale_y_start_ = 0.f;
 237
 238   // Factor the velocity by 8. Testing on device shows this works best to
 239   // reflect the strength of the user's scrolling.
 240   edge_alpha_finish_ = Clamp(scaled_velocity * kVelocityEdgeFactor, 0.f, 1.f);
 241   // Edge should never get larger than the size of its asset.
 242   edge_scale_y_finish_ = Clamp(scaled_velocity * kVelocityEdgeFactor,
 243                                kHeldEdgeScaleY, 1.f);
 244
 245   // Growth for the size of the glow should be quadratic to properly
 246   // respond
 247   // to a user's scrolling speed. The faster the scrolling speed, the more
 248   // intense the effect should be for both the size and the saturation.
 249   glow_scale_y_finish_ = std::min(
 250       0.025f + (scaled_velocity * (scaled_velocity / 100) * 0.00015f), 1.75f);
 251   // Alpha should change for the glow as well as size.
 252   glow_alpha_finish_ = Clamp(glow_alpha_start_,
 253                              scaled_velocity * kVelocityGlowFactor * .00001f,
 254                              kMaxAlpha);
 255 }
 256
 257 bool EdgeEffect::Update(base::TimeTicks current_time) {
 258   if (IsFinished())
 259     return false;
 260
 261   const double dt = (current_time - start_time_).InMilliseconds();
 262   const double t = std::min(dt / duration_.InMilliseconds(), 1.);
 263   const float interp = static_cast<float>(Damp(t, 1.));
 264
 265   edge_alpha_ = Lerp(edge_alpha_start_, edge_alpha_finish_, interp);
 266   edge_scale_y_ = Lerp(edge_scale_y_start_, edge_scale_y_finish_, interp);
 267   glow_alpha_ = Lerp(glow_alpha_start_, glow_alpha_finish_, interp);
 268   glow_scale_y_ = Lerp(glow_scale_y_start_, glow_scale_y_finish_, interp);
 269
 270   if (t >= 1.f - kEpsilon) {
 271     switch (state_) {
 272       case STATE_ABSORB:
 273         state_ = STATE_RECEDE;
 274         start_time_ = current_time;
 275         duration_ = base::TimeDelta::FromMilliseconds(kRecedeTime);
 276
 277         edge_alpha_start_ = edge_alpha_;
 278         edge_scale_y_start_ = edge_scale_y_;
 279         glow_alpha_start_ = glow_alpha_;
 280         glow_scale_y_start_ = glow_scale_y_;
 281
 282         // After absorb, the glow and edge should fade to nothing.
 283         edge_alpha_finish_ = 0.f;
 284         edge_scale_y_finish_ = 0.f;
 285         glow_alpha_finish_ = 0.f;
 286         glow_scale_y_finish_ = 0.f;
 287         break;
 288       case STATE_PULL:
 289         state_ = STATE_PULL_DECAY;
 290         start_time_ = current_time;
 291         duration_ = base::TimeDelta::FromMilliseconds(kPullDecayTime);
 292
 293         edge_alpha_start_ = edge_alpha_;
 294         edge_scale_y_start_ = edge_scale_y_;
 295         glow_alpha_start_ = glow_alpha_;
 296         glow_scale_y_start_ = glow_scale_y_;
 297
 298         // After pull, the glow and edge should fade to nothing.
 299         edge_alpha_finish_ = 0.f;
 300         edge_scale_y_finish_ = 0.f;
 301         glow_alpha_finish_ = 0.f;
 302         glow_scale_y_finish_ = 0.f;
 303         break;
 304       case STATE_PULL_DECAY:
 305         {
 306           // When receding, we want edge to decrease more slowly
 307           // than the glow.
 308           float factor = glow_scale_y_finish_ != 0 ?
 309               1 / (glow_scale_y_finish_ * glow_scale_y_finish_) :
 310               std::numeric_limits<float>::max();
 311           edge_scale_y_ = edge_scale_y_start_ +
 312               (edge_scale_y_finish_ - edge_scale_y_start_) * interp * factor;
 313           state_ = STATE_RECEDE;
 314         }
 315         break;
 316       case STATE_RECEDE:
 317         Finish();
 318         break;
 319       default:
 320         break;
 321     }
 322   }
 323
 324   if (state_ == STATE_RECEDE && glow_scale_y_ <= 0 && edge_scale_y_ <= 0)
 325     Finish();
 326
 327   return !IsFinished();
 328 }
 329
 330 void EdgeEffect::ApplyToLayers(gfx::SizeF size, Edge edge) {
 331   if (IsFinished())
 332     return;
 333
 334   // An empty effect size, while meaningless, is also relatively harmless, and
 335   // will simply prevent any drawing of the layers.
 336   if (size.IsEmpty()) {
 337     DisableLayer(edge_.get());
 338     DisableLayer(glow_.get());
 339     return;
 340   }
 341
 342   float dummy_scale_x, dummy_scale_y;
 343
 344   // Glow
 345   gfx::Size glow_image_bounds;
 346   glow_->CalculateContentsScale(1.f, 1.f, 1.f, false,
 347                                 &dummy_scale_x, &dummy_scale_y,
 348                                 &glow_image_bounds);
 349   const int glow_height = glow_image_bounds.height();
 350   const int glow_width = glow_image_bounds.width();
 351   const int glow_bottom = static_cast<int>(std::min(
 352       glow_height * glow_scale_y_ * glow_height / glow_width * 0.6f,
 353       glow_height * kMaxGlowHeight) * dpi_scale_ + 0.5f);
 354   UpdateLayer(glow_.get(), edge, size, glow_bottom, glow_alpha_);
 355
 356   // Edge
 357   gfx::Size edge_image_bounds;
 358   edge_->CalculateContentsScale(1.f, 1.f, 1.f, false,
 359                                 &dummy_scale_x, &dummy_scale_y,
 360                                 &edge_image_bounds);
 361   const int edge_height = edge_image_bounds.height();
 362   const int edge_bottom = static_cast<int>(
 363       edge_height * edge_scale_y_ * dpi_scale_);
 364   UpdateLayer(edge_.get(), edge, size, edge_bottom, edge_alpha_);
 365 }
 366
 367 } // namespace content