OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2014 Google Inc. | 3 * Copyright 2014 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 #include "gm.h" | 9 #include "gm.h" |
10 #if SK_SUPPORT_GPU | 10 #if SK_SUPPORT_GPU |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
43 } | 43 } |
44 #endif | 44 #endif |
45 | 45 |
46 private: | 46 private: |
47 const SkMatrix fDeviceMatrix; | 47 const SkMatrix fDeviceMatrix; |
48 }; | 48 }; |
49 | 49 |
50 SkFlattenable* DCShader::CreateProc(SkReadBuffer& buf) { | 50 SkFlattenable* DCShader::CreateProc(SkReadBuffer& buf) { |
51 SkMatrix matrix; | 51 SkMatrix matrix; |
52 buf.readMatrix(&matrix); | 52 buf.readMatrix(&matrix); |
53 return SkNEW_ARGS(DCShader, (matrix)); | 53 return new DCShader(matrix); |
54 } | 54 } |
55 | 55 |
56 class DCFP : public GrFragmentProcessor { | 56 class DCFP : public GrFragmentProcessor { |
57 public: | 57 public: |
58 DCFP(GrProcessorDataManager*, const SkMatrix& m) : fDeviceTransform(kDevice_
GrCoordSet, m) { | 58 DCFP(GrProcessorDataManager*, const SkMatrix& m) : fDeviceTransform(kDevice_
GrCoordSet, m) { |
59 this->addCoordTransform(&fDeviceTransform); | 59 this->addCoordTransform(&fDeviceTransform); |
60 this->initClassID<DCFP>(); | 60 this->initClassID<DCFP>(); |
61 } | 61 } |
62 | 62 |
63 GrGLFragmentProcessor* onCreateGLInstance() const override { | 63 GrGLFragmentProcessor* onCreateGLInstance() const override { |
64 class DCGLFP : public GrGLFragmentProcessor { | 64 class DCGLFP : public GrGLFragmentProcessor { |
65 void emitCode(EmitArgs& args) override { | 65 void emitCode(EmitArgs& args) override { |
66 GrGLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuild
er(); | 66 GrGLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuild
er(); |
67 fpb->codeAppendf("vec2 c = %s;", fpb->ensureFSCoords2D(args.fCoo
rds, 0).c_str()); | 67 fpb->codeAppendf("vec2 c = %s;", fpb->ensureFSCoords2D(args.fCoo
rds, 0).c_str()); |
68 fpb->codeAppend("vec2 r = mod(c, vec2(20.0));"); | 68 fpb->codeAppend("vec2 r = mod(c, vec2(20.0));"); |
69 fpb->codeAppend("vec4 color = vec4(0.5*sin(c.x / 15.0) + 0.5," | 69 fpb->codeAppend("vec4 color = vec4(0.5*sin(c.x / 15.0) + 0.5," |
70 "0.5*cos((c.x + c.y) / 15.0)
+ 0.5," | 70 "0.5*cos((c.x + c.y) / 15.0)
+ 0.5," |
71 "(r.x + r.y) / 20.0," | 71 "(r.x + r.y) / 20.0," |
72 "distance(r, vec2(15.0)) / 2
0.0 + 0.2);"); | 72 "distance(r, vec2(15.0)) / 2
0.0 + 0.2);"); |
73 fpb->codeAppendf("color.rgb *= color.a;" | 73 fpb->codeAppendf("color.rgb *= color.a;" |
74 "%s = color * %s;", | 74 "%s = color * %s;", |
75 args.fOutputColor, GrGLSLExpr4(args.fInputCo
lor).c_str()); | 75 args.fOutputColor, GrGLSLExpr4(args.fInputCo
lor).c_str()); |
76 } | 76 } |
77 void onSetData(const GrGLProgramDataManager&, const GrProcessor&) ov
erride {} | 77 void onSetData(const GrGLProgramDataManager&, const GrProcessor&) ov
erride {} |
78 }; | 78 }; |
79 return SkNEW(DCGLFP); | 79 return new DCGLFP; |
80 } | 80 } |
81 | 81 |
82 const char* name() const override { return "DCFP"; } | 82 const char* name() const override { return "DCFP"; } |
83 | 83 |
84 void onComputeInvariantOutput(GrInvariantOutput* inout) const override { | 84 void onComputeInvariantOutput(GrInvariantOutput* inout) const override { |
85 inout->mulByUnknownFourComponents(); | 85 inout->mulByUnknownFourComponents(); |
86 } | 86 } |
87 | 87 |
88 private: | 88 private: |
89 void onGetGLProcessorKey(const GrGLSLCaps& caps, | 89 void onGetGLProcessorKey(const GrGLSLCaps& caps, |
90 GrProcessorKeyBuilder* b) const override {} | 90 GrProcessorKeyBuilder* b) const override {} |
91 | 91 |
92 bool onIsEqual(const GrFragmentProcessor&) const override { return true; } | 92 bool onIsEqual(const GrFragmentProcessor&) const override { return true; } |
93 | 93 |
94 GrCoordTransform fDeviceTransform; | 94 GrCoordTransform fDeviceTransform; |
95 }; | 95 }; |
96 | 96 |
97 bool DCShader::asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMat
rix& viewM, | 97 bool DCShader::asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMat
rix& viewM, |
98 const SkMatrix* localMatrix, GrColor* color, | 98 const SkMatrix* localMatrix, GrColor* color, |
99 GrProcessorDataManager* procDataManager, | 99 GrProcessorDataManager* procDataManager, |
100 GrFragmentProcessor** fp) const { | 100 GrFragmentProcessor** fp) const { |
101 *fp = SkNEW_ARGS(DCFP, (procDataManager, fDeviceMatrix)); | 101 *fp = new DCFP(procDataManager, fDeviceMatrix); |
102 *color = GrColorPackA4(paint.getAlpha()); | 102 *color = GrColorPackA4(paint.getAlpha()); |
103 return true; | 103 return true; |
104 } | 104 } |
105 | 105 |
106 class DCShaderGM : public GM { | 106 class DCShaderGM : public GM { |
107 public: | 107 public: |
108 DCShaderGM() { | 108 DCShaderGM() { |
109 this->setBGColor(sk_tool_utils::color_to_565(0xFFAABBCC)); | 109 this->setBGColor(sk_tool_utils::color_to_565(0xFFAABBCC)); |
110 } | 110 } |
111 | 111 |
112 ~DCShaderGM() override { | 112 ~DCShaderGM() override { |
113 for (int i = 0; i < fPrims.count(); ++i) { | 113 for (int i = 0; i < fPrims.count(); ++i) { |
114 SkDELETE(fPrims[i]); | 114 delete fPrims[i]; |
115 } | 115 } |
116 } | 116 } |
117 | 117 |
118 protected: | 118 protected: |
119 | 119 |
120 SkString onShortName() override { | 120 SkString onShortName() override { |
121 return SkString("dcshader"); | 121 return SkString("dcshader"); |
122 } | 122 } |
123 | 123 |
124 SkISize onISize() override { return SkISize::Make(1000, 900); } | 124 SkISize onISize() override { return SkISize::Make(1000, 900); } |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
205 return bounds; | 205 return bounds; |
206 } | 206 } |
207 | 207 |
208 virtual void setFont(SkPaint* paint) { | 208 virtual void setFont(SkPaint* paint) { |
209 sk_tool_utils::set_portable_typeface(paint); | 209 sk_tool_utils::set_portable_typeface(paint); |
210 } | 210 } |
211 | 211 |
212 virtual const char* text() const { return "Hello, Skia!"; } | 212 virtual const char* text() const { return "Hello, Skia!"; } |
213 }; | 213 }; |
214 | 214 |
215 fPrims.push_back(SkNEW(Rect)); | 215 fPrims.push_back(new Rect); |
216 fPrims.push_back(SkNEW(Circle)); | 216 fPrims.push_back(new Circle); |
217 fPrims.push_back(SkNEW(RRect)); | 217 fPrims.push_back(new RRect); |
218 fPrims.push_back(SkNEW(DRRect)); | 218 fPrims.push_back(new DRRect); |
219 fPrims.push_back(SkNEW(Path)); | 219 fPrims.push_back(new Path); |
220 fPrims.push_back(SkNEW(Points(SkCanvas::kPoints_PointMode))); | 220 fPrims.push_back(new Points(SkCanvas::kPoints_PointMode)); |
221 fPrims.push_back(SkNEW(Points(SkCanvas::kLines_PointMode))); | 221 fPrims.push_back(new Points(SkCanvas::kLines_PointMode)); |
222 fPrims.push_back(SkNEW(Points(SkCanvas::kPolygon_PointMode))); | 222 fPrims.push_back(new Points(SkCanvas::kPolygon_PointMode)); |
223 fPrims.push_back(SkNEW(Text)); | 223 fPrims.push_back(new Text); |
224 } | 224 } |
225 | 225 |
226 void onDraw(SkCanvas* canvas) override { | 226 void onDraw(SkCanvas* canvas) override { |
227 // This GM exists to test a specific feature of the GPU backend. It does
not work with the | 227 // This GM exists to test a specific feature of the GPU backend. It does
not work with the |
228 // sw rasterizer, tile modes, etc. | 228 // sw rasterizer, tile modes, etc. |
229 if (NULL == canvas->getGrContext()) { | 229 if (NULL == canvas->getGrContext()) { |
230 this->drawGpuOnlyMessage(canvas); | 230 this->drawGpuOnlyMessage(canvas); |
231 return; | 231 return; |
232 } | 232 } |
233 SkPaint paint; | 233 SkPaint paint; |
(...skipping 12 matching lines...) Expand all Loading... |
246 | 246 |
247 canvas->translate(10, 20); | 247 canvas->translate(10, 20); |
248 canvas->save(); | 248 canvas->save(); |
249 SkScalar tx = 0, maxTy = 0; | 249 SkScalar tx = 0, maxTy = 0; |
250 static const SkScalar kW = 900; | 250 static const SkScalar kW = 900; |
251 | 251 |
252 for (int aa = 0; aa < 2; ++aa) { | 252 for (int aa = 0; aa < 2; ++aa) { |
253 for (int i = 0; i < fPrims.count(); ++i) { | 253 for (int i = 0; i < fPrims.count(); ++i) { |
254 for (int j = 0; j < devMats.count(); ++j) { | 254 for (int j = 0; j < devMats.count(); ++j) { |
255 for (int k = 0; k < viewMats.count(); ++k) { | 255 for (int k = 0; k < viewMats.count(); ++k) { |
256 paint.setShader(SkNEW_ARGS(DCShader, (devMats[j])))->unr
ef(); | 256 paint.setShader(new DCShader(devMats[j]))->unref(); |
257 paint.setAntiAlias(SkToBool(aa)); | 257 paint.setAntiAlias(SkToBool(aa)); |
258 canvas->save(); | 258 canvas->save(); |
259 canvas->concat(viewMats[k]); | 259 canvas->concat(viewMats[k]); |
260 SkRect bounds = fPrims[i]->draw(canvas, paint); | 260 SkRect bounds = fPrims[i]->draw(canvas, paint); |
261 canvas->restore(); | 261 canvas->restore(); |
262 viewMats[k].mapRect(&bounds); | 262 viewMats[k].mapRect(&bounds); |
263 // add margins | 263 // add margins |
264 bounds.fRight += 20; | 264 bounds.fRight += 20; |
265 bounds.fBottom += 20; | 265 bounds.fBottom += 20; |
266 canvas->translate(bounds.fRight, 0); | 266 canvas->translate(bounds.fRight, 0); |
(...skipping 17 matching lines...) Expand all Loading... |
284 struct Prim { | 284 struct Prim { |
285 virtual ~Prim() {} | 285 virtual ~Prim() {} |
286 virtual SkRect draw(SkCanvas*, const SkPaint&) = 0; | 286 virtual SkRect draw(SkCanvas*, const SkPaint&) = 0; |
287 }; | 287 }; |
288 | 288 |
289 SkTArray<Prim*> fPrims; | 289 SkTArray<Prim*> fPrims; |
290 | 290 |
291 typedef GM INHERITED; | 291 typedef GM INHERITED; |
292 }; | 292 }; |
293 | 293 |
294 DEF_GM( return SkNEW(DCShaderGM); ) | 294 DEF_GM(return new DCShaderGM;) |
295 } | 295 } |
296 #endif | 296 #endif |
OLD | NEW |