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