sky/engine/core/animation/InterpolableValue.h - Issue 1229273004: Remove Animations and Transitions.

Side by Side Diff: sky/engine/core/animation/InterpolableValue.h

Issue 1229273004: Remove Animations and Transitions. (Closed) Base URL: https://github.com/domokit/mojo.git@master

Patch Set: Created 5 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 // Copyright 2014 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 #ifndef SKY_ENGINE_CORE_ANIMATION_INTERPOLABLEVALUE_H_

6 #define SKY_ENGINE_CORE_ANIMATION_INTERPOLABLEVALUE_H_

7

8 #include "sky/engine/core/animation/animatable/AnimatableValue.h"

9 #include "sky/engine/wtf/OwnPtr.h"

10 #include "sky/engine/wtf/PassOwnPtr.h"

11 #include "sky/engine/wtf/Vector.h"

12

13 namespace blink {

14

15 class InterpolableValue {

16 DECLARE_EMPTY_VIRTUAL_DESTRUCTOR_WILL_BE_REMOVED(InterpolableValue);

17 public:

18 virtual bool isNumber() const { return false; }

19 virtual bool isBool() const { return false; }

20 virtual bool isList() const { return false; }

21 virtual bool isAnimatableValue() const { return false; }

22

23 virtual PassOwnPtr<InterpolableValue> clone() const = 0;

24

25 private:

26 virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &t o, const double progress) const = 0;

27

28 friend class Interpolation;

29

30 // Keep interpolate private, but allow calls within the hierarchy without

31 // knowledge of type.

32 friend class DeferredLegacyStyleInterpolation;

33 friend class InterpolableNumber;

34 friend class InterpolableBool;

35 friend class InterpolableList;

36 };

37

38 class InterpolableNumber : public InterpolableValue {

39 public:

40 static PassOwnPtr<InterpolableNumber> create(double value)

41 {

42 return adoptPtr(new InterpolableNumber(value));

43 }

44

45 virtual bool isNumber() const override final { return true; }

46 double value() const { return m_value; }

47 virtual PassOwnPtr<InterpolableValue> clone() const override final { return create(m_value); }

48

49 private:

50 virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &t o, const double progress) const override final;

51 double m_value;

52

53 explicit InterpolableNumber(double value)

54 : m_value(value)

55 {

56 }

57

58 };

59

60 class InterpolableBool : public InterpolableValue {

61 public:

62 static PassOwnPtr<InterpolableBool> create(bool value)

63 {

64 return adoptPtr(new InterpolableBool(value));

65 }

66

67 virtual bool isBool() const override final { return true; }

68 bool value() const { return m_value; }

69 virtual PassOwnPtr<InterpolableValue> clone() const override final { return create(m_value); }

70

71 private:

72 virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &t o, const double progress) const override final;

73 bool m_value;

74

75 explicit InterpolableBool(bool value)

76 : m_value(value)

77 {

78 }

79

80 };

81

82 class InterpolableList : public InterpolableValue {

83 public:

84 static PassOwnPtr<InterpolableList> create(const InterpolableList &other)

85 {

86 return adoptPtr(new InterpolableList(other));

87 }

88

89 static PassOwnPtr<InterpolableList> create(size_t size)

90 {

91 return adoptPtr(new InterpolableList(size));

92 }

93

94 virtual bool isList() const override final { return true; }

95 void set(size_t position, PassOwnPtr<InterpolableValue> value)

96 {

97 ASSERT(position < m_size);

98 m_values[position] = value;

99 }

100 const InterpolableValue* get(size_t position) const

101 {

102 ASSERT(position < m_size);

103 return m_values[position].get();

104 }

105 size_t length() const { return m_size; }

106 virtual PassOwnPtr<InterpolableValue> clone() const override final { return create(*this); }

107

108 private:

109 virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &o ther, const double progress) const override final;

110 explicit InterpolableList(size_t size)

111 : m_size(size)

112 , m_values(m_size)

113 {

114 }

115

116 InterpolableList(const InterpolableList& other)

117 : m_size(other.m_size)

118 , m_values(m_size)

119 {

120 for (size_t i = 0; i < m_size; i++)

121 set(i, other.m_values[i]->clone());

122 }

123

124 size_t m_size;

125 Vector<OwnPtr<InterpolableValue> > m_values;

126 };

127

128 // FIXME: Remove this when we can.

129 class InterpolableAnimatableValue : public InterpolableValue {

130 public:

131 static PassOwnPtr<InterpolableAnimatableValue> create(PassRefPtr<AnimatableV alue> value)

132 {

133 return adoptPtr(new InterpolableAnimatableValue(value));

134 }

135

136 virtual bool isAnimatableValue() const override final { return true; }

137 AnimatableValue* value() const { return m_value.get(); }

138 virtual PassOwnPtr<InterpolableValue> clone() const override final { return create(m_value); }

139

140 private:

141 virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &o ther, const double progress) const override final;

142 RefPtr<AnimatableValue> m_value;

143

144 InterpolableAnimatableValue(PassRefPtr<AnimatableValue> value)

145 : m_value(value)

146 {

147 }

148 };

149

150 DEFINE_TYPE_CASTS(InterpolableNumber, InterpolableValue, value, value->isNumber( ), value.isNumber());

151 DEFINE_TYPE_CASTS(InterpolableBool, InterpolableValue, value, value->isBool(), v alue.isBool());

152 DEFINE_TYPE_CASTS(InterpolableList, InterpolableValue, value, value->isList(), v alue.isList());

153 DEFINE_TYPE_CASTS(InterpolableAnimatableValue, InterpolableValue, value, value-> isAnimatableValue(), value.isAnimatableValue());

154

155 }

156

157 #endif // SKY_ENGINE_CORE_ANIMATION_INTERPOLABLEVALUE_H_

OLD	NEW

« no previous file with comments | « sky/engine/core/animation/InertAnimation.cpp ('k') | sky/engine/core/animation/InterpolableValue.cpp » ('j') | no next file with comments »