| // 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 "ui/android/edge_effect.h" |
| |
| #include "base/macros.h" |
| #include "cc/layers/layer.h" |
| #include "cc/layers/ui_resource_layer.h" |
| #include "ui/android/animation_utils.h" |
| #include "ui/android/resources/resource_manager.h" |
| #include "ui/android/resources/system_ui_resource_type.h" |
| #include "ui/android/window_android_compositor.h" |
| |
| namespace ui { |
| |
| namespace { |
| |
| const ui::SystemUIResourceType kEdgeResourceId = ui::OVERSCROLL_EDGE; |
| const ui::SystemUIResourceType kGlowResourceId = ui::OVERSCROLL_GLOW; |
| |
| // Time it will take the effect to fully recede in ms |
| const int kRecedeTimeMs = 1000; |
| |
| // Time it will take before a pulled glow begins receding in ms |
| const int kPullTimeMs = 167; |
| |
| // Time it will take in ms for a pulled glow to decay before release |
| const int kPullDecayTimeMs = 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 kGlowHeightWidthRatio = 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; |
| |
| const float kEdgeHeightAtMdpi = 12.f; |
| const float kGlowHeightAtMdpi = 128.f; |
| |
| } // namespace |
| |
| class EdgeEffect::EffectLayer { |
| public: |
| EffectLayer(ui::SystemUIResourceType resource_type, |
| ui::ResourceManager* resource_manager) |
| : ui_resource_layer_(cc::UIResourceLayer::Create()), |
| resource_type_(resource_type), |
| resource_manager_(resource_manager) {} |
| |
| ~EffectLayer() { ui_resource_layer_->RemoveFromParent(); } |
| |
| void SetParent(cc::Layer* parent) { |
| if (ui_resource_layer_->parent() != parent) |
| parent->AddChild(ui_resource_layer_); |
| } |
| |
| void Disable() { ui_resource_layer_->SetIsDrawable(false); } |
| |
| void Update(const gfx::Size& size, |
| const gfx::Transform& transform, |
| float opacity) { |
| ui_resource_layer_->SetUIResourceId(resource_manager_->GetUIResourceId( |
| ui::ANDROID_RESOURCE_TYPE_SYSTEM, resource_type_)); |
| ui_resource_layer_->SetIsDrawable(true); |
| ui_resource_layer_->SetTransformOrigin( |
| gfx::Point3F(size.width() * 0.5f, 0, 0)); |
| ui_resource_layer_->SetTransform(transform); |
| ui_resource_layer_->SetBounds(size); |
| ui_resource_layer_->SetOpacity(Clamp(opacity, 0.f, 1.f)); |
| } |
| |
| scoped_refptr<cc::UIResourceLayer> ui_resource_layer_; |
| ui::SystemUIResourceType resource_type_; |
| ui::ResourceManager* resource_manager_; |
| |
| DISALLOW_COPY_AND_ASSIGN(EffectLayer); |
| }; |
| |
| EdgeEffect::EdgeEffect(ui::ResourceManager* resource_manager, |
| float device_scale_factor) |
| : edge_(new EffectLayer(kEdgeResourceId, resource_manager)), |
| glow_(new EffectLayer(kGlowResourceId, resource_manager)), |
| base_edge_height_(kEdgeHeightAtMdpi * device_scale_factor), |
| base_glow_height_(kGlowHeightAtMdpi * device_scale_factor), |
| 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) { |
| } |
| |
| EdgeEffect::~EdgeEffect() { |
| } |
| |
| bool EdgeEffect::IsFinished() const { |
| return state_ == STATE_IDLE; |
| } |
| |
| void EdgeEffect::Finish() { |
| edge_->Disable(); |
| glow_->Disable(); |
| pull_distance_ = 0; |
| state_ = STATE_IDLE; |
| } |
| |
| void EdgeEffect::Pull(base::TimeTicks current_time, |
| float delta_distance, |
| float displacement) { |
| 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(kPullTimeMs); |
| |
| 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(kRecedeTimeMs); |
| } |
| |
| 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(kRecedeTimeMs); |
| |
| 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(kPullDecayTimeMs); |
| |
| 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_ |
| ? 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(); |
| } |
| |
| float EdgeEffect::GetAlpha() const { |
| return IsFinished() ? 0.f : std::max(glow_alpha_, edge_alpha_); |
| } |
| |
| void EdgeEffect::ApplyToLayers(Edge edge, |
| const gfx::SizeF& viewport_size, |
| 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 (viewport_size.IsEmpty()) { |
| edge_->Disable(); |
| glow_->Disable(); |
| return; |
| } |
| |
| gfx::SizeF size = ComputeOrientedSize(edge, viewport_size); |
| gfx::Transform transform = ComputeTransform(edge, viewport_size, offset); |
| |
| // Glow |
| const int scaled_glow_height = static_cast<int>( |
| std::min(base_glow_height_ * glow_scale_y_ * kGlowHeightWidthRatio * 0.6f, |
| base_glow_height_ * kMaxGlowHeight) + |
| 0.5f); |
| const gfx::Size glow_size(size.width(), scaled_glow_height); |
| glow_->Update(glow_size, transform, glow_alpha_); |
| |
| // Edge |
| const int scaled_edge_height = |
| static_cast<int>(base_edge_height_ * edge_scale_y_); |
| const gfx::Size edge_size(size.width(), scaled_edge_height); |
| edge_->Update(edge_size, transform, edge_alpha_); |
| } |
| |
| void EdgeEffect::SetParent(cc::Layer* parent) { |
| edge_->SetParent(parent); |
| glow_->SetParent(parent); |
| } |
| |
| // static |
| void EdgeEffect::PreloadResources(ui::ResourceManager* resource_manager) { |
| DCHECK(resource_manager); |
| resource_manager->PreloadResource(ui::ANDROID_RESOURCE_TYPE_SYSTEM, |
| kEdgeResourceId); |
| resource_manager->PreloadResource(ui::ANDROID_RESOURCE_TYPE_SYSTEM, |
| kGlowResourceId); |
| } |
| |
| } // namespace ui |