1/*
2 * Copyright 2016 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "gm.h"
9#include "sk_tool_utils.h"
10#include "SkLightingShader.h"
11#include "SkNormalSource.h"
12#include "SkPoint3.h"
13#include "SkShader.h"
14
15// Create a truncated pyramid normal map
16static SkBitmap make_frustum_normalmap(int texSize) {
17    SkBitmap frustum;
18    frustum.allocN32Pixels(texSize, texSize);
19
20    sk_tool_utils::create_frustum_normal_map(&frustum, SkIRect::MakeWH(texSize, texSize));
21    return frustum;
22}
23
24namespace skiagm {
25
26// This GM exercises lighting shaders. Specifically, nullptr arguments, scaling when using
27// normal maps, paint transparency, zero directional lights, multiple directional lights.
28class LightingShader2GM : public GM {
29public:
30    LightingShader2GM() {
31        this->setBGColor(sk_tool_utils::color_to_565(0xFFCCCCCC));
32    }
33
34protected:
35    SkString onShortName() override {
36        return SkString("lightingshader2");
37    }
38
39    SkISize onISize() override {
40        return SkISize::Make(600, 740);
41    }
42
43    void onOnceBeforeDraw() override {
44        const SkVector3 kLightFromUpperRight = SkVector3::Make(0.788f, 0.394f, 0.473f);
45        const SkVector3 kLightFromUpperLeft = SkVector3::Make(-0.788f, 0.394f, 0.473f);
46
47        // Standard set of lights
48        SkLights::Builder builder;
49        builder.add(SkLights::Light::MakeDirectional(SkColor3f::Make(1.0f, 1.0f, 1.0f),
50                                                     kLightFromUpperRight));
51        builder.setAmbientLightColor(SkColor3f::Make(0.2f, 0.2f, 0.2f));
52        fLights = builder.finish();
53
54        // No directional lights
55        SkLights::Builder builderNoDir;
56        builderNoDir.setAmbientLightColor(SkColor3f::Make(0.2f, 0.2f, 0.2f));
57        fLightsNoDir = builderNoDir.finish();
58
59        // Two directional lights
60        SkLights::Builder builderTwoDir;
61        builderTwoDir.add(SkLights::Light::MakeDirectional(SkColor3f::Make(1.0f, 0.0f, 1.0f),
62                                                           kLightFromUpperRight));
63        builderTwoDir.add(SkLights::Light::MakeDirectional(SkColor3f::Make(0.0f, 1.0f, 1.0f),
64                                                           kLightFromUpperLeft));
65        builderTwoDir.setAmbientLightColor(SkColor3f::Make(0.2f, 0.2f, 0.2f));
66        fLightsTwoDir = builderTwoDir.finish();
67
68        fRect = SkRect::MakeIWH(kTexSize, kTexSize);
69        SkMatrix matrix;
70        SkRect bitmapBounds = SkRect::MakeIWH(kTexSize, kTexSize);
71        matrix.setRectToRect(bitmapBounds, fRect, SkMatrix::kFill_ScaleToFit);
72
73        SkBitmap opaqueDiffuseMap = sk_tool_utils::create_checkerboard_bitmap(
74                kTexSize, kTexSize,
75                sk_tool_utils::color_to_565(0x0),
76                sk_tool_utils::color_to_565(0xFF804020),
77                8);
78        fOpaqueDiffuse = SkShader::MakeBitmapShader(opaqueDiffuseMap, SkShader::kClamp_TileMode,
79                                                    SkShader::kClamp_TileMode, &matrix);
80
81        SkBitmap translucentDiffuseMap = sk_tool_utils::create_checkerboard_bitmap(
82                kTexSize, kTexSize,
83                SkColorSetARGB(0x55, 0x00, 0x00, 0x00),
84                SkColorSetARGB(0x55, 0x80, 0x40, 0x20),
85                8);
86        fTranslucentDiffuse = SkShader::MakeBitmapShader(translucentDiffuseMap,
87                                                         SkShader::kClamp_TileMode,
88                                                         SkShader::kClamp_TileMode, &matrix);
89
90        SkBitmap normalMap = make_frustum_normalmap(kTexSize);
91        fNormalMapShader = SkShader::MakeBitmapShader(normalMap, SkShader::kClamp_TileMode,
92                                                      SkShader::kClamp_TileMode, &matrix);
93
94    }
95
96    // Scales shape around origin, rotates shape around origin, then translates shape to origin
97    void positionCTM(SkCanvas *canvas, SkScalar scaleX, SkScalar scaleY, SkScalar rotate) const {
98        canvas->translate(kTexSize/2.0f, kTexSize/2.0f);
99        canvas->scale(scaleX, scaleY);
100        canvas->rotate(rotate);
101        canvas->translate(-kTexSize/2.0f, -kTexSize/2.0f);
102    }
103
104    static constexpr int NUM_BOOLEAN_PARAMS = 4;
105    void drawRect(SkCanvas* canvas, SkScalar scaleX, SkScalar scaleY,
106                  SkScalar rotate, bool useNormalSource, bool useDiffuseShader,
107                  bool useTranslucentPaint, bool useTranslucentShader, sk_sp<SkLights> lights) {
108        canvas->save();
109
110        this->positionCTM(canvas, scaleX, scaleY, rotate);
111
112        const SkMatrix& ctm = canvas->getTotalMatrix();
113
114        SkPaint paint;
115        sk_sp<SkNormalSource> normalSource = nullptr;
116        sk_sp<SkShader> diffuseShader = nullptr;
117
118        if (useNormalSource) {
119            normalSource = SkNormalSource::MakeFromNormalMap(fNormalMapShader, ctm);
120        }
121
122        if (useDiffuseShader) {
123            diffuseShader = (useTranslucentShader) ? fTranslucentDiffuse : fOpaqueDiffuse;
124        } else {
125            paint.setColor(0xFF00FF00);
126        }
127
128        if (useTranslucentPaint) {
129            paint.setAlpha(0x99);
130        }
131
132        paint.setShader(SkLightingShader::Make(std::move(diffuseShader), std::move(normalSource),
133                                               std::move(lights)));
134        canvas->drawRect(fRect, paint);
135
136        canvas->restore();
137    }
138
139    void onDraw(SkCanvas* canvas) override {
140
141        constexpr SkScalar LABEL_SIZE = 10.0f;
142        SkPaint labelPaint;
143        labelPaint.setTypeface(sk_tool_utils::create_portable_typeface("sans-serif",
144                                                                       SkFontStyle()));
145        labelPaint.setAntiAlias(true);
146        labelPaint.setTextSize(LABEL_SIZE);
147
148        constexpr int GRID_COLUMN_NUM = 4;
149        constexpr SkScalar GRID_CELL_WIDTH = kTexSize + 20.0f + NUM_BOOLEAN_PARAMS * LABEL_SIZE;
150
151        int gridNum = 0;
152
153        // Running through all possible bool parameter combinations
154        for (bool useNormalSource : {true, false}) {
155            for (bool useDiffuseShader : {true, false}) {
156                for (bool useTranslucentPaint : {true, false}) {
157                    for (bool useTranslucentShader : {true, false}) {
158
159                        // Determining position
160                        SkScalar xPos = (gridNum % GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
161                        SkScalar yPos = (gridNum / GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
162
163                        canvas->save();
164
165                        canvas->translate(xPos, yPos);
166                        this->drawRect(canvas, 1.0f, 1.0f, 0.f, useNormalSource, useDiffuseShader,
167                                       useTranslucentPaint, useTranslucentShader, fLights);
168                        // Drawing labels
169                        canvas->translate(0.0f, SkIntToScalar(kTexSize));
170                        {
171                            canvas->translate(0.0f, LABEL_SIZE);
172                            SkString label;
173                            label.appendf("useNormalSource: %d", useNormalSource);
174                            canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
175                        }
176                        {
177                            canvas->translate(0.0f, LABEL_SIZE);
178                            SkString label;
179                            label.appendf("useDiffuseShader: %d", useDiffuseShader);
180                            canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
181                        }
182                        {
183                            canvas->translate(0.0f, LABEL_SIZE);
184                            SkString label;
185                            label.appendf("useTranslucentPaint: %d", useTranslucentPaint);
186                            canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
187                        }
188                        {
189                            canvas->translate(0.0f, LABEL_SIZE);
190                            SkString label;
191                            label.appendf("useTranslucentShader: %d", useTranslucentShader);
192                            canvas->drawText(label.c_str(), label.size(), 0.0f, 0.0f, labelPaint);
193                        }
194
195                        canvas->restore();
196
197                        gridNum++;
198                    }
199                }
200            }
201        }
202
203
204        // Rotation/scale test
205        {
206            SkScalar xPos = (gridNum % GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
207            SkScalar yPos = (gridNum / GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
208
209            canvas->save();
210            canvas->translate(xPos, yPos);
211            this->drawRect(canvas, 0.6f, 0.6f, 45.0f, true, true, true, true, fLights);
212            canvas->restore();
213
214            gridNum++;
215        }
216
217        // Anisotropic scale test
218        {
219            SkScalar xPos = (gridNum % GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
220            SkScalar yPos = (gridNum / GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
221
222            canvas->save();
223            canvas->translate(xPos, yPos);
224            this->drawRect(canvas, 0.6f, 0.4f, 30.0f, true, true, true, true, fLights);
225            canvas->restore();
226
227            gridNum++;
228        }
229
230        // No directional lights test
231        {
232            SkScalar xPos = (gridNum % GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
233            SkScalar yPos = (gridNum / GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
234
235            canvas->save();
236            canvas->translate(xPos, yPos);
237            this->drawRect(canvas, 1.0f, 1.0f, 0.0f, true, true, false, false, fLightsNoDir);
238            canvas->restore();
239
240            gridNum++;
241        }
242
243        // Two directional lights test
244        {
245            SkScalar xPos = (gridNum % GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
246            SkScalar yPos = (gridNum / GRID_COLUMN_NUM) * GRID_CELL_WIDTH;
247
248            canvas->save();
249            canvas->translate(xPos, yPos);
250            this->drawRect(canvas, 1.0f, 1.0f, 0.0f, true, true, false, false, fLightsTwoDir);
251            canvas->restore();
252
253            gridNum++;
254        }
255    }
256
257private:
258    static constexpr int kTexSize = 96;
259
260    sk_sp<SkShader> fOpaqueDiffuse;
261    sk_sp<SkShader> fTranslucentDiffuse;
262    sk_sp<SkShader> fNormalMapShader;
263
264    SkRect fRect;
265    sk_sp<SkLights> fLights;
266    sk_sp<SkLights> fLightsNoDir;
267    sk_sp<SkLights> fLightsTwoDir;
268
269    typedef GM INHERITED;
270};
271
272//////////////////////////////////////////////////////////////////////////////
273
274DEF_GM(return new LightingShader2GM;)
275}
276