OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 The Android Open Source Project | 2 * Copyright 2012 The Android Open Source Project |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkLightingImageFilter.h" | 8 #include "SkLightingImageFilter.h" |
9 #include "SkBitmap.h" | 9 #include "SkBitmap.h" |
10 #include "SkColorPriv.h" | 10 #include "SkColorPriv.h" |
11 #include "SkReadBuffer.h" | 11 #include "SkReadBuffer.h" |
12 #include "SkWriteBuffer.h" | 12 #include "SkWriteBuffer.h" |
13 #include "SkReadBuffer.h" | 13 #include "SkReadBuffer.h" |
14 #include "SkWriteBuffer.h" | 14 #include "SkWriteBuffer.h" |
15 #include "SkTypes.h" | 15 #include "SkTypes.h" |
16 | 16 |
17 #if SK_SUPPORT_GPU | 17 #if SK_SUPPORT_GPU |
18 #include "effects/GrSingleTextureEffect.h" | 18 #include "effects/GrSingleTextureEffect.h" |
19 #include "gl/GrGLEffect.h" | 19 #include "gl/GrGLProcessor.h" |
20 #include "gl/builders/GrGLProgramBuilder.h" | 20 #include "gl/builders/GrGLProgramBuilder.h" |
21 #include "GrEffect.h" | 21 #include "GrProcessor.h" |
22 #include "GrTBackendEffectFactory.h" | 22 #include "GrTBackendProcessorFactory.h" |
23 | 23 |
24 class GrGLDiffuseLightingEffect; | 24 class GrGLDiffuseLightingEffect; |
25 class GrGLSpecularLightingEffect; | 25 class GrGLSpecularLightingEffect; |
26 | 26 |
27 // For brevity | 27 // For brevity |
28 typedef GrGLProgramDataManager::UniformHandle UniformHandle; | 28 typedef GrGLProgramDataManager::UniformHandle UniformHandle; |
29 #endif | 29 #endif |
30 | 30 |
31 namespace { | 31 namespace { |
32 | 32 |
33 const SkScalar gOneThird = SkScalarInvert(SkIntToScalar(3)); | 33 const SkScalar gOneThird = SkScalarInvert(SkIntToScalar(3)); |
34 const SkScalar gTwoThirds = SkScalarDiv(SkIntToScalar(2), SkIntToScalar(3)); | 34 const SkScalar gTwoThirds = SkScalarDiv(SkIntToScalar(2), SkIntToScalar(3)); |
35 const SkScalar gOneHalf = 0.5f; | 35 const SkScalar gOneHalf = 0.5f; |
36 const SkScalar gOneQuarter = 0.25f; | 36 const SkScalar gOneQuarter = 0.25f; |
37 | 37 |
38 #if SK_SUPPORT_GPU | 38 #if SK_SUPPORT_GPU |
39 void setUniformPoint3(const GrGLProgramDataManager& pdman, UniformHandle uni, co
nst SkPoint3& point) { | 39 void setUniformPoint3(const GrGLProgramDataManager& pdman, UniformHandle uni, |
| 40 const SkPoint3& point) { |
40 GR_STATIC_ASSERT(sizeof(SkPoint3) == 3 * sizeof(GrGLfloat)); | 41 GR_STATIC_ASSERT(sizeof(SkPoint3) == 3 * sizeof(GrGLfloat)); |
41 pdman.set3fv(uni, 1, &point.fX); | 42 pdman.set3fv(uni, 1, &point.fX); |
42 } | 43 } |
43 | 44 |
44 void setUniformNormal3(const GrGLProgramDataManager& pdman, UniformHandle uni, c
onst SkPoint3& point) { | 45 void setUniformNormal3(const GrGLProgramDataManager& pdman, UniformHandle uni, |
| 46 const SkPoint3& point) { |
45 setUniformPoint3(pdman, uni, SkPoint3(point.fX, point.fY, point.fZ)); | 47 setUniformPoint3(pdman, uni, SkPoint3(point.fX, point.fY, point.fZ)); |
46 } | 48 } |
47 #endif | 49 #endif |
48 | 50 |
49 // Shift matrix components to the left, as we advance pixels to the right. | 51 // Shift matrix components to the left, as we advance pixels to the right. |
50 inline void shiftMatrixLeft(int m[9]) { | 52 inline void shiftMatrixLeft(int m[9]) { |
51 m[0] = m[1]; | 53 m[0] = m[1]; |
52 m[3] = m[4]; | 54 m[3] = m[4]; |
53 m[6] = m[7]; | 55 m[6] = m[7]; |
54 m[1] = m[2]; | 56 m[1] = m[2]; |
55 m[4] = m[5]; | 57 m[4] = m[5]; |
56 m[7] = m[8]; | 58 m[7] = m[8]; |
57 } | 59 } |
58 | 60 |
59 class DiffuseLightingType { | 61 class DiffuseLightingType { |
60 public: | 62 public: |
61 DiffuseLightingType(SkScalar kd) | 63 DiffuseLightingType(SkScalar kd) |
62 : fKD(kd) {} | 64 : fKD(kd) {} |
63 SkPMColor light(const SkPoint3& normal, const SkPoint3& surfaceTolight, cons
t SkPoint3& lightColor) const { | 65 SkPMColor light(const SkPoint3& normal, const SkPoint3& surfaceTolight, |
| 66 const SkPoint3& lightColor) const { |
64 SkScalar colorScale = SkScalarMul(fKD, normal.dot(surfaceTolight)); | 67 SkScalar colorScale = SkScalarMul(fKD, normal.dot(surfaceTolight)); |
65 colorScale = SkScalarClampMax(colorScale, SK_Scalar1); | 68 colorScale = SkScalarClampMax(colorScale, SK_Scalar1); |
66 SkPoint3 color(lightColor * colorScale); | 69 SkPoint3 color(lightColor * colorScale); |
67 return SkPackARGB32(255, | 70 return SkPackARGB32(255, |
68 SkClampMax(SkScalarRoundToInt(color.fX), 255), | 71 SkClampMax(SkScalarRoundToInt(color.fX), 255), |
69 SkClampMax(SkScalarRoundToInt(color.fY), 255), | 72 SkClampMax(SkScalarRoundToInt(color.fY), 255), |
70 SkClampMax(SkScalarRoundToInt(color.fZ), 255)); | 73 SkClampMax(SkScalarRoundToInt(color.fZ), 255)); |
71 } | 74 } |
72 private: | 75 private: |
73 SkScalar fKD; | 76 SkScalar fKD; |
74 }; | 77 }; |
75 | 78 |
76 class SpecularLightingType { | 79 class SpecularLightingType { |
77 public: | 80 public: |
78 SpecularLightingType(SkScalar ks, SkScalar shininess) | 81 SpecularLightingType(SkScalar ks, SkScalar shininess) |
79 : fKS(ks), fShininess(shininess) {} | 82 : fKS(ks), fShininess(shininess) {} |
80 SkPMColor light(const SkPoint3& normal, const SkPoint3& surfaceTolight, cons
t SkPoint3& lightColor) const { | 83 SkPMColor light(const SkPoint3& normal, const SkPoint3& surfaceTolight, |
| 84 const SkPoint3& lightColor) const { |
81 SkPoint3 halfDir(surfaceTolight); | 85 SkPoint3 halfDir(surfaceTolight); |
82 halfDir.fZ += SK_Scalar1; // eye position is always (0, 0, 1) | 86 halfDir.fZ += SK_Scalar1; // eye position is always (0, 0, 1) |
83 halfDir.normalize(); | 87 halfDir.normalize(); |
84 SkScalar colorScale = SkScalarMul(fKS, | 88 SkScalar colorScale = SkScalarMul(fKS, |
85 SkScalarPow(normal.dot(halfDir), fShininess)); | 89 SkScalarPow(normal.dot(halfDir), fShininess)); |
86 colorScale = SkScalarClampMax(colorScale, SK_Scalar1); | 90 colorScale = SkScalarClampMax(colorScale, SK_Scalar1); |
87 SkPoint3 color(lightColor * colorScale); | 91 SkPoint3 color(lightColor * colorScale); |
88 return SkPackARGB32(SkClampMax(SkScalarRoundToInt(color.maxComponent()),
255), | 92 return SkPackARGB32(SkClampMax(SkScalarRoundToInt(color.maxComponent()),
255), |
89 SkClampMax(SkScalarRoundToInt(color.fX), 255), | 93 SkClampMax(SkScalarRoundToInt(color.fX), 255), |
90 SkClampMax(SkScalarRoundToInt(color.fY), 255), | 94 SkClampMax(SkScalarRoundToInt(color.fY), 255), |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
155 sobel(m[0], m[3], m[1], m[4], m[2], m[5], gOneHalf), | 159 sobel(m[0], m[3], m[1], m[4], m[2], m[5], gOneHalf), |
156 surfaceScale); | 160 surfaceScale); |
157 } | 161 } |
158 | 162 |
159 inline SkPoint3 bottomRightNormal(int m[9], SkScalar surfaceScale) { | 163 inline SkPoint3 bottomRightNormal(int m[9], SkScalar surfaceScale) { |
160 return pointToNormal(sobel(m[0], m[1], m[3], m[4], 0, 0, gTwoThirds), | 164 return pointToNormal(sobel(m[0], m[1], m[3], m[4], 0, 0, gTwoThirds), |
161 sobel(m[0], m[3], m[1], m[4], 0, 0, gTwoThirds), | 165 sobel(m[0], m[3], m[1], m[4], 0, 0, gTwoThirds), |
162 surfaceScale); | 166 surfaceScale); |
163 } | 167 } |
164 | 168 |
165 template <class LightingType, class LightType> void lightBitmap(const LightingTy
pe& lightingType, const SkLight* light, const SkBitmap& src, SkBitmap* dst, SkSc
alar surfaceScale, const SkIRect& bounds) { | 169 template <class LightingType, class LightType> void lightBitmap( |
| 170 const LightingType& lightingType, const SkLight* light, const SkBitmap&
src, SkBitmap* dst, |
| 171 SkScalar surfaceScale, const SkIRect& bounds) { |
166 SkASSERT(dst->width() == bounds.width() && dst->height() == bounds.height())
; | 172 SkASSERT(dst->width() == bounds.width() && dst->height() == bounds.height())
; |
167 const LightType* l = static_cast<const LightType*>(light); | 173 const LightType* l = static_cast<const LightType*>(light); |
168 int left = bounds.left(), right = bounds.right(); | 174 int left = bounds.left(), right = bounds.right(); |
169 int bottom = bounds.bottom(); | 175 int bottom = bounds.bottom(); |
170 int y = bounds.top(); | 176 int y = bounds.top(); |
171 SkPMColor* dptr = dst->getAddr32(0, 0); | 177 SkPMColor* dptr = dst->getAddr32(0, 0); |
172 { | 178 { |
173 int x = left; | 179 int x = left; |
174 const SkPMColor* row1 = src.getAddr32(x, y); | 180 const SkPMColor* row1 = src.getAddr32(x, y); |
175 const SkPMColor* row2 = src.getAddr32(x, y + 1); | 181 const SkPMColor* row2 = src.getAddr32(x, y + 1); |
176 int m[9]; | 182 int m[9]; |
177 m[4] = SkGetPackedA32(*row1++); | 183 m[4] = SkGetPackedA32(*row1++); |
178 m[5] = SkGetPackedA32(*row1++); | 184 m[5] = SkGetPackedA32(*row1++); |
179 m[7] = SkGetPackedA32(*row2++); | 185 m[7] = SkGetPackedA32(*row2++); |
180 m[8] = SkGetPackedA32(*row2++); | 186 m[8] = SkGetPackedA32(*row2++); |
181 SkPoint3 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); | 187 SkPoint3 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); |
182 *dptr++ = lightingType.light(topLeftNormal(m, surfaceScale), surfaceToLi
ght, l->lightColor(surfaceToLight)); | 188 *dptr++ = lightingType.light(topLeftNormal(m, surfaceScale), surfaceToLi
ght, |
| 189 l->lightColor(surfaceToLight)); |
183 for (++x; x < right - 1; ++x) | 190 for (++x; x < right - 1; ++x) |
184 { | 191 { |
185 shiftMatrixLeft(m); | 192 shiftMatrixLeft(m); |
186 m[5] = SkGetPackedA32(*row1++); | 193 m[5] = SkGetPackedA32(*row1++); |
187 m[8] = SkGetPackedA32(*row2++); | 194 m[8] = SkGetPackedA32(*row2++); |
188 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); | 195 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); |
189 *dptr++ = lightingType.light(topNormal(m, surfaceScale), surfaceToLi
ght, l->lightColor(surfaceToLight)); | 196 *dptr++ = lightingType.light(topNormal(m, surfaceScale), surfaceToLi
ght, |
| 197 l->lightColor(surfaceToLight)); |
190 } | 198 } |
191 shiftMatrixLeft(m); | 199 shiftMatrixLeft(m); |
192 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); | 200 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); |
193 *dptr++ = lightingType.light(topRightNormal(m, surfaceScale), surfaceToL
ight, l->lightColor(surfaceToLight)); | 201 *dptr++ = lightingType.light(topRightNormal(m, surfaceScale), surfaceToL
ight, |
| 202 l->lightColor(surfaceToLight)); |
194 } | 203 } |
195 | 204 |
196 for (++y; y < bottom - 1; ++y) { | 205 for (++y; y < bottom - 1; ++y) { |
197 int x = left; | 206 int x = left; |
198 const SkPMColor* row0 = src.getAddr32(x, y - 1); | 207 const SkPMColor* row0 = src.getAddr32(x, y - 1); |
199 const SkPMColor* row1 = src.getAddr32(x, y); | 208 const SkPMColor* row1 = src.getAddr32(x, y); |
200 const SkPMColor* row2 = src.getAddr32(x, y + 1); | 209 const SkPMColor* row2 = src.getAddr32(x, y + 1); |
201 int m[9]; | 210 int m[9]; |
202 m[1] = SkGetPackedA32(*row0++); | 211 m[1] = SkGetPackedA32(*row0++); |
203 m[2] = SkGetPackedA32(*row0++); | 212 m[2] = SkGetPackedA32(*row0++); |
204 m[4] = SkGetPackedA32(*row1++); | 213 m[4] = SkGetPackedA32(*row1++); |
205 m[5] = SkGetPackedA32(*row1++); | 214 m[5] = SkGetPackedA32(*row1++); |
206 m[7] = SkGetPackedA32(*row2++); | 215 m[7] = SkGetPackedA32(*row2++); |
207 m[8] = SkGetPackedA32(*row2++); | 216 m[8] = SkGetPackedA32(*row2++); |
208 SkPoint3 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); | 217 SkPoint3 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); |
209 *dptr++ = lightingType.light(leftNormal(m, surfaceScale), surfaceToLight
, l->lightColor(surfaceToLight)); | 218 *dptr++ = lightingType.light(leftNormal(m, surfaceScale), surfaceToLight
, |
| 219 l->lightColor(surfaceToLight)); |
210 for (++x; x < right - 1; ++x) { | 220 for (++x; x < right - 1; ++x) { |
211 shiftMatrixLeft(m); | 221 shiftMatrixLeft(m); |
212 m[2] = SkGetPackedA32(*row0++); | 222 m[2] = SkGetPackedA32(*row0++); |
213 m[5] = SkGetPackedA32(*row1++); | 223 m[5] = SkGetPackedA32(*row1++); |
214 m[8] = SkGetPackedA32(*row2++); | 224 m[8] = SkGetPackedA32(*row2++); |
215 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); | 225 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); |
216 *dptr++ = lightingType.light(interiorNormal(m, surfaceScale), surfac
eToLight, l->lightColor(surfaceToLight)); | 226 *dptr++ = lightingType.light(interiorNormal(m, surfaceScale), surfac
eToLight, |
| 227 l->lightColor(surfaceToLight)); |
217 } | 228 } |
218 shiftMatrixLeft(m); | 229 shiftMatrixLeft(m); |
219 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); | 230 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); |
220 *dptr++ = lightingType.light(rightNormal(m, surfaceScale), surfaceToLigh
t, l->lightColor(surfaceToLight)); | 231 *dptr++ = lightingType.light(rightNormal(m, surfaceScale), surfaceToLigh
t, |
| 232 l->lightColor(surfaceToLight)); |
221 } | 233 } |
222 | 234 |
223 { | 235 { |
224 int x = left; | 236 int x = left; |
225 const SkPMColor* row0 = src.getAddr32(x, bottom - 2); | 237 const SkPMColor* row0 = src.getAddr32(x, bottom - 2); |
226 const SkPMColor* row1 = src.getAddr32(x, bottom - 1); | 238 const SkPMColor* row1 = src.getAddr32(x, bottom - 1); |
227 int m[9]; | 239 int m[9]; |
228 m[1] = SkGetPackedA32(*row0++); | 240 m[1] = SkGetPackedA32(*row0++); |
229 m[2] = SkGetPackedA32(*row0++); | 241 m[2] = SkGetPackedA32(*row0++); |
230 m[4] = SkGetPackedA32(*row1++); | 242 m[4] = SkGetPackedA32(*row1++); |
231 m[5] = SkGetPackedA32(*row1++); | 243 m[5] = SkGetPackedA32(*row1++); |
232 SkPoint3 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); | 244 SkPoint3 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); |
233 *dptr++ = lightingType.light(bottomLeftNormal(m, surfaceScale), surfaceT
oLight, l->lightColor(surfaceToLight)); | 245 *dptr++ = lightingType.light(bottomLeftNormal(m, surfaceScale), surfaceT
oLight, |
| 246 l->lightColor(surfaceToLight)); |
234 for (++x; x < right - 1; ++x) | 247 for (++x; x < right - 1; ++x) |
235 { | 248 { |
236 shiftMatrixLeft(m); | 249 shiftMatrixLeft(m); |
237 m[2] = SkGetPackedA32(*row0++); | 250 m[2] = SkGetPackedA32(*row0++); |
238 m[5] = SkGetPackedA32(*row1++); | 251 m[5] = SkGetPackedA32(*row1++); |
239 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); | 252 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); |
240 *dptr++ = lightingType.light(bottomNormal(m, surfaceScale), surfaceT
oLight, l->lightColor(surfaceToLight)); | 253 *dptr++ = lightingType.light(bottomNormal(m, surfaceScale), surfaceT
oLight, |
| 254 l->lightColor(surfaceToLight)); |
241 } | 255 } |
242 shiftMatrixLeft(m); | 256 shiftMatrixLeft(m); |
243 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); | 257 surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale); |
244 *dptr++ = lightingType.light(bottomRightNormal(m, surfaceScale), surface
ToLight, l->lightColor(surfaceToLight)); | 258 *dptr++ = lightingType.light(bottomRightNormal(m, surfaceScale), surface
ToLight, |
| 259 l->lightColor(surfaceToLight)); |
245 } | 260 } |
246 } | 261 } |
247 | 262 |
248 SkPoint3 readPoint3(SkReadBuffer& buffer) { | 263 SkPoint3 readPoint3(SkReadBuffer& buffer) { |
249 SkPoint3 point; | 264 SkPoint3 point; |
250 point.fX = buffer.readScalar(); | 265 point.fX = buffer.readScalar(); |
251 point.fY = buffer.readScalar(); | 266 point.fY = buffer.readScalar(); |
252 point.fZ = buffer.readScalar(); | 267 point.fZ = buffer.readScalar(); |
253 buffer.validate(SkScalarIsFinite(point.fX) && | 268 buffer.validate(SkScalarIsFinite(point.fX) && |
254 SkScalarIsFinite(point.fY) && | 269 SkScalarIsFinite(point.fY) && |
(...skipping 19 matching lines...) Expand all Loading... |
274 SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale, | 289 SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale, |
275 SkScalar kd, SkImageFilter* input, const CropRe
ct* cropRect, | 290 SkScalar kd, SkImageFilter* input, const CropRe
ct* cropRect, |
276 uint32_t uniqueID); | 291 uint32_t uniqueID); |
277 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING | 292 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING |
278 explicit SkDiffuseLightingImageFilter(SkReadBuffer& buffer); | 293 explicit SkDiffuseLightingImageFilter(SkReadBuffer& buffer); |
279 #endif | 294 #endif |
280 virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE; | 295 virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE; |
281 virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&, | 296 virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&, |
282 SkBitmap* result, SkIPoint* offset) const SK_OVER
RIDE; | 297 SkBitmap* result, SkIPoint* offset) const SK_OVER
RIDE; |
283 #if SK_SUPPORT_GPU | 298 #if SK_SUPPORT_GPU |
284 virtual bool asNewEffect(GrEffect** effect, GrTexture*, const SkMatrix& matr
ix, | 299 virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const Sk
Matrix&, |
285 const SkIRect& bounds) const SK_OVERRIDE; | 300 const SkIRect& bounds) const SK_OVERRIDE; |
286 #endif | 301 #endif |
287 | 302 |
288 private: | 303 private: |
289 friend class SkLightingImageFilter; | 304 friend class SkLightingImageFilter; |
290 typedef SkLightingImageFilter INHERITED; | 305 typedef SkLightingImageFilter INHERITED; |
291 SkScalar fKD; | 306 SkScalar fKD; |
292 }; | 307 }; |
293 | 308 |
294 class SkSpecularLightingImageFilter : public SkLightingImageFilter { | 309 class SkSpecularLightingImageFilter : public SkLightingImageFilter { |
295 public: | 310 public: |
296 static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale, | 311 static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale, |
297 SkScalar ks, SkScalar shininess, SkImageFilter*
, const CropRect*, uint32_t uniqueID = 0); | 312 SkScalar ks, SkScalar shininess, SkImageFilter*
, const CropRect*, |
| 313 uint32_t uniqueID = 0); |
298 | 314 |
299 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageF
ilter) | 315 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageF
ilter) |
300 | 316 |
301 SkScalar ks() const { return fKS; } | 317 SkScalar ks() const { return fKS; } |
302 SkScalar shininess() const { return fShininess; } | 318 SkScalar shininess() const { return fShininess; } |
303 | 319 |
304 protected: | 320 protected: |
305 SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScala
r ks, | 321 SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScala
r ks, |
306 SkScalar shininess, SkImageFilter* input, cons
t CropRect*, | 322 SkScalar shininess, SkImageFilter* input, cons
t CropRect*, |
307 uint32_t uniqueID); | 323 uint32_t uniqueID); |
308 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING | 324 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING |
309 explicit SkSpecularLightingImageFilter(SkReadBuffer& buffer); | 325 explicit SkSpecularLightingImageFilter(SkReadBuffer& buffer); |
310 #endif | 326 #endif |
311 virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE; | 327 virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE; |
312 virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&, | 328 virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&, |
313 SkBitmap* result, SkIPoint* offset) const SK_OVER
RIDE; | 329 SkBitmap* result, SkIPoint* offset) const SK_OVER
RIDE; |
314 #if SK_SUPPORT_GPU | 330 #if SK_SUPPORT_GPU |
315 virtual bool asNewEffect(GrEffect** effect, GrTexture*, const SkMatrix& matr
ix, | 331 virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const Sk
Matrix&, |
316 const SkIRect& bounds) const SK_OVERRIDE; | 332 const SkIRect& bounds) const SK_OVERRIDE; |
317 #endif | 333 #endif |
318 | 334 |
319 private: | 335 private: |
320 SkScalar fKS; | 336 SkScalar fKS; |
321 SkScalar fShininess; | 337 SkScalar fShininess; |
322 friend class SkLightingImageFilter; | 338 friend class SkLightingImageFilter; |
323 typedef SkLightingImageFilter INHERITED; | 339 typedef SkLightingImageFilter INHERITED; |
324 }; | 340 }; |
325 | 341 |
326 #if SK_SUPPORT_GPU | 342 #if SK_SUPPORT_GPU |
327 | 343 |
328 class GrLightingEffect : public GrSingleTextureEffect { | 344 class GrLightingEffect : public GrSingleTextureEffect { |
329 public: | 345 public: |
330 GrLightingEffect(GrTexture* texture, const SkLight* light, SkScalar surfaceS
cale, const SkMatrix& matrix); | 346 GrLightingEffect(GrTexture* texture, const SkLight* light, SkScalar surfaceS
cale, const SkMatrix& matrix); |
331 virtual ~GrLightingEffect(); | 347 virtual ~GrLightingEffect(); |
332 | 348 |
333 const SkLight* light() const { return fLight; } | 349 const SkLight* light() const { return fLight; } |
334 SkScalar surfaceScale() const { return fSurfaceScale; } | 350 SkScalar surfaceScale() const { return fSurfaceScale; } |
335 const SkMatrix& filterMatrix() const { return fFilterMatrix; } | 351 const SkMatrix& filterMatrix() const { return fFilterMatrix; } |
336 | 352 |
337 virtual void getConstantColorComponents(GrColor* color, | 353 virtual void getConstantColorComponents(GrColor* color, |
338 uint32_t* validFlags) const SK_OVERR
IDE { | 354 uint32_t* validFlags) const SK_OVERR
IDE { |
339 // lighting shaders are complicated. We just throw up our hands. | 355 // lighting shaders are complicated. We just throw up our hands. |
340 *validFlags = 0; | 356 *validFlags = 0; |
341 } | 357 } |
342 | 358 |
343 protected: | 359 protected: |
344 virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE; | 360 virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE; |
345 | 361 |
346 private: | 362 private: |
347 typedef GrSingleTextureEffect INHERITED; | 363 typedef GrSingleTextureEffect INHERITED; |
348 const SkLight* fLight; | 364 const SkLight* fLight; |
349 SkScalar fSurfaceScale; | 365 SkScalar fSurfaceScale; |
350 SkMatrix fFilterMatrix; | 366 SkMatrix fFilterMatrix; |
351 }; | 367 }; |
352 | 368 |
353 class GrDiffuseLightingEffect : public GrLightingEffect { | 369 class GrDiffuseLightingEffect : public GrLightingEffect { |
354 public: | 370 public: |
355 static GrEffect* Create(GrTexture* texture, | 371 static GrFragmentProcessor* Create(GrTexture* texture, |
356 const SkLight* light, | 372 const SkLight* light, |
357 SkScalar surfaceScale, | 373 SkScalar surfaceScale, |
358 const SkMatrix& matrix, | 374 const SkMatrix& matrix, |
359 SkScalar kd) { | 375 SkScalar kd) { |
360 return SkNEW_ARGS(GrDiffuseLightingEffect, (texture, | 376 return SkNEW_ARGS(GrDiffuseLightingEffect, (texture, |
361 light, | 377 light, |
362 surfaceScale, | 378 surfaceScale, |
363 matrix, | 379 matrix, |
364 kd)); | 380 kd)); |
365 } | 381 } |
366 | 382 |
367 static const char* Name() { return "DiffuseLighting"; } | 383 static const char* Name() { return "DiffuseLighting"; } |
368 | 384 |
369 typedef GrGLDiffuseLightingEffect GLEffect; | 385 typedef GrGLDiffuseLightingEffect GLProcessor; |
370 | 386 |
371 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; | 387 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; |
372 SkScalar kd() const { return fKD; } | 388 SkScalar kd() const { return fKD; } |
373 | 389 |
374 private: | 390 private: |
375 virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE; | 391 virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE; |
376 | 392 |
377 GrDiffuseLightingEffect(GrTexture* texture, | 393 GrDiffuseLightingEffect(GrTexture* texture, |
378 const SkLight* light, | 394 const SkLight* light, |
379 SkScalar surfaceScale, | 395 SkScalar surfaceScale, |
380 const SkMatrix& matrix, | 396 const SkMatrix& matrix, |
381 SkScalar kd); | 397 SkScalar kd); |
382 | 398 |
383 GR_DECLARE_EFFECT_TEST; | 399 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
384 typedef GrLightingEffect INHERITED; | 400 typedef GrLightingEffect INHERITED; |
385 SkScalar fKD; | 401 SkScalar fKD; |
386 }; | 402 }; |
387 | 403 |
388 class GrSpecularLightingEffect : public GrLightingEffect { | 404 class GrSpecularLightingEffect : public GrLightingEffect { |
389 public: | 405 public: |
390 static GrEffect* Create(GrTexture* texture, | 406 static GrFragmentProcessor* Create(GrTexture* texture, |
391 const SkLight* light, | 407 const SkLight* light, |
392 SkScalar surfaceScale, | 408 SkScalar surfaceScale, |
393 const SkMatrix& matrix, | 409 const SkMatrix& matrix, |
394 SkScalar ks, | 410 SkScalar ks, |
395 SkScalar shininess) { | 411 SkScalar shininess) { |
396 return SkNEW_ARGS(GrSpecularLightingEffect, (texture, | 412 return SkNEW_ARGS(GrSpecularLightingEffect, (texture, |
397 light, | 413 light, |
398 surfaceScale, | 414 surfaceScale, |
399 matrix, | 415 matrix, |
400 ks, | 416 ks, |
401 shininess)); | 417 shininess)); |
402 } | 418 } |
403 static const char* Name() { return "SpecularLighting"; } | 419 static const char* Name() { return "SpecularLighting"; } |
404 | 420 |
405 typedef GrGLSpecularLightingEffect GLEffect; | 421 typedef GrGLSpecularLightingEffect GLProcessor; |
406 | 422 |
407 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; | 423 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; |
408 SkScalar ks() const { return fKS; } | 424 SkScalar ks() const { return fKS; } |
409 SkScalar shininess() const { return fShininess; } | 425 SkScalar shininess() const { return fShininess; } |
410 | 426 |
411 private: | 427 private: |
412 virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE; | 428 virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE; |
413 | 429 |
414 GrSpecularLightingEffect(GrTexture* texture, | 430 GrSpecularLightingEffect(GrTexture* texture, |
415 const SkLight* light, | 431 const SkLight* light, |
416 SkScalar surfaceScale, | 432 SkScalar surfaceScale, |
417 const SkMatrix& matrix, | 433 const SkMatrix& matrix, |
418 SkScalar ks, | 434 SkScalar ks, |
419 SkScalar shininess); | 435 SkScalar shininess); |
420 | 436 |
421 GR_DECLARE_EFFECT_TEST; | 437 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
422 typedef GrLightingEffect INHERITED; | 438 typedef GrLightingEffect INHERITED; |
423 SkScalar fKS; | 439 SkScalar fKS; |
424 SkScalar fShininess; | 440 SkScalar fShininess; |
425 }; | 441 }; |
426 | 442 |
427 /////////////////////////////////////////////////////////////////////////////// | 443 /////////////////////////////////////////////////////////////////////////////// |
428 | 444 |
429 class GrGLLight { | 445 class GrGLLight { |
430 public: | 446 public: |
431 virtual ~GrGLLight() {} | 447 virtual ~GrGLLight() {} |
(...skipping 603 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1035 break; | 1051 break; |
1036 case SkLight::kSpot_LightType: | 1052 case SkLight::kSpot_LightType: |
1037 lightBitmap<DiffuseLightingType, SkSpotLight>(lightingType, transfor
medLight, src, dst, surfaceScale(), bounds); | 1053 lightBitmap<DiffuseLightingType, SkSpotLight>(lightingType, transfor
medLight, src, dst, surfaceScale(), bounds); |
1038 break; | 1054 break; |
1039 } | 1055 } |
1040 | 1056 |
1041 return true; | 1057 return true; |
1042 } | 1058 } |
1043 | 1059 |
1044 #if SK_SUPPORT_GPU | 1060 #if SK_SUPPORT_GPU |
1045 bool SkDiffuseLightingImageFilter::asNewEffect(GrEffect** effect, GrTexture* tex
ture, | 1061 bool SkDiffuseLightingImageFilter::asFragmentProcessor(GrFragmentProcessor** fp, |
1046 const SkMatrix& matrix, const SkI
Rect&) const { | 1062 GrTexture* texture, |
1047 if (effect) { | 1063 const SkMatrix& matrix, |
| 1064 const SkIRect&) const { |
| 1065 if (fp) { |
1048 SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255)); | 1066 SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255)); |
1049 *effect = GrDiffuseLightingEffect::Create(texture, light(), scale, matri
x, kd()); | 1067 *fp = GrDiffuseLightingEffect::Create(texture, light(), scale, matrix, k
d()); |
1050 } | 1068 } |
1051 return true; | 1069 return true; |
1052 } | 1070 } |
1053 #endif | 1071 #endif |
1054 | 1072 |
1055 /////////////////////////////////////////////////////////////////////////////// | 1073 /////////////////////////////////////////////////////////////////////////////// |
1056 | 1074 |
1057 SkImageFilter* SkSpecularLightingImageFilter::Create(SkLight* light, SkScalar su
rfaceScale, | 1075 SkImageFilter* SkSpecularLightingImageFilter::Create(SkLight* light, SkScalar su
rfaceScale, |
1058 SkScalar ks, SkScalar shininess, SkImageFilter* input, const Cro
pRect* cropRect, uint32_t uniqueID) { | 1076 SkScalar ks, SkScalar shininess, SkImageFilter* input, const Cro
pRect* cropRect, uint32_t uniqueID) { |
1059 if (NULL == light) { | 1077 if (NULL == light) { |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1151 lightBitmap<SpecularLightingType, SkPointLight>(lightingType, transf
ormedLight, src, dst, surfaceScale(), bounds); | 1169 lightBitmap<SpecularLightingType, SkPointLight>(lightingType, transf
ormedLight, src, dst, surfaceScale(), bounds); |
1152 break; | 1170 break; |
1153 case SkLight::kSpot_LightType: | 1171 case SkLight::kSpot_LightType: |
1154 lightBitmap<SpecularLightingType, SkSpotLight>(lightingType, transfo
rmedLight, src, dst, surfaceScale(), bounds); | 1172 lightBitmap<SpecularLightingType, SkSpotLight>(lightingType, transfo
rmedLight, src, dst, surfaceScale(), bounds); |
1155 break; | 1173 break; |
1156 } | 1174 } |
1157 return true; | 1175 return true; |
1158 } | 1176 } |
1159 | 1177 |
1160 #if SK_SUPPORT_GPU | 1178 #if SK_SUPPORT_GPU |
1161 bool SkSpecularLightingImageFilter::asNewEffect(GrEffect** effect, GrTexture* te
xture, | 1179 bool SkSpecularLightingImageFilter::asFragmentProcessor(GrFragmentProcessor** fp
, |
1162 const SkMatrix& matrix, const Sk
IRect&) const { | 1180 GrTexture* texture, |
1163 if (effect) { | 1181 const SkMatrix& matrix, |
| 1182 const SkIRect&) const { |
| 1183 if (fp) { |
1164 SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255)); | 1184 SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255)); |
1165 *effect = GrSpecularLightingEffect::Create(texture, light(), scale, matr
ix, ks(), shininess()); | 1185 *fp = GrSpecularLightingEffect::Create(texture, light(), scale, matrix,
ks(), shininess()); |
1166 } | 1186 } |
1167 return true; | 1187 return true; |
1168 } | 1188 } |
1169 #endif | 1189 #endif |
1170 | 1190 |
1171 /////////////////////////////////////////////////////////////////////////////// | 1191 /////////////////////////////////////////////////////////////////////////////// |
1172 | 1192 |
1173 #if SK_SUPPORT_GPU | 1193 #if SK_SUPPORT_GPU |
1174 | 1194 |
1175 namespace { | 1195 namespace { |
(...skipping 20 matching lines...) Expand all Loading... |
1196 random->nextU())); | 1216 random->nextU())); |
1197 } | 1217 } |
1198 default: | 1218 default: |
1199 SkFAIL("Unexpected value."); | 1219 SkFAIL("Unexpected value."); |
1200 return NULL; | 1220 return NULL; |
1201 } | 1221 } |
1202 } | 1222 } |
1203 | 1223 |
1204 } | 1224 } |
1205 | 1225 |
1206 class GrGLLightingEffect : public GrGLEffect { | 1226 class GrGLLightingEffect : public GrGLFragmentProcessor { |
1207 public: | 1227 public: |
1208 GrGLLightingEffect(const GrBackendEffectFactory& factory, | 1228 GrGLLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&); |
1209 const GrEffect& effect); | |
1210 virtual ~GrGLLightingEffect(); | 1229 virtual ~GrGLLightingEffect(); |
1211 | 1230 |
1212 virtual void emitCode(GrGLProgramBuilder*, | 1231 virtual void emitCode(GrGLProgramBuilder*, |
1213 const GrEffect&, | 1232 const GrFragmentProcessor&, |
1214 const GrEffectKey&, | 1233 const GrProcessorKey&, |
1215 const char* outputColor, | 1234 const char* outputColor, |
1216 const char* inputColor, | 1235 const char* inputColor, |
1217 const TransformedCoordsArray&, | 1236 const TransformedCoordsArray&, |
1218 const TextureSamplerArray&) SK_OVERRIDE; | 1237 const TextureSamplerArray&) SK_OVERRIDE; |
1219 | 1238 |
1220 static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuild
er* b); | 1239 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder* b); |
1221 | 1240 |
1222 /** | 1241 /** |
1223 * Subclasses of GrGLLightingEffect must call INHERITED::setData(); | 1242 * Subclasses of GrGLLightingEffect must call INHERITED::setData(); |
1224 */ | 1243 */ |
1225 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 1244 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
1226 | 1245 |
1227 protected: | 1246 protected: |
1228 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) = 0; | 1247 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) = 0; |
1229 | 1248 |
1230 private: | 1249 private: |
1231 typedef GrGLEffect INHERITED; | 1250 typedef GrGLFragmentProcessor INHERITED; |
1232 | 1251 |
1233 UniformHandle fImageIncrementUni; | 1252 UniformHandle fImageIncrementUni; |
1234 UniformHandle fSurfaceScaleUni; | 1253 UniformHandle fSurfaceScaleUni; |
1235 GrGLLight* fLight; | 1254 GrGLLight* fLight; |
1236 }; | 1255 }; |
1237 | 1256 |
1238 /////////////////////////////////////////////////////////////////////////////// | 1257 /////////////////////////////////////////////////////////////////////////////// |
1239 | 1258 |
1240 class GrGLDiffuseLightingEffect : public GrGLLightingEffect { | 1259 class GrGLDiffuseLightingEffect : public GrGLLightingEffect { |
1241 public: | 1260 public: |
1242 GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory, | 1261 GrGLDiffuseLightingEffect(const GrBackendProcessorFactory&, const GrProcesso
r&); |
1243 const GrEffect& effect); | |
1244 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERR
IDE; | 1262 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERR
IDE; |
1245 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 1263 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
1246 | 1264 |
1247 private: | 1265 private: |
1248 typedef GrGLLightingEffect INHERITED; | 1266 typedef GrGLLightingEffect INHERITED; |
1249 | 1267 |
1250 UniformHandle fKDUni; | 1268 UniformHandle fKDUni; |
1251 }; | 1269 }; |
1252 | 1270 |
1253 /////////////////////////////////////////////////////////////////////////////// | 1271 /////////////////////////////////////////////////////////////////////////////// |
1254 | 1272 |
1255 class GrGLSpecularLightingEffect : public GrGLLightingEffect { | 1273 class GrGLSpecularLightingEffect : public GrGLLightingEffect { |
1256 public: | 1274 public: |
1257 GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory, | 1275 GrGLSpecularLightingEffect(const GrBackendProcessorFactory&, const GrProcess
or&); |
1258 const GrEffect& effect); | |
1259 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERR
IDE; | 1276 virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERR
IDE; |
1260 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 1277 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
1261 | 1278 |
1262 private: | 1279 private: |
1263 typedef GrGLLightingEffect INHERITED; | 1280 typedef GrGLLightingEffect INHERITED; |
1264 | 1281 |
1265 UniformHandle fKSUni; | 1282 UniformHandle fKSUni; |
1266 UniformHandle fShininessUni; | 1283 UniformHandle fShininessUni; |
1267 }; | 1284 }; |
1268 | 1285 |
1269 /////////////////////////////////////////////////////////////////////////////// | 1286 /////////////////////////////////////////////////////////////////////////////// |
1270 | 1287 |
1271 GrLightingEffect::GrLightingEffect(GrTexture* texture, | 1288 GrLightingEffect::GrLightingEffect(GrTexture* texture, |
1272 const SkLight* light, | 1289 const SkLight* light, |
1273 SkScalar surfaceScale, | 1290 SkScalar surfaceScale, |
1274 const SkMatrix& matrix) | 1291 const SkMatrix& matrix) |
1275 : INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture)) | 1292 : INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture)) |
1276 , fLight(light) | 1293 , fLight(light) |
1277 , fSurfaceScale(surfaceScale) | 1294 , fSurfaceScale(surfaceScale) |
1278 , fFilterMatrix(matrix) { | 1295 , fFilterMatrix(matrix) { |
1279 fLight->ref(); | 1296 fLight->ref(); |
1280 if (light->requiresFragmentPosition()) { | 1297 if (light->requiresFragmentPosition()) { |
1281 this->setWillReadFragmentPosition(); | 1298 this->setWillReadFragmentPosition(); |
1282 } | 1299 } |
1283 } | 1300 } |
1284 | 1301 |
1285 GrLightingEffect::~GrLightingEffect() { | 1302 GrLightingEffect::~GrLightingEffect() { |
1286 fLight->unref(); | 1303 fLight->unref(); |
1287 } | 1304 } |
1288 | 1305 |
1289 bool GrLightingEffect::onIsEqual(const GrEffect& sBase) const { | 1306 bool GrLightingEffect::onIsEqual(const GrProcessor& sBase) const { |
1290 const GrLightingEffect& s = sBase.cast<GrLightingEffect>(); | 1307 const GrLightingEffect& s = sBase.cast<GrLightingEffect>(); |
1291 return this->texture(0) == s.texture(0) && | 1308 return this->texture(0) == s.texture(0) && |
1292 fLight->isEqual(*s.fLight) && | 1309 fLight->isEqual(*s.fLight) && |
1293 fSurfaceScale == s.fSurfaceScale; | 1310 fSurfaceScale == s.fSurfaceScale; |
1294 } | 1311 } |
1295 | 1312 |
1296 /////////////////////////////////////////////////////////////////////////////// | 1313 /////////////////////////////////////////////////////////////////////////////// |
1297 | 1314 |
1298 GrDiffuseLightingEffect::GrDiffuseLightingEffect(GrTexture* texture, | 1315 GrDiffuseLightingEffect::GrDiffuseLightingEffect(GrTexture* texture, |
1299 const SkLight* light, | 1316 const SkLight* light, |
1300 SkScalar surfaceScale, | 1317 SkScalar surfaceScale, |
1301 const SkMatrix& matrix, | 1318 const SkMatrix& matrix, |
1302 SkScalar kd) | 1319 SkScalar kd) |
1303 : INHERITED(texture, light, surfaceScale, matrix), fKD(kd) { | 1320 : INHERITED(texture, light, surfaceScale, matrix), fKD(kd) { |
1304 } | 1321 } |
1305 | 1322 |
1306 const GrBackendEffectFactory& GrDiffuseLightingEffect::getFactory() const { | 1323 const GrBackendFragmentProcessorFactory& GrDiffuseLightingEffect::getFactory() c
onst { |
1307 return GrTBackendEffectFactory<GrDiffuseLightingEffect>::getInstance(); | 1324 return GrTBackendFragmentProcessorFactory<GrDiffuseLightingEffect>::getInsta
nce(); |
1308 } | 1325 } |
1309 | 1326 |
1310 bool GrDiffuseLightingEffect::onIsEqual(const GrEffect& sBase) const { | 1327 bool GrDiffuseLightingEffect::onIsEqual(const GrProcessor& sBase) const { |
1311 const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>(); | 1328 const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>(); |
1312 return INHERITED::onIsEqual(sBase) && | 1329 return INHERITED::onIsEqual(sBase) && |
1313 this->kd() == s.kd(); | 1330 this->kd() == s.kd(); |
1314 } | 1331 } |
1315 | 1332 |
1316 GR_DEFINE_EFFECT_TEST(GrDiffuseLightingEffect); | 1333 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect); |
1317 | 1334 |
1318 GrEffect* GrDiffuseLightingEffect::TestCreate(SkRandom* random, | 1335 GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(SkRandom* random, |
1319 GrContext* context, | 1336 GrContext* context, |
1320 const GrDrawTargetCaps&, | 1337 const GrDrawTargetCaps&, |
1321 GrTexture* textures[]) { | 1338 GrTexture* textures[]) { |
1322 SkScalar surfaceScale = random->nextSScalar1(); | 1339 SkScalar surfaceScale = random->nextSScalar1(); |
1323 SkScalar kd = random->nextUScalar1(); | 1340 SkScalar kd = random->nextUScalar1(); |
1324 SkAutoTUnref<SkLight> light(create_random_light(random)); | 1341 SkAutoTUnref<SkLight> light(create_random_light(random)); |
1325 SkMatrix matrix; | 1342 SkMatrix matrix; |
1326 for (int i = 0; i < 9; i++) { | 1343 for (int i = 0; i < 9; i++) { |
1327 matrix[i] = random->nextUScalar1(); | 1344 matrix[i] = random->nextUScalar1(); |
1328 } | 1345 } |
1329 return GrDiffuseLightingEffect::Create(textures[GrEffectUnitTest::kAlphaText
ureIdx], | 1346 return GrDiffuseLightingEffect::Create(textures[GrProcessorUnitTest::kAlphaT
extureIdx], |
1330 light, surfaceScale, matrix, kd); | 1347 light, surfaceScale, matrix, kd); |
1331 } | 1348 } |
1332 | 1349 |
1333 | 1350 |
1334 /////////////////////////////////////////////////////////////////////////////// | 1351 /////////////////////////////////////////////////////////////////////////////// |
1335 | 1352 |
1336 GrGLLightingEffect::GrGLLightingEffect(const GrBackendEffectFactory& factory, | 1353 GrGLLightingEffect::GrGLLightingEffect(const GrBackendProcessorFactory& factory, |
1337 const GrEffect& effect) | 1354 const GrProcessor& fp) |
1338 : INHERITED(factory) { | 1355 : INHERITED(factory) { |
1339 const GrLightingEffect& m = effect.cast<GrLightingEffect>(); | 1356 const GrLightingEffect& m = fp.cast<GrLightingEffect>(); |
1340 fLight = m.light()->createGLLight(); | 1357 fLight = m.light()->createGLLight(); |
1341 } | 1358 } |
1342 | 1359 |
1343 GrGLLightingEffect::~GrGLLightingEffect() { | 1360 GrGLLightingEffect::~GrGLLightingEffect() { |
1344 delete fLight; | 1361 delete fLight; |
1345 } | 1362 } |
1346 | 1363 |
1347 void GrGLLightingEffect::emitCode(GrGLProgramBuilder* builder, | 1364 void GrGLLightingEffect::emitCode(GrGLProgramBuilder* builder, |
1348 const GrEffect&, | 1365 const GrFragmentProcessor&, |
1349 const GrEffectKey& key, | 1366 const GrProcessorKey& key, |
1350 const char* outputColor, | 1367 const char* outputColor, |
1351 const char* inputColor, | 1368 const char* inputColor, |
1352 const TransformedCoordsArray& coords, | 1369 const TransformedCoordsArray& coords, |
1353 const TextureSamplerArray& samplers) { | 1370 const TextureSamplerArray& samplers) { |
1354 fImageIncrementUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visib
ility, | 1371 fImageIncrementUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visib
ility, |
1355 kVec2f_GrSLType, | 1372 kVec2f_GrSLType, |
1356 "ImageIncrement"); | 1373 "ImageIncrement"); |
1357 fSurfaceScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibil
ity, | 1374 fSurfaceScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibil
ity, |
1358 kFloat_GrSLType, | 1375 kFloat_GrSLType, |
1359 "SurfaceScale"); | 1376 "SurfaceScale"); |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1434 fsBuilder->codeAppend(";\n"); | 1451 fsBuilder->codeAppend(";\n"); |
1435 fsBuilder->codeAppendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ", | 1452 fsBuilder->codeAppendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ", |
1436 outputColor, lightFunc.c_str(), interiorNormalName.c_
str(), surfScale); | 1453 outputColor, lightFunc.c_str(), interiorNormalName.c_
str(), surfScale); |
1437 fLight->emitLightColor(builder, "surfaceToLight"); | 1454 fLight->emitLightColor(builder, "surfaceToLight"); |
1438 fsBuilder->codeAppend(");\n"); | 1455 fsBuilder->codeAppend(");\n"); |
1439 SkString modulate; | 1456 SkString modulate; |
1440 GrGLSLMulVarBy4f(&modulate, 2, outputColor, inputColor); | 1457 GrGLSLMulVarBy4f(&modulate, 2, outputColor, inputColor); |
1441 fsBuilder->codeAppend(modulate.c_str()); | 1458 fsBuilder->codeAppend(modulate.c_str()); |
1442 } | 1459 } |
1443 | 1460 |
1444 void GrGLLightingEffect::GenKey(const GrEffect& effect, | 1461 void GrGLLightingEffect::GenKey(const GrProcessor& proc, |
1445 const GrGLCaps& caps, GrEffectKeyBuilder* b) { | 1462 const GrGLCaps& caps, GrProcessorKeyBuilder* b)
{ |
1446 b->add32(effect.cast<GrLightingEffect>().light()->type()); | 1463 b->add32(proc.cast<GrLightingEffect>().light()->type()); |
1447 } | 1464 } |
1448 | 1465 |
1449 void GrGLLightingEffect::setData(const GrGLProgramDataManager& pdman, | 1466 void GrGLLightingEffect::setData(const GrGLProgramDataManager& pdman, |
1450 const GrEffect& effect) { | 1467 const GrProcessor& proc) { |
1451 const GrLightingEffect& lighting = effect.cast<GrLightingEffect>(); | 1468 const GrLightingEffect& lighting = proc.cast<GrLightingEffect>(); |
1452 GrTexture* texture = lighting.texture(0); | 1469 GrTexture* texture = lighting.texture(0); |
1453 float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f; | 1470 float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f; |
1454 pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->he
ight()); | 1471 pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->he
ight()); |
1455 pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale()); | 1472 pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale()); |
1456 SkAutoTUnref<SkLight> transformedLight(lighting.light()->transform(lighting.
filterMatrix())); | 1473 SkAutoTUnref<SkLight> transformedLight(lighting.light()->transform(lighting.
filterMatrix())); |
1457 fLight->setData(pdman, transformedLight); | 1474 fLight->setData(pdman, transformedLight); |
1458 } | 1475 } |
1459 | 1476 |
1460 /////////////////////////////////////////////////////////////////////////////// | 1477 /////////////////////////////////////////////////////////////////////////////// |
1461 | 1478 |
1462 /////////////////////////////////////////////////////////////////////////////// | 1479 /////////////////////////////////////////////////////////////////////////////// |
1463 | 1480 |
1464 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendEffectFactor
y& factory, | 1481 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendProcessorFac
tory& factory, |
1465 const GrEffect& effect) | 1482 const GrProcessor& proc) |
1466 : INHERITED(factory, effect) { | 1483 : INHERITED(factory, proc) { |
1467 } | 1484 } |
1468 | 1485 |
1469 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkStr
ing* funcName) { | 1486 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkStr
ing* funcName) { |
1470 const char* kd; | 1487 const char* kd; |
1471 fKDUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1488 fKDUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1472 kFloat_GrSLType, | 1489 kFloat_GrSLType, |
1473 "KD", | 1490 "KD", |
1474 &kd); | 1491 &kd); |
1475 | 1492 |
1476 static const GrGLShaderVar gLightArgs[] = { | 1493 static const GrGLShaderVar gLightArgs[] = { |
1477 GrGLShaderVar("normal", kVec3f_GrSLType), | 1494 GrGLShaderVar("normal", kVec3f_GrSLType), |
1478 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType), | 1495 GrGLShaderVar("surfaceToLight", kVec3f_GrSLType), |
1479 GrGLShaderVar("lightColor", kVec3f_GrSLType) | 1496 GrGLShaderVar("lightColor", kVec3f_GrSLType) |
1480 }; | 1497 }; |
1481 SkString lightBody; | 1498 SkString lightBody; |
1482 lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n"
, kd); | 1499 lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n"
, kd); |
1483 lightBody.appendf("\treturn vec4(lightColor * clamp(colorScale, 0.0, 1.0), 1
.0);\n"); | 1500 lightBody.appendf("\treturn vec4(lightColor * clamp(colorScale, 0.0, 1.0), 1
.0);\n"); |
1484 builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType, | 1501 builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType, |
1485 "light", | 1502 "light", |
1486 SK_ARRAY_COUNT(gLightArgs)
, | 1503 SK_ARRAY_COUNT(gLightArgs)
, |
1487 gLightArgs, | 1504 gLightArgs, |
1488 lightBody.c_str(), | 1505 lightBody.c_str(), |
1489 funcName); | 1506 funcName); |
1490 } | 1507 } |
1491 | 1508 |
1492 void GrGLDiffuseLightingEffect::setData(const GrGLProgramDataManager& pdman, | 1509 void GrGLDiffuseLightingEffect::setData(const GrGLProgramDataManager& pdman, |
1493 const GrEffect& effect) { | 1510 const GrProcessor& proc) { |
1494 INHERITED::setData(pdman, effect); | 1511 INHERITED::setData(pdman, proc); |
1495 const GrDiffuseLightingEffect& diffuse = effect.cast<GrDiffuseLightingEffect
>(); | 1512 const GrDiffuseLightingEffect& diffuse = proc.cast<GrDiffuseLightingEffect>(
); |
1496 pdman.set1f(fKDUni, diffuse.kd()); | 1513 pdman.set1f(fKDUni, diffuse.kd()); |
1497 } | 1514 } |
1498 | 1515 |
1499 /////////////////////////////////////////////////////////////////////////////// | 1516 /////////////////////////////////////////////////////////////////////////////// |
1500 | 1517 |
1501 GrSpecularLightingEffect::GrSpecularLightingEffect(GrTexture* texture, | 1518 GrSpecularLightingEffect::GrSpecularLightingEffect(GrTexture* texture, |
1502 const SkLight* light, | 1519 const SkLight* light, |
1503 SkScalar surfaceScale, | 1520 SkScalar surfaceScale, |
1504 const SkMatrix& matrix, | 1521 const SkMatrix& matrix, |
1505 SkScalar ks, | 1522 SkScalar ks, |
1506 SkScalar shininess) | 1523 SkScalar shininess) |
1507 : INHERITED(texture, light, surfaceScale, matrix), | 1524 : INHERITED(texture, light, surfaceScale, matrix), |
1508 fKS(ks), | 1525 fKS(ks), |
1509 fShininess(shininess) { | 1526 fShininess(shininess) { |
1510 } | 1527 } |
1511 | 1528 |
1512 const GrBackendEffectFactory& GrSpecularLightingEffect::getFactory() const { | 1529 const GrBackendFragmentProcessorFactory& GrSpecularLightingEffect::getFactory()
const { |
1513 return GrTBackendEffectFactory<GrSpecularLightingEffect>::getInstance(); | 1530 return GrTBackendFragmentProcessorFactory<GrSpecularLightingEffect>::getInst
ance(); |
1514 } | 1531 } |
1515 | 1532 |
1516 bool GrSpecularLightingEffect::onIsEqual(const GrEffect& sBase) const { | 1533 bool GrSpecularLightingEffect::onIsEqual(const GrProcessor& sBase) const { |
1517 const GrSpecularLightingEffect& s = sBase.cast<GrSpecularLightingEffect>(); | 1534 const GrSpecularLightingEffect& s = sBase.cast<GrSpecularLightingEffect>(); |
1518 return INHERITED::onIsEqual(sBase) && | 1535 return INHERITED::onIsEqual(sBase) && |
1519 this->ks() == s.ks() && | 1536 this->ks() == s.ks() && |
1520 this->shininess() == s.shininess(); | 1537 this->shininess() == s.shininess(); |
1521 } | 1538 } |
1522 | 1539 |
1523 GR_DEFINE_EFFECT_TEST(GrSpecularLightingEffect); | 1540 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect); |
1524 | 1541 |
1525 GrEffect* GrSpecularLightingEffect::TestCreate(SkRandom* random, | 1542 GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(SkRandom* random, |
1526 GrContext* context, | 1543 GrContext* context, |
1527 const GrDrawTargetCaps&, | 1544 const GrDrawTargetCaps
&, |
1528 GrTexture* textures[]) { | 1545 GrTexture* textures[])
{ |
1529 SkScalar surfaceScale = random->nextSScalar1(); | 1546 SkScalar surfaceScale = random->nextSScalar1(); |
1530 SkScalar ks = random->nextUScalar1(); | 1547 SkScalar ks = random->nextUScalar1(); |
1531 SkScalar shininess = random->nextUScalar1(); | 1548 SkScalar shininess = random->nextUScalar1(); |
1532 SkAutoTUnref<SkLight> light(create_random_light(random)); | 1549 SkAutoTUnref<SkLight> light(create_random_light(random)); |
1533 SkMatrix matrix; | 1550 SkMatrix matrix; |
1534 for (int i = 0; i < 9; i++) { | 1551 for (int i = 0; i < 9; i++) { |
1535 matrix[i] = random->nextUScalar1(); | 1552 matrix[i] = random->nextUScalar1(); |
1536 } | 1553 } |
1537 return GrSpecularLightingEffect::Create(textures[GrEffectUnitTest::kAlphaTex
tureIdx], | 1554 return GrSpecularLightingEffect::Create(textures[GrProcessorUnitTest::kAlpha
TextureIdx], |
1538 light, surfaceScale, matrix, ks, shi
niness); | 1555 light, surfaceScale, matrix, ks, shi
niness); |
1539 } | 1556 } |
1540 | 1557 |
1541 /////////////////////////////////////////////////////////////////////////////// | 1558 /////////////////////////////////////////////////////////////////////////////// |
1542 | 1559 |
1543 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendEffectFact
ory& factory, | 1560 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendProcessorF
actory& factory, |
1544 const GrEffect& effect) | 1561 const GrProcessor& proc) |
1545 : INHERITED(factory, effect) { | 1562 : INHERITED(factory, proc) { |
1546 } | 1563 } |
1547 | 1564 |
1548 void GrGLSpecularLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkSt
ring* funcName) { | 1565 void GrGLSpecularLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkSt
ring* funcName) { |
1549 const char* ks; | 1566 const char* ks; |
1550 const char* shininess; | 1567 const char* shininess; |
1551 | 1568 |
1552 fKSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1569 fKSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1553 kFloat_GrSLType, "KS", &ks); | 1570 kFloat_GrSLType, "KS", &ks); |
1554 fShininessUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, | 1571 fShininessUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility
, |
1555 kFloat_GrSLType, "Shininess", &shininess
); | 1572 kFloat_GrSLType, "Shininess", &shininess
); |
(...skipping 10 matching lines...) Expand all Loading... |
1566 lightBody.appendf("\treturn vec4(color, max(max(color.r, color.g), color.b))
;\n"); | 1583 lightBody.appendf("\treturn vec4(color, max(max(color.r, color.g), color.b))
;\n"); |
1567 builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType, | 1584 builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType, |
1568 "light", | 1585 "light", |
1569 SK_ARRAY_COUNT(gLightArgs)
, | 1586 SK_ARRAY_COUNT(gLightArgs)
, |
1570 gLightArgs, | 1587 gLightArgs, |
1571 lightBody.c_str(), | 1588 lightBody.c_str(), |
1572 funcName); | 1589 funcName); |
1573 } | 1590 } |
1574 | 1591 |
1575 void GrGLSpecularLightingEffect::setData(const GrGLProgramDataManager& pdman, | 1592 void GrGLSpecularLightingEffect::setData(const GrGLProgramDataManager& pdman, |
1576 const GrEffect& effect) { | 1593 const GrProcessor& effect) { |
1577 INHERITED::setData(pdman, effect); | 1594 INHERITED::setData(pdman, effect); |
1578 const GrSpecularLightingEffect& spec = effect.cast<GrSpecularLightingEffect>
(); | 1595 const GrSpecularLightingEffect& spec = effect.cast<GrSpecularLightingEffect>
(); |
1579 pdman.set1f(fKSUni, spec.ks()); | 1596 pdman.set1f(fKSUni, spec.ks()); |
1580 pdman.set1f(fShininessUni, spec.shininess()); | 1597 pdman.set1f(fShininessUni, spec.shininess()); |
1581 } | 1598 } |
1582 | 1599 |
1583 /////////////////////////////////////////////////////////////////////////////// | 1600 /////////////////////////////////////////////////////////////////////////////// |
1584 void GrGLLight::emitLightColorUniform(GrGLProgramBuilder* builder) { | 1601 void GrGLLight::emitLightColorUniform(GrGLProgramBuilder* builder) { |
1585 fColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1602 fColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1586 kVec3f_GrSLType, "LightColor"); | 1603 kVec3f_GrSLType, "LightColor"); |
1587 } | 1604 } |
1588 | 1605 |
1589 void GrGLLight::emitLightColor(GrGLProgramBuilder* builder, | 1606 void GrGLLight::emitLightColor(GrGLProgramBuilder* builder, |
1590 const char *surfaceToLight) { | 1607 const char *surfaceToLight) { |
1591 builder->getFragmentShaderBuilder()-> | 1608 builder->getFragmentShaderBuilder()->codeAppend(builder->getUniformCStr(this
->lightColorUni())); |
1592 codeAppend(builder->getUniformCStr(this->lightColorUni())); | |
1593 } | 1609 } |
1594 | 1610 |
1595 void GrGLLight::setData(const GrGLProgramDataManager& pdman, | 1611 void GrGLLight::setData(const GrGLProgramDataManager& pdman, |
1596 const SkLight* light) const { | 1612 const SkLight* light) const { |
1597 setUniformPoint3(pdman, fColorUni, light->color() * SkScalarInvert(SkIntToSc
alar(255))); | 1613 setUniformPoint3(pdman, fColorUni, light->color() * SkScalarInvert(SkIntToSc
alar(255))); |
1598 } | 1614 } |
1599 | 1615 |
1600 /////////////////////////////////////////////////////////////////////////////// | 1616 /////////////////////////////////////////////////////////////////////////////// |
1601 | 1617 |
1602 void GrGLDistantLight::setData(const GrGLProgramDataManager& pdman, | 1618 void GrGLDistantLight::setData(const GrGLProgramDataManager& pdman, |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1703 | 1719 |
1704 fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight); | 1720 fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight); |
1705 } | 1721 } |
1706 | 1722 |
1707 #endif | 1723 #endif |
1708 | 1724 |
1709 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter) | 1725 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter) |
1710 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter) | 1726 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter) |
1711 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter) | 1727 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter) |
1712 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | 1728 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
OLD | NEW |