1 /*
2  * Copyright 2017 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 "SkCanvas.h"
10 #include "SkPath.h"
11 #include "SkResourceCache.h"
12 #include "SkShadowUtils.h"
13 
draw_shadow(SkCanvas * canvas,const SkPath & path,SkScalar height,SkColor color,SkPoint3 lightPos,SkScalar lightR,bool isAmbient,uint32_t flags)14 void draw_shadow(SkCanvas* canvas, const SkPath& path, SkScalar height, SkColor color,
15                  SkPoint3 lightPos, SkScalar lightR, bool isAmbient, uint32_t flags) {
16     SkScalar ambientAlpha = isAmbient ? .5f : 0.f;
17     SkScalar spotAlpha = isAmbient ? 0.f : .5f;
18     SkColor ambientColor = SkColorSetARGB(ambientAlpha*SkColorGetA(color), SkColorGetR(color),
19                                           SkColorGetG(color), SkColorGetB(color));
20     SkColor spotColor = SkColorSetARGB(spotAlpha*SkColorGetA(color), SkColorGetR(color),
21                                        SkColorGetG(color), SkColorGetB(color));
22     SkShadowUtils::DrawShadow(canvas, path, SkPoint3{ 0, 0, height}, lightPos, lightR,
23                               ambientColor, spotColor, flags);
24 }
25 
26 static constexpr int kW = 800;
27 static constexpr int kH = 960;
28 
29 enum ShadowMode {
30     kDebugColorNoOccluders,
31     kDebugColorOccluders,
32     kGrayscale
33 };
34 
draw_paths(SkCanvas * canvas,ShadowMode mode)35 void draw_paths(SkCanvas* canvas, ShadowMode mode) {
36     SkTArray<SkPath> paths;
37     paths.push_back().addRoundRect(SkRect::MakeWH(50, 50), 10, 10);
38     SkRRect oddRRect;
39     oddRRect.setNinePatch(SkRect::MakeWH(50, 50), 9, 13, 6, 16);
40     paths.push_back().addRRect(oddRRect);
41     paths.push_back().addRect(SkRect::MakeWH(50, 50));
42     paths.push_back().addCircle(25, 25, 25);
43     paths.push_back().cubicTo(100, 50, 20, 100, 0, 0);
44     paths.push_back().addOval(SkRect::MakeWH(20, 60));
45 
46     // star
47     SkTArray<SkPath> concavePaths;
48     concavePaths.push_back().moveTo(0.0f, -33.3333f);
49     concavePaths.back().lineTo(9.62f, -16.6667f);
50     concavePaths.back().lineTo(28.867f, -16.6667f);
51     concavePaths.back().lineTo(19.24f, 0.0f);
52     concavePaths.back().lineTo(28.867f, 16.6667f);
53     concavePaths.back().lineTo(9.62f, 16.6667f);
54     concavePaths.back().lineTo(0.0f, 33.3333f);
55     concavePaths.back().lineTo(-9.62f, 16.6667f);
56     concavePaths.back().lineTo(-28.867f, 16.6667f);
57     concavePaths.back().lineTo(-19.24f, 0.0f);
58     concavePaths.back().lineTo(-28.867f, -16.6667f);
59     concavePaths.back().lineTo(-9.62f, -16.6667f);
60     concavePaths.back().close();
61 
62     // dumbbell
63     concavePaths.push_back().moveTo(50, 0);
64     concavePaths.back().cubicTo(100, 25, 60, 50, 50, 0);
65     concavePaths.back().cubicTo(0, -25, 40, -50, 50, 0);
66 
67     static constexpr SkScalar kPad = 15.f;
68     static constexpr SkScalar kLightR = 100.f;
69     static constexpr SkScalar kHeight = 50.f;
70 
71     // transform light position relative to canvas to handle tiling
72     SkPoint lightXY = canvas->getTotalMatrix().mapXY(250, 400);
73     SkPoint3 lightPos = { lightXY.fX, lightXY.fY, 500 };
74 
75     canvas->translate(3 * kPad, 3 * kPad);
76     canvas->save();
77     SkScalar x = 0;
78     SkScalar dy = 0;
79     SkTDArray<SkMatrix> matrices;
80     matrices.push()->reset();
81     SkMatrix* m = matrices.push();
82     m->setRotate(33.f, 25.f, 25.f);
83     m->postScale(1.2f, 0.8f, 25.f, 25.f);
84     for (auto& m : matrices) {
85         for (int flags : { kNone_ShadowFlag, kTransparentOccluder_ShadowFlag }) {
86             for (const auto& path : paths) {
87                 SkRect postMBounds = path.getBounds();
88                 m.mapRect(&postMBounds);
89                 SkScalar w = postMBounds.width() + kHeight;
90                 SkScalar dx = w + kPad;
91                 if (x + dx > kW - 3 * kPad) {
92                     canvas->restore();
93                     canvas->translate(0, dy);
94                     canvas->save();
95                     x = 0;
96                     dy = 0;
97                 }
98 
99                 canvas->save();
100                 canvas->concat(m);
101 
102                 if (kDebugColorNoOccluders == mode || kDebugColorOccluders == mode) {
103                     draw_shadow(canvas, path, kHeight, SK_ColorRED, lightPos, kLightR,
104                                 true, flags);
105                     draw_shadow(canvas, path, kHeight, SK_ColorBLUE, lightPos, kLightR,
106                                 false, flags);
107                 } else if (kGrayscale == mode) {
108                     SkColor ambientColor = SkColorSetARGB(0.1f * 255, 0, 0, 0);
109                     SkColor spotColor = SkColorSetARGB(0.25f * 255, 0, 0, 0);
110                     SkShadowUtils::DrawShadow(canvas, path, SkPoint3{0, 0, kHeight}, lightPos,
111                                               kLightR, ambientColor, spotColor, flags);
112                 }
113 
114                 SkPaint paint;
115                 paint.setAntiAlias(true);
116                 if (kDebugColorNoOccluders == mode) {
117                     // Draw the path outline in green on top of the ambient and spot shadows.
118                     if (SkToBool(flags & kTransparentOccluder_ShadowFlag)) {
119                         paint.setColor(SK_ColorCYAN);
120                     } else {
121                         paint.setColor(SK_ColorGREEN);
122                     }
123                     paint.setStyle(SkPaint::kStroke_Style);
124                     paint.setStrokeWidth(0);
125                 } else {
126                     paint.setColor(kDebugColorOccluders == mode ? SK_ColorLTGRAY : SK_ColorWHITE);
127                     if (SkToBool(flags & kTransparentOccluder_ShadowFlag)) {
128                         paint.setAlphaf(0.5f);
129                     }
130                     paint.setStyle(SkPaint::kFill_Style);
131                 }
132                 canvas->drawPath(path, paint);
133                 canvas->restore();
134 
135                 canvas->translate(dx, 0);
136                 x += dx;
137                 dy = SkTMax(dy, postMBounds.height() + kPad + kHeight);
138             }
139         }
140     }
141 
142     // concave paths
143     canvas->restore();
144     canvas->translate(kPad, dy);
145     canvas->save();
146     x = kPad;
147     dy = 0;
148     for (auto& m : matrices) {
149         // for the concave paths we are not clipping, so transparent and opaque are the same
150         for (const auto& path : concavePaths) {
151             SkRect postMBounds = path.getBounds();
152             m.mapRect(&postMBounds);
153             SkScalar w = postMBounds.width() + kHeight;
154             SkScalar dx = w + kPad;
155 
156             canvas->save();
157             canvas->concat(m);
158 
159             if (kDebugColorNoOccluders == mode || kDebugColorOccluders == mode) {
160                 draw_shadow(canvas, path, kHeight, SK_ColorRED, lightPos, kLightR,
161                             true, kNone_ShadowFlag);
162                 draw_shadow(canvas, path, kHeight, SK_ColorBLUE, lightPos, kLightR,
163                             false, kNone_ShadowFlag);
164             } else if (kGrayscale == mode) {
165                 SkColor ambientColor = SkColorSetARGB(0.1f * 255, 0, 0, 0);
166                 SkColor spotColor = SkColorSetARGB(0.25f * 255, 0, 0, 0);
167                 SkShadowUtils::DrawShadow(canvas, path, SkPoint3{ 0, 0, kHeight }, lightPos,
168                                           kLightR, ambientColor, spotColor, kNone_ShadowFlag);
169             }
170 
171             SkPaint paint;
172             paint.setAntiAlias(true);
173             if (kDebugColorNoOccluders == mode) {
174                 // Draw the path outline in green on top of the ambient and spot shadows.
175                 paint.setColor(SK_ColorGREEN);
176                 paint.setStyle(SkPaint::kStroke_Style);
177                 paint.setStrokeWidth(0);
178             } else {
179                 paint.setColor(kDebugColorOccluders == mode ? SK_ColorLTGRAY : SK_ColorWHITE);
180                 paint.setStyle(SkPaint::kFill_Style);
181             }
182             canvas->drawPath(path, paint);
183             canvas->restore();
184 
185             canvas->translate(dx, 0);
186             x += dx;
187             dy = SkTMax(dy, postMBounds.height() + kPad + kHeight);
188         }
189     }
190 
191     // Show where the light is in x,y as a circle (specified in device space).
192     SkMatrix invCanvasM = canvas->getTotalMatrix();
193     if (invCanvasM.invert(&invCanvasM)) {
194         canvas->save();
195         canvas->concat(invCanvasM);
196         SkPaint paint;
197         paint.setColor(SK_ColorBLACK);
198         paint.setAntiAlias(true);
199         canvas->drawCircle(lightPos.fX, lightPos.fY, kLightR / 10.f, paint);
200         canvas->restore();
201     }
202 }
203 
DEF_SIMPLE_GM(shadow_utils,canvas,kW,kH)204 DEF_SIMPLE_GM(shadow_utils, canvas, kW, kH) {
205     draw_paths(canvas, kDebugColorNoOccluders);
206 }
207 
DEF_SIMPLE_GM(shadow_utils_occl,canvas,kW,kH)208 DEF_SIMPLE_GM(shadow_utils_occl, canvas, kW, kH) {
209     draw_paths(canvas, kDebugColorOccluders);
210 }
211 
DEF_SIMPLE_GM(shadow_utils_gray,canvas,kW,kH)212 DEF_SIMPLE_GM(shadow_utils_gray, canvas, kW, kH) {
213     draw_paths(canvas, kGrayscale);
214 }
215