1 // Copyright 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 #ifndef CC_OUTPUT_FILTER_OPERATION_H_ 6 #define CC_OUTPUT_FILTER_OPERATION_H_ 7 8 #include "base/logging.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "cc/base/cc_export.h" 11 #include "third_party/skia/include/core/SkColor.h" 12 #include "third_party/skia/include/core/SkScalar.h" 13 #include "ui/gfx/point.h" 14 15 namespace base { 16 class Value; 17 } 18 19 namespace cc { 20 21 class CC_EXPORT FilterOperation { 22 public: 23 enum FilterType { 24 GRAYSCALE, 25 SEPIA, 26 SATURATE, 27 HUE_ROTATE, 28 INVERT, 29 BRIGHTNESS, 30 CONTRAST, 31 OPACITY, 32 BLUR, 33 DROP_SHADOW, 34 COLOR_MATRIX, 35 ZOOM, 36 SATURATING_BRIGHTNESS, // Not used in CSS/SVG. 37 }; 38 39 FilterType type() const { return type_; } 40 41 float amount() const { 42 DCHECK_NE(type_, COLOR_MATRIX); 43 return amount_; 44 } 45 46 gfx::Point drop_shadow_offset() const { 47 DCHECK_EQ(type_, DROP_SHADOW); 48 return drop_shadow_offset_; 49 } 50 51 SkColor drop_shadow_color() const { 52 DCHECK_EQ(type_, DROP_SHADOW); 53 return drop_shadow_color_; 54 } 55 56 const SkScalar* matrix() const { 57 DCHECK_EQ(type_, COLOR_MATRIX); 58 return matrix_; 59 } 60 61 int zoom_inset() const { 62 DCHECK_EQ(type_, ZOOM); 63 return zoom_inset_; 64 } 65 66 static FilterOperation CreateGrayscaleFilter(float amount) { 67 return FilterOperation(GRAYSCALE, amount); 68 } 69 70 static FilterOperation CreateSepiaFilter(float amount) { 71 return FilterOperation(SEPIA, amount); 72 } 73 74 static FilterOperation CreateSaturateFilter(float amount) { 75 return FilterOperation(SATURATE, amount); 76 } 77 78 static FilterOperation CreateHueRotateFilter(float amount) { 79 return FilterOperation(HUE_ROTATE, amount); 80 } 81 82 static FilterOperation CreateInvertFilter(float amount) { 83 return FilterOperation(INVERT, amount); 84 } 85 86 static FilterOperation CreateBrightnessFilter(float amount) { 87 return FilterOperation(BRIGHTNESS, amount); 88 } 89 90 static FilterOperation CreateContrastFilter(float amount) { 91 return FilterOperation(CONTRAST, amount); 92 } 93 94 static FilterOperation CreateOpacityFilter(float amount) { 95 return FilterOperation(OPACITY, amount); 96 } 97 98 static FilterOperation CreateBlurFilter(float amount) { 99 return FilterOperation(BLUR, amount); 100 } 101 102 static FilterOperation CreateDropShadowFilter(gfx::Point offset, 103 float std_deviation, 104 SkColor color) { 105 return FilterOperation(DROP_SHADOW, offset, std_deviation, color); 106 } 107 108 static FilterOperation CreateColorMatrixFilter(SkScalar matrix[20]) { 109 return FilterOperation(COLOR_MATRIX, matrix); 110 } 111 112 static FilterOperation CreateZoomFilter(float amount, int inset) { 113 return FilterOperation(ZOOM, amount, inset); 114 } 115 116 static FilterOperation CreateSaturatingBrightnessFilter(float amount) { 117 return FilterOperation(SATURATING_BRIGHTNESS, amount); 118 } 119 120 bool operator==(const FilterOperation& other) const; 121 122 bool operator!=(const FilterOperation& other) const { 123 return !(*this == other); 124 } 125 126 // Methods for restoring a FilterOperation. 127 static FilterOperation CreateEmptyFilter() { 128 return FilterOperation(GRAYSCALE, 0.f); 129 } 130 131 void set_type(FilterType type) { type_ = type; } 132 133 void set_amount(float amount) { 134 DCHECK_NE(type_, COLOR_MATRIX); 135 amount_ = amount; 136 } 137 138 void set_drop_shadow_offset(gfx::Point offset) { 139 DCHECK_EQ(type_, DROP_SHADOW); 140 drop_shadow_offset_ = offset; 141 } 142 143 void set_drop_shadow_color(SkColor color) { 144 DCHECK_EQ(type_, DROP_SHADOW); 145 drop_shadow_color_ = color; 146 } 147 148 void set_matrix(const SkScalar matrix[20]) { 149 DCHECK_EQ(type_, COLOR_MATRIX); 150 for (unsigned i = 0; i < 20; ++i) 151 matrix_[i] = matrix[i]; 152 } 153 154 void set_zoom_inset(int inset) { 155 DCHECK_EQ(type_, ZOOM); 156 zoom_inset_ = inset; 157 } 158 159 // Given two filters of the same type, returns a filter operation created by 160 // linearly interpolating a |progress| fraction from |from| to |to|. If either 161 // |from| or |to| (but not both) is null, it is treated as a no-op filter of 162 // the same type as the other given filter. If both |from| and |to| are null, 163 // or if |from| and |to| are non-null but of different types, returns a 164 // no-op filter. 165 static FilterOperation Blend(const FilterOperation* from, 166 const FilterOperation* to, 167 double progress); 168 169 scoped_ptr<base::Value> AsValue() const; 170 171 private: 172 FilterOperation(FilterType type, float amount); 173 174 FilterOperation(FilterType type, 175 gfx::Point offset, 176 float stdDeviation, 177 SkColor color); 178 179 FilterOperation(FilterType, SkScalar matrix[20]); 180 181 FilterOperation(FilterType type, float amount, int inset); 182 183 FilterType type_; 184 float amount_; 185 gfx::Point drop_shadow_offset_; 186 SkColor drop_shadow_color_; 187 SkScalar matrix_[20]; 188 int zoom_inset_; 189 }; 190 191 } // namespace cc 192 193 #endif // CC_OUTPUT_FILTER_OPERATION_H_ 194