1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include "VectorDrawable.h" 20 21 #include <SkColor.h> 22 23 namespace android { 24 namespace uirenderer { 25 26 /** 27 * PropertyValues holder contains data needed to change a property of a Vector Drawable object. 28 * When a fraction in [0f, 1f] is provided, the holder will calculate an interpolated value based 29 * on its start and end value, and set the new value on the VectorDrawble's corresponding property. 30 */ 31 class ANDROID_API PropertyValuesHolder { 32 public: 33 virtual void setFraction(float fraction) = 0; 34 virtual ~PropertyValuesHolder() {} 35 }; 36 37 template <typename T> 38 class Evaluator { 39 public: 40 virtual void evaluate(T* out, const T& from, const T& to, float fraction) const {}; 41 virtual ~Evaluator() {} 42 }; 43 44 class FloatEvaluator : public Evaluator<float> { 45 public: 46 virtual void evaluate(float* out, const float& from, const float& to, float fraction) 47 const override { 48 *out = from * (1 - fraction) + to * fraction; 49 } 50 }; 51 52 class ANDROID_API ColorEvaluator : public Evaluator<SkColor> { 53 public: 54 virtual void evaluate(SkColor* outColor, const SkColor& from, const SkColor& to, 55 float fraction) const override; 56 }; 57 58 class ANDROID_API PathEvaluator : public Evaluator<PathData> { 59 virtual void evaluate(PathData* out, const PathData& from, const PathData& to, float fraction) 60 const override; 61 }; 62 63 template <typename T> 64 class ANDROID_API PropertyValuesHolderImpl : public PropertyValuesHolder { 65 public: 66 PropertyValuesHolderImpl(const T& startValue, const T& endValue) 67 : mStartValue(startValue) 68 , mEndValue(endValue) {} 69 void setPropertyDataSource(T* dataSource, int length) { 70 mDataSource.insert(mDataSource.begin(), dataSource, dataSource + length); 71 } 72 // Calculate the animated value from the data source. 73 const T getValueFromData(float fraction) const; 74 // Convenient method to favor getting animated value from data source. If no data source is set 75 // fall back to linear interpolation. 76 const T calculateAnimatedValue(float fraction) const; 77 protected: 78 std::unique_ptr<Evaluator<T>> mEvaluator = nullptr; 79 // This contains uniformly sampled data throughout the animation duration. The first element 80 // should be the start value and the last should be the end value of the animation. When the 81 // data source is set, we'll favor data source over the linear interpolation of start/end value 82 // for calculation of animated value. 83 std::vector<T> mDataSource; 84 T mStartValue; 85 T mEndValue; 86 }; 87 88 class ANDROID_API GroupPropertyValuesHolder : public PropertyValuesHolderImpl<float> { 89 public: 90 GroupPropertyValuesHolder(VectorDrawable::Group* ptr, int propertyId, float startValue, 91 float endValue) 92 : PropertyValuesHolderImpl(startValue, endValue) 93 , mGroup(ptr) 94 , mPropertyId(propertyId) { 95 mEvaluator.reset(new FloatEvaluator()); 96 } 97 void setFraction(float fraction) override; 98 private: 99 VectorDrawable::Group* mGroup; 100 int mPropertyId; 101 }; 102 103 class ANDROID_API FullPathColorPropertyValuesHolder : public PropertyValuesHolderImpl<SkColor> { 104 public: 105 FullPathColorPropertyValuesHolder(VectorDrawable::FullPath* ptr, int propertyId, 106 SkColor startValue, SkColor endValue) 107 : PropertyValuesHolderImpl(startValue, endValue) 108 , mFullPath(ptr) 109 , mPropertyId(propertyId) { 110 mEvaluator.reset(new ColorEvaluator()); 111 } 112 void setFraction(float fraction) override; 113 static SkColor interpolateColors(SkColor fromColor, SkColor toColor, float fraction); 114 private: 115 VectorDrawable::FullPath* mFullPath; 116 int mPropertyId; 117 }; 118 119 class ANDROID_API FullPathPropertyValuesHolder : public PropertyValuesHolderImpl<float> { 120 public: 121 FullPathPropertyValuesHolder(VectorDrawable::FullPath* ptr, int propertyId, float startValue, 122 float endValue) 123 : PropertyValuesHolderImpl(startValue, endValue) 124 , mFullPath(ptr) 125 , mPropertyId(propertyId) { 126 mEvaluator.reset(new FloatEvaluator()); 127 }; 128 void setFraction(float fraction) override; 129 private: 130 VectorDrawable::FullPath* mFullPath; 131 int mPropertyId; 132 }; 133 134 class ANDROID_API PathDataPropertyValuesHolder : public PropertyValuesHolderImpl<PathData> { 135 public: 136 PathDataPropertyValuesHolder(VectorDrawable::Path* ptr, PathData* startValue, 137 PathData* endValue) 138 : PropertyValuesHolderImpl(*startValue, *endValue) 139 , mPath(ptr) { 140 mEvaluator.reset(new PathEvaluator()); 141 }; 142 void setFraction(float fraction) override; 143 private: 144 VectorDrawable::Path* mPath; 145 PathData mPathData; 146 }; 147 148 class ANDROID_API RootAlphaPropertyValuesHolder : public PropertyValuesHolderImpl<float> { 149 public: 150 RootAlphaPropertyValuesHolder(VectorDrawable::Tree* tree, float startValue, float endValue) 151 : PropertyValuesHolderImpl(startValue, endValue) 152 , mTree(tree) { 153 mEvaluator.reset(new FloatEvaluator()); 154 } 155 void setFraction(float fraction) override; 156 private: 157 VectorDrawable::Tree* mTree; 158 }; 159 } 160 } 161