| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "content/browser/android/edge_effect.h" |
| |
| #include "cc/layers/layer.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| enum State { |
| STATE_IDLE = 0, |
| STATE_PULL, |
| STATE_ABSORB, |
| STATE_RECEDE, |
| STATE_PULL_DECAY |
| }; |
| |
| // Time it will take the effect to fully recede in ms |
| const int kRecedeTime = 1000; |
| |
| // Time it will take before a pulled glow begins receding in ms |
| const int kPullTime = 167; |
| |
| // Time it will take in ms for a pulled glow to decay before release |
| const int kPullDecayTime = 1000; |
| |
| const float kMaxAlpha = 1.f; |
| const float kHeldEdgeScaleY = .5f; |
| |
| const float kMaxGlowHeight = 4.f; |
| |
| const float kPullGlowBegin = 1.f; |
| const float kPullEdgeBegin = 0.6f; |
| |
| // Min/max velocity that will be absorbed |
| const float kMinVelocity = 100.f; |
| const float kMaxVelocity = 10000.f; |
| |
| const float kEpsilon = 0.001f; |
| |
| const float kGlowHeightToWidthRatio = 0.25f; |
| |
| // How much dragging should effect the height of the edge image. |
| // Number determined by user testing. |
| const int kPullDistanceEdgeFactor = 7; |
| |
| // How much dragging should effect the height of the glow image. |
| // Number determined by user testing. |
| const int kPullDistanceGlowFactor = 7; |
| const float kPullDistanceAlphaGlowFactor = 1.1f; |
| |
| const int kVelocityEdgeFactor = 8; |
| const int kVelocityGlowFactor = 12; |
| |
| template <typename T> |
| T Lerp(T a, T b, T t) { |
| return a + (b - a) * t; |
| } |
| |
| template <typename T> |
| T Clamp(T value, T low, T high) { |
| return value < low ? low : (value > high ? high : value); |
| } |
| |
| template <typename T> |
| T Damp(T input, T factor) { |
| T result; |
| if (factor == 1) { |
| result = 1 - (1 - input) * (1 - input); |
| } else { |
| result = 1 - std::pow(1 - input, 2 * factor); |
| } |
| return result; |
| } |
| |
| gfx::Transform ComputeTransform(EdgeEffect::Edge edge, |
| const gfx::SizeF& window_size, |
| int offset, |
| int height) { |
| // Edge effects that require rotation are translated to the center about which |
| // the layer should be rotated to align with the corresponding edge. |
| switch (edge) { |
| case EdgeEffect::EDGE_TOP: |
| return gfx::Transform(1, 0, 0, 1, 0, offset); |
| case EdgeEffect::EDGE_LEFT: |
| return gfx::Transform(0, 1, -1, 0, |
| (-window_size.height() + height) / 2.f + offset, |
| (window_size.height() - height) / 2.f); |
| case EdgeEffect::EDGE_BOTTOM: |
| return gfx::Transform(-1, 0, 0, -1, |
| 0, window_size.height() - height + offset); |
| case EdgeEffect::EDGE_RIGHT: |
| return gfx::Transform(0, -1, 1, 0, |
| (-window_size.height() - height) / 2.f + window_size.width() + offset, |
| (window_size.height() - height) / 2.f); |
| default: |
| NOTREACHED() << "Invalid edge: " << edge; |
| return gfx::Transform(); |
| }; |
| } |
| |
| gfx::Size ComputeBounds(EdgeEffect::Edge edge, |
| const gfx::SizeF& window_size, |
| int height) { |
| switch (edge) { |
| case EdgeEffect::EDGE_TOP: |
| case EdgeEffect::EDGE_BOTTOM: |
| return gfx::Size(window_size.width(), height); |
| case EdgeEffect::EDGE_LEFT: |
| case EdgeEffect::EDGE_RIGHT: |
| return gfx::Size(window_size.height(), height); |
| default: |
| NOTREACHED() << "Invalid edge: " << edge; |
| return gfx::Size(); |
| }; |
| } |
| |
| void DisableLayer(cc::Layer* layer) { |
| DCHECK(layer); |
| layer->SetIsDrawable(false); |
| layer->SetTransform(gfx::Transform()); |
| layer->SetOpacity(1.f); |
| } |
| |
| void UpdateLayer(cc::Layer* layer, |
| EdgeEffect::Edge edge, |
| const gfx::SizeF& window_size, |
| int offset, |
| int height, |
| float opacity) { |
| DCHECK(layer); |
| layer->SetIsDrawable(true); |
| gfx::Size bounds = ComputeBounds(edge, window_size, height); |
| layer->SetTransformOrigin( |
| gfx::Point3F(bounds.width() * 0.5f, bounds.height() * 0.5f, 0)); |
| layer->SetTransform(ComputeTransform(edge, window_size, offset, height)); |
| layer->SetBounds(bounds); |
| layer->SetOpacity(Clamp(opacity, 0.f, 1.f)); |
| } |
| |
| } // namespace |
| |
| EdgeEffect::EdgeEffect(scoped_refptr<cc::Layer> edge, |
| scoped_refptr<cc::Layer> glow) |
| : edge_(edge) |
| , glow_(glow) |
| , edge_alpha_(0) |
| , edge_scale_y_(0) |
| , glow_alpha_(0) |
| , glow_scale_y_(0) |
| , edge_alpha_start_(0) |
| , edge_alpha_finish_(0) |
| , edge_scale_y_start_(0) |
| , edge_scale_y_finish_(0) |
| , glow_alpha_start_(0) |
| , glow_alpha_finish_(0) |
| , glow_scale_y_start_(0) |
| , glow_scale_y_finish_(0) |
| , state_(STATE_IDLE) |
| , pull_distance_(0) { |
| // Prevent the provided layers from drawing until the effect is activated. |
| DisableLayer(edge_.get()); |
| DisableLayer(glow_.get()); |
| } |
| |
| EdgeEffect::~EdgeEffect() { } |
| |
| bool EdgeEffect::IsFinished() const { |
| return state_ == STATE_IDLE; |
| } |
| |
| void EdgeEffect::Finish() { |
| DisableLayer(edge_.get()); |
| DisableLayer(glow_.get()); |
| pull_distance_ = 0; |
| state_ = STATE_IDLE; |
| } |
| |
| void EdgeEffect::Pull(base::TimeTicks current_time, float delta_distance) { |
| if (state_ == STATE_PULL_DECAY && current_time - start_time_ < duration_) { |
| return; |
| } |
| if (state_ != STATE_PULL) { |
| glow_scale_y_ = kPullGlowBegin; |
| } |
| state_ = STATE_PULL; |
| |
| start_time_ = current_time; |
| duration_ = base::TimeDelta::FromMilliseconds(kPullTime); |
| |
| float abs_delta_distance = std::abs(delta_distance); |
| pull_distance_ += delta_distance; |
| float distance = std::abs(pull_distance_); |
| |
| edge_alpha_ = edge_alpha_start_ = Clamp(distance, kPullEdgeBegin, kMaxAlpha); |
| edge_scale_y_ = edge_scale_y_start_ |
| = Clamp(distance * kPullDistanceEdgeFactor, kHeldEdgeScaleY, 1.f); |
| |
| glow_alpha_ = glow_alpha_start_ = |
| std::min(kMaxAlpha, |
| glow_alpha_ + abs_delta_distance * kPullDistanceAlphaGlowFactor); |
| |
| float glow_change = abs_delta_distance; |
| if (delta_distance > 0 && pull_distance_ < 0) |
| glow_change = -glow_change; |
| if (pull_distance_ == 0) |
| glow_scale_y_ = 0; |
| |
| // Do not allow glow to get larger than kMaxGlowHeight. |
| glow_scale_y_ = glow_scale_y_start_ = |
| Clamp(glow_scale_y_ + glow_change * kPullDistanceGlowFactor, |
| 0.f, kMaxGlowHeight); |
| |
| edge_alpha_finish_ = edge_alpha_; |
| edge_scale_y_finish_ = edge_scale_y_; |
| glow_alpha_finish_ = glow_alpha_; |
| glow_scale_y_finish_ = glow_scale_y_; |
| } |
| |
| void EdgeEffect::Release(base::TimeTicks current_time) { |
| pull_distance_ = 0; |
| |
| if (state_ != STATE_PULL && state_ != STATE_PULL_DECAY) |
| return; |
| |
| state_ = STATE_RECEDE; |
| edge_alpha_start_ = edge_alpha_; |
| edge_scale_y_start_ = edge_scale_y_; |
| glow_alpha_start_ = glow_alpha_; |
| glow_scale_y_start_ = glow_scale_y_; |
| |
| edge_alpha_finish_ = 0.f; |
| edge_scale_y_finish_ = 0.f; |
| glow_alpha_finish_ = 0.f; |
| glow_scale_y_finish_ = 0.f; |
| |
| start_time_ = current_time; |
| duration_ = base::TimeDelta::FromMilliseconds(kRecedeTime); |
| } |
| |
| void EdgeEffect::Absorb(base::TimeTicks current_time, float velocity) { |
| state_ = STATE_ABSORB; |
| velocity = Clamp(std::abs(velocity), kMinVelocity, kMaxVelocity); |
| |
| start_time_ = current_time; |
| // This should never be less than 1 millisecond. |
| duration_ = base::TimeDelta::FromMilliseconds(0.15f + (velocity * 0.02f)); |
| |
| // The edge should always be at least partially visible, regardless |
| // of velocity. |
| edge_alpha_start_ = 0.f; |
| edge_scale_y_ = edge_scale_y_start_ = 0.f; |
| // The glow depends more on the velocity, and therefore starts out |
| // nearly invisible. |
| glow_alpha_start_ = 0.3f; |
| glow_scale_y_start_ = 0.f; |
| |
| // Factor the velocity by 8. Testing on device shows this works best to |
| // reflect the strength of the user's scrolling. |
| edge_alpha_finish_ = Clamp(velocity * kVelocityEdgeFactor, 0.f, 1.f); |
| // Edge should never get larger than the size of its asset. |
| edge_scale_y_finish_ = Clamp(velocity * kVelocityEdgeFactor, |
| kHeldEdgeScaleY, 1.f); |
| |
| // Growth for the size of the glow should be quadratic to properly |
| // respond |
| // to a user's scrolling speed. The faster the scrolling speed, the more |
| // intense the effect should be for both the size and the saturation. |
| glow_scale_y_finish_ = std::min( |
| 0.025f + (velocity * (velocity / 100) * 0.00015f), 1.75f); |
| // Alpha should change for the glow as well as size. |
| glow_alpha_finish_ = Clamp(glow_alpha_start_, |
| velocity * kVelocityGlowFactor * .00001f, |
| kMaxAlpha); |
| } |
| |
| bool EdgeEffect::Update(base::TimeTicks current_time) { |
| if (IsFinished()) |
| return false; |
| |
| const double dt = (current_time - start_time_).InMilliseconds(); |
| const double t = std::min(dt / duration_.InMilliseconds(), 1.); |
| const float interp = static_cast<float>(Damp(t, 1.)); |
| |
| edge_alpha_ = Lerp(edge_alpha_start_, edge_alpha_finish_, interp); |
| edge_scale_y_ = Lerp(edge_scale_y_start_, edge_scale_y_finish_, interp); |
| glow_alpha_ = Lerp(glow_alpha_start_, glow_alpha_finish_, interp); |
| glow_scale_y_ = Lerp(glow_scale_y_start_, glow_scale_y_finish_, interp); |
| |
| if (t >= 1.f - kEpsilon) { |
| switch (state_) { |
| case STATE_ABSORB: |
| state_ = STATE_RECEDE; |
| start_time_ = current_time; |
| duration_ = base::TimeDelta::FromMilliseconds(kRecedeTime); |
| |
| edge_alpha_start_ = edge_alpha_; |
| edge_scale_y_start_ = edge_scale_y_; |
| glow_alpha_start_ = glow_alpha_; |
| glow_scale_y_start_ = glow_scale_y_; |
| |
| // After absorb, the glow and edge should fade to nothing. |
| edge_alpha_finish_ = 0.f; |
| edge_scale_y_finish_ = 0.f; |
| glow_alpha_finish_ = 0.f; |
| glow_scale_y_finish_ = 0.f; |
| break; |
| case STATE_PULL: |
| state_ = STATE_PULL_DECAY; |
| start_time_ = current_time; |
| duration_ = base::TimeDelta::FromMilliseconds(kPullDecayTime); |
| |
| edge_alpha_start_ = edge_alpha_; |
| edge_scale_y_start_ = edge_scale_y_; |
| glow_alpha_start_ = glow_alpha_; |
| glow_scale_y_start_ = glow_scale_y_; |
| |
| // After pull, the glow and edge should fade to nothing. |
| edge_alpha_finish_ = 0.f; |
| edge_scale_y_finish_ = 0.f; |
| glow_alpha_finish_ = 0.f; |
| glow_scale_y_finish_ = 0.f; |
| break; |
| case STATE_PULL_DECAY: { |
| // When receding, we want edge to decrease more slowly |
| // than the glow. |
| const float factor = glow_scale_y_finish_ != 0 ? |
| 1 / (glow_scale_y_finish_ * glow_scale_y_finish_) : |
| std::numeric_limits<float>::max(); |
| edge_scale_y_ = edge_scale_y_start_ + |
| (edge_scale_y_finish_ - edge_scale_y_start_) * interp * factor; |
| state_ = STATE_RECEDE; |
| } break; |
| case STATE_RECEDE: |
| Finish(); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| if (state_ == STATE_RECEDE && glow_scale_y_ <= 0 && edge_scale_y_ <= 0) |
| Finish(); |
| |
| return !IsFinished(); |
| } |
| |
| void EdgeEffect::ApplyToLayers(gfx::SizeF window_size, |
| Edge edge, |
| float edge_height, |
| float glow_height, |
| float offset) { |
| if (IsFinished()) |
| return; |
| |
| // An empty window size, while meaningless, is also relatively harmless, and |
| // will simply prevent any drawing of the layers. |
| if (window_size.IsEmpty()) { |
| DisableLayer(edge_.get()); |
| DisableLayer(glow_.get()); |
| return; |
| } |
| |
| // Glow |
| const int scaled_glow_height = static_cast<int>( |
| std::min(glow_height * glow_scale_y_ * kGlowHeightToWidthRatio * 0.6f, |
| glow_height * kMaxGlowHeight) + 0.5f); |
| UpdateLayer( |
| glow_.get(), edge, window_size, offset, scaled_glow_height, glow_alpha_); |
| |
| // Edge |
| const int scaled_edge_height = static_cast<int>(edge_height * edge_scale_y_); |
| UpdateLayer( |
| edge_.get(), edge, window_size, offset, scaled_edge_height, edge_alpha_); |
| } |
| |
| } // namespace content |