1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
// 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 "third_party/blink/renderer/core/animation/interpolable_value.h"
#include <memory>
namespace blink {
bool InterpolableNumber::Equals(const InterpolableValue& other) const {
return value_ == To<InterpolableNumber>(other).value_;
}
bool InterpolableList::Equals(const InterpolableValue& other) const {
const auto& other_list = To<InterpolableList>(other);
if (length() != other_list.length())
return false;
for (wtf_size_t i = 0; i < length(); i++) {
if (!values_[i]->Equals(*other_list.values_[i]))
return false;
}
return true;
}
void InterpolableNumber::AssertCanInterpolateWith(
const InterpolableValue& other) const {
DCHECK(other.IsNumber());
}
void InterpolableNumber::Interpolate(const InterpolableValue& to,
const double progress,
InterpolableValue& result) const {
const auto& to_number = To<InterpolableNumber>(to);
auto& result_number = To<InterpolableNumber>(result);
if (progress == 0 || value_ == to_number.value_)
result_number.value_ = value_;
else if (progress == 1)
result_number.value_ = to_number.value_;
else
result_number.value_ =
value_ * (1 - progress) + to_number.value_ * progress;
}
void InterpolableList::AssertCanInterpolateWith(
const InterpolableValue& other) const {
DCHECK(other.IsList());
DCHECK_EQ(To<InterpolableList>(other).length(), length());
}
void InterpolableList::Interpolate(const InterpolableValue& to,
const double progress,
InterpolableValue& result) const {
const auto& to_list = To<InterpolableList>(to);
auto& result_list = To<InterpolableList>(result);
for (wtf_size_t i = 0; i < length(); i++) {
DCHECK(values_[i]);
DCHECK(to_list.values_[i]);
values_[i]->Interpolate(*(to_list.values_[i]), progress,
*(result_list.values_[i]));
}
}
InterpolableList* InterpolableList::RawCloneAndZero() const {
auto* result = new InterpolableList(length());
for (wtf_size_t i = 0; i < length(); i++)
result->Set(i, values_[i]->CloneAndZero());
return result;
}
void InterpolableNumber::Scale(double scale) {
value_ = value_ * scale;
}
void InterpolableList::Scale(double scale) {
for (wtf_size_t i = 0; i < length(); i++)
values_[i]->Scale(scale);
}
void InterpolableNumber::Add(const InterpolableValue& other) {
value_ += To<InterpolableNumber>(other).value_;
}
void InterpolableList::Add(const InterpolableValue& other) {
const auto& other_list = To<InterpolableList>(other);
DCHECK_EQ(other_list.length(), length());
for (wtf_size_t i = 0; i < length(); i++)
values_[i]->Add(*other_list.values_[i]);
}
void InterpolableList::ScaleAndAdd(double scale,
const InterpolableValue& other) {
const auto& other_list = To<InterpolableList>(other);
DCHECK_EQ(other_list.length(), length());
for (wtf_size_t i = 0; i < length(); i++)
values_[i]->ScaleAndAdd(scale, *other_list.values_[i]);
}
} // namespace blink
|
