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