dcshader.cpp revision 29bee0fe657fabf7c396502b69c9167fba13eaaa 
1
2/*
3 * Copyright 2014 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9#include "gm.h"
10#if SK_SUPPORT_GPU
11#include "GrFragmentProcessor.h"
12#include "GrCoordTransform.h"
13#include "gl/GrGLProcessor.h"
14#include "gl/builders/GrGLProgramBuilder.h"
15#include "Resources.h"
16#include "SkReadBuffer.h"
17#include "SkShader.h"
18#include "SkStream.h"
19#include "SkTypeface.h"
20#include "SkWriteBuffer.h"
21
22namespace skiagm {
23
24///////////////////////////////////////////////////////////////////////////////
25
26class DCShader : public SkShader {
27public:
28    DCShader(const SkMatrix& matrix) : fDeviceMatrix(matrix) {}
29
30    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(DCShader);
31
32    void flatten(SkWriteBuffer& buf) const override {
33        buf.writeMatrix(fDeviceMatrix);
34    }
35
36    bool asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
37                             const SkMatrix* localMatrix, GrColor* color,
38                             GrFragmentProcessor** fp) const override;
39
40#ifndef SK_IGNORE_TO_STRING
41    void toString(SkString* str) const override {
42        str->appendf("DCShader: ()");
43    }
44#endif
45
46private:
47    const SkMatrix fDeviceMatrix;
48};
49
50SkFlattenable* DCShader::CreateProc(SkReadBuffer& buf) {
51    SkMatrix matrix;
52    buf.readMatrix(&matrix);
53    return SkNEW_ARGS(DCShader, (matrix));
54}
55
56class DCFP : public GrFragmentProcessor {
57public:
58    DCFP(const SkMatrix& m) : fDeviceTransform(kDevice_GrCoordSet, m) {
59        this->addCoordTransform(&fDeviceTransform);
60        this->initClassID<DCFP>();
61    }
62
63    void getGLProcessorKey(const GrGLSLCaps& caps,
64                            GrProcessorKeyBuilder* b) const override {}
65
66    GrGLFragmentProcessor* createGLInstance() const override {
67        class DCGLFP : public GrGLFragmentProcessor {
68            void emitCode(GrGLFPBuilder* builder,
69                            const GrFragmentProcessor& fp,
70                            const char* outputColor,
71                            const char* inputColor,
72                            const TransformedCoordsArray& coords,
73                            const TextureSamplerArray& samplers) {
74                GrGLFragmentBuilder* fpb = builder->getFragmentShaderBuilder();
75                fpb->codeAppendf("vec2 c = %s;", fpb->ensureFSCoords2D(coords, 0).c_str());
76                fpb->codeAppend("vec2 r = mod(c, vec2(20.0));");
77                fpb->codeAppend("vec4 color = vec4(0.5*sin(c.x / 15.0) + 0.5,"
78                                                    "0.5*cos((c.x + c.y) / 15.0) + 0.5,"
79                                                    "(r.x + r.y) / 20.0,"
80                                                    "distance(r, vec2(15.0)) / 20.0 + 0.2);");
81                fpb->codeAppendf("color.rgb *= color.a;"
82                                    "%s = color * %s;",
83                                    outputColor, GrGLSLExpr4(inputColor).c_str());
84            }
85            void setData(const GrGLProgramDataManager&, const GrProcessor&) override {}
86        };
87        return SkNEW(DCGLFP);
88    }
89
90    const char* name() const override { return "DCFP"; }
91
92    void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
93        inout->mulByUnknownFourComponents();
94    }
95
96private:
97    bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
98
99    GrCoordTransform fDeviceTransform;
100};
101
102bool DCShader::asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
103                                   const SkMatrix* localMatrix, GrColor* color,
104                                   GrFragmentProcessor** fp) const {
105    *fp = SkNEW_ARGS(DCFP, (fDeviceMatrix));
106    *color = GrColorPackA4(paint.getAlpha());
107    return true;
108}
109
110class DCShaderGM : public GM {
111public:
112    DCShaderGM() {
113        this->setBGColor(0xFFAABBCC);
114    }
115
116    ~DCShaderGM() override {
117        for (int i = 0; i < fPrims.count(); ++i) {
118            SkDELETE(fPrims[i]);
119        }
120    }
121
122protected:
123
124    SkString onShortName() override {
125        return SkString("dcshader");
126    }
127
128    SkISize onISize() override { return SkISize::Make(1000, 900); }
129
130    void onOnceBeforeDraw() override {
131        struct Rect : public Prim {
132            SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
133                SkRect rect = SkRect::MakeXYWH(0, 0, 50, 50);
134                canvas->drawRect(rect, paint);
135                return rect;
136            }
137        };
138
139        struct Circle : public Prim {
140            SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
141                static const SkScalar radius = 25;
142                canvas->drawCircle(radius, radius, radius, paint);
143                return SkRect::MakeXYWH(0, 0, 2 * radius, 2 * radius);
144            }
145        };
146
147        struct RRect : public Prim {
148            SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
149                SkRRect rrect;
150                rrect.setRectXY(SkRect::MakeXYWH(0, 0, 50, 50), 10, 10);
151                canvas->drawRRect(rrect, paint);
152                return rrect.getBounds();
153            }
154        };
155
156        struct DRRect : public Prim {
157            SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
158                SkRRect outerRRect;
159                outerRRect.setRectXY(SkRect::MakeXYWH(0, 0, 50, 50), 5, 5);
160                SkRRect innerRRect;
161                innerRRect.setRectXY(SkRect::MakeXYWH(5, 8, 35, 30), 8, 3);
162                canvas->drawDRRect(outerRRect, innerRRect, paint);
163                return outerRRect.getBounds();
164            }
165        };
166        struct Path : public Prim {
167            SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
168                SkPath path;
169                path.addCircle(15, 15, 10);
170                path.addOval(SkRect::MakeXYWH(2, 2, 22, 37));
171                path.setFillType(SkPath::kEvenOdd_FillType);
172                canvas->drawPath(path, paint);
173                return path.getBounds();
174            }
175        };
176
177        struct Points : public Prim {
178            Points(SkCanvas::PointMode mode) : fMode(mode) {}
179
180            SkRect draw(SkCanvas* canvas, const SkPaint& paint) override {
181                SkRandom random;
182                SkPoint points[500];
183                SkRect bounds = SkRect::MakeWH(50, 50);
184                int count = SkToInt(SK_ARRAY_COUNT(points));
185                if (SkCanvas::kPoints_PointMode != fMode) {
186                    count = SkTMin(count, 10);
187                }
188                for (int p = 0; p < count; ++p) {
189                    points[p].fX = random.nextUScalar1() * bounds.width();
190                    points[p].fY = random.nextUScalar1() * bounds.width();
191                }
192                canvas->drawPoints(fMode, count, points, paint);
193                return bounds;
194            }
195            SkCanvas::PointMode fMode;
196        };
197
198        struct Text : public Prim {
199            SkRect draw(SkCanvas* canvas, const SkPaint& origPaint) override {
200                SkPaint paint = origPaint;
201                paint.setTextSize(30.f);
202                this->setFont(&paint);
203                const char* text = this->text();
204                static const SkVector offset = SkVector::Make(10, 10);
205                canvas->drawText(text, strlen(text), offset.fX, offset.fY, paint);
206                SkRect bounds;
207                paint.measureText(text, strlen(text), &bounds);
208                bounds.offset(offset);
209                return bounds;
210            }
211
212            virtual void setFont(SkPaint* paint) {
213                sk_tool_utils::set_portable_typeface(paint);
214            }
215
216            virtual const char* text() const { return "Hello, Skia!"; }
217        };
218
219        struct BmpText : public Text {
220           void setFont(SkPaint* paint) override {
221               if (!fTypeface) {
222                    SkString filename = GetResourcePath("/Funkster.ttf");
223                    SkAutoTDelete<SkFILEStream> stream(new SkFILEStream(filename.c_str()));
224                    if (!stream->isValid()) {
225                        SkDebugf("Could not find Funkster.ttf, please set --resourcePath "
226                                 "correctly.\n");
227                        return;
228                    }
229                    fTypeface.reset(SkTypeface::CreateFromStream(stream.detach()));
230               }
231               paint->setTypeface(fTypeface);
232            }
233
234            const char* text() const override { return "Hi, Skia!"; }
235
236            SkAutoTUnref<SkTypeface> fTypeface;
237        };
238        fPrims.push_back(SkNEW(Rect));
239        fPrims.push_back(SkNEW(Circle));
240        fPrims.push_back(SkNEW(RRect));
241        fPrims.push_back(SkNEW(DRRect));
242        fPrims.push_back(SkNEW(Path));
243        fPrims.push_back(SkNEW(Points(SkCanvas::kPoints_PointMode)));
244        fPrims.push_back(SkNEW(Points(SkCanvas::kLines_PointMode)));
245        fPrims.push_back(SkNEW(Points(SkCanvas::kPolygon_PointMode)));
246        fPrims.push_back(SkNEW(Text));
247        fPrims.push_back(SkNEW(BmpText));
248    }
249
250    void onDraw(SkCanvas* canvas) override {
251        // This GM exists to test a specific feature of the GPU backend. It does not work with the
252        // sw rasterizer, tile modes, etc.
253        if (NULL == canvas->getGrContext()) {
254            this->drawGpuOnlyMessage(canvas);
255            return;
256        }
257        SkPaint paint;
258        SkTArray<SkMatrix> devMats;
259        devMats.push_back().reset();
260        devMats.push_back().setRotate(45, 500, 500);
261        devMats.push_back().setRotate(-30, 200, 200);
262        devMats.back().setPerspX(-SK_Scalar1 / 2000);
263        devMats.back().setPerspY(SK_Scalar1 / 1000);
264
265
266        SkTArray<SkMatrix> viewMats;
267        viewMats.push_back().setScale(0.75f, 0.75f);
268        viewMats.push_back().setRotate(45, 50, 50);
269        viewMats.back().postScale(0.5f, 1.1f);
270
271        canvas->translate(10, 20);
272        canvas->save();
273        SkScalar tx = 0, maxTy = 0;
274        static const SkScalar kW = 900;
275
276        for (int aa = 0; aa < 2; ++aa) {
277            for (int i = 0; i < fPrims.count(); ++i) {
278                for (int j = 0; j < devMats.count(); ++j) {
279                    for (int k = 0; k < viewMats.count(); ++k) {
280                        paint.setShader(SkNEW_ARGS(DCShader, (devMats[j])))->unref();
281                        paint.setAntiAlias(SkToBool(aa));
282                        canvas->save();
283                        canvas->concat(viewMats[k]);
284                        SkRect bounds = fPrims[i]->draw(canvas, paint);
285                        canvas->restore();
286                        viewMats[k].mapRect(&bounds);
287                        // add margins
288                        bounds.fRight += 20;
289                        bounds.fBottom += 20;
290                        canvas->translate(bounds.fRight, 0);
291                        tx += bounds.fRight;
292                        maxTy = SkTMax(bounds.fBottom, maxTy);
293                        if (tx > kW) {
294                            tx = 0;
295                            canvas->restore();
296                            canvas->translate(0, maxTy);
297                            canvas->save();
298                            maxTy = 0;
299                        }
300                    }
301                }
302            }
303        }
304        canvas->restore();
305    }
306
307private:
308    struct Prim {
309        virtual ~Prim() {}
310        virtual SkRect draw(SkCanvas*, const SkPaint&) = 0;
311    };
312
313    SkTArray<Prim*> fPrims;
314
315    typedef GM INHERITED;
316};
317
318DEF_GM( return SkNEW(DCShaderGM); )
319}
320#endif
321