| // Copyright 2014 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_l.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" |
| #include "ui/gfx/geometry/rect_f.h" |
| #include "ui/gfx/geometry/size_conversions.h" |
| |
| namespace ui { |
| |
| namespace { |
| |
| // Time it will take the effect to fully recede in ms |
| const int kRecedeTimeMs = 600; |
| |
| // Time it will take before a pulled glow begins receding in ms |
| const int kPullTimeMs = 167; |
| |
| // Time it will take for a pulled glow to decay to partial strength before |
| // release |
| const int kPullDecayTimeMs = 2000; |
| |
| const float kMaxAlpha = 0.5f; |
| |
| const float kPullGlowBegin = 0.f; |
| |
| // Min/max velocity that will be absorbed |
| const float kMinVelocity = 100.f; |
| const float kMaxVelocity = 10000.f; |
| |
| const float kEpsilon = 0.001f; |
| |
| const float kSin = 0.5f; // sin(PI / 6) |
| const float kCos = 0.866f; // cos(PI / 6); |
| |
| // How much dragging should effect the height of the glow image. |
| // Number determined by user testing. |
| const float kPullDistanceAlphaGlowFactor = 0.8f; |
| |
| const int kVelocityGlowFactor = 6; |
| |
| const ui::SystemUIResourceType kResourceId = ui::OVERSCROLL_GLOW_L; |
| |
| } // namespace |
| |
| EdgeEffectL::EdgeEffectL(ui::ResourceManager* resource_manager) |
| : resource_manager_(resource_manager), |
| glow_(cc::UIResourceLayer::Create()), |
| glow_alpha_(0), |
| glow_scale_y_(0), |
| glow_alpha_start_(0), |
| glow_alpha_finish_(0), |
| glow_scale_y_start_(0), |
| glow_scale_y_finish_(0), |
| displacement_(0.5f), |
| target_displacement_(0.5f), |
| state_(STATE_IDLE), |
| pull_distance_(0) { |
| // Prevent the provided layers from drawing until the effect is activated. |
| glow_->SetIsDrawable(false); |
| } |
| |
| EdgeEffectL::~EdgeEffectL() { |
| glow_->RemoveFromParent(); |
| } |
| |
| bool EdgeEffectL::IsFinished() const { |
| return state_ == STATE_IDLE; |
| } |
| |
| void EdgeEffectL::Finish() { |
| glow_->SetIsDrawable(false); |
| pull_distance_ = 0; |
| state_ = STATE_IDLE; |
| } |
| |
| void EdgeEffectL::Pull(base::TimeTicks current_time, |
| float delta_distance, |
| float displacement) { |
| target_displacement_ = displacement; |
| if (state_ == STATE_PULL_DECAY && current_time - start_time_ < duration_) { |
| return; |
| } |
| if (state_ != STATE_PULL) { |
| glow_scale_y_ = std::max(kPullGlowBegin, glow_scale_y_); |
| } |
| state_ = STATE_PULL; |
| |
| start_time_ = current_time; |
| duration_ = base::TimeDelta::FromMilliseconds(kPullTimeMs); |
| |
| float abs_delta_distance = std::abs(delta_distance); |
| pull_distance_ += delta_distance; |
| |
| glow_alpha_ = glow_alpha_start_ = std::min( |
| kMaxAlpha, |
| glow_alpha_ + (abs_delta_distance * kPullDistanceAlphaGlowFactor)); |
| |
| if (pull_distance_ == 0) { |
| glow_scale_y_ = glow_scale_y_start_ = 0; |
| } else { |
| float scale = 1.f - |
| 1.f / std::sqrt(std::abs(pull_distance_) * bounds_.height()) - |
| 0.3f; |
| glow_scale_y_ = glow_scale_y_start_ = std::max(0.f, scale) / 0.7f; |
| } |
| |
| glow_alpha_finish_ = glow_alpha_; |
| glow_scale_y_finish_ = glow_scale_y_; |
| } |
| |
| void EdgeEffectL::Release(base::TimeTicks current_time) { |
| pull_distance_ = 0; |
| |
| if (state_ != STATE_PULL && state_ != STATE_PULL_DECAY) |
| return; |
| |
| state_ = STATE_RECEDE; |
| glow_alpha_start_ = glow_alpha_; |
| glow_scale_y_start_ = glow_scale_y_; |
| |
| glow_alpha_finish_ = 0.f; |
| glow_scale_y_finish_ = 0.f; |
| |
| start_time_ = current_time; |
| duration_ = base::TimeDelta::FromMilliseconds(kRecedeTimeMs); |
| } |
| |
| void EdgeEffectL::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 glow depends more on the velocity, and therefore starts out |
| // nearly invisible. |
| glow_alpha_start_ = 0.3f; |
| glow_scale_y_start_ = std::max(glow_scale_y_, 0.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) / 2.f, 1.f); |
| // Alpha should change for the glow as well as size. |
| glow_alpha_finish_ = Clamp( |
| glow_alpha_start_, velocity * kVelocityGlowFactor * .00001f, kMaxAlpha); |
| target_displacement_ = 0.5; |
| } |
| |
| bool EdgeEffectL::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.)); |
| |
| glow_alpha_ = Lerp(glow_alpha_start_, glow_alpha_finish_, interp); |
| glow_scale_y_ = Lerp(glow_scale_y_start_, glow_scale_y_finish_, interp); |
| displacement_ = (displacement_ + target_displacement_) / 2.f; |
| |
| if (t >= 1.f - kEpsilon) { |
| switch (state_) { |
| case STATE_ABSORB: |
| state_ = STATE_RECEDE; |
| start_time_ = current_time; |
| duration_ = base::TimeDelta::FromMilliseconds(kRecedeTimeMs); |
| |
| glow_alpha_start_ = glow_alpha_; |
| glow_scale_y_start_ = glow_scale_y_; |
| |
| 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); |
| |
| glow_alpha_start_ = glow_alpha_; |
| glow_scale_y_start_ = glow_scale_y_; |
| |
| // After pull, the glow should fade to nothing. |
| glow_alpha_finish_ = 0.f; |
| glow_scale_y_finish_ = 0.f; |
| break; |
| case STATE_PULL_DECAY: |
| state_ = STATE_RECEDE; |
| break; |
| case STATE_RECEDE: |
| Finish(); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| bool one_last_frame = false; |
| if (state_ == STATE_RECEDE && glow_scale_y_ <= 0) { |
| Finish(); |
| one_last_frame = true; |
| } |
| |
| return !IsFinished() || one_last_frame; |
| } |
| |
| float EdgeEffectL::GetAlpha() const { |
| return IsFinished() ? 0.f : glow_alpha_; |
| } |
| |
| void EdgeEffectL::ApplyToLayers(Edge edge, |
| const gfx::SizeF& viewport_size, |
| float offset) { |
| if (IsFinished()) |
| return; |
| |
| // An empty viewport, while meaningless, is also relatively harmless, and will |
| // simply prevent any drawing of the layers. |
| if (viewport_size.IsEmpty()) { |
| glow_->SetIsDrawable(false); |
| return; |
| } |
| |
| gfx::SizeF size = ComputeOrientedSize(edge, viewport_size); |
| const float r = size.width() * 0.75f / kSin; |
| const float y = kCos * r; |
| const float h = r - y; |
| const float o_r = size.height() * 0.75f / kSin; |
| const float o_y = kCos * o_r; |
| const float o_h = o_r - o_y; |
| const float base_glow_scale = h > 0.f ? std::min(o_h / h, 1.f) : 1.f; |
| bounds_ = gfx::Size(size.width(), (int)std::min(size.height(), h)); |
| gfx::Size image_bounds( |
| r, std::min(1.f, glow_scale_y_) * base_glow_scale * bounds_.height()); |
| |
| // Compute the displaced image rect. This includes both the horizontal |
| // offset from the |displacement_| factor, as well as the vertical edge offset |
| // provided by the method call. |
| const float displacement = Clamp(displacement_, 0.f, 1.f) - 0.5f; |
| const float displacement_offset_x = bounds_.width() * displacement * 0.5f; |
| const float image_offset_x = (bounds_.width() - image_bounds.width()) * 0.5f; |
| gfx::RectF image_rect = gfx::RectF(gfx::SizeF(image_bounds)); |
| image_rect.Offset(image_offset_x - displacement_offset_x, -std::abs(offset)); |
| |
| // Clip the image rect against the viewport. If either rect is empty there's |
| // no need to draw anything further. |
| gfx::RectF clipped_rect(size.width(), size.height()); |
| clipped_rect.Intersect(image_rect); |
| if (clipped_rect.IsEmpty() || image_rect.IsEmpty()) { |
| glow_->SetIsDrawable(false); |
| return; |
| } |
| |
| // Compute the logical UV coordinates of the clipped rect relative to the |
| // displaced image rect. |
| gfx::PointF clipped_top_left = clipped_rect.origin(); |
| gfx::PointF clipped_bottom_right = clipped_rect.bottom_right(); |
| gfx::PointF uv_top_left( |
| (clipped_top_left.x() - image_rect.x()) / image_rect.width(), |
| (clipped_top_left.y() - image_rect.y()) / image_rect.height()); |
| gfx::PointF uv_bottom_right( |
| (clipped_bottom_right.x() - image_rect.x()) / image_rect.width(), |
| (clipped_bottom_right.y() - image_rect.y()) / image_rect.height()); |
| glow_->SetUV(uv_top_left, uv_bottom_right); |
| |
| // There's no need to use the provided |offset| when computing the transform; |
| // the offset is built in to the computed UV coordinates. |
| glow_->SetTransform(ComputeTransform(edge, viewport_size, 0)); |
| |
| glow_->SetIsDrawable(true); |
| glow_->SetUIResourceId(resource_manager_->GetUIResourceId( |
| ui::ANDROID_RESOURCE_TYPE_SYSTEM, kResourceId)); |
| glow_->SetTransformOrigin(gfx::Point3F(bounds_.width() * 0.5f, 0, 0)); |
| glow_->SetBounds(gfx::ToRoundedSize(clipped_rect.size())); |
| glow_->SetContentsOpaque(false); |
| glow_->SetOpacity(Clamp(glow_alpha_, 0.f, 1.f)); |
| } |
| |
| void EdgeEffectL::SetParent(cc::Layer* parent) { |
| if (glow_->parent() != parent) |
| parent->AddChild(glow_); |
| } |
| |
| // static |
| void EdgeEffectL::PreloadResources(ui::ResourceManager* resource_manager) { |
| DCHECK(resource_manager); |
| resource_manager->PreloadResource(ui::ANDROID_RESOURCE_TYPE_SYSTEM, |
| kResourceId); |
| } |
| |
| } // namespace ui |