| |
| /* |
| * Copyright 2017 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| #include "include/core/SkCanvas.h" |
| #include "include/core/SkColorFilter.h" |
| #include "include/core/SkPath.h" |
| #include "include/core/SkPoint3.h" |
| #include "include/pathops/SkPathOps.h" |
| #include "include/utils/SkCamera.h" |
| #include "include/utils/SkShadowUtils.h" |
| #include "samplecode/Sample.h" |
| #include "src/core/SkBlurMask.h" |
| #include "src/utils/SkUTF.h" |
| #include "tools/ToolUtils.h" |
| |
| //////////////////////////////////////////////////////////////////////////// |
| |
| class ShadowUtilsView : public Sample { |
| SkTArray<SkPath> fConvexPaths; |
| SkTArray<SkPath> fConcavePaths; |
| SkScalar fZDelta; |
| |
| bool fShowAmbient; |
| bool fShowSpot; |
| bool fUseAlt; |
| bool fShowObject; |
| bool fIgnoreShadowAlpha; |
| |
| public: |
| ShadowUtilsView() |
| : fZDelta(0) |
| , fShowAmbient(true) |
| , fShowSpot(true) |
| , fUseAlt(false) |
| , fShowObject(false) |
| , fIgnoreShadowAlpha(false) {} |
| |
| protected: |
| void onOnceBeforeDraw() override { |
| fConvexPaths.push_back().addRoundRect(SkRect::MakeWH(50, 50), 10, 10); |
| SkRRect oddRRect; |
| oddRRect.setNinePatch(SkRect::MakeWH(50, 50), 9, 13, 6, 16); |
| fConvexPaths.push_back().addRRect(oddRRect); |
| fConvexPaths.push_back().addRect(SkRect::MakeWH(50, 50)); |
| fConvexPaths.push_back().addCircle(25, 25, 25); |
| fConvexPaths.push_back().cubicTo(100, 50, 20, 100, 0, 0); |
| fConvexPaths.push_back().addOval(SkRect::MakeWH(20, 60)); |
| |
| // star |
| fConcavePaths.push_back().moveTo(0.0f, -33.3333f); |
| fConcavePaths.back().lineTo(9.62f, -16.6667f); |
| fConcavePaths.back().lineTo(28.867f, -16.6667f); |
| fConcavePaths.back().lineTo(19.24f, 0.0f); |
| fConcavePaths.back().lineTo(28.867f, 16.6667f); |
| fConcavePaths.back().lineTo(9.62f, 16.6667f); |
| fConcavePaths.back().lineTo(0.0f, 33.3333f); |
| fConcavePaths.back().lineTo(-9.62f, 16.6667f); |
| fConcavePaths.back().lineTo(-28.867f, 16.6667f); |
| fConcavePaths.back().lineTo(-19.24f, 0.0f); |
| fConcavePaths.back().lineTo(-28.867f, -16.6667f); |
| fConcavePaths.back().lineTo(-9.62f, -16.6667f); |
| fConcavePaths.back().close(); |
| |
| // dumbbell |
| fConcavePaths.push_back().moveTo(50, 0); |
| fConcavePaths.back().cubicTo(100, 25, 60, 50, 50, 0); |
| fConcavePaths.back().cubicTo(0, -25, 40, -50, 50, 0); |
| } |
| |
| SkString name() override { return SkString("ShadowUtils"); } |
| |
| bool onChar(SkUnichar uni) override { |
| bool handled = false; |
| switch (uni) { |
| case 'W': |
| fShowAmbient = !fShowAmbient; |
| handled = true; |
| break; |
| case 'S': |
| fShowSpot = !fShowSpot; |
| handled = true; |
| break; |
| case 'T': |
| fUseAlt = !fUseAlt; |
| handled = true; |
| break; |
| case 'O': |
| fShowObject = !fShowObject; |
| handled = true; |
| break; |
| case '>': |
| fZDelta += 0.5f; |
| handled = true; |
| break; |
| case '<': |
| fZDelta -= 0.5f; |
| handled = true; |
| break; |
| case '?': |
| fIgnoreShadowAlpha = !fIgnoreShadowAlpha; |
| handled = true; |
| break; |
| default: |
| break; |
| } |
| if (handled) { |
| return true; |
| } |
| return false; |
| } |
| |
| void drawBG(SkCanvas* canvas) { |
| canvas->drawColor(0xFFFFFFFF); |
| } |
| |
| void drawShadowedPath(SkCanvas* canvas, const SkPath& path, |
| const SkPoint3& zPlaneParams, |
| const SkPaint& paint, SkScalar ambientAlpha, |
| const SkPoint3& lightPos, SkScalar lightWidth, SkScalar spotAlpha, |
| uint32_t flags) { |
| if (fIgnoreShadowAlpha) { |
| ambientAlpha = 255; |
| spotAlpha = 255; |
| } |
| if (!fShowAmbient) { |
| ambientAlpha = 0; |
| } |
| if (!fShowSpot) { |
| spotAlpha = 0; |
| } |
| if (fUseAlt) { |
| flags |= SkShadowFlags::kGeometricOnly_ShadowFlag; |
| } |
| |
| SkColor ambientColor = SkColorSetARGB(ambientAlpha * 255, 255, 0, 0); |
| SkColor spotColor = SkColorSetARGB(spotAlpha * 255, 0, 0, 255); |
| SkShadowUtils::DrawShadow(canvas, path, zPlaneParams, |
| lightPos, lightWidth, |
| ambientColor, spotColor, flags); |
| |
| if (fShowObject) { |
| canvas->drawPath(path, paint); |
| } else { |
| SkPaint strokePaint; |
| |
| strokePaint.setColor(paint.getColor()); |
| strokePaint.setStyle(SkPaint::kStroke_Style); |
| |
| canvas->drawPath(path, strokePaint); |
| } |
| } |
| |
| void onDrawContent(SkCanvas* canvas) override { |
| this->drawBG(canvas); |
| |
| static constexpr int kW = 800; |
| static constexpr SkScalar kPad = 15.f; |
| static constexpr SkScalar kLightR = 100.f; |
| static constexpr SkScalar kHeight = 50.f; |
| static constexpr SkScalar kAmbientAlpha = 0.5f; |
| static constexpr SkScalar kSpotAlpha = 0.5f; |
| static constexpr SkPoint3 lightPos = { 250, 400, 500 }; |
| |
| canvas->translate(3 * kPad, 3 * kPad); |
| canvas->save(); |
| SkScalar x = 0; |
| SkScalar dy = 0; |
| SkTDArray<SkMatrix> matrices; |
| matrices.push()->reset(); |
| SkMatrix* m = matrices.push(); |
| m->setRotate(33.f, 25.f, 25.f); |
| m->postScale(1.2f, 0.8f, 25.f, 25.f); |
| SkPaint paint; |
| paint.setColor(SK_ColorGREEN); |
| paint.setAntiAlias(true); |
| SkPoint3 zPlaneParams = SkPoint3::Make(0, 0, std::max(1.0f, kHeight + fZDelta)); |
| |
| // convex paths |
| for (auto& m : matrices) { |
| for (auto flags : { kNone_ShadowFlag, kTransparentOccluder_ShadowFlag }) { |
| for (const auto& path : fConvexPaths) { |
| SkRect postMBounds = path.getBounds(); |
| m.mapRect(&postMBounds); |
| SkScalar w = postMBounds.width() + kHeight; |
| SkScalar dx = w + kPad; |
| if (x + dx > kW - 3 * kPad) { |
| canvas->restore(); |
| canvas->translate(0, dy); |
| canvas->save(); |
| x = 0; |
| dy = 0; |
| } |
| |
| canvas->save(); |
| canvas->concat(m); |
| this->drawShadowedPath(canvas, path, zPlaneParams, paint, kAmbientAlpha, |
| lightPos, kLightR, kSpotAlpha, flags); |
| canvas->restore(); |
| |
| canvas->translate(dx, 0); |
| x += dx; |
| dy = std::max(dy, postMBounds.height() + kPad + kHeight); |
| } |
| } |
| } |
| |
| // concave paths |
| canvas->restore(); |
| canvas->translate(kPad, dy); |
| canvas->save(); |
| x = kPad; |
| dy = 0; |
| for (auto& m : matrices) { |
| for (const auto& path : fConcavePaths) { |
| SkRect postMBounds = path.getBounds(); |
| m.mapRect(&postMBounds); |
| SkScalar w = postMBounds.width(); |
| SkScalar dx = w + kPad; |
| |
| canvas->save(); |
| canvas->concat(m); |
| this->drawShadowedPath(canvas, path, zPlaneParams, paint, kAmbientAlpha, lightPos, |
| kLightR, kSpotAlpha, kNone_ShadowFlag); |
| canvas->restore(); |
| |
| canvas->translate(dx, 0); |
| x += dx; |
| dy = std::max(dy, postMBounds.height() + kPad + kHeight); |
| } |
| } |
| |
| // Show where the light is in x,y as a circle (specified in device space). |
| SkMatrix invCanvasM = canvas->getTotalMatrix(); |
| if (invCanvasM.invert(&invCanvasM)) { |
| canvas->save(); |
| canvas->concat(invCanvasM); |
| SkPaint paint; |
| paint.setColor(SK_ColorBLACK); |
| paint.setAntiAlias(true); |
| canvas->drawCircle(lightPos.fX, lightPos.fY, kLightR / 10.f, paint); |
| canvas->restore(); |
| } |
| } |
| |
| private: |
| typedef Sample INHERITED; |
| }; |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| DEF_SAMPLE( return new ShadowUtilsView(); ) |