Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(180)

Side by Side Diff: src/effects/SkLightingImageFilter.cpp

Issue 582963002: Solo gp (Closed) Base URL: https://skia.googlesource.com/skia.git@no_peb
Patch Set: rebase Created 6 years, 2 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:
View unified diff | Download patch
« no previous file with comments | « src/effects/SkGpuBlurUtils.cpp ('k') | src/effects/SkLumaColorFilter.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « src/effects/SkGpuBlurUtils.cpp ('k') | src/effects/SkLumaColorFilter.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698