Import Cobalt 25.master.0.1033734
diff --git a/third_party/skia/samplecode/PerlinPatch.cpp b/third_party/skia/samplecode/PerlinPatch.cpp
deleted file mode 100644
index 43dce62..0000000
--- a/third_party/skia/samplecode/PerlinPatch.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * Copyright 2015 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/effects/SkGradientShader.h"
-#include "include/effects/SkPerlinNoiseShader.h"
-#include "samplecode/Sample.h"
-#include "src/utils/SkPatchUtils.h"
-#include "tools/skui/ModifierKey.h"
-
-static void draw_control_points(SkCanvas* canvas, const SkPoint cubics[12]) {
- //draw control points
- SkPaint paint;
- SkPoint bottom[SkPatchUtils::kNumPtsCubic];
- SkPatchUtils::GetBottomCubic(cubics, bottom);
- SkPoint top[SkPatchUtils::kNumPtsCubic];
- SkPatchUtils::GetTopCubic(cubics, top);
- SkPoint left[SkPatchUtils::kNumPtsCubic];
- SkPatchUtils::GetLeftCubic(cubics, left);
- SkPoint right[SkPatchUtils::kNumPtsCubic];
- SkPatchUtils::GetRightCubic(cubics, right);
-
- paint.setColor(SK_ColorBLACK);
- paint.setStrokeWidth(0.5f);
- SkPoint corners[4] = { bottom[0], bottom[3], top[0], top[3] };
- canvas->drawPoints(SkCanvas::kLines_PointMode, 4, bottom, paint);
- canvas->drawPoints(SkCanvas::kLines_PointMode, 2, bottom + 1, paint);
- canvas->drawPoints(SkCanvas::kLines_PointMode, 4, top, paint);
- canvas->drawPoints(SkCanvas::kLines_PointMode, 4, left, paint);
- canvas->drawPoints(SkCanvas::kLines_PointMode, 4, right, paint);
-
- canvas->drawPoints(SkCanvas::kLines_PointMode, 2, top + 1, paint);
- canvas->drawPoints(SkCanvas::kLines_PointMode, 2, left + 1, paint);
- canvas->drawPoints(SkCanvas::kLines_PointMode, 2, right + 1, paint);
-
- paint.setStrokeWidth(2);
-
- paint.setColor(SK_ColorRED);
- canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, corners, paint);
-
- paint.setColor(SK_ColorBLUE);
- canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, bottom + 1, paint);
-
- paint.setColor(SK_ColorCYAN);
- canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, top + 1, paint);
-
- paint.setColor(SK_ColorYELLOW);
- canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, left + 1, paint);
-
- paint.setColor(SK_ColorGREEN);
- canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, right + 1, paint);
-}
-
-// These are actually half the total width and hieghts
-const SkScalar TexWidth = 100.0f;
-const SkScalar TexHeight = 100.0f;
-
-class PerlinPatchView : public Sample {
- sk_sp<SkShader> fShader0;
- sk_sp<SkShader> fShader1;
- sk_sp<SkShader> fShaderCompose;
- SkScalar fXFreq;
- SkScalar fYFreq;
- SkScalar fSeed;
- SkPoint fPts[SkPatchUtils::kNumCtrlPts];
- SkScalar fTexX;
- SkScalar fTexY;
- SkScalar fTexScale;
- SkMatrix fInvMatrix;
- bool fShowGrid = false;
-
-public:
- PerlinPatchView() : fXFreq(0.025f), fYFreq(0.025f), fSeed(0.0f),
- fTexX(100.0), fTexY(50.0), fTexScale(1.0f) {
- const SkScalar s = 2;
- // The order of the colors and points is clockwise starting at upper-left corner.
- //top points
- fPts[0].set(100 * s, 100 * s);
- fPts[1].set(150 * s, 50 * s);
- fPts[2].set(250 * s, 150 * s);
- fPts[3].set(300 * s, 100 * s);
- //right points
- fPts[4].set(275 * s, 150 * s);
- fPts[5].set(350 * s, 250 * s);
- //bottom points
- fPts[6].set(300 * s, 300 * s);
- fPts[7].set(250 * s, 250 * s);
- //left points
- fPts[8].set(150 * s, 350 * s);
- fPts[9].set(100 * s, 300 * s);
- fPts[10].set(50 * s, 250 * s);
- fPts[11].set(150 * s, 150 * s);
-
- const SkColor colors[SkPatchUtils::kNumCorners] = {
- 0xFF5555FF, 0xFF8888FF, 0xFFCCCCFF
- };
- const SkPoint points[2] = { SkPoint::Make(0.0f, 0.0f),
- SkPoint::Make(100.0f, 100.0f) };
- fShader0 = SkGradientShader::MakeLinear(points,
- colors,
- nullptr,
- 3,
- SkTileMode::kMirror,
- 0,
- nullptr);
- }
-
-protected:
- SkString name() override { return SkString("PerlinPatch"); }
-
- bool onChar(SkUnichar uni) override {
- switch (uni) {
- case 'g': fShowGrid = !fShowGrid; return true;
- default: break;
- }
- return false;
- }
-
- bool onAnimate(double nanos) override {
- fSeed += 0.005f;
- return true;
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- if (!canvas->getTotalMatrix().invert(&fInvMatrix)) {
- return;
- }
-
- SkPaint paint;
-
- SkScalar texWidth = fTexScale * TexWidth;
- SkScalar texHeight = fTexScale * TexHeight;
- const SkPoint texCoords[SkPatchUtils::kNumCorners] = {
- { fTexX - texWidth, fTexY - texHeight},
- { fTexX + texWidth, fTexY - texHeight},
- { fTexX + texWidth, fTexY + texHeight},
- { fTexX - texWidth, fTexY + texHeight}}
- ;
-
- SkScalar scaleFreq = 2.0;
- fShader1 = SkPerlinNoiseShader::MakeImprovedNoise(fXFreq/scaleFreq, fYFreq/scaleFreq, 4,
- fSeed);
- fShaderCompose = SkShaders::Blend(SkBlendMode::kSrcOver, fShader0, fShader1);
-
- paint.setShader(fShaderCompose);
-
- const SkPoint* tex = texCoords;
- if (fShowGrid) {
- tex = nullptr;
- }
- canvas->drawPatch(fPts, nullptr, tex, SkBlendMode::kSrc, paint);
-
- draw_control_points(canvas, fPts);
- }
-
- class PtClick : public Click {
- public:
- int fIndex;
- PtClick(int index) : fIndex(index) {}
- };
-
- static bool hittest(const SkPoint& pt, SkScalar x, SkScalar y) {
- return SkPoint::Length(pt.fX - x, pt.fY - y) < SkIntToScalar(5);
- }
-
- Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
- modi &= ~skui::ModifierKey::kFirstPress; // ignore this
- if (skui::ModifierKey::kShift == modi) {
- return new PtClick(-1);
- }
- if (skui::ModifierKey::kControl == modi) {
- return new PtClick(-2);
- }
- SkPoint clickPoint = {x, y};
- fInvMatrix.mapPoints(&clickPoint, 1);
- for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); i++) {
- if (hittest(fPts[i], clickPoint.fX, clickPoint.fY)) {
- return new PtClick((int)i);
- }
- }
- return nullptr;
- }
-
- bool onClick(Click* click) override {
- PtClick* ptClick = (PtClick*)click;
- if (ptClick->fIndex >= 0) {
- fPts[ptClick->fIndex].set(click->fCurr.fX , click->fCurr.fY );
- } else if (-1 == ptClick->fIndex) {
- SkScalar xDiff = click->fPrev.fX - click->fCurr.fX;
- SkScalar yDiff = click->fPrev.fY - click->fCurr.fY;
- fTexX += xDiff * fTexScale;
- fTexY += yDiff * fTexScale;
- } else if (-2 == ptClick->fIndex) {
- SkScalar yDiff = click->fCurr.fY - click->fPrev.fY;
- fTexScale += yDiff / 10.0f;
- fTexScale = SkTMax(0.1f, SkTMin(20.f, fTexScale));
- }
- return true;
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-DEF_SAMPLE( return new PerlinPatchView(); )
diff --git a/third_party/skia/samplecode/Sample.cpp b/third_party/skia/samplecode/Sample.cpp
index c2ba788..a69de8e 100644
--- a/third_party/skia/samplecode/Sample.cpp
+++ b/third_party/skia/samplecode/Sample.cpp
@@ -10,16 +10,16 @@
#include "samplecode/Sample.h"
#if SK_SUPPORT_GPU
-# include "include/gpu/GrContext.h"
+# include "include/gpu/GrDirectContext.h"
#else
-class GrContext;
+class GrDirectContext;
#endif
//////////////////////////////////////////////////////////////////////////////
void Sample::setSize(SkScalar width, SkScalar height) {
- width = SkMaxScalar(0, width);
- height = SkMaxScalar(0, height);
+ width = std::max(0.0f, width);
+ height = std::max(0.0f, height);
if (fWidth != width || fHeight != height)
{
@@ -49,9 +49,9 @@
SkAutoCanvasRestore acr(canvas, true);
this->onDrawContent(canvas);
#if SK_SUPPORT_GPU
- // Ensure the GrContext doesn't combine GrDrawOps across draw loops.
- if (GrContext* context = canvas->getGrContext()) {
- context->flush();
+ // Ensure the context doesn't combine GrDrawOps across draw loops.
+ if (auto direct = GrAsDirectContext(canvas->recordingContext())) {
+ direct->flushAndSubmit();
}
#endif
@@ -62,12 +62,13 @@
////////////////////////////////////////////////////////////////////////////
bool Sample::mouse(SkPoint point, skui::InputState clickState, skui::ModifierKey modifierKeys) {
+ auto dispatch = [this](Click* c) {
+ return c->fHasFunc ? c->fFunc(c) : this->onClick(c);
+ };
+
switch (clickState) {
case skui::InputState::kDown:
fClick = nullptr;
- if (point.x() < 0 || point.y() < 0 || point.x() >= fWidth || point.y() >= fHeight) {
- return false;
- }
fClick.reset(this->onFindClickHandler(point.x(), point.y(), modifierKeys));
if (!fClick) {
return false;
@@ -75,7 +76,7 @@
fClick->fPrev = fClick->fCurr = fClick->fOrig = point;
fClick->fState = skui::InputState::kDown;
fClick->fModifierKeys = modifierKeys;
- this->onClick(fClick.get());
+ dispatch(fClick.get());
return true;
case skui::InputState::kMove:
if (fClick) {
@@ -83,7 +84,7 @@
fClick->fCurr = point;
fClick->fState = skui::InputState::kMove;
fClick->fModifierKeys = modifierKeys;
- return this->onClick(fClick.get());
+ return dispatch(fClick.get());
}
return false;
case skui::InputState::kUp:
@@ -92,7 +93,7 @@
fClick->fCurr = point;
fClick->fState = skui::InputState::kUp;
fClick->fModifierKeys = modifierKeys;
- bool result = this->onClick(fClick.get());
+ bool result = dispatch(fClick.get());
fClick = nullptr;
return result;
}
diff --git a/third_party/skia/samplecode/Sample.h b/third_party/skia/samplecode/Sample.h
index d6ccf48..f1026bd 100644
--- a/third_party/skia/samplecode/Sample.h
+++ b/third_party/skia/samplecode/Sample.h
@@ -18,6 +18,8 @@
#include "tools/skui/InputState.h"
#include "tools/skui/ModifierKey.h"
+#include <functional>
+
class SkCanvas;
class Sample;
@@ -55,13 +57,19 @@
// Click handling
class Click {
public:
+ Click() {}
+ Click(std::function<bool(Click*)> f) : fFunc(f), fHasFunc(true) {}
virtual ~Click() = default;
+
SkPoint fOrig = {0, 0};
SkPoint fPrev = {0, 0};
SkPoint fCurr = {0, 0};
skui::InputState fState = skui::InputState::kDown;
skui::ModifierKey fModifierKeys = skui::ModifierKey::kNone;
SkMetaData fMeta;
+
+ std::function<bool(Click*)> fFunc;
+ bool fHasFunc = false;
};
bool mouse(SkPoint point, skui::InputState clickState, skui::ModifierKey modifierKeys);
diff --git a/third_party/skia/samplecode/Sample2PtRadial.cpp b/third_party/skia/samplecode/Sample2PtRadial.cpp
index 64f9e66..f404d14 100644
--- a/third_party/skia/samplecode/Sample2PtRadial.cpp
+++ b/third_party/skia/samplecode/Sample2PtRadial.cpp
@@ -14,9 +14,9 @@
TwoPtConicalView() {}
protected:
- virtual SkString name() { return SkString("2PtConical"); }
+ SkString name() override { return SkString("2PtConical"); }
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
@@ -32,7 +32,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/Sample3D.cpp b/third_party/skia/samplecode/Sample3D.cpp
new file mode 100644
index 0000000..7e958bc
--- /dev/null
+++ b/third_party/skia/samplecode/Sample3D.cpp
@@ -0,0 +1,487 @@
+/*
+ * Copyright 2020 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/SkM44.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkRRect.h"
+#include "include/core/SkVertices.h"
+#include "include/utils/SkRandom.h"
+#include "samplecode/Sample.h"
+#include "tools/Resources.h"
+
+struct VSphere {
+ SkV2 fCenter;
+ SkScalar fRadius;
+
+ VSphere(SkV2 center, SkScalar radius) : fCenter(center), fRadius(radius) {}
+
+ bool contains(SkV2 v) const {
+ return (v - fCenter).length() <= fRadius;
+ }
+
+ SkV2 pinLoc(SkV2 p) const {
+ auto v = p - fCenter;
+ if (v.length() > fRadius) {
+ v *= (fRadius / v.length());
+ }
+ return fCenter + v;
+ }
+
+ SkV3 computeUnitV3(SkV2 v) const {
+ v = (v - fCenter) * (1 / fRadius);
+ SkScalar len2 = v.lengthSquared();
+ if (len2 > 1) {
+ v = v.normalize();
+ len2 = 1;
+ }
+ SkScalar z = SkScalarSqrt(1 - len2);
+ return {v.x, v.y, z};
+ }
+
+ struct RotateInfo {
+ SkV3 fAxis;
+ SkScalar fAngle;
+ };
+
+ RotateInfo computeRotationInfo(SkV2 a, SkV2 b) const {
+ SkV3 u = this->computeUnitV3(a);
+ SkV3 v = this->computeUnitV3(b);
+ SkV3 axis = u.cross(v);
+ SkScalar length = axis.length();
+
+ if (!SkScalarNearlyZero(length)) {
+ return {axis * (1.0f / length), acos(u.dot(v))};
+ }
+ return {{0, 0, 0}, 0};
+ }
+
+ SkM44 computeRotation(SkV2 a, SkV2 b) const {
+ auto [axis, angle] = this->computeRotationInfo(a, b);
+ return SkM44::Rotate(axis, angle);
+ }
+};
+
+static SkM44 inv(const SkM44& m) {
+ SkM44 inverse;
+ SkAssertResult(m.invert(&inverse));
+ return inverse;
+}
+
+// Compute the inverse transpose (of the upper-left 3x3) of a matrix, used to transform vectors
+static SkM44 normals(SkM44 m) {
+ m.setRow(3, {0, 0, 0, 1});
+ m.setCol(3, {0, 0, 0, 1});
+ SkAssertResult(m.invert(&m));
+ return m.transpose();
+}
+
+class Sample3DView : public Sample {
+protected:
+ float fNear = 0.05f;
+ float fFar = 4;
+ float fAngle = SK_ScalarPI / 12;
+
+ SkV3 fEye { 0, 0, 1.0f/tan(fAngle/2) - 1 };
+ SkV3 fCOA { 0, 0, 0 };
+ SkV3 fUp { 0, 1, 0 };
+
+public:
+ void concatCamera(SkCanvas* canvas, const SkRect& area, SkScalar zscale) {
+ SkM44 camera = SkM44::LookAt(fEye, fCOA, fUp),
+ perspective = SkM44::Perspective(fNear, fFar, fAngle),
+ viewport = SkM44::Translate(area.centerX(), area.centerY(), 0) *
+ SkM44::Scale(area.width()*0.5f, area.height()*0.5f, zscale);
+
+ canvas->concat(viewport * perspective * camera * inv(viewport));
+ }
+};
+
+struct Face {
+ SkScalar fRx, fRy;
+ SkColor fColor;
+
+ static SkM44 T(SkScalar x, SkScalar y, SkScalar z) {
+ return SkM44::Translate(x, y, z);
+ }
+
+ static SkM44 R(SkV3 axis, SkScalar rad) {
+ return SkM44::Rotate(axis, rad);
+ }
+
+ SkM44 asM44(SkScalar scale) const {
+ return R({0,1,0}, fRy) * R({1,0,0}, fRx) * T(0, 0, scale);
+ }
+};
+
+static bool front(const SkM44& m) {
+ SkM44 m2(SkM44::kUninitialized_Constructor);
+ if (!m.invert(&m2)) {
+ m2.setIdentity();
+ }
+ /*
+ * Classically we want to dot the transpose(inverse(ctm)) with our surface normal.
+ * In this case, the normal is known to be {0, 0, 1}, so we only actually need to look
+ * at the z-scale of the inverse (the transpose doesn't change the main diagonal, so
+ * no need to actually transpose).
+ */
+ return m2.rc(2,2) > 0;
+}
+
+const Face faces[] = {
+ { 0, 0, SK_ColorRED }, // front
+ { 0, SK_ScalarPI, SK_ColorGREEN }, // back
+
+ { SK_ScalarPI/2, 0, SK_ColorBLUE }, // top
+ {-SK_ScalarPI/2, 0, SK_ColorCYAN }, // bottom
+
+ { 0, SK_ScalarPI/2, SK_ColorMAGENTA }, // left
+ { 0,-SK_ScalarPI/2, SK_ColorYELLOW }, // right
+};
+
+#include "include/effects/SkRuntimeEffect.h"
+
+struct LightOnSphere {
+ SkV2 fLoc;
+ SkScalar fDistance;
+ SkScalar fRadius;
+
+ SkV3 computeWorldPos(const VSphere& s) const {
+ return s.computeUnitV3(fLoc) * fDistance;
+ }
+
+ void draw(SkCanvas* canvas) const {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setColor(SK_ColorWHITE);
+ canvas->drawCircle(fLoc.x, fLoc.y, fRadius + 2, paint);
+ paint.setColor(SK_ColorBLACK);
+ canvas->drawCircle(fLoc.x, fLoc.y, fRadius, paint);
+ }
+};
+
+#include "include/core/SkTime.h"
+
+class RotateAnimator {
+ SkV3 fAxis = {0, 0, 0};
+ SkScalar fAngle = 0,
+ fPrevAngle = 1234567;
+ double fNow = 0,
+ fPrevNow = 0;
+
+ SkScalar fAngleSpeed = 0,
+ fAngleSign = 1;
+
+ inline static constexpr double kSlowDown = 4;
+ inline static constexpr SkScalar kMaxSpeed = 16;
+
+public:
+ void update(SkV3 axis, SkScalar angle) {
+ if (angle != fPrevAngle) {
+ fPrevAngle = fAngle;
+ fAngle = angle;
+
+ fPrevNow = fNow;
+ fNow = SkTime::GetSecs();
+
+ fAxis = axis;
+ }
+ }
+
+ SkM44 rotation() {
+ if (fAngleSpeed > 0) {
+ double now = SkTime::GetSecs();
+ double dtime = now - fPrevNow;
+ fPrevNow = now;
+ double delta = fAngleSign * fAngleSpeed * dtime;
+ fAngle += delta;
+ fAngleSpeed -= kSlowDown * dtime;
+ if (fAngleSpeed < 0) {
+ fAngleSpeed = 0;
+ }
+ }
+ return SkM44::Rotate(fAxis, fAngle);
+
+ }
+
+ void start() {
+ if (fPrevNow != fNow) {
+ fAngleSpeed = (fAngle - fPrevAngle) / (fNow - fPrevNow);
+ fAngleSign = fAngleSpeed < 0 ? -1 : 1;
+ fAngleSpeed = std::min(kMaxSpeed, std::abs(fAngleSpeed));
+ } else {
+ fAngleSpeed = 0;
+ }
+ fPrevNow = SkTime::GetSecs();
+ fAngle = 0;
+ }
+
+ void reset() {
+ fAngleSpeed = 0;
+ fAngle = 0;
+ fPrevAngle = 1234567;
+ }
+
+ bool isAnimating() const { return fAngleSpeed != 0; }
+};
+
+class SampleCubeBase : public Sample3DView {
+ enum {
+ DX = 400,
+ DY = 300
+ };
+
+ SkM44 fRotation; // part of model
+
+ RotateAnimator fRotateAnimator;
+
+protected:
+ enum Flags {
+ kCanRunOnCPU = 1 << 0,
+ kShowLightDome = 1 << 1,
+ };
+
+ LightOnSphere fLight = {{200 + DX, 200 + DY}, 800, 12};
+
+ VSphere fSphere;
+ Flags fFlags;
+
+public:
+ SampleCubeBase(Flags flags)
+ : fSphere({200 + DX, 200 + DY}, 400)
+ , fFlags(flags)
+ {}
+
+ bool onChar(SkUnichar uni) override {
+ switch (uni) {
+ case 'Z': fLight.fDistance += 10; return true;
+ case 'z': fLight.fDistance -= 10; return true;
+ }
+ return this->Sample3DView::onChar(uni);
+ }
+
+ virtual void drawContent(
+ SkCanvas* canvas, SkColor, int index, bool drawFront, const SkM44& localToWorld) = 0;
+
+ void onDrawContent(SkCanvas* canvas) override {
+ if (!canvas->recordingContext() && !(fFlags & kCanRunOnCPU)) {
+ return;
+ }
+
+ canvas->save();
+ canvas->translate(DX, DY);
+
+ this->concatCamera(canvas, {0, 0, 400, 400}, 200);
+
+ for (bool drawFront : {false, true}) {
+ int index = 0;
+ for (auto f : faces) {
+ SkAutoCanvasRestore acr(canvas, true);
+
+ SkM44 trans = SkM44::Translate(200, 200, 0); // center of the rotation
+ SkM44 m = fRotateAnimator.rotation() * fRotation * f.asM44(200);
+
+ canvas->concat(trans);
+
+ // "World" space - content is centered at the origin, in device scale (+-200)
+ SkM44 localToWorld = m * inv(trans);
+
+ canvas->concat(localToWorld);
+ this->drawContent(canvas, f.fColor, index++, drawFront, localToWorld);
+ }
+ }
+
+ canvas->restore(); // camera & center the content in the window
+
+ if (fFlags & kShowLightDome){
+ fLight.draw(canvas);
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setColor(0x40FF0000);
+ canvas->drawCircle(fSphere.fCenter.x, fSphere.fCenter.y, fSphere.fRadius, paint);
+ canvas->drawLine(fSphere.fCenter.x, fSphere.fCenter.y - fSphere.fRadius,
+ fSphere.fCenter.x, fSphere.fCenter.y + fSphere.fRadius, paint);
+ canvas->drawLine(fSphere.fCenter.x - fSphere.fRadius, fSphere.fCenter.y,
+ fSphere.fCenter.x + fSphere.fRadius, fSphere.fCenter.y, paint);
+ }
+ }
+
+ Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
+ SkV2 p = fLight.fLoc - SkV2{x, y};
+ if (p.length() <= fLight.fRadius) {
+ Click* c = new Click();
+ c->fMeta.setS32("type", 0);
+ return c;
+ }
+ if (fSphere.contains({x, y})) {
+ Click* c = new Click();
+ c->fMeta.setS32("type", 1);
+
+ fRotation = fRotateAnimator.rotation() * fRotation;
+ fRotateAnimator.reset();
+ return c;
+ }
+ return nullptr;
+ }
+ bool onClick(Click* click) override {
+ if (click->fMeta.hasS32("type", 0)) {
+ fLight.fLoc = fSphere.pinLoc({click->fCurr.fX, click->fCurr.fY});
+ return true;
+ }
+ if (click->fMeta.hasS32("type", 1)) {
+ if (click->fState == skui::InputState::kUp) {
+ fRotation = fRotateAnimator.rotation() * fRotation;
+ fRotateAnimator.start();
+ } else {
+ auto [axis, angle] = fSphere.computeRotationInfo(
+ {click->fOrig.fX, click->fOrig.fY},
+ {click->fCurr.fX, click->fCurr.fY});
+ fRotateAnimator.update(axis, angle);
+ }
+ return true;
+ }
+ return true;
+ }
+
+ bool onAnimate(double nanos) override {
+ return fRotateAnimator.isAnimating();
+ }
+
+private:
+ using INHERITED = Sample3DView;
+};
+
+class SampleBump3D : public SampleCubeBase {
+ sk_sp<SkShader> fBmpShader, fImgShader;
+ sk_sp<SkRuntimeEffect> fEffect;
+ SkRRect fRR;
+
+public:
+ SampleBump3D() : SampleCubeBase(Flags(kCanRunOnCPU | kShowLightDome)) {}
+
+ SkString name() override { return SkString("bump3d"); }
+
+ void onOnceBeforeDraw() override {
+ fRR = SkRRect::MakeRectXY({20, 20, 380, 380}, 50, 50);
+ auto img = GetResourceAsImage("images/brickwork-texture.jpg");
+ fImgShader = img->makeShader(SkSamplingOptions(), SkMatrix::Scale(2, 2));
+ img = GetResourceAsImage("images/brickwork_normal-map.jpg");
+ fBmpShader = img->makeShader(SkSamplingOptions(), SkMatrix::Scale(2, 2));
+
+ const char code[] = R"(
+ uniform shader color_map;
+ uniform shader normal_map;
+
+ uniform float4x4 localToWorld;
+ uniform float4x4 localToWorldAdjInv;
+ uniform float3 lightPos;
+
+ float3 convert_normal_sample(half4 c) {
+ float3 n = 2 * c.rgb - 1;
+ n.y = -n.y;
+ return n;
+ }
+
+ half4 main(float2 p) {
+ float3 norm = convert_normal_sample(normal_map.eval(p));
+ float3 plane_norm = normalize(localToWorldAdjInv * norm.xyz0).xyz;
+
+ float3 plane_pos = (localToWorld * p.xy01).xyz;
+ float3 light_dir = normalize(lightPos - plane_pos);
+
+ float ambient = 0.2;
+ float dp = dot(plane_norm, light_dir);
+ float scale = min(ambient + max(dp, 0), 1);
+
+ return color_map.eval(p) * scale.xxx1;
+ }
+ )";
+ auto [effect, error] = SkRuntimeEffect::MakeForShader(SkString(code));
+ if (!effect) {
+ SkDebugf("runtime error %s\n", error.c_str());
+ }
+ fEffect = effect;
+ }
+
+ void drawContent(SkCanvas* canvas,
+ SkColor color,
+ int index,
+ bool drawFront,
+ const SkM44& localToWorld) override {
+ if (!drawFront || !front(canvas->getLocalToDevice())) {
+ return;
+ }
+
+ SkRuntimeShaderBuilder builder(fEffect);
+ builder.uniform("lightPos") = fLight.computeWorldPos(fSphere);
+ builder.uniform("localToWorld") = localToWorld;
+ builder.uniform("localToWorldAdjInv") = normals(localToWorld);
+
+ builder.child("color_map") = fImgShader;
+ builder.child("normal_map") = fBmpShader;
+
+ SkPaint paint;
+ paint.setColor(color);
+ paint.setShader(builder.makeShader());
+
+ canvas->drawRRect(fRR, paint);
+ }
+};
+DEF_SAMPLE( return new SampleBump3D; )
+
+#include "modules/skottie/include/Skottie.h"
+
+class SampleSkottieCube : public SampleCubeBase {
+ sk_sp<skottie::Animation> fAnim[6];
+
+public:
+ SampleSkottieCube() : SampleCubeBase(kCanRunOnCPU) {}
+
+ SkString name() override { return SkString("skottie3d"); }
+
+ void onOnceBeforeDraw() override {
+ const char* files[] = {
+ "skottie/skottie-chained-mattes.json",
+ "skottie/skottie-gradient-ramp.json",
+ "skottie/skottie_sample_2.json",
+ "skottie/skottie-3d-3planes.json",
+ "skottie/skottie-text-animator-4.json",
+ "skottie/skottie-motiontile-effect-phase.json",
+
+ };
+ for (unsigned i = 0; i < SK_ARRAY_COUNT(files); ++i) {
+ if (auto stream = GetResourceAsStream(files[i])) {
+ fAnim[i] = skottie::Animation::Make(stream.get());
+ }
+ }
+ }
+
+ void drawContent(
+ SkCanvas* canvas, SkColor color, int index, bool drawFront, const SkM44&) override {
+ if (!drawFront || !front(canvas->getLocalToDevice())) {
+ return;
+ }
+
+ SkPaint paint;
+ paint.setColor(color);
+ SkRect r = {0, 0, 400, 400};
+ canvas->drawRect(r, paint);
+ fAnim[index]->render(canvas, &r);
+ }
+
+ bool onAnimate(double nanos) override {
+ for (auto& anim : fAnim) {
+ SkScalar dur = anim->duration();
+ SkScalar t = fmod(1e-9 * nanos, dur) / dur;
+ anim->seek(t);
+ }
+ return true;
+ }
+};
+DEF_SAMPLE( return new SampleSkottieCube; )
diff --git a/third_party/skia/samplecode/SampleAAClip.cpp b/third_party/skia/samplecode/SampleAAClip.cpp
deleted file mode 100644
index 46e4fe2..0000000
--- a/third_party/skia/samplecode/SampleAAClip.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright 2011 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/SkPath.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkAAClip.h"
-
-static void testop(const SkIRect& r0, const SkIRect& r1, SkRegion::Op op,
- const SkIRect& expectedR) {
- SkAAClip c0, c1, c2;
- c0.setRect(r0);
- c1.setRect(r1);
- c2.op(c0, c1, op);
-
- SkDEBUGCODE(SkIRect r2 = c2.getBounds());
- SkASSERT(r2 == expectedR);
-}
-
-static const struct {
- SkIRect r0;
- SkIRect r1;
- SkRegion::Op op;
- SkIRect expectedR;
-} gRec[] = {
- {{ 1, 2, 9, 3 }, { -3, 2, 5, 11 }, SkRegion::kDifference_Op, { 5, 2, 9, 3 }},
- {{ 1, 10, 5, 13 }, { 1, 2, 5, 11 }, SkRegion::kDifference_Op, { 1, 11, 5, 13 }},
- {{ 1, 10, 5, 13 }, { 1, 2, 5, 11 }, SkRegion::kReverseDifference_Op, { 1, 2, 5, 10 }},
-};
-
-static void testop() {
- for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
- testop(gRec[i].r0, gRec[i].r1, gRec[i].op, gRec[i].expectedR);
- }
-}
-
-static void drawClip(SkCanvas* canvas, const SkAAClip& clip) {
- SkMask mask;
- SkBitmap bm;
-
- clip.copyToMask(&mask);
- SkAutoMaskFreeImage amfi(mask.fImage);
-
- bm.installMaskPixels(mask);
-
- SkPaint paint;
- canvas->drawBitmap(bm,
- SK_Scalar1 * mask.fBounds.fLeft,
- SK_Scalar1 * mask.fBounds.fTop,
- &paint);
-}
-
-class AAClipView : public Sample {
- SkString name() override { return SkString("AAClip"); }
-
- void onOnceBeforeDraw() override { testop(); }
-
- void onDrawContent(SkCanvas* canvas) override {
-#if 1
- SkAAClip aaclip;
- SkPath path;
- SkRect bounds;
-
- bounds.setLTRB(0, 0, 20, 20);
- bounds.inset(SK_ScalarHalf, SK_ScalarHalf);
-
-// path.addRect(bounds);
-// path.addOval(bounds);
- path.addRoundRect(bounds, 4, 4);
- aaclip.setPath(path);
- canvas->translate(30, 30);
- drawClip(canvas, aaclip);
-
- SkAAClip aaclip2;
- path.offset(10, 10);
- aaclip2.setPath(path);
- canvas->translate(30, 0);
- drawClip(canvas, aaclip2);
-
- SkAAClip aaclip3;
- aaclip3.op(aaclip, aaclip2, SkRegion::kIntersect_Op);
- canvas->translate(30, 0);
- drawClip(canvas, aaclip3);
-
-#endif
-
-#if 0
- SkRect r;
- r.set(0, 0, this->width(), this->height());
- r.inset(20, 20);
- canvas->clipRect(r);
-
- SkPath path;
- path.addRect(r);
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setColor(SK_ColorRED);
- canvas->drawPath(path, paint);
-#endif
- }
-};
-DEF_SAMPLE( return new AAClipView(); )
diff --git a/third_party/skia/samplecode/SampleAAGeometry.cpp b/third_party/skia/samplecode/SampleAAGeometry.cpp
deleted file mode 100644
index b2aa97d..0000000
--- a/third_party/skia/samplecode/SampleAAGeometry.cpp
+++ /dev/null
@@ -1,1847 +0,0 @@
-/*
- * Copyright 2015 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/SkBitmap.h"
-#include "include/core/SkCanvas.h"
-#include "include/core/SkString.h"
-#include "include/private/SkMacros.h"
-#include "include/utils/SkTextUtils.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkGeometry.h"
-#include "src/core/SkPointPriv.h"
-#include "src/pathops/SkIntersections.h"
-#include "src/pathops/SkOpEdgeBuilder.h"
-
-#if 0
-void SkStrokeSegment::dump() const {
- SkDebugf("{{{%1.9g,%1.9g}, {%1.9g,%1.9g}", fPts[0].fX, fPts[0].fY, fPts[1].fX, fPts[1].fY);
- if (SkPath::kQuad_Verb == fVerb) {
- SkDebugf(", {%1.9g,%1.9g}", fPts[2].fX, fPts[2].fY);
- }
- SkDebugf("}}");
-#ifdef SK_DEBUG
- SkDebugf(" id=%d", fDebugID);
-#endif
- SkDebugf("\n");
-}
-
-void SkStrokeSegment::dumpAll() const {
- const SkStrokeSegment* segment = this;
- while (segment) {
- segment->dump();
- segment = segment->fNext;
- }
-}
-
-void SkStrokeTriple::dump() const {
- SkDebugf("{{{%1.9g,%1.9g}, {%1.9g,%1.9g}", fPts[0].fX, fPts[0].fY, fPts[1].fX, fPts[1].fY);
- if (SkPath::kQuad_Verb <= fVerb) {
- SkDebugf(", {%1.9g,%1.9g}", fPts[2].fX, fPts[2].fY);
- }
- if (SkPath::kCubic_Verb == fVerb) {
- SkDebugf(", {%1.9g,%1.9g}", fPts[3].fX, fPts[3].fY);
- } else if (SkPath::kConic_Verb == fVerb) {
- SkDebugf(", %1.9g", weight());
- }
- SkDebugf("}}");
-#ifdef SK_DEBUG
- SkDebugf(" triple id=%d", fDebugID);
-#endif
- SkDebugf("\ninner:\n");
- fInner->dumpAll();
- SkDebugf("outer:\n");
- fOuter->dumpAll();
- SkDebugf("join:\n");
- fJoin->dumpAll();
-}
-
-void SkStrokeTriple::dumpAll() const {
- const SkStrokeTriple* triple = this;
- while (triple) {
- triple->dump();
- triple = triple->fNext;
- }
-}
-
-void SkStrokeContour::dump() const {
-#ifdef SK_DEBUG
- SkDebugf("id=%d ", fDebugID);
-#endif
- SkDebugf("head:\n");
- fHead->dumpAll();
- SkDebugf("head cap:\n");
- fHeadCap->dumpAll();
- SkDebugf("tail cap:\n");
- fTailCap->dumpAll();
-}
-
-void SkStrokeContour::dumpAll() const {
- const SkStrokeContour* contour = this;
- while (contour) {
- contour->dump();
- contour = contour->fNext;
- }
-}
-#endif
-
-SkScalar gCurveDistance = 10;
-
-#if 0 // unused
-static SkPath::Verb get_path_verb(int index, const SkPath& path) {
- if (index < 0) {
- return SkPath::kMove_Verb;
- }
- SkPoint pts[4];
- SkPath::Verb verb;
- SkPath::Iter iter(path, true);
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- if (++counter < index) {
- continue;
- }
- return verb;
- }
- SkASSERT(0);
- return SkPath::kMove_Verb;
-}
-#endif
-
-static SkScalar get_path_weight(int index, const SkPath& path) {
- SkPoint pts[4];
- SkPath::Verb verb;
- SkPath::Iter iter(path, true);
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- if (++counter < index) {
- continue;
- }
- return verb == SkPath::kConic_Verb ? iter.conicWeight() : 1;
- }
- SkASSERT(0);
- return 0;
-}
-
-static void set_path_pt(int index, const SkPoint& pt, SkPath* path) {
- SkPath result;
- SkPoint pts[4];
- SkPath::Verb verb;
- SkPath::RawIter iter(*path);
- int startIndex = 0;
- int endIndex = 0;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- switch (verb) {
- case SkPath::kMove_Verb:
- endIndex += 1;
- break;
- case SkPath::kLine_Verb:
- endIndex += 1;
- break;
- case SkPath::kQuad_Verb:
- case SkPath::kConic_Verb:
- endIndex += 2;
- break;
- case SkPath::kCubic_Verb:
- endIndex += 3;
- break;
- case SkPath::kClose_Verb:
- break;
- case SkPath::kDone_Verb:
- break;
- default:
- SkASSERT(0);
- }
- if (startIndex <= index && index < endIndex) {
- pts[index - startIndex] = pt;
- index = -1;
- }
- switch (verb) {
- case SkPath::kMove_Verb:
- result.moveTo(pts[0]);
- break;
- case SkPath::kLine_Verb:
- result.lineTo(pts[1]);
- startIndex += 1;
- break;
- case SkPath::kQuad_Verb:
- result.quadTo(pts[1], pts[2]);
- startIndex += 2;
- break;
- case SkPath::kConic_Verb:
- result.conicTo(pts[1], pts[2], iter.conicWeight());
- startIndex += 2;
- break;
- case SkPath::kCubic_Verb:
- result.cubicTo(pts[1], pts[2], pts[3]);
- startIndex += 3;
- break;
- case SkPath::kClose_Verb:
- result.close();
- startIndex += 1;
- break;
- case SkPath::kDone_Verb:
- break;
- default:
- SkASSERT(0);
- }
- }
-#if 0
- SkDebugf("\n\noriginal\n");
- path->dump();
- SkDebugf("\nedited\n");
- result.dump();
-#endif
- *path = result;
-}
-
-static void add_path_segment(int index, SkPath* path) {
- SkPath result;
- SkPoint pts[4];
- SkPoint firstPt = { 0, 0 }; // init to avoid warning
- SkPoint lastPt = { 0, 0 }; // init to avoid warning
- SkPath::Verb verb;
- SkPath::RawIter iter(*path);
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- SkScalar weight SK_INIT_TO_AVOID_WARNING;
- if (++counter == index) {
- switch (verb) {
- case SkPath::kLine_Verb:
- result.lineTo((pts[0].fX + pts[1].fX) / 2, (pts[0].fY + pts[1].fY) / 2);
- break;
- case SkPath::kQuad_Verb: {
- SkPoint chop[5];
- SkChopQuadAtHalf(pts, chop);
- result.quadTo(chop[1], chop[2]);
- pts[1] = chop[3];
- } break;
- case SkPath::kConic_Verb: {
- SkConic chop[2];
- SkConic conic;
- conic.set(pts, iter.conicWeight());
- if (!conic.chopAt(0.5f, chop)) {
- return;
- }
- result.conicTo(chop[0].fPts[1], chop[0].fPts[2], chop[0].fW);
- pts[1] = chop[1].fPts[1];
- weight = chop[1].fW;
- } break;
- case SkPath::kCubic_Verb: {
- SkPoint chop[7];
- SkChopCubicAtHalf(pts, chop);
- result.cubicTo(chop[1], chop[2], chop[3]);
- pts[1] = chop[4];
- pts[2] = chop[5];
- } break;
- case SkPath::kClose_Verb: {
- result.lineTo((lastPt.fX + firstPt.fX) / 2, (lastPt.fY + firstPt.fY) / 2);
- } break;
- default:
- SkASSERT(0);
- }
- } else if (verb == SkPath::kConic_Verb) {
- weight = iter.conicWeight();
- }
- switch (verb) {
- case SkPath::kMove_Verb:
- result.moveTo(firstPt = pts[0]);
- break;
- case SkPath::kLine_Verb:
- result.lineTo(lastPt = pts[1]);
- break;
- case SkPath::kQuad_Verb:
- result.quadTo(pts[1], lastPt = pts[2]);
- break;
- case SkPath::kConic_Verb:
- result.conicTo(pts[1], lastPt = pts[2], weight);
- break;
- case SkPath::kCubic_Verb:
- result.cubicTo(pts[1], pts[2], lastPt = pts[3]);
- break;
- case SkPath::kClose_Verb:
- result.close();
- break;
- case SkPath::kDone_Verb:
- break;
- default:
- SkASSERT(0);
- }
- }
- *path = result;
-}
-
-static void delete_path_segment(int index, SkPath* path) {
- SkPath result;
- SkPoint pts[4];
- SkPath::Verb verb;
- SkPath::RawIter iter(*path);
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- if (++counter == index) {
- continue;
- }
- switch (verb) {
- case SkPath::kMove_Verb:
- result.moveTo(pts[0]);
- break;
- case SkPath::kLine_Verb:
- result.lineTo(pts[1]);
- break;
- case SkPath::kQuad_Verb:
- result.quadTo(pts[1], pts[2]);
- break;
- case SkPath::kConic_Verb:
- result.conicTo(pts[1], pts[2], iter.conicWeight());
- break;
- case SkPath::kCubic_Verb:
- result.cubicTo(pts[1], pts[2], pts[3]);
- break;
- case SkPath::kClose_Verb:
- result.close();
- break;
- case SkPath::kDone_Verb:
- break;
- default:
- SkASSERT(0);
- }
- }
- *path = result;
-}
-
-static void set_path_weight(int index, SkScalar w, SkPath* path) {
- SkPath result;
- SkPoint pts[4];
- SkPath::Verb verb;
- SkPath::Iter iter(*path, true);
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- ++counter;
- switch (verb) {
- case SkPath::kMove_Verb:
- result.moveTo(pts[0]);
- break;
- case SkPath::kLine_Verb:
- result.lineTo(pts[1]);
- break;
- case SkPath::kQuad_Verb:
- result.quadTo(pts[1], pts[2]);
- break;
- case SkPath::kConic_Verb:
- result.conicTo(pts[1], pts[2], counter == index ? w : iter.conicWeight());
- break;
- case SkPath::kCubic_Verb:
- result.cubicTo(pts[1], pts[2], pts[3]);
- break;
- case SkPath::kClose_Verb:
- result.close();
- break;
- case SkPath::kDone_Verb:
- break;
- default:
- SkASSERT(0);
- }
- }
- *path = result;
-}
-
-static void set_path_verb(int index, SkPath::Verb v, SkPath* path, SkScalar w) {
- SkASSERT(SkPath::kLine_Verb <= v && v <= SkPath::kCubic_Verb);
- SkPath result;
- SkPoint pts[4];
- SkPath::Verb verb;
- SkPath::Iter iter(*path, true);
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- SkScalar weight = verb == SkPath::kConic_Verb ? iter.conicWeight() : 1;
- if (++counter == index && v != verb) {
- SkASSERT(SkPath::kLine_Verb <= verb && verb <= SkPath::kCubic_Verb);
- switch (verb) {
- case SkPath::kLine_Verb:
- switch (v) {
- case SkPath::kConic_Verb:
- weight = w;
- case SkPath::kQuad_Verb:
- pts[2] = pts[1];
- pts[1].fX = (pts[0].fX + pts[2].fX) / 2;
- pts[1].fY = (pts[0].fY + pts[2].fY) / 2;
- break;
- case SkPath::kCubic_Verb:
- pts[3] = pts[1];
- pts[1].fX = (pts[0].fX * 2 + pts[3].fX) / 3;
- pts[1].fY = (pts[0].fY * 2 + pts[3].fY) / 3;
- pts[2].fX = (pts[0].fX + pts[3].fX * 2) / 3;
- pts[2].fY = (pts[0].fY + pts[3].fY * 2) / 3;
- break;
- default:
- SkASSERT(0);
- break;
- }
- break;
- case SkPath::kQuad_Verb:
- case SkPath::kConic_Verb:
- switch (v) {
- case SkPath::kLine_Verb:
- pts[1] = pts[2];
- break;
- case SkPath::kConic_Verb:
- weight = w;
- case SkPath::kQuad_Verb:
- break;
- case SkPath::kCubic_Verb: {
- SkDQuad dQuad;
- dQuad.set(pts);
- SkDCubic dCubic = dQuad.debugToCubic();
- pts[3] = pts[2];
- pts[1] = dCubic[1].asSkPoint();
- pts[2] = dCubic[2].asSkPoint();
- } break;
- default:
- SkASSERT(0);
- break;
- }
- break;
- case SkPath::kCubic_Verb:
- switch (v) {
- case SkPath::kLine_Verb:
- pts[1] = pts[3];
- break;
- case SkPath::kConic_Verb:
- weight = w;
- case SkPath::kQuad_Verb: {
- SkDCubic dCubic;
- dCubic.set(pts);
- SkDQuad dQuad = dCubic.toQuad();
- pts[1] = dQuad[1].asSkPoint();
- pts[2] = pts[3];
- } break;
- default:
- SkASSERT(0);
- break;
- }
- break;
- default:
- SkASSERT(0);
- break;
- }
- verb = v;
- }
- switch (verb) {
- case SkPath::kMove_Verb:
- result.moveTo(pts[0]);
- break;
- case SkPath::kLine_Verb:
- result.lineTo(pts[1]);
- break;
- case SkPath::kQuad_Verb:
- result.quadTo(pts[1], pts[2]);
- break;
- case SkPath::kConic_Verb:
- result.conicTo(pts[1], pts[2], weight);
- break;
- case SkPath::kCubic_Verb:
- result.cubicTo(pts[1], pts[2], pts[3]);
- break;
- case SkPath::kClose_Verb:
- result.close();
- break;
- default:
- SkASSERT(0);
- break;
- }
- }
- *path = result;
-}
-
-static void add_to_map(SkScalar coverage, int x, int y, uint8_t* distanceMap, int w, int h) {
- int byteCoverage = (int) (coverage * 256);
- if (byteCoverage < 0) {
- byteCoverage = 0;
- } else if (byteCoverage > 255) {
- byteCoverage = 255;
- }
- SkASSERT(x < w);
- SkASSERT(y < h);
- distanceMap[y * w + x] = SkTMax(distanceMap[y * w + x], (uint8_t) byteCoverage);
-}
-
-static void filter_coverage(const uint8_t* map, int len, uint8_t min, uint8_t max,
- uint8_t* filter) {
- for (int index = 0; index < len; ++index) {
- uint8_t in = map[index];
- filter[index] = in < min ? 0 : max < in ? 0 : in;
- }
-}
-
-static void construct_path(SkPath& path) {
- path.reset();
- path.moveTo(442, 101.5f);
- path.quadTo(413.5f, 691, 772, 514);
- path.lineTo(346, 721.5f);
- path.lineTo(154, 209);
- path.lineTo(442, 101.5f);
- path.close();
-}
-
-struct ButtonPaints {
- static const int kMaxStateCount = 3;
- SkPaint fDisabled;
- SkPaint fStates[kMaxStateCount];
- SkFont fLabelFont;
-
- ButtonPaints() {
- fStates[0].setAntiAlias(true);
- fStates[0].setStyle(SkPaint::kStroke_Style);
- fStates[0].setColor(0xFF3F0000);
- fStates[1] = fStates[0];
- fStates[1].setStrokeWidth(3);
- fStates[2] = fStates[1];
- fStates[2].setColor(0xFFcf0000);
- fLabelFont.setSize(25.0f);
- }
-};
-
-struct Button {
- SkRect fBounds;
- int fStateCount;
- int fState;
- char fLabel;
- bool fVisible;
-
- Button(char label) {
- fStateCount = 2;
- fState = 0;
- fLabel = label;
- fVisible = false;
- }
-
- Button(char label, int stateCount) {
- SkASSERT(stateCount <= ButtonPaints::kMaxStateCount);
- fStateCount = stateCount;
- fState = 0;
- fLabel = label;
- fVisible = false;
- }
-
- bool contains(const SkRect& rect) {
- return fVisible && fBounds.contains(rect);
- }
-
- bool enabled() {
- return SkToBool(fState);
- }
-
- void draw(SkCanvas* canvas, const ButtonPaints& paints) {
- if (!fVisible) {
- return;
- }
- canvas->drawRect(fBounds, paints.fStates[fState]);
- SkTextUtils::Draw(canvas, &fLabel, 1, SkTextEncoding::kUTF8, fBounds.centerX(), fBounds.fBottom - 5,
- paints.fLabelFont, SkPaint(), SkTextUtils::kCenter_Align);
- }
-
- void toggle() {
- if (++fState == fStateCount) {
- fState = 0;
- }
- }
-
- void setEnabled(bool enabled) {
- fState = (int) enabled;
- }
-};
-
-struct ControlPaints {
- SkPaint fOutline;
- SkPaint fIndicator;
- SkPaint fFill;
- SkPaint fLabel;
- SkPaint fValue;
-
- SkFont fLabelFont;
- SkFont fValueFont;
-
- ControlPaints() {
- fOutline.setAntiAlias(true);
- fOutline.setStyle(SkPaint::kStroke_Style);
- fIndicator = fOutline;
- fIndicator.setColor(SK_ColorRED);
- fFill.setAntiAlias(true);
- fFill.setColor(0x7fff0000);
- fLabel.setAntiAlias(true);
- fLabelFont.setSize(13.0f);
- fValue.setAntiAlias(true);
- fValueFont.setSize(11.0f);
- }
-};
-
-struct UniControl {
- SkString fName;
- SkRect fBounds;
- SkScalar fMin;
- SkScalar fMax;
- SkScalar fValLo;
- SkScalar fYLo;
- bool fVisible;
-
- UniControl(const char* name, SkScalar min, SkScalar max) {
- fName = name;
- fValLo = fMin = min;
- fMax = max;
- fVisible = false;
-
- }
-
- virtual ~UniControl() {}
-
- bool contains(const SkRect& rect) {
- return fVisible && fBounds.contains(rect);
- }
-
- virtual void draw(SkCanvas* canvas, const ControlPaints& paints) {
- if (!fVisible) {
- return;
- }
- canvas->drawRect(fBounds, paints.fOutline);
- fYLo = fBounds.fTop + (fValLo - fMin) * fBounds.height() / (fMax - fMin);
- canvas->drawLine(fBounds.fLeft - 5, fYLo, fBounds.fRight + 5, fYLo, paints.fIndicator);
- SkString label;
- label.printf("%0.3g", fValLo);
- canvas->drawString(label, fBounds.fLeft + 5, fYLo - 5, paints.fValueFont, paints.fValue);
- canvas->drawString(fName, fBounds.fLeft, fBounds.bottom() + 11, paints.fLabelFont,
- paints.fLabel);
- }
-};
-
-struct BiControl : public UniControl {
- SkScalar fValHi;
-
- BiControl(const char* name, SkScalar min, SkScalar max)
- : UniControl(name, min, max)
- , fValHi(fMax) {
- }
-
- virtual ~BiControl() {}
-
- virtual void draw(SkCanvas* canvas, const ControlPaints& paints) {
- UniControl::draw(canvas, paints);
- if (!fVisible || fValHi == fValLo) {
- return;
- }
- SkScalar yPos = fBounds.fTop + (fValHi - fMin) * fBounds.height() / (fMax - fMin);
- canvas->drawLine(fBounds.fLeft - 5, yPos, fBounds.fRight + 5, yPos, paints.fIndicator);
- SkString label;
- label.printf("%0.3g", fValHi);
- if (yPos < fYLo + 10) {
- yPos = fYLo + 10;
- }
- canvas->drawString(label, fBounds.fLeft + 5, yPos - 5, paints.fValueFont, paints.fValue);
- SkRect fill = { fBounds.fLeft, fYLo, fBounds.fRight, yPos };
- canvas->drawRect(fill, paints.fFill);
- }
-};
-
-
-class MyClick : public Sample::Click {
-public:
- enum ClickType {
- kInvalidType = -1,
- kPtType,
- kVerbType,
- kControlType,
- kPathType,
- } fType;
-
- enum ControlType {
- kInvalidControl = -1,
- kFirstControl,
- kFilterControl = kFirstControl,
- kResControl,
- kWeightControl,
- kWidthControl,
- kLastControl = kWidthControl,
- kFirstButton,
- kCubicButton = kFirstButton,
- kConicButton,
- kQuadButton,
- kLineButton,
- kLastVerbButton = kLineButton,
- kAddButton,
- kDeleteButton,
- kInOutButton,
- kFillButton,
- kSkeletonButton,
- kFilterButton,
- kBisectButton,
- kJoinButton,
- kLastButton = kJoinButton,
- kPathMove,
- } fControl;
-
- SkPath::Verb fVerb;
- SkScalar fWeight;
-
- MyClick(ClickType type, ControlType control)
- : fType(type)
- , fControl(control)
- , fVerb((SkPath::Verb) -1)
- , fWeight(1) {
- }
-
- MyClick(ClickType type, int index)
- : fType(type)
- , fControl((ControlType) index)
- , fVerb((SkPath::Verb) -1)
- , fWeight(1) {
- }
-
- MyClick(ClickType type, int index, SkPath::Verb verb, SkScalar weight)
- : fType(type)
- , fControl((ControlType) index)
- , fVerb(verb)
- , fWeight(weight) {
- }
-
- bool isButton() {
- return kFirstButton <= fControl && fControl <= kLastButton;
- }
-
- int ptHit() const {
- SkASSERT(fType == kPtType);
- return (int) fControl;
- }
-
- int verbHit() const {
- SkASSERT(fType == kVerbType);
- return (int) fControl;
- }
-};
-
-enum {
- kControlCount = MyClick::kLastControl - MyClick::kFirstControl + 1,
-};
-
-static struct ControlPair {
- UniControl* fControl;
- MyClick::ControlType fControlType;
-} kControlList[kControlCount];
-
-enum {
- kButtonCount = MyClick::kLastButton - MyClick::kFirstButton + 1,
- kVerbCount = MyClick::kLastVerbButton - MyClick::kFirstButton + 1,
-};
-
-static struct ButtonPair {
- Button* fButton;
- MyClick::ControlType fButtonType;
-} kButtonList[kButtonCount];
-
-static void enable_verb_button(MyClick::ControlType type) {
- for (int index = 0; index < kButtonCount; ++index) {
- MyClick::ControlType testType = kButtonList[index].fButtonType;
- if (MyClick::kFirstButton <= testType && testType <= MyClick::kLastVerbButton) {
- Button* button = kButtonList[index].fButton;
- button->setEnabled(testType == type);
- }
- }
-}
-
-struct Stroke;
-
-struct Active {
- Active* fNext;
- Stroke* fParent;
- SkScalar fStart;
- SkScalar fEnd;
-
- void reset() {
- fNext = nullptr;
- fStart = 0;
- fEnd = 1;
- }
-};
-
-struct Stroke {
- SkPath fPath;
- Active fActive;
- bool fInner;
-
- void reset() {
- fPath.reset();
- fActive.reset();
- }
-};
-
-struct PathUndo {
- SkPath fPath;
- std::unique_ptr<PathUndo> fNext;
-};
-
-class AAGeometryView : public Sample {
- SkPaint fActivePaint;
- SkPaint fComplexPaint;
- SkPaint fCoveragePaint;
- SkFont fLegendLeftFont;
- SkFont fLegendRightFont;
- SkPaint fPointPaint;
- SkPaint fSkeletonPaint;
- SkPaint fLightSkeletonPaint;
- SkPath fPath;
- ControlPaints fControlPaints;
- UniControl fResControl;
- UniControl fWeightControl;
- UniControl fWidthControl;
- BiControl fFilterControl;
- ButtonPaints fButtonPaints;
- Button fCubicButton;
- Button fConicButton;
- Button fQuadButton;
- Button fLineButton;
- Button fAddButton;
- Button fDeleteButton;
- Button fFillButton;
- Button fSkeletonButton;
- Button fFilterButton;
- Button fBisectButton;
- Button fJoinButton;
- Button fInOutButton;
- SkTArray<Stroke> fStrokes;
- std::unique_ptr<PathUndo> fUndo;
- int fActivePt;
- int fActiveVerb;
- bool fHandlePathMove;
- bool fShowLegend;
- bool fHideAll;
- const int kHitToleranace = 25;
-
-public:
-
- AAGeometryView()
- : fResControl("error", 0, 10)
- , fWeightControl("weight", 0, 5)
- , fWidthControl("width", FLT_EPSILON, 100)
- , fFilterControl("filter", 0, 255)
- , fCubicButton('C')
- , fConicButton('K')
- , fQuadButton('Q')
- , fLineButton('L')
- , fAddButton('+')
- , fDeleteButton('x')
- , fFillButton('p')
- , fSkeletonButton('s')
- , fFilterButton('f', 3)
- , fBisectButton('b')
- , fJoinButton('j')
- , fInOutButton('|')
- , fActivePt(-1)
- , fActiveVerb(-1)
- , fHandlePathMove(true)
- , fShowLegend(false)
- , fHideAll(false)
- {
- fCoveragePaint.setAntiAlias(true);
- fCoveragePaint.setColor(SK_ColorBLUE);
- SkPaint strokePaint;
- strokePaint.setAntiAlias(true);
- strokePaint.setStyle(SkPaint::kStroke_Style);
- fPointPaint = strokePaint;
- fPointPaint.setColor(0x99ee3300);
- fSkeletonPaint = strokePaint;
- fSkeletonPaint.setColor(SK_ColorRED);
- fLightSkeletonPaint = fSkeletonPaint;
- fLightSkeletonPaint.setColor(0xFFFF7f7f);
- fActivePaint = strokePaint;
- fActivePaint.setColor(0x99ee3300);
- fActivePaint.setStrokeWidth(5);
- fComplexPaint = fActivePaint;
- fComplexPaint.setColor(SK_ColorBLUE);
- fLegendLeftFont.setSize(13);
- fLegendRightFont = fLegendLeftFont;
- construct_path(fPath);
- fFillButton.fVisible = fSkeletonButton.fVisible = fFilterButton.fVisible
- = fBisectButton.fVisible = fJoinButton.fVisible = fInOutButton.fVisible = true;
- fSkeletonButton.setEnabled(true);
- fInOutButton.setEnabled(true);
- fJoinButton.setEnabled(true);
- fFilterControl.fValLo = 120;
- fFilterControl.fValHi = 141;
- fFilterControl.fVisible = fFilterButton.fState == 2;
- fResControl.fValLo = 5;
- fResControl.fVisible = true;
- fWidthControl.fValLo = 50;
- fWidthControl.fVisible = true;
- init_controlList();
- init_buttonList();
- }
-
- ~AAGeometryView() override {
- // Free linked list without deep recursion.
- std::unique_ptr<PathUndo> undo = std::move(fUndo);
- while (undo) {
- undo = std::move(undo->fNext);
- }
- }
-
- bool constructPath() {
- construct_path(fPath);
- return true;
- }
-
- void savePath(skui::InputState state) {
- if (state != skui::InputState::kDown) {
- return;
- }
- if (fUndo && fUndo->fPath == fPath) {
- return;
- }
- std::unique_ptr<PathUndo> undo(new PathUndo);
- undo->fPath = fPath;
- undo->fNext = std::move(fUndo);
- fUndo = std::move(undo);
- }
-
- bool undo() {
- if (!fUndo) {
- return false;
- }
- fPath = std::move(fUndo->fPath);
- fUndo = std::move(fUndo->fNext);
- validatePath();
- return true;
- }
-
- void validatePath() {}
-
- void set_controlList(int index, UniControl* control, MyClick::ControlType type) {
- kControlList[index].fControl = control;
- kControlList[index].fControlType = type;
- }
-
- #define SET_CONTROL(Name) set_controlList(index++, &f##Name##Control, \
- MyClick::k##Name##Control)
-
- bool hideAll() {
- fHideAll ^= true;
- return true;
- }
-
- void init_controlList() {
- int index = 0;
- SET_CONTROL(Width);
- SET_CONTROL(Res);
- SET_CONTROL(Filter);
- SET_CONTROL(Weight);
- }
-
- #undef SET_CONTROL
-
- void set_buttonList(int index, Button* button, MyClick::ControlType type) {
- kButtonList[index].fButton = button;
- kButtonList[index].fButtonType = type;
- }
-
- #define SET_BUTTON(Name) set_buttonList(index++, &f##Name##Button, \
- MyClick::k##Name##Button)
-
- void init_buttonList() {
- int index = 0;
- SET_BUTTON(Fill);
- SET_BUTTON(Skeleton);
- SET_BUTTON(Filter);
- SET_BUTTON(Bisect);
- SET_BUTTON(Join);
- SET_BUTTON(InOut);
- SET_BUTTON(Cubic);
- SET_BUTTON(Conic);
- SET_BUTTON(Quad);
- SET_BUTTON(Line);
- SET_BUTTON(Add);
- SET_BUTTON(Delete);
- }
-
- #undef SET_BUTTON
-
- SkString name() override { return SkString("AAGeometry"); }
-
- bool onChar(SkUnichar) override;
-
- void onSizeChange() override {
- setControlButtonsPos();
- this->INHERITED::onSizeChange();
- }
-
- bool pathDump() {
- fPath.dump();
- return true;
- }
-
- bool scaleDown() {
- SkMatrix matrix;
- SkRect bounds = fPath.getBounds();
- matrix.setScale(1.f / 1.5f, 1.f / 1.5f, bounds.centerX(), bounds.centerY());
- fPath.transform(matrix);
- validatePath();
- return true;
- }
-
- bool scaleToFit() {
- SkMatrix matrix;
- SkRect bounds = fPath.getBounds();
- SkScalar scale = SkTMin(this->width() / bounds.width(), this->height() / bounds.height())
- * 0.8f;
- matrix.setScale(scale, scale, bounds.centerX(), bounds.centerY());
- fPath.transform(matrix);
- bounds = fPath.getBounds();
- SkScalar offsetX = (this->width() - bounds.width()) / 2 - bounds.fLeft;
- SkScalar offsetY = (this->height() - bounds.height()) / 2 - bounds.fTop;
- fPath.offset(offsetX, offsetY);
- validatePath();
- return true;
- }
-
- bool scaleUp() {
- SkMatrix matrix;
- SkRect bounds = fPath.getBounds();
- matrix.setScale(1.5f, 1.5f, bounds.centerX(), bounds.centerY());
- fPath.transform(matrix);
- validatePath();
- return true;
- }
-
- void setControlButtonsPos() {
- SkScalar widthOffset = this->width() - 100;
- for (int index = 0; index < kControlCount; ++index) {
- if (kControlList[index].fControl->fVisible) {
- kControlList[index].fControl->fBounds.setXYWH(widthOffset, 30, 30, 400);
- widthOffset -= 50;
- }
- }
- SkScalar buttonOffset = 0;
- for (int index = 0; index < kButtonCount; ++index) {
- kButtonList[index].fButton->fBounds.setXYWH(this->width() - 50,
- buttonOffset += 50, 30, 30);
- }
- }
-
- bool showLegend() {
- fShowLegend ^= true;
- return true;
- }
-
- void draw_bisect(SkCanvas* canvas, const SkVector& lastVector, const SkVector& vector,
- const SkPoint& pt) {
- SkVector lastV = lastVector;
- SkScalar lastLen = lastVector.length();
- SkVector nextV = vector;
- SkScalar nextLen = vector.length();
- if (lastLen < nextLen) {
- lastV.setLength(nextLen);
- } else {
- nextV.setLength(lastLen);
- }
-
- SkVector bisect = { (lastV.fX + nextV.fX) / 2, (lastV.fY + nextV.fY) / 2 };
- bisect.setLength(fWidthControl.fValLo * 2);
- if (fBisectButton.enabled()) {
- canvas->drawLine(pt, pt + bisect, fSkeletonPaint);
- }
- lastV.setLength(fWidthControl.fValLo);
- if (fBisectButton.enabled()) {
- canvas->drawLine(pt, {pt.fX - lastV.fY, pt.fY + lastV.fX}, fSkeletonPaint);
- }
- nextV.setLength(fWidthControl.fValLo);
- if (fBisectButton.enabled()) {
- canvas->drawLine(pt, {pt.fX + nextV.fY, pt.fY - nextV.fX}, fSkeletonPaint);
- }
- if (fJoinButton.enabled()) {
- SkScalar r = fWidthControl.fValLo;
- SkRect oval = { pt.fX - r, pt.fY - r, pt.fX + r, pt.fY + r};
- SkScalar startAngle = SkScalarATan2(lastV.fX, -lastV.fY) * 180.f / SK_ScalarPI;
- SkScalar endAngle = SkScalarATan2(-nextV.fX, nextV.fY) * 180.f / SK_ScalarPI;
- if (endAngle > startAngle) {
- canvas->drawArc(oval, startAngle, endAngle - startAngle, false, fSkeletonPaint);
- } else {
- canvas->drawArc(oval, startAngle, 360 - (startAngle - endAngle), false,
- fSkeletonPaint);
- }
- }
- }
-
- void draw_bisects(SkCanvas* canvas, bool activeOnly) {
- SkVector firstVector, lastVector, nextLast, vector;
- SkPoint pts[4];
- SkPoint firstPt = { 0, 0 }; // init to avoid warning;
- SkPath::Verb verb;
- SkPath::Iter iter(fPath, true);
- bool foundFirst = false;
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- ++counter;
- if (activeOnly && counter != fActiveVerb && counter - 1 != fActiveVerb
- && counter + 1 != fActiveVerb
- && (fActiveVerb != 1 || counter != fPath.countVerbs())) {
- continue;
- }
- switch (verb) {
- case SkPath::kLine_Verb:
- nextLast = pts[0] - pts[1];
- vector = pts[1] - pts[0];
- break;
- case SkPath::kQuad_Verb: {
- nextLast = pts[1] - pts[2];
- if (SkScalarNearlyZero(nextLast.length())) {
- nextLast = pts[0] - pts[2];
- }
- vector = pts[1] - pts[0];
- if (SkScalarNearlyZero(vector.length())) {
- vector = pts[2] - pts[0];
- }
- if (!fBisectButton.enabled()) {
- break;
- }
- SkScalar t = SkFindQuadMaxCurvature(pts);
- if (0 < t && t < 1) {
- SkPoint maxPt = SkEvalQuadAt(pts, t);
- SkVector tangent = SkEvalQuadTangentAt(pts, t);
- tangent.setLength(fWidthControl.fValLo * 2);
- canvas->drawLine(maxPt, {maxPt.fX + tangent.fY, maxPt.fY - tangent.fX},
- fSkeletonPaint);
- }
- } break;
- case SkPath::kConic_Verb:
- nextLast = pts[1] - pts[2];
- if (SkScalarNearlyZero(nextLast.length())) {
- nextLast = pts[0] - pts[2];
- }
- vector = pts[1] - pts[0];
- if (SkScalarNearlyZero(vector.length())) {
- vector = pts[2] - pts[0];
- }
- if (!fBisectButton.enabled()) {
- break;
- }
- // FIXME : need max curvature or equivalent here
- break;
- case SkPath::kCubic_Verb: {
- nextLast = pts[2] - pts[3];
- if (SkScalarNearlyZero(nextLast.length())) {
- nextLast = pts[1] - pts[3];
- if (SkScalarNearlyZero(nextLast.length())) {
- nextLast = pts[0] - pts[3];
- }
- }
- vector = pts[0] - pts[1];
- if (SkScalarNearlyZero(vector.length())) {
- vector = pts[0] - pts[2];
- if (SkScalarNearlyZero(vector.length())) {
- vector = pts[0] - pts[3];
- }
- }
- if (!fBisectButton.enabled()) {
- break;
- }
- SkScalar tMax[2];
- int tMaxCount = SkFindCubicMaxCurvature(pts, tMax);
- for (int tIndex = 0; tIndex < tMaxCount; ++tIndex) {
- if (0 >= tMax[tIndex] || tMax[tIndex] >= 1) {
- continue;
- }
- SkPoint maxPt;
- SkVector tangent;
- SkEvalCubicAt(pts, tMax[tIndex], &maxPt, &tangent, nullptr);
- tangent.setLength(fWidthControl.fValLo * 2);
- canvas->drawLine(maxPt, {maxPt.fX + tangent.fY, maxPt.fY - tangent.fX},
- fSkeletonPaint);
- }
- } break;
- case SkPath::kClose_Verb:
- if (foundFirst) {
- draw_bisect(canvas, lastVector, firstVector, firstPt);
- foundFirst = false;
- }
- break;
- default:
- break;
- }
- if (SkPath::kLine_Verb <= verb && verb <= SkPath::kCubic_Verb) {
- if (!foundFirst) {
- firstPt = pts[0];
- firstVector = vector;
- foundFirst = true;
- } else {
- draw_bisect(canvas, lastVector, vector, pts[0]);
- }
- lastVector = nextLast;
- }
- }
- }
-
- void draw_legend(SkCanvas* canvas);
-
- void draw_segment(SkCanvas* canvas) {
- SkPoint pts[4];
- SkPath::Verb verb;
- SkPath::Iter iter(fPath, true);
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- if (++counter < fActiveVerb) {
- continue;
- }
- switch (verb) {
- case SkPath::kLine_Verb:
- canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, fActivePaint);
- draw_points(canvas, pts, 2);
- break;
- case SkPath::kQuad_Verb: {
- SkPath qPath;
- qPath.moveTo(pts[0]);
- qPath.quadTo(pts[1], pts[2]);
- canvas->drawPath(qPath, fActivePaint);
- draw_points(canvas, pts, 3);
- } break;
- case SkPath::kConic_Verb: {
- SkPath conicPath;
- conicPath.moveTo(pts[0]);
- conicPath.conicTo(pts[1], pts[2], iter.conicWeight());
- canvas->drawPath(conicPath, fActivePaint);
- draw_points(canvas, pts, 3);
- } break;
- case SkPath::kCubic_Verb: {
- SkScalar loopT[3];
- int complex = SkDCubic::ComplexBreak(pts, loopT);
- SkPath cPath;
- cPath.moveTo(pts[0]);
- cPath.cubicTo(pts[1], pts[2], pts[3]);
- canvas->drawPath(cPath, complex ? fComplexPaint : fActivePaint);
- draw_points(canvas, pts, 4);
- } break;
- default:
- break;
- }
- return;
- }
- }
-
- void draw_points(SkCanvas* canvas, SkPoint* points, int count) {
- for (int index = 0; index < count; ++index) {
- canvas->drawCircle(points[index].fX, points[index].fY, 10, fPointPaint);
- }
- }
-
- int hittest_verb(SkPoint pt, SkPath::Verb* verbPtr, SkScalar* weight) {
- SkIntersections i;
- SkDLine hHit = {{{pt.fX - kHitToleranace, pt.fY }, {pt.fX + kHitToleranace, pt.fY}}};
- SkDLine vHit = {{{pt.fX, pt.fY - kHitToleranace }, {pt.fX, pt.fY + kHitToleranace}}};
- SkPoint pts[4];
- SkPath::Verb verb;
- SkPath::Iter iter(fPath, true);
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- ++counter;
- switch (verb) {
- case SkPath::kLine_Verb: {
- SkDLine line;
- line.set(pts);
- if (i.intersect(line, hHit) || i.intersect(line, vHit)) {
- *verbPtr = verb;
- *weight = 1;
- return counter;
- }
- } break;
- case SkPath::kQuad_Verb: {
- SkDQuad quad;
- quad.set(pts);
- if (i.intersect(quad, hHit) || i.intersect(quad, vHit)) {
- *verbPtr = verb;
- *weight = 1;
- return counter;
- }
- } break;
- case SkPath::kConic_Verb: {
- SkDConic conic;
- SkScalar w = iter.conicWeight();
- conic.set(pts, w);
- if (i.intersect(conic, hHit) || i.intersect(conic, vHit)) {
- *verbPtr = verb;
- *weight = w;
- return counter;
- }
- } break;
- case SkPath::kCubic_Verb: {
- SkDCubic cubic;
- cubic.set(pts);
- if (i.intersect(cubic, hHit) || i.intersect(cubic, vHit)) {
- *verbPtr = verb;
- *weight = 1;
- return counter;
- }
- } break;
- default:
- break;
- }
- }
- return -1;
- }
-
- SkScalar pt_to_line(SkPoint s, SkPoint e, int x, int y) {
- SkScalar radius = fWidthControl.fValLo;
- SkVector adjOpp = e - s;
- SkScalar lenSq = SkPointPriv::LengthSqd(adjOpp);
- SkPoint rotated = {
- (y - s.fY) * adjOpp.fY + (x - s.fX) * adjOpp.fX,
- (y - s.fY) * adjOpp.fX - (x - s.fX) * adjOpp.fY,
- };
- if (rotated.fX < 0 || rotated.fX > lenSq) {
- return -radius;
- }
- rotated.fY /= SkScalarSqrt(lenSq);
- return SkTMax(-radius, SkTMin(radius, rotated.fY));
- }
-
- // given a line, compute the interior and exterior gradient coverage
- bool coverage(SkPoint s, SkPoint e, uint8_t* distanceMap, int w, int h) {
- SkScalar radius = fWidthControl.fValLo;
- int minX = SkTMax(0, (int) (SkTMin(s.fX, e.fX) - radius));
- int minY = SkTMax(0, (int) (SkTMin(s.fY, e.fY) - radius));
- int maxX = SkTMin(w, (int) (SkTMax(s.fX, e.fX) + radius) + 1);
- int maxY = SkTMin(h, (int) (SkTMax(s.fY, e.fY) + radius) + 1);
- for (int y = minY; y < maxY; ++y) {
- for (int x = minX; x < maxX; ++x) {
- SkScalar ptToLineDist = pt_to_line(s, e, x, y);
- if (ptToLineDist > -radius && ptToLineDist < radius) {
- SkScalar coverage = ptToLineDist / radius;
- add_to_map(1 - SkScalarAbs(coverage), x, y, distanceMap, w, h);
- }
- SkVector ptToS = { x - s.fX, y - s.fY };
- SkScalar dist = ptToS.length();
- if (dist < radius) {
- SkScalar coverage = dist / radius;
- add_to_map(1 - SkScalarAbs(coverage), x, y, distanceMap, w, h);
- }
- SkVector ptToE = { x - e.fX, y - e.fY };
- dist = ptToE.length();
- if (dist < radius) {
- SkScalar coverage = dist / radius;
- add_to_map(1 - SkScalarAbs(coverage), x, y, distanceMap, w, h);
- }
- }
- }
- return true;
- }
-
- void quad_coverage(SkPoint pts[3], uint8_t* distanceMap, int w, int h) {
- SkScalar dist = pts[0].Distance(pts[0], pts[2]);
- if (dist < gCurveDistance) {
- (void) coverage(pts[0], pts[2], distanceMap, w, h);
- return;
- }
- SkPoint split[5];
- SkChopQuadAt(pts, split, 0.5f);
- quad_coverage(&split[0], distanceMap, w, h);
- quad_coverage(&split[2], distanceMap, w, h);
- }
-
- void conic_coverage(SkPoint pts[3], SkScalar weight, uint8_t* distanceMap, int w, int h) {
- SkScalar dist = pts[0].Distance(pts[0], pts[2]);
- if (dist < gCurveDistance) {
- (void) coverage(pts[0], pts[2], distanceMap, w, h);
- return;
- }
- SkConic split[2];
- SkConic conic;
- conic.set(pts, weight);
- if (conic.chopAt(0.5f, split)) {
- conic_coverage(split[0].fPts, split[0].fW, distanceMap, w, h);
- conic_coverage(split[1].fPts, split[1].fW, distanceMap, w, h);
- }
- }
-
- void cubic_coverage(SkPoint pts[4], uint8_t* distanceMap, int w, int h) {
- SkScalar dist = pts[0].Distance(pts[0], pts[3]);
- if (dist < gCurveDistance) {
- (void) coverage(pts[0], pts[3], distanceMap, w, h);
- return;
- }
- SkPoint split[7];
- SkChopCubicAt(pts, split, 0.5f);
- cubic_coverage(&split[0], distanceMap, w, h);
- cubic_coverage(&split[3], distanceMap, w, h);
- }
-
- void path_coverage(const SkPath& path, uint8_t* distanceMap, int w, int h) {
- memset(distanceMap, 0, sizeof(distanceMap[0]) * w * h);
- SkPoint pts[4];
- SkPath::Verb verb;
- SkPath::Iter iter(path, true);
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- switch (verb) {
- case SkPath::kLine_Verb:
- (void) coverage(pts[0], pts[1], distanceMap, w, h);
- break;
- case SkPath::kQuad_Verb:
- quad_coverage(pts, distanceMap, w, h);
- break;
- case SkPath::kConic_Verb:
- conic_coverage(pts, iter.conicWeight(), distanceMap, w, h);
- break;
- case SkPath::kCubic_Verb:
- cubic_coverage(pts, distanceMap, w, h);
- break;
- default:
- break;
- }
- }
- }
-
- static uint8_t* set_up_dist_map(const SkImageInfo& imageInfo, SkBitmap* distMap) {
- distMap->setInfo(imageInfo);
- distMap->setIsVolatile(true);
- SkAssertResult(distMap->tryAllocPixels());
- SkASSERT((int) distMap->rowBytes() == imageInfo.width());
- return distMap->getAddr8(0, 0);
- }
-
- void path_stroke(int index, SkPath* inner, SkPath* outer) {
- #if 0
- SkPathStroker stroker(fPath, fWidthControl.fValLo, 0,
- SkPaint::kRound_Cap, SkPaint::kRound_Join, fResControl.fValLo);
- SkPoint pts[4], firstPt, lastPt;
- SkPath::Verb verb;
- SkPath::Iter iter(fPath, true);
- int counter = -1;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
- ++counter;
- switch (verb) {
- case SkPath::kMove_Verb:
- firstPt = pts[0];
- break;
- case SkPath::kLine_Verb:
- if (counter == index) {
- stroker.moveTo(pts[0]);
- stroker.lineTo(pts[1]);
- goto done;
- }
- lastPt = pts[1];
- break;
- case SkPath::kQuad_Verb:
- if (counter == index) {
- stroker.moveTo(pts[0]);
- stroker.quadTo(pts[1], pts[2]);
- goto done;
- }
- lastPt = pts[2];
- break;
- case SkPath::kConic_Verb:
- if (counter == index) {
- stroker.moveTo(pts[0]);
- stroker.conicTo(pts[1], pts[2], iter.conicWeight());
- goto done;
- }
- lastPt = pts[2];
- break;
- case SkPath::kCubic_Verb:
- if (counter == index) {
- stroker.moveTo(pts[0]);
- stroker.cubicTo(pts[1], pts[2], pts[3]);
- goto done;
- }
- lastPt = pts[3];
- break;
- case SkPath::kClose_Verb:
- if (counter == index) {
- stroker.moveTo(lastPt);
- stroker.lineTo(firstPt);
- goto done;
- }
- break;
- case SkPath::kDone_Verb:
- break;
- default:
- SkASSERT(0);
- }
- }
- done:
- *inner = stroker.fInner;
- *outer = stroker.fOuter;
-#endif
- }
-
- void draw_stroke(SkCanvas* canvas, int active) {
- SkPath inner, outer;
- path_stroke(active, &inner, &outer);
- canvas->drawPath(inner, fSkeletonPaint);
- canvas->drawPath(outer, fSkeletonPaint);
- }
-
- void gather_strokes() {
- fStrokes.reset();
- for (int index = 0; index < fPath.countVerbs(); ++index) {
- Stroke& inner = fStrokes.push_back();
- inner.reset();
- inner.fInner = true;
- Stroke& outer = fStrokes.push_back();
- outer.reset();
- outer.fInner = false;
- path_stroke(index, &inner.fPath, &outer.fPath);
- }
- }
-
- void trim_strokes() {
- // eliminate self-itersecting loops
- // trim outside edges
- gather_strokes();
- for (int index = 0; index < fStrokes.count(); ++index) {
- SkPath& outPath = fStrokes[index].fPath;
- for (int inner = 0; inner < fStrokes.count(); ++inner) {
- if (index == inner) {
- continue;
- }
- SkPath& inPath = fStrokes[inner].fPath;
- if (!outPath.getBounds().intersects(inPath.getBounds())) {
- continue;
- }
-
- }
- }
- }
-
- void onDrawContent(SkCanvas* canvas) override {
-#if 0
- SkDEBUGCODE(SkDebugStrokeGlobals debugGlobals);
- SkOpAA aaResult(fPath, fWidthControl.fValLo, fResControl.fValLo
- SkDEBUGPARAMS(&debugGlobals));
-#endif
- SkPath strokePath;
-// aaResult.simplify(&strokePath);
- canvas->drawPath(strokePath, fSkeletonPaint);
- SkRect bounds = fPath.getBounds();
- SkScalar radius = fWidthControl.fValLo;
- int w = (int) (bounds.fRight + radius + 1);
- int h = (int) (bounds.fBottom + radius + 1);
- SkImageInfo imageInfo = SkImageInfo::MakeA8(w, h);
- SkBitmap distMap;
- uint8_t* distanceMap = set_up_dist_map(imageInfo, &distMap);
- path_coverage(fPath, distanceMap, w, h);
- if (fFillButton.enabled()) {
- canvas->drawPath(fPath, fCoveragePaint);
- }
- if (fFilterButton.fState == 2
- && (0 < fFilterControl.fValLo || fFilterControl.fValHi < 255)) {
- SkBitmap filteredMap;
- uint8_t* filtered = set_up_dist_map(imageInfo, &filteredMap);
- filter_coverage(distanceMap, sizeof(uint8_t) * w * h, (uint8_t) fFilterControl.fValLo,
- (uint8_t) fFilterControl.fValHi, filtered);
- canvas->drawBitmap(filteredMap, 0, 0, &fCoveragePaint);
- } else if (fFilterButton.enabled()) {
- canvas->drawBitmap(distMap, 0, 0, &fCoveragePaint);
- }
- if (fSkeletonButton.enabled()) {
- canvas->drawPath(fPath, fActiveVerb >= 0 ? fLightSkeletonPaint : fSkeletonPaint);
- }
- if (fActiveVerb >= 0) {
- draw_segment(canvas);
- }
- if (fBisectButton.enabled() || fJoinButton.enabled()) {
- draw_bisects(canvas, fActiveVerb >= 0);
- }
- if (fInOutButton.enabled()) {
- if (fActiveVerb >= 0) {
- draw_stroke(canvas, fActiveVerb);
- } else {
- for (int index = 0; index < fPath.countVerbs(); ++index) {
- draw_stroke(canvas, index);
- }
- }
- }
- if (fHideAll) {
- return;
- }
- for (int index = 0; index < kControlCount; ++index) {
- kControlList[index].fControl->draw(canvas, fControlPaints);
- }
- for (int index = 0; index < kButtonCount; ++index) {
- kButtonList[index].fButton->draw(canvas, fButtonPaints);
- }
- if (fShowLegend) {
- draw_legend(canvas);
- }
-
-#if 0
- SkPaint paint;
- paint.setARGB(255, 34, 31, 31);
- paint.setAntiAlias(true);
-
- SkPath path;
- path.moveTo(18,439);
- path.lineTo(414,439);
- path.lineTo(414,702);
- path.lineTo(18,702);
- path.lineTo(18,439);
-
- path.moveTo(19,701);
- path.lineTo(413,701);
- path.lineTo(413,440);
- path.lineTo(19,440);
- path.lineTo(19,701);
- path.close();
- canvas->drawPath(path, paint);
-
- canvas->scale(1.0f, -1.0f);
- canvas->translate(0.0f, -800.0f);
- canvas->drawPath(path, paint);
-#endif
-
- }
-
- int hittest_pt(SkPoint pt) {
- for (int index = 0; index < fPath.countPoints(); ++index) {
- if (SkPoint::Distance(fPath.getPoint(index), pt) <= kHitToleranace * 2) {
- return index;
- }
- }
- return -1;
- }
-
- virtual Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
- SkPoint pt = {x, y};
- int ptHit = hittest_pt(pt);
- if (ptHit >= 0) {
- return new MyClick(MyClick::kPtType, ptHit);
- }
- SkPath::Verb verb;
- SkScalar weight;
- int verbHit = hittest_verb(pt, &verb, &weight);
- if (verbHit >= 0) {
- return new MyClick(MyClick::kVerbType, verbHit, verb, weight);
- }
- if (!fHideAll) {
- const SkRect& rectPt = SkRect::MakeXYWH(x, y, 1, 1);
- for (int index = 0; index < kControlCount; ++index) {
- if (kControlList[index].fControl->contains(rectPt)) {
- return new MyClick(MyClick::kControlType,
- kControlList[index].fControlType);
- }
- }
- for (int index = 0; index < kButtonCount; ++index) {
- if (kButtonList[index].fButton->contains(rectPt)) {
- return new MyClick(MyClick::kControlType, kButtonList[index].fButtonType);
- }
- }
- }
- fLineButton.fVisible = fQuadButton.fVisible = fConicButton.fVisible
- = fCubicButton.fVisible = fWeightControl.fVisible = fAddButton.fVisible
- = fDeleteButton.fVisible = false;
- fActiveVerb = -1;
- fActivePt = -1;
- if (fHandlePathMove) {
- return new MyClick(MyClick::kPathType, MyClick::kPathMove);
- }
- return nullptr;
- }
-
- static SkScalar MapScreenYtoValue(int y, const UniControl& control) {
- return SkTMin(1.f, SkTMax(0.f,
- SkIntToScalar(y) - control.fBounds.fTop) / control.fBounds.height())
- * (control.fMax - control.fMin) + control.fMin;
- }
-
- bool onClick(Click* click) override {
- MyClick* myClick = (MyClick*) click;
- switch (myClick->fType) {
- case MyClick::kPtType: {
- savePath(click->fState);
- fActivePt = myClick->ptHit();
- SkPoint pt = fPath.getPoint((int) myClick->fControl);
- pt.offset(SkIntToScalar(click->fCurr.fX - click->fPrev.fX),
- SkIntToScalar(click->fCurr.fY - click->fPrev.fY));
- set_path_pt(fActivePt, pt, &fPath);
- validatePath();
- return true;
- }
- case MyClick::kPathType:
- savePath(click->fState);
- fPath.offset(SkIntToScalar(click->fCurr.fX - click->fPrev.fX),
- SkIntToScalar(click->fCurr.fY - click->fPrev.fY));
- validatePath();
- return true;
- case MyClick::kVerbType: {
- fActiveVerb = myClick->verbHit();
- fLineButton.fVisible = fQuadButton.fVisible = fConicButton.fVisible
- = fCubicButton.fVisible = fAddButton.fVisible = fDeleteButton.fVisible
- = true;
- fLineButton.setEnabled(myClick->fVerb == SkPath::kLine_Verb);
- fQuadButton.setEnabled(myClick->fVerb == SkPath::kQuad_Verb);
- fConicButton.setEnabled(myClick->fVerb == SkPath::kConic_Verb);
- fCubicButton.setEnabled(myClick->fVerb == SkPath::kCubic_Verb);
- fWeightControl.fValLo = myClick->fWeight;
- fWeightControl.fVisible = myClick->fVerb == SkPath::kConic_Verb;
- } break;
- case MyClick::kControlType: {
- if (click->fState != skui::InputState::kDown && myClick->isButton()) {
- return true;
- }
- switch (myClick->fControl) {
- case MyClick::kFilterControl: {
- SkScalar val = MapScreenYtoValue(click->fCurr.fY, fFilterControl);
- if (val - fFilterControl.fValLo < fFilterControl.fValHi - val) {
- fFilterControl.fValLo = SkTMax(0.f, val);
- } else {
- fFilterControl.fValHi = SkTMin(255.f, val);
- }
- } break;
- case MyClick::kResControl:
- fResControl.fValLo = MapScreenYtoValue(click->fCurr.fY, fResControl);
- break;
- case MyClick::kWeightControl: {
- savePath(click->fState);
- SkScalar w = MapScreenYtoValue(click->fCurr.fY, fWeightControl);
- set_path_weight(fActiveVerb, w, &fPath);
- validatePath();
- fWeightControl.fValLo = w;
- } break;
- case MyClick::kWidthControl:
- fWidthControl.fValLo = MapScreenYtoValue(click->fCurr.fY, fWidthControl);
- break;
- case MyClick::kLineButton:
- savePath(click->fState);
- enable_verb_button(myClick->fControl);
- fWeightControl.fVisible = false;
- set_path_verb(fActiveVerb, SkPath::kLine_Verb, &fPath, 1);
- validatePath();
- break;
- case MyClick::kQuadButton:
- savePath(click->fState);
- enable_verb_button(myClick->fControl);
- fWeightControl.fVisible = false;
- set_path_verb(fActiveVerb, SkPath::kQuad_Verb, &fPath, 1);
- validatePath();
- break;
- case MyClick::kConicButton: {
- savePath(click->fState);
- enable_verb_button(myClick->fControl);
- fWeightControl.fVisible = true;
- const SkScalar defaultConicWeight = 1.f / SkScalarSqrt(2);
- set_path_verb(fActiveVerb, SkPath::kConic_Verb, &fPath, defaultConicWeight);
- validatePath();
- fWeightControl.fValLo = get_path_weight(fActiveVerb, fPath);
- } break;
- case MyClick::kCubicButton:
- savePath(click->fState);
- enable_verb_button(myClick->fControl);
- fWeightControl.fVisible = false;
- set_path_verb(fActiveVerb, SkPath::kCubic_Verb, &fPath, 1);
- validatePath();
- break;
- case MyClick::kAddButton:
- savePath(click->fState);
- add_path_segment(fActiveVerb, &fPath);
- validatePath();
- if (fWeightControl.fVisible) {
- fWeightControl.fValLo = get_path_weight(fActiveVerb, fPath);
- }
- break;
- case MyClick::kDeleteButton:
- savePath(click->fState);
- delete_path_segment(fActiveVerb, &fPath);
- validatePath();
- break;
- case MyClick::kFillButton:
- fFillButton.toggle();
- break;
- case MyClick::kSkeletonButton:
- fSkeletonButton.toggle();
- break;
- case MyClick::kFilterButton:
- fFilterButton.toggle();
- fFilterControl.fVisible = fFilterButton.fState == 2;
- break;
- case MyClick::kBisectButton:
- fBisectButton.toggle();
- break;
- case MyClick::kJoinButton:
- fJoinButton.toggle();
- break;
- case MyClick::kInOutButton:
- fInOutButton.toggle();
- break;
- default:
- SkASSERT(0);
- break;
- }
- } break;
- default:
- SkASSERT(0);
- break;
- }
- setControlButtonsPos();
- return true;
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-static struct KeyCommand {
- char fKey;
- char fAlternate;
- const char* fDescriptionL;
- const char* fDescriptionR;
- bool (AAGeometryView::*fFunction)();
-} kKeyCommandList[] = {
- { ' ', 0, "space", "center path", &AAGeometryView::scaleToFit },
- { '-', 0, "-", "zoom out", &AAGeometryView::scaleDown },
- { '+', '=', "+/=", "zoom in", &AAGeometryView::scaleUp },
- { 'D', 0, "D", "dump to console", &AAGeometryView::pathDump },
- { 'H', 0, "H", "hide controls", &AAGeometryView::hideAll },
- { 'R', 0, "R", "reset path", &AAGeometryView::constructPath },
- { 'Z', 0, "Z", "undo", &AAGeometryView::undo },
- { '?', 0, "?", "show legend", &AAGeometryView::showLegend },
-};
-
-const int kKeyCommandCount = (int) SK_ARRAY_COUNT(kKeyCommandList);
-
-void AAGeometryView::draw_legend(SkCanvas* canvas) {
- SkScalar bottomOffset = this->height() - 10;
- for (int index = kKeyCommandCount - 1; index >= 0; --index) {
- bottomOffset -= 15;
- SkTextUtils::DrawString(canvas, kKeyCommandList[index].fDescriptionL, this->width() - 160, bottomOffset,
- fLegendLeftFont, SkPaint());
- SkTextUtils::DrawString(canvas, kKeyCommandList[index].fDescriptionR,
- this->width() - 20, bottomOffset,
- fLegendRightFont, SkPaint(), SkTextUtils::kRight_Align);
- }
-}
-
-bool AAGeometryView::onChar(SkUnichar uni) {
- for (int index = 0; index < kButtonCount; ++index) {
- Button* button = kButtonList[index].fButton;
- if (button->fVisible && uni == button->fLabel) {
- MyClick click(MyClick::kControlType, kButtonList[index].fButtonType);
- click.fState = skui::InputState::kDown;
- (void) this->onClick(&click);
- return true;
- }
- }
- for (int index = 0; index < kKeyCommandCount; ++index) {
- KeyCommand& keyCommand = kKeyCommandList[index];
- if (uni == keyCommand.fKey || uni == keyCommand.fAlternate) {
- return (this->*keyCommand.fFunction)();
- }
- }
- if (('A' <= uni && uni <= 'Z') || ('a' <= uni && uni <= 'z')) {
- for (int index = 0; index < kButtonCount; ++index) {
- Button* button = kButtonList[index].fButton;
- if (button->fVisible && (uni & ~0x20) == (button->fLabel & ~0x20)) {
- MyClick click(MyClick::kControlType, kButtonList[index].fButtonType);
- click.fState = skui::InputState::kDown;
- (void) this->onClick(&click);
- return true;
- }
- }
- }
- return false;
-}
-
-DEF_SAMPLE( return new AAGeometryView; )
diff --git a/third_party/skia/samplecode/SampleAARectModes.cpp b/third_party/skia/samplecode/SampleAARectModes.cpp
index a3c5ea3..99d8f77 100644
--- a/third_party/skia/samplecode/SampleAARectModes.cpp
+++ b/third_party/skia/samplecode/SampleAARectModes.cpp
@@ -62,10 +62,8 @@
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC,
0xCC, 0xCC);
- SkMatrix m;
- m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-
- return bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
+ return bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, SkSamplingOptions(),
+ SkMatrix::Scale(6, 6));
}
class AARectsModesView : public Sample {
diff --git a/third_party/skia/samplecode/SampleAARects.cpp b/third_party/skia/samplecode/SampleAARects.cpp
index 834a1e5..b7cc5e8 100644
--- a/third_party/skia/samplecode/SampleAARects.cpp
+++ b/third_party/skia/samplecode/SampleAARects.cpp
@@ -49,7 +49,8 @@
SkPaint bluePaint;
bluePaint.setARGB(0xff, 0x0, 0x0, 0xff);
SkPaint bmpPaint;
- bmpPaint.setShader(fBitmap.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat));
+ bmpPaint.setShader(fBitmap.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat,
+ SkSamplingOptions()));
bluePaint.setStrokeWidth(3);
bmpPaint.setStrokeWidth(3);
@@ -170,7 +171,7 @@
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleAndroidShadows.cpp b/third_party/skia/samplecode/SampleAndroidShadows.cpp
index a4518f2..50c626e 100644
--- a/third_party/skia/samplecode/SampleAndroidShadows.cpp
+++ b/third_party/skia/samplecode/SampleAndroidShadows.cpp
@@ -9,7 +9,6 @@
#include "include/core/SkColorFilter.h"
#include "include/core/SkPath.h"
#include "include/core/SkPoint3.h"
-#include "include/effects/SkBlurMaskFilter.h"
#include "include/pathops/SkPathOps.h"
#include "include/utils/SkCamera.h"
#include "include/utils/SkShadowUtils.h"
@@ -192,55 +191,55 @@
paint.setColor(SK_ColorWHITE);
canvas->translate(200, 90);
- zPlaneParams.fZ = SkTMax(1.0f, 2 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 2 + fZDelta);
this->drawShadowedPath(canvas, fRRPath, zPlaneParams, paint, fAnimAlpha*kAmbientAlpha,
lightPos, kLightWidth, fAnimAlpha*kSpotAlpha);
paint.setColor(SK_ColorRED);
canvas->translate(250, 0);
- zPlaneParams.fZ = SkTMax(1.0f, 8 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 8 + fZDelta);
this->drawShadowedPath(canvas, fRectPath, zPlaneParams, paint, fAnimAlpha*kAmbientAlpha,
lightPos, kLightWidth, fAnimAlpha*kSpotAlpha);
paint.setColor(SK_ColorBLUE);
canvas->translate(-250, 110);
- zPlaneParams.fZ = SkTMax(1.0f, 12 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 12 + fZDelta);
this->drawShadowedPath(canvas, fCirclePath, zPlaneParams, paint, fAnimAlpha*kAmbientAlpha,
lightPos, kLightWidth, fAnimAlpha*0.5f);
paint.setColor(SK_ColorGREEN);
canvas->translate(250, 0);
- zPlaneParams.fZ = SkTMax(1.0f, 64 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 64 + fZDelta);
this->drawShadowedPath(canvas, fRRPath, zPlaneParams, paint, fAnimAlpha*kAmbientAlpha,
lightPos, kLightWidth, fAnimAlpha*kSpotAlpha);
paint.setColor(SK_ColorYELLOW);
canvas->translate(-250, 110);
- zPlaneParams.fZ = SkTMax(1.0f, 8 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 8 + fZDelta);
this->drawShadowedPath(canvas, fFunkyRRPath, zPlaneParams, paint, fAnimAlpha*kAmbientAlpha,
lightPos, kLightWidth, fAnimAlpha*kSpotAlpha);
paint.setColor(SK_ColorCYAN);
canvas->translate(250, 0);
- zPlaneParams.fZ = SkTMax(1.0f, 16 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 16 + fZDelta);
this->drawShadowedPath(canvas, fCubicPath, zPlaneParams, paint, fAnimAlpha*kAmbientAlpha,
lightPos, kLightWidth, fAnimAlpha*kSpotAlpha);
paint.setColor(SK_ColorWHITE);
canvas->translate(250, -180);
- zPlaneParams.fZ = SkTMax(1.0f, 8 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 8 + fZDelta);
this->drawShadowedPath(canvas, fStarPath, zPlaneParams, paint,
kAmbientAlpha, lightPos, kLightWidth, kSpotAlpha);
paint.setColor(SK_ColorWHITE);
canvas->translate(150, 0);
- zPlaneParams.fZ = SkTMax(1.0f, 2 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 2 + fZDelta);
this->drawShadowedPath(canvas, fNotchPath, zPlaneParams, paint,
kAmbientAlpha, lightPos, kLightWidth, kSpotAlpha);
paint.setColor(SK_ColorWHITE);
canvas->translate(200, 0);
- zPlaneParams.fZ = SkTMax(1.0f, 16 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 16 + fZDelta);
this->drawShadowedPath(canvas, fTabPath, zPlaneParams, paint,
kAmbientAlpha, lightPos, kLightWidth, kSpotAlpha);
@@ -252,7 +251,7 @@
paint.setColor(SK_ColorMAGENTA);
canvas->translate(-725, 240);
- zPlaneParams.fZ = SkTMax(1.0f, 32 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 32 + fZDelta);
this->drawShadowedPath(canvas, tmpPath, zPlaneParams, paint, .1f,
lightPos, kLightWidth, .5f);
@@ -262,7 +261,7 @@
Op(fSquareRRectPath, tmpClipPathBug, kIntersect_SkPathOp, &tmpPath);
canvas->translate(250, 0);
- zPlaneParams.fZ = SkTMax(1.0f, 32 + fZDelta);
+ zPlaneParams.fZ = std::max(1.0f, 32 + fZDelta);
this->drawShadowedPath(canvas, tmpPath, zPlaneParams, paint, .1f,
lightPos, kLightWidth, .5f);
@@ -282,7 +281,7 @@
SkScalar radians = SkDegreesToRadians(fAnimAngle);
zPlaneParams = SkPoint3::Make(0,
SkScalarSin(radians),
- SkTMax(1.0f, 16 + fZDelta) - SkScalarSin(radians)*pivot.fY);
+ std::max(1.0f, 16 + fZDelta) - SkScalarSin(radians)*pivot.fY);
this->drawShadowedPath(canvas, fWideRectPath, zPlaneParams, paint, .1f,
lightPos, kLightWidth, .5f);
@@ -298,7 +297,7 @@
canvas->setMatrix(persp);
zPlaneParams = SkPoint3::Make(-SkScalarSin(radians),
0,
- SkTMax(1.0f, 32 + fZDelta) + SkScalarSin(radians)*pivot.fX);
+ std::max(1.0f, 32 + fZDelta) + SkScalarSin(radians)*pivot.fX);
this->drawShadowedPath(canvas, fWideOvalPath, zPlaneParams, paint, .1f,
lightPos, kLightWidth, .5f);
@@ -313,7 +312,7 @@
canvas->setMatrix(persp);
zPlaneParams = SkPoint3::Make(-SkScalarSin(radians),
0,
- SkTMax(1.0f, 8 + fZDelta) + SkScalarSin(radians)*pivot.fX);
+ std::max(1.0f, 8 + fZDelta) + SkScalarSin(radians)*pivot.fX);
this->drawShadowedPath(canvas, fStarPath, zPlaneParams, paint, .1f,
lightPos, kLightWidth, .5f);
}
@@ -328,7 +327,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleAnimatedImage.cpp b/third_party/skia/samplecode/SampleAnimatedImage.cpp
index da6ac28..1ca7ac1 100644
--- a/third_party/skia/samplecode/SampleAnimatedImage.cpp
+++ b/third_party/skia/samplecode/SampleAnimatedImage.cpp
@@ -104,11 +104,10 @@
switch (uni) {
case kPauseKey:
fRunning = !fRunning;
- if (fImage->isFinished()) {
- // fall through
- } else {
+ if (!fImage->isFinished()) {
return true;
}
+ [[fallthrough]];
case kResetKey:
fImage->reset();
fCurrentTime = fLastWallTime;
diff --git a/third_party/skia/samplecode/SampleAnimatedText.cpp b/third_party/skia/samplecode/SampleAnimatedText.cpp
index 8e7ed0e..80aafdc 100644
--- a/third_party/skia/samplecode/SampleAnimatedText.cpp
+++ b/third_party/skia/samplecode/SampleAnimatedText.cpp
@@ -8,6 +8,7 @@
#include "include/core/SkCanvas.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorPriv.h"
+#include "include/core/SkFont.h"
#include "include/core/SkImage.h"
#include "include/core/SkTime.h"
#include "include/core/SkTypeface.h"
@@ -16,8 +17,8 @@
#include "src/utils/SkUTF.h"
#if SK_SUPPORT_GPU
-#include "include/gpu/GrContext.h"
-#include "src/gpu/GrContextPriv.h"
+#include "include/gpu/GrDirectContext.h"
+#include "src/gpu/GrDirectContextPriv.h"
#endif
SkRandom gRand;
@@ -62,17 +63,18 @@
SkPaint paint;
paint.setAntiAlias(true);
- paint.setFilterQuality(kMedium_SkFilterQuality);
canvas->save();
#if SK_SUPPORT_GPU
- GrContext* grContext = canvas->getGrContext();
- if (grContext) {
- sk_sp<SkImage> image = grContext->priv().testingOnly_getFontAtlasImage(
+ auto direct = GrAsDirectContext(canvas->recordingContext());
+ if (direct) {
+ SkSamplingOptions sampling(SkFilterMode::kLinear, SkMipmapMode::kNearest);
+ sk_sp<SkImage> image = direct->priv().testingOnly_getFontAtlasImage(
GrMaskFormat::kA8_GrMaskFormat);
- canvas->drawImageRect(image,
- SkRect::MakeXYWH(512.0f, 10.0f, 512.0f, 512.0f), &paint);
+ const SkRect rect = SkRect::MakeXYWH(512.0f, 10.0f, 512.0f, 512.0f);
+ canvas->drawImageRect(image.get(), rect, rect, sampling, &paint,
+ SkCanvas::kFast_SrcRectConstraint);
}
#endif
canvas->translate(180, 180);
diff --git a/third_party/skia/samplecode/SampleAtlas.cpp b/third_party/skia/samplecode/SampleAtlas.cpp
index 85d267c..8f7f116 100644
--- a/third_party/skia/samplecode/SampleAtlas.cpp
+++ b/third_party/skia/samplecode/SampleAtlas.cpp
@@ -13,27 +13,30 @@
#include "include/utils/SkRandom.h"
#include "include/utils/SkTextUtils.h"
#include "samplecode/Sample.h"
+#include "src/core/SkPaintPriv.h"
typedef void (*DrawAtlasProc)(SkCanvas*, SkImage*, const SkRSXform[], const SkRect[],
- const SkColor[], int, const SkRect*, const SkPaint*);
+ const SkColor[], int, const SkRect*, const SkSamplingOptions&,
+ const SkPaint*);
static void draw_atlas(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
- const SkPaint* paint) {
- canvas->drawAtlas(atlas, xform, tex, colors, count, SkBlendMode::kModulate, cull, paint);
+ const SkSamplingOptions& sampling, const SkPaint* paint) {
+ canvas->drawAtlas(atlas, xform, tex, colors, count, SkBlendMode::kModulate,
+ sampling, cull, paint);
}
static void draw_atlas_sim(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
- const SkPaint* paint) {
+ const SkSamplingOptions& sampling, const SkPaint* paint) {
for (int i = 0; i < count; ++i) {
SkMatrix matrix;
matrix.setRSXform(xform[i]);
canvas->save();
canvas->concat(matrix);
- canvas->drawImageRect(atlas, tex[i], tex[i].makeOffset(-tex[i].x(), -tex[i].y()), paint,
- SkCanvas::kFast_SrcRectConstraint);
+ canvas->drawImageRect(atlas, tex[i], tex[i].makeOffset(-tex[i].x(), -tex[i].y()),
+ sampling, paint, SkCanvas::kFast_SrcRectConstraint);
canvas->restore();
}
}
@@ -183,11 +186,11 @@
}
}
SkPaint paint;
- paint.setFilterQuality(kLow_SkFilterQuality);
+ SkSamplingOptions sampling(SkFilterMode::kLinear);
const SkRect cull = this->getBounds();
const SkColor* colorsPtr = fUseColors ? colors : nullptr;
- fProc(canvas, fAtlas.get(), xform, fTex, colorsPtr, N, &cull, &paint);
+ fProc(canvas, fAtlas.get(), xform, fTex, colorsPtr, N, &cull, sampling, &paint);
}
SkRect onGetBounds() override {
@@ -198,7 +201,7 @@
}
private:
- typedef SkDrawable INHERITED;
+ using INHERITED = SkDrawable;
};
class DrawAtlasView : public Sample {
@@ -239,7 +242,7 @@
#endif
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleAudio.cpp b/third_party/skia/samplecode/SampleAudio.cpp
new file mode 100644
index 0000000..a3347d7
--- /dev/null
+++ b/third_party/skia/samplecode/SampleAudio.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2020 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/SkData.h"
+#include "modules/audioplayer/SkAudioPlayer.h"
+#include "samplecode/Sample.h"
+#include "src/core/SkUtils.h"
+#include "tools/Resources.h"
+
+class AudioView : public Sample {
+ std::unique_ptr<SkAudioPlayer> fPlayer;
+ SkRect fBar;
+
+public:
+ AudioView() {}
+
+protected:
+ SkString name() override { return SkString("Audio"); }
+
+ void onOnceBeforeDraw() override {
+ auto data = SkData::MakeFromFileName("/Users/reed/skia/mp3/scott-joplin-peacherine-rag.mp3");
+ if (data) {
+ fPlayer = SkAudioPlayer::Make(data);
+
+ SkDebugf("make: dur:%g time%g state:%d",
+ fPlayer->duration(),
+ fPlayer->time(),
+ (int)fPlayer->state());
+ }
+
+ fBar = { 10, 10, 510, 30 };
+ }
+
+ void onDrawContent(SkCanvas* canvas) override {
+ if (!fPlayer) {
+ return;
+ }
+
+ SkPaint p;
+ p.setColor(0xFFCCCCCC);
+ canvas->drawRect(fBar, p);
+
+ p.setColor(fPlayer->isPlaying() ? SK_ColorBLUE : 0xFF8888FF);
+ SkRect r = fBar;
+ r.fRight = r.fLeft + (float)fPlayer->normalizedTime() * r.width();
+ canvas->drawRect(r, p);
+ }
+
+ bool onChar(SkUnichar c) override {
+ if (c == ' ') {
+ switch (fPlayer->state()) {
+ case SkAudioPlayer::State::kPlaying: fPlayer->pause(); break;
+ case SkAudioPlayer::State::kPaused: fPlayer->play(); break;
+ case SkAudioPlayer::State::kStopped: fPlayer->play(); break;
+ }
+ return true;
+ }
+ return this->INHERITED::onChar(c);
+ }
+
+ Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override {
+ if (fPlayer && fBar.contains(x, y)) {
+ bool wasPlaying = fPlayer->isPlaying();
+ if (wasPlaying) {
+ fPlayer->pause();
+ }
+ return new Click([this, wasPlaying](Click* click) {
+ if (fBar.contains(click->fCurr.fX, click->fCurr.fY)) {
+ fPlayer->setNormalizedTime((click->fCurr.fX - fBar.fLeft) / fBar.width());
+ }
+
+ if (click->fState == skui::InputState::kUp) {
+ if (wasPlaying) {
+ fPlayer->play();
+ }
+ }
+ return true;
+ });
+ }
+ return nullptr;
+ }
+
+ bool onAnimate(double /*nanos*/) override {
+ return true;
+ }
+
+private:
+ using INHERITED = Sample;
+};
+DEF_SAMPLE( return new AudioView; )
diff --git a/third_party/skia/samplecode/SampleBackdropBounds.cpp b/third_party/skia/samplecode/SampleBackdropBounds.cpp
deleted file mode 100644
index d16d0b9..0000000
--- a/third_party/skia/samplecode/SampleBackdropBounds.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Copyright 2019 Google LLC
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "samplecode/Sample.h"
-
-#include "include/core/SkCanvas.h"
-#include "include/core/SkColor.h"
-#include "include/core/SkFont.h"
-#include "include/core/SkPaint.h"
-#include "include/core/SkPath.h"
-#include "include/core/SkPoint.h"
-#include "include/core/SkRect.h"
-
-#include "tools/ToolUtils.h"
-
-static constexpr float kLineHeight = 16.f;
-static constexpr float kLineInset = 8.f;
-
-static float print_size(SkCanvas* canvas, const char* prefix, const SkIRect& rect,
- float x, float y, const SkFont& font, const SkPaint& paint) {
- canvas->drawString(prefix, x, y, font, paint);
- y += kLineHeight;
- SkString sz;
- sz.appendf("%d x %d", rect.width(), rect.height());
- canvas->drawString(sz, x, y, font, paint);
- return y + kLineHeight;
-}
-
-static float print_info(SkCanvas* canvas, const SkIRect& origLayerBounds,
- const SkIRect& localLayerBounds, const SkIRect& filterInputBounds,
- const SkIRect& devLayerBounds) {
- SkFont font(nullptr, 12);
- SkPaint text;
- text.setAntiAlias(true);
-
- float y = kLineHeight;
-
- text.setColor(SK_ColorBLACK);
- y = print_size(canvas, "Orig layer", origLayerBounds, kLineInset, y, font, text);
- text.setColor(SK_ColorRED);
- y = print_size(canvas, "Filter layer", localLayerBounds, kLineInset, y, font, text);
- text.setColor(SK_ColorBLUE);
- y = print_size(canvas, "Filter input", filterInputBounds, kLineInset, y, font, text);
- text.setColor(SK_ColorMAGENTA);
- y = print_size(canvas, "Backdrop size", devLayerBounds, kLineInset, y, font, text);
-
- return y;
-}
-
-static SkPaint line_paint(SkScalar width, SkColor color) {
- SkPaint paint;
- paint.setColor(color);
- paint.setStrokeWidth(width);
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setAntiAlias(true);
- return paint;
-}
-
-class BackdropBoundsSample : public Sample {
-public:
- BackdropBoundsSample() {}
-
- void onDrawContent(SkCanvas* canvas) override {
- SkMatrix ctm = canvas->getTotalMatrix();
-
- // This decomposition is for the backdrop filtering, and does not represent the CTM that
- // the layer actually uses (unless it also has a filter during restore).
- SkMatrix toGlobal, layerMatrix;
- SkSize scale;
- if (ctm.isScaleTranslate()) {
- // No decomposition needed
- toGlobal = SkMatrix::I();
- layerMatrix = ctm;
- } else if (ctm.decomposeScale(&scale, &toGlobal)) {
- layerMatrix = SkMatrix::MakeScale(scale.fWidth, scale.fHeight);
- } else {
- toGlobal = ctm;
- layerMatrix = SkMatrix::I();
- }
-
- SkMatrix fromGlobal;
- if (!toGlobal.invert(&fromGlobal)) {
- SkDebugf("Unable to invert CTM\n");
- return;
- }
-
- // The local content, e.g. what would be submitted to drawRect
- const SkRect localContentRect = SkRect::MakeLTRB(45.5f, 23.123f, 150.f, 140.45f);
- canvas->drawRect(localContentRect, line_paint(0.f, SK_ColorBLACK));
-
- canvas->save();
- // The layer bounds of the content, this is the size of the actual layer and does not
- // reflect the backdrop specific decomposition.
- canvas->setMatrix(SkMatrix::I());
- SkIRect origLayerBounds = ctm.mapRect(localContentRect).roundOut();
- canvas->drawRect(SkRect::Make(origLayerBounds), line_paint(1.f, SK_ColorBLACK));
-
- // Have to undo the full CTM transform on the layer bounds to get the layer bounds
- // for the specific backdrop filter decomposition
- canvas->setMatrix(toGlobal);
- SkIRect layerBounds = fromGlobal.mapRect(SkRect::Make(origLayerBounds)).roundOut();
- canvas->drawRect(SkRect::Make(layerBounds), line_paint(0.5f, SK_ColorRED));
-
- // Input bounds for the backdrop filter to cover the actual layer bounds (emulate some
- // blur that must outset by 5px for reading on the edge).
- SkIRect filterInputBounds = layerBounds;
- filterInputBounds.outset(5, 5);
- canvas->drawRect(SkRect::Make(filterInputBounds), line_paint(1.f, SK_ColorBLUE));
-
- // The destination bounds that must be snapped in order to transform and fill the
- // filterInputBounds
- canvas->setMatrix(SkMatrix::I());
- SkIRect devLayerBounds = toGlobal.mapRect(SkRect::Make(filterInputBounds)).roundOut();
- canvas->drawRect(SkRect::Make(devLayerBounds), line_paint(2.f, SK_ColorMAGENTA));
-
- // The destination bounds mapped back into the layer space, which should cover 'layerBounds'
- SkPath backdropCoveringBounds;
-
- // Add axis lines, to show perspective distortion
- SkIRect local = fromGlobal.mapRect(SkRect::Make(devLayerBounds)).roundOut();
- static int kAxisSpace = 10;
- for (int y = local.fTop + kAxisSpace; y <= local.fBottom - kAxisSpace; y += kAxisSpace) {
- backdropCoveringBounds.moveTo(local.fLeft, y);
- backdropCoveringBounds.lineTo(local.fRight, y);
- }
- for (int x = local.fLeft + kAxisSpace; x <= local.fRight - kAxisSpace; x += kAxisSpace) {
- backdropCoveringBounds.moveTo(x, local.fTop);
- backdropCoveringBounds.lineTo(x, local.fBottom);
- }
-
- canvas->setMatrix(toGlobal);
- canvas->drawPath(backdropCoveringBounds, line_paint(0.f, SK_ColorGREEN));
-
- canvas->resetMatrix();
- print_info(canvas, origLayerBounds, layerBounds, filterInputBounds, devLayerBounds);
-
- canvas->restore();
- }
-
- SkString name() override { return SkString("BackdropBounds"); }
-
-private:
-
- typedef Sample INHERITED;
-};
-
-DEF_SAMPLE(return new BackdropBoundsSample();)
diff --git a/third_party/skia/samplecode/SampleBitmapRect.cpp b/third_party/skia/samplecode/SampleBitmapRect.cpp
deleted file mode 100644
index 1f757f5..0000000
--- a/third_party/skia/samplecode/SampleBitmapRect.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * Copyright 2011 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/SkBitmap.h"
-#include "include/core/SkCanvas.h"
-#include "include/core/SkColorFilter.h"
-#include "include/core/SkColorPriv.h"
-#include "include/core/SkFont.h"
-#include "include/core/SkGraphics.h"
-#include "include/core/SkPath.h"
-#include "include/core/SkRegion.h"
-#include "include/core/SkShader.h"
-#include "include/core/SkTime.h"
-#include "include/core/SkTypeface.h"
-#include "include/effects/SkGradientShader.h"
-#include "samplecode/Sample.h"
-#include "src/utils/SkUTF.h"
-
-#include "include/core/SkStream.h"
-#include "src/core/SkOSFile.h"
-
-static constexpr int INT_SIZE = 64;
-static constexpr float SCALAR_SIZE = (float)INT_SIZE;
-
-static void make_bitmap(SkBitmap* bitmap) {
- bitmap->allocN32Pixels(INT_SIZE, INT_SIZE);
- SkCanvas canvas(*bitmap);
-
- canvas.drawColor(SK_ColorRED);
- SkPaint paint;
- paint.setAntiAlias(true);
- const SkPoint pts[] = { { 0, 0 }, { SCALAR_SIZE, SCALAR_SIZE } };
- const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
- paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp));
- canvas.drawCircle(SCALAR_SIZE/2, SCALAR_SIZE/2, SCALAR_SIZE/2, paint);
-}
-
-static void bounce(SkScalar* value, SkScalar* delta, SkScalar min, SkScalar max) {
- *value += *delta;
- if (*value < min) {
- *value = min;
- *delta = - *delta;
- } else if (*value > max) {
- *value = max;
- *delta = - *delta;
- }
-}
-
-static void bounce_pt(SkPoint* pt, SkVector* vec, const SkRect& limit) {
- bounce(&pt->fX, &vec->fX, limit.fLeft, limit.fRight);
- bounce(&pt->fY, &vec->fY, limit.fTop, limit.fBottom);
-}
-
-class BitmapRectView : public Sample {
- SkPoint fSrcPt = {0, 0};
- SkPoint fSrcVec = {0.866025f, 0.5f};
-
- SkRect fSrcLimit = {-SCALAR_SIZE/4, -SCALAR_SIZE/4,
- SCALAR_SIZE*5/4, SCALAR_SIZE*5/4};
- SkRect fDstR[2] = {{10, 100, 260, 400}, {322.5, 100, 572.5, 400}};
- SkBitmap fBitmap;
-
- SkString name() override { return SkString("BitmapRect"); }
-
- void onOnceBeforeDraw() override {
- this->setBGColor(SK_ColorGRAY);
- make_bitmap(&fBitmap);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- SkRect srcR = {fSrcPt.fX - 16, fSrcPt.fY - 16,
- fSrcPt.fX + 16, fSrcPt.fY + 16};
-
- SkPaint paint(SkColors::kYellow);
- paint.setStyle(SkPaint::kStroke_Style);
-
- canvas->translate(20, 20);
-
- canvas->drawBitmap(fBitmap, 0, 0, &paint);
- canvas->drawRect(srcR, paint);
-
- for (int i = 0; i < 2; ++i) {
- paint.setFilterQuality(1 == i ? kLow_SkFilterQuality : kNone_SkFilterQuality);
- canvas->drawBitmapRect(fBitmap, srcR, fDstR[i], &paint,
- SkCanvas::kStrict_SrcRectConstraint);
- canvas->drawRect(fDstR[i], paint);
- }
- }
-
- bool onAnimate(double nanos) override {
- bounce_pt(&fSrcPt, &fSrcVec, fSrcLimit);
- return true;
- }
-};
-
-static constexpr int BIG_H = 120;
-
-static void make_big_bitmap(SkBitmap* bm) {
- static const char gText[] =
- "We the people, in order to form a more perfect union, establish justice,"
- " ensure domestic tranquility, provide for the common defense, promote the"
- " general welfare and ensure the blessings of liberty to ourselves and our"
- " posterity, do ordain and establish this constitution for the United"
- " States of America.";
-
- SkFont font;
- font.setSize(SkIntToScalar(BIG_H));
-
- const int BIG_W = SkScalarRoundToInt(font.measureText(gText, strlen(gText), SkTextEncoding::kUTF8));
-
- bm->allocN32Pixels(BIG_W, BIG_H);
- bm->eraseColor(SK_ColorWHITE);
-
- SkCanvas canvas(*bm);
-
- canvas.drawSimpleText(gText, strlen(gText), SkTextEncoding::kUTF8, 0, font.getSize()*4/5, font, SkPaint());
-}
-
-class BitmapRectView2 : public Sample {
- SkBitmap fBitmap;
- SkRect fSrcR = {0, 0, 3 * BIG_H, BIG_H};
- SkRect fLimitR;
- SkScalar fDX = 1;
- SkRect fDstR[2] = {{20, 20, 620, 220}, {20, 270, 620, 470}};
-
- SkString name() override { return SkString("BigBitmapRect"); }
-
- void onOnceBeforeDraw() override {
- this->setBGColor(SK_ColorGRAY);
- make_big_bitmap(&fBitmap);
- fLimitR = SkRect::Make(fBitmap.dimensions());
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- SkPaint paint;
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setColor(SK_ColorYELLOW);
-
- for (int i = 0; i < 2; ++i) {
- paint.setFilterQuality(1 == i ? kLow_SkFilterQuality : kNone_SkFilterQuality);
- canvas->drawBitmapRect(fBitmap, fSrcR, fDstR[i], &paint,
- SkCanvas::kStrict_SrcRectConstraint);
- canvas->drawRect(fDstR[i], paint);
- }
- }
-
- bool onAnimate(double nanos) override {
- SkScalar width = fSrcR.width();
- bounce(&fSrcR.fLeft, &fDX, fLimitR.fLeft, fLimitR.fRight - width);
- fSrcR.fRight = fSrcR.fLeft + width;
- return true;
- }
-};
-
-DEF_SAMPLE( return new BitmapRectView(); )
-DEF_SAMPLE( return new BitmapRectView2(); )
diff --git a/third_party/skia/samplecode/SampleCCPRGeometry.cpp b/third_party/skia/samplecode/SampleCCPRGeometry.cpp
deleted file mode 100644
index dff8ed9..0000000
--- a/third_party/skia/samplecode/SampleCCPRGeometry.cpp
+++ /dev/null
@@ -1,495 +0,0 @@
-/*
- * 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/SkTypes.h"
-
-#if SK_SUPPORT_GPU
-
-#include "include/core/SkCanvas.h"
-#include "include/core/SkPaint.h"
-#include "include/core/SkPath.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkMakeUnique.h"
-#include "src/core/SkRectPriv.h"
-#include "src/gpu/GrClip.h"
-#include "src/gpu/GrContextPriv.h"
-#include "src/gpu/GrMemoryPool.h"
-#include "src/gpu/GrRenderTargetContext.h"
-#include "src/gpu/GrRenderTargetContextPriv.h"
-#include "src/gpu/GrResourceProvider.h"
-#include "src/gpu/ccpr/GrCCCoverageProcessor.h"
-#include "src/gpu/ccpr/GrCCFillGeometry.h"
-#include "src/gpu/ccpr/GrCCStroker.h"
-#include "src/gpu/ccpr/GrGSCoverageProcessor.h"
-#include "src/gpu/ccpr/GrVSCoverageProcessor.h"
-#include "src/gpu/geometry/GrPathUtils.h"
-#include "src/gpu/gl/GrGLGpu.h"
-#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
-#include "src/gpu/ops/GrDrawOp.h"
-
-using TriPointInstance = GrCCCoverageProcessor::TriPointInstance;
-using QuadPointInstance = GrCCCoverageProcessor::QuadPointInstance;
-using PrimitiveType = GrCCCoverageProcessor::PrimitiveType;
-
-static constexpr float kDebugBloat = 40;
-
-/**
- * This sample visualizes the AA bloat geometry generated by the ccpr geometry shaders. It
- * increases the AA bloat by 50x and outputs color instead of coverage (coverage=+1 -> green,
- * coverage=0 -> black, coverage=-1 -> red). Use the keys 1-7 to cycle through the different
- * geometry processors.
- */
-class CCPRGeometryView : public Sample {
- void onOnceBeforeDraw() override { this->updateGpuData(); }
- void onDrawContent(SkCanvas*) override;
-
- Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override;
- bool onClick(Sample::Click*) override;
- bool onChar(SkUnichar) override;
- SkString name() override { return SkString("CCPRGeometry"); }
-
- class Click;
- class DrawCoverageCountOp;
- class VisualizeCoverageCountFP;
-
- void updateAndInval() { this->updateGpuData(); }
-
- void updateGpuData();
-
- PrimitiveType fPrimitiveType = PrimitiveType::kTriangles;
- SkCubicType fCubicType;
- SkMatrix fCubicKLM;
-
- SkPoint fPoints[4] = {
- {100.05f, 100.05f}, {400.75f, 100.05f}, {400.75f, 300.95f}, {100.05f, 300.95f}};
-
- float fConicWeight = .5;
- float fStrokeWidth = 40;
- bool fDoStroke = false;
-
- SkTArray<TriPointInstance> fTriPointInstances;
- SkTArray<QuadPointInstance> fQuadPointInstances;
- SkPath fPath;
-};
-
-class CCPRGeometryView::DrawCoverageCountOp : public GrDrawOp {
- DEFINE_OP_CLASS_ID
-
-public:
- DrawCoverageCountOp(CCPRGeometryView* view) : INHERITED(ClassID()), fView(view) {
- this->setBounds(SkRect::MakeIWH(fView->width(), fView->height()), GrOp::HasAABloat::kNo,
- GrOp::IsHairline::kNo);
- }
-
- const char* name() const override {
- return "[Testing/Sample code] CCPRGeometryView::DrawCoverageCountOp";
- }
-
-private:
- FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
- GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
- bool hasMixedSampledCoverage, GrClampType) override {
- return GrProcessorSet::EmptySetAnalysis();
- }
- void onPrepare(GrOpFlushState*) override {}
- void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;
-
- CCPRGeometryView* fView;
-
- typedef GrDrawOp INHERITED;
-};
-
-class CCPRGeometryView::VisualizeCoverageCountFP : public GrFragmentProcessor {
-public:
- VisualizeCoverageCountFP() : GrFragmentProcessor(kTestFP_ClassID, kNone_OptimizationFlags) {}
-
-private:
- const char* name() const override {
- return "[Testing/Sample code] CCPRGeometryView::VisualizeCoverageCountFP";
- }
- std::unique_ptr<GrFragmentProcessor> clone() const override {
- return skstd::make_unique<VisualizeCoverageCountFP>();
- }
- void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
- bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
-
- class Impl : public GrGLSLFragmentProcessor {
- void emitCode(EmitArgs& args) override {
- GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
- f->codeAppendf("half count = %s.a;", args.fInputColor);
- f->codeAppendf("%s = half4(clamp(-count, 0, 1), clamp(+count, 0, 1), 0, abs(count));",
- args.fOutputColor);
- }
- };
-
- GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new Impl; }
-};
-
-static void draw_klm_line(int w, int h, SkCanvas* canvas, const SkScalar line[3], SkColor color) {
- SkPoint p1, p2;
- if (SkScalarAbs(line[1]) > SkScalarAbs(line[0])) {
- // Draw from vertical edge to vertical edge.
- p1 = {0, -line[2] / line[1]};
- p2 = {(SkScalar)w, (-line[2] - w * line[0]) / line[1]};
- } else {
- // Draw from horizontal edge to horizontal edge.
- p1 = {-line[2] / line[0], 0};
- p2 = {(-line[2] - h * line[1]) / line[0], (SkScalar)h};
- }
-
- SkPaint linePaint;
- linePaint.setColor(color);
- linePaint.setAlpha(128);
- linePaint.setStyle(SkPaint::kStroke_Style);
- linePaint.setStrokeWidth(0);
- linePaint.setAntiAlias(true);
- canvas->drawLine(p1, p2, linePaint);
-}
-
-void CCPRGeometryView::onDrawContent(SkCanvas* canvas) {
- canvas->clear(SK_ColorBLACK);
-
- if (!fDoStroke) {
- SkPaint outlinePaint;
- outlinePaint.setColor(0x80ffffff);
- outlinePaint.setStyle(SkPaint::kStroke_Style);
- outlinePaint.setStrokeWidth(0);
- outlinePaint.setAntiAlias(true);
- canvas->drawPath(fPath, outlinePaint);
- }
-
-#if 0
- SkPaint gridPaint;
- gridPaint.setColor(0x10000000);
- gridPaint.setStyle(SkPaint::kStroke_Style);
- gridPaint.setStrokeWidth(0);
- gridPaint.setAntiAlias(true);
- for (int y = 0; y < this->height(); y += kDebugBloat) {
- canvas->drawLine(0, y, this->width(), y, gridPaint);
- }
- for (int x = 0; x < this->width(); x += kDebugBloat) {
- canvas->drawLine(x, 0, x, this->height(), outlinePaint);
- }
-#endif
-
- SkString caption;
- if (GrRenderTargetContext* rtc = canvas->internal_private_accessTopLayerRenderTargetContext()) {
- // Render coverage count.
- GrContext* ctx = canvas->getGrContext();
- SkASSERT(ctx);
-
- GrOpMemoryPool* pool = ctx->priv().opMemoryPool();
-
- auto ccbuff = ctx->priv().makeDeferredRenderTargetContext(SkBackingFit::kApprox,
- this->width(), this->height(),
- GrColorType::kAlpha_F16, nullptr);
- SkASSERT(ccbuff);
- ccbuff->clear(nullptr, SK_PMColor4fTRANSPARENT,
- GrRenderTargetContext::CanClearFullscreen::kYes);
- ccbuff->priv().testingOnly_addDrawOp(pool->allocate<DrawCoverageCountOp>(this));
-
- // Visualize coverage count in main canvas.
- GrPaint paint;
- paint.addColorFragmentProcessor(
- GrSimpleTextureEffect::Make(sk_ref_sp(ccbuff->asTextureProxy()),
- ccbuff->colorInfo().alphaType(), SkMatrix::I()));
- paint.addColorFragmentProcessor(
- skstd::make_unique<VisualizeCoverageCountFP>());
- paint.setPorterDuffXPFactory(SkBlendMode::kSrcOver);
- rtc->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(),
- SkRect::MakeIWH(this->width(), this->height()));
-
- // Add label.
- caption.appendf("PrimitiveType_%s",
- GrCCCoverageProcessor::PrimitiveTypeName(fPrimitiveType));
- if (PrimitiveType::kCubics == fPrimitiveType) {
- caption.appendf(" (%s)", SkCubicTypeName(fCubicType));
- } else if (PrimitiveType::kConics == fPrimitiveType) {
- caption.appendf(" (w=%f)", fConicWeight);
- }
- if (fDoStroke) {
- caption.appendf(" (stroke_width=%f)", fStrokeWidth);
- }
- } else {
- caption = "Use GPU backend to visualize geometry.";
- }
-
- SkPaint pointsPaint;
- pointsPaint.setColor(SK_ColorBLUE);
- pointsPaint.setStrokeWidth(8);
- pointsPaint.setAntiAlias(true);
-
- if (PrimitiveType::kCubics == fPrimitiveType) {
- canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, fPoints, pointsPaint);
- if (!fDoStroke) {
- int w = this->width(), h = this->height();
- draw_klm_line(w, h, canvas, &fCubicKLM[0], SK_ColorYELLOW);
- draw_klm_line(w, h, canvas, &fCubicKLM[3], SK_ColorBLUE);
- draw_klm_line(w, h, canvas, &fCubicKLM[6], SK_ColorRED);
- }
- } else {
- canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, fPoints, pointsPaint);
- canvas->drawPoints(SkCanvas::kPoints_PointMode, 1, fPoints + 3, pointsPaint);
- }
-
- SkFont font(nullptr, 20);
- SkPaint captionPaint;
- captionPaint.setColor(SK_ColorWHITE);
- canvas->drawString(caption, 10, 30, font, captionPaint);
-}
-
-void CCPRGeometryView::updateGpuData() {
- using Verb = GrCCFillGeometry::Verb;
- fTriPointInstances.reset();
- fQuadPointInstances.reset();
-
- fPath.reset();
- fPath.moveTo(fPoints[0]);
-
- if (PrimitiveType::kCubics == fPrimitiveType) {
- double t[2], s[2];
- fCubicType = GrPathUtils::getCubicKLM(fPoints, &fCubicKLM, t, s);
- GrCCFillGeometry geometry;
- geometry.beginContour(fPoints[0]);
- geometry.cubicTo(fPoints, kDebugBloat / 2, kDebugBloat / 2);
- geometry.endContour();
- int ptsIdx = 0;
- for (Verb verb : geometry.verbs()) {
- switch (verb) {
- case Verb::kLineTo:
- ++ptsIdx;
- continue;
- case Verb::kMonotonicQuadraticTo:
- ptsIdx += 2;
- continue;
- case Verb::kMonotonicCubicTo:
- fQuadPointInstances.push_back().set(&geometry.points()[ptsIdx], 0, 0);
- ptsIdx += 3;
- continue;
- default:
- continue;
- }
- }
- fPath.cubicTo(fPoints[1], fPoints[2], fPoints[3]);
- } else if (PrimitiveType::kTriangles != fPrimitiveType) {
- SkPoint P3[3] = {fPoints[0], fPoints[1], fPoints[3]};
- GrCCFillGeometry geometry;
- geometry.beginContour(P3[0]);
- if (PrimitiveType::kQuadratics == fPrimitiveType) {
- geometry.quadraticTo(P3);
- fPath.quadTo(fPoints[1], fPoints[3]);
- } else {
- SkASSERT(PrimitiveType::kConics == fPrimitiveType);
- geometry.conicTo(P3, fConicWeight);
- fPath.conicTo(fPoints[1], fPoints[3], fConicWeight);
- }
- geometry.endContour();
- int ptsIdx = 0, conicWeightIdx = 0;
- for (Verb verb : geometry.verbs()) {
- if (Verb::kBeginContour == verb ||
- Verb::kEndOpenContour == verb ||
- Verb::kEndClosedContour == verb) {
- continue;
- }
- if (Verb::kLineTo == verb) {
- ++ptsIdx;
- continue;
- }
- SkASSERT(Verb::kMonotonicQuadraticTo == verb || Verb::kMonotonicConicTo == verb);
- if (PrimitiveType::kQuadratics == fPrimitiveType &&
- Verb::kMonotonicQuadraticTo == verb) {
- fTriPointInstances.push_back().set(
- &geometry.points()[ptsIdx], Sk2f(0, 0),
- TriPointInstance::Ordering::kXYTransposed);
- } else if (PrimitiveType::kConics == fPrimitiveType &&
- Verb::kMonotonicConicTo == verb) {
- fQuadPointInstances.push_back().setW(&geometry.points()[ptsIdx], Sk2f(0, 0),
- geometry.getConicWeight(conicWeightIdx++));
- }
- ptsIdx += 2;
- }
- } else {
- fTriPointInstances.push_back().set(
- fPoints[0], fPoints[1], fPoints[3], Sk2f(0, 0),
- TriPointInstance::Ordering::kXYTransposed);
- fPath.lineTo(fPoints[1]);
- fPath.lineTo(fPoints[3]);
- fPath.close();
- }
-}
-
-void CCPRGeometryView::DrawCoverageCountOp::onExecute(GrOpFlushState* state,
- const SkRect& chainBounds) {
- GrResourceProvider* rp = state->resourceProvider();
- GrContext* context = state->gpu()->getContext();
- GrGLGpu* glGpu = GrBackendApi::kOpenGL == context->backend()
- ? static_cast<GrGLGpu*>(state->gpu())
- : nullptr;
- if (glGpu) {
- glGpu->handleDirtyContext();
- // GR_GL_CALL(glGpu->glInterface(), PolygonMode(GR_GL_FRONT_AND_BACK, GR_GL_LINE));
- GR_GL_CALL(glGpu->glInterface(), Enable(GR_GL_LINE_SMOOTH));
- }
-
- GrPipeline pipeline(GrScissorTest::kDisabled, SkBlendMode::kPlus,
- state->drawOpArgs().outputSwizzle());
-
- std::unique_ptr<GrCCCoverageProcessor> proc;
- if (state->caps().shaderCaps()->geometryShaderSupport()) {
- proc = skstd::make_unique<GrGSCoverageProcessor>();
- } else {
- proc = skstd::make_unique<GrVSCoverageProcessor>();
- }
-
- if (!fView->fDoStroke) {
- proc->reset(fView->fPrimitiveType, rp);
- SkDEBUGCODE(proc->enableDebugBloat(kDebugBloat));
-
- SkSTArray<1, GrMesh> mesh;
- if (PrimitiveType::kCubics == fView->fPrimitiveType ||
- PrimitiveType::kConics == fView->fPrimitiveType) {
- sk_sp<GrGpuBuffer> instBuff(
- rp->createBuffer(fView->fQuadPointInstances.count() * sizeof(QuadPointInstance),
- GrGpuBufferType::kVertex, kDynamic_GrAccessPattern,
- fView->fQuadPointInstances.begin()));
- if (!fView->fQuadPointInstances.empty() && instBuff) {
- proc->appendMesh(std::move(instBuff), fView->fQuadPointInstances.count(), 0, &mesh);
- }
- } else {
- sk_sp<GrGpuBuffer> instBuff(
- rp->createBuffer(fView->fTriPointInstances.count() * sizeof(TriPointInstance),
- GrGpuBufferType::kVertex, kDynamic_GrAccessPattern,
- fView->fTriPointInstances.begin()));
- if (!fView->fTriPointInstances.empty() && instBuff) {
- proc->appendMesh(std::move(instBuff), fView->fTriPointInstances.count(), 0, &mesh);
- }
- }
-
- if (!mesh.empty()) {
- SkASSERT(1 == mesh.count());
- proc->draw(state, pipeline, nullptr, mesh.begin(), 1, this->bounds());
- }
- } else if (PrimitiveType::kConics != fView->fPrimitiveType) { // No conic stroke support yet.
- GrCCStroker stroker(0,0,0);
-
- SkPaint p;
- p.setStyle(SkPaint::kStroke_Style);
- p.setStrokeWidth(fView->fStrokeWidth);
- p.setStrokeJoin(SkPaint::kMiter_Join);
- p.setStrokeMiter(4);
- // p.setStrokeCap(SkPaint::kRound_Cap);
- stroker.parseDeviceSpaceStroke(fView->fPath, SkPathPriv::PointData(fView->fPath),
- SkStrokeRec(p), p.getStrokeWidth(), GrScissorTest::kDisabled,
- SkIRect::MakeWH(fView->width(), fView->height()), {0, 0});
- GrCCStroker::BatchID batchID = stroker.closeCurrentBatch();
-
- GrOnFlushResourceProvider onFlushRP(context->priv().drawingManager());
- stroker.prepareToDraw(&onFlushRP);
-
- SkIRect ibounds;
- this->bounds().roundOut(&ibounds);
- stroker.drawStrokes(state, proc.get(), batchID, ibounds);
- }
-
- if (glGpu) {
- context->resetContext(kMisc_GrGLBackendState);
- }
-}
-
-class CCPRGeometryView::Click : public Sample::Click {
-public:
- Click(int ptIdx) : fPtIdx(ptIdx) {}
-
- void doClick(SkPoint points[]) {
- if (fPtIdx >= 0) {
- points[fPtIdx] += fCurr - fPrev;
- } else {
- for (int i = 0; i < 4; ++i) {
- points[i] += fCurr - fPrev;
- }
- }
- }
-
-private:
- int fPtIdx;
-};
-
-Sample::Click* CCPRGeometryView::onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) {
- for (int i = 0; i < 4; ++i) {
- if (PrimitiveType::kCubics != fPrimitiveType && 2 == i) {
- continue;
- }
- if (fabs(x - fPoints[i].x()) < 20 && fabsf(y - fPoints[i].y()) < 20) {
- return new Click(i);
- }
- }
- return new Click(-1);
-}
-
-bool CCPRGeometryView::onClick(Sample::Click* click) {
- Click* myClick = (Click*)click;
- myClick->doClick(fPoints);
- this->updateAndInval();
- return true;
-}
-
-bool CCPRGeometryView::onChar(SkUnichar unichar) {
- if (unichar >= '1' && unichar <= '4') {
- fPrimitiveType = PrimitiveType(unichar - '1');
- if (fPrimitiveType >= PrimitiveType::kWeightedTriangles) {
- fPrimitiveType = (PrimitiveType) ((int)fPrimitiveType + 1);
- }
- this->updateAndInval();
- return true;
- }
- float* valueToScale = nullptr;
- if (fDoStroke) {
- valueToScale = &fStrokeWidth;
- } else if (PrimitiveType::kConics == fPrimitiveType) {
- valueToScale = &fConicWeight;
- }
- if (valueToScale) {
- if (unichar == '+') {
- *valueToScale *= 2;
- this->updateAndInval();
- return true;
- }
- if (unichar == '+' || unichar == '=') {
- *valueToScale *= 5/4.f;
- this->updateAndInval();
- return true;
- }
- if (unichar == '-') {
- *valueToScale *= 4/5.f;
- this->updateAndInval();
- return true;
- }
- if (unichar == '_') {
- *valueToScale *= .5f;
- this->updateAndInval();
- return true;
- }
- }
- if (unichar == 'D') {
- SkDebugf(" SkPoint fPoints[4] = {\n");
- SkDebugf(" {%ff, %ff},\n", fPoints[0].x(), fPoints[0].y());
- SkDebugf(" {%ff, %ff},\n", fPoints[1].x(), fPoints[1].y());
- SkDebugf(" {%ff, %ff},\n", fPoints[2].x(), fPoints[2].y());
- SkDebugf(" {%ff, %ff}\n", fPoints[3].x(), fPoints[3].y());
- SkDebugf(" };\n");
- return true;
- }
- if (unichar == 'S') {
- fDoStroke = !fDoStroke;
- this->updateAndInval();
- }
- return false;
-}
-
-DEF_SAMPLE(return new CCPRGeometryView;)
-
-#endif // SK_SUPPORT_GPU
diff --git a/third_party/skia/samplecode/SampleCamera.cpp b/third_party/skia/samplecode/SampleCamera.cpp
index 38201eb..41da126 100644
--- a/third_party/skia/samplecode/SampleCamera.cpp
+++ b/third_party/skia/samplecode/SampleCamera.cpp
@@ -6,6 +6,7 @@
*/
#include "include/core/SkCanvas.h"
+#include "include/core/SkImage.h"
#include "include/core/SkShader.h"
#include "include/core/SkString.h"
#include "include/utils/SkCamera.h"
@@ -35,9 +36,8 @@
if (GetResourceAsBitmap(resource, &bm)) {
SkRect src = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
SkRect dst = { -150, -150, 150, 150 };
- SkMatrix matrix;
- matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
- fShaders.push_back(bm.makeShader(&matrix));
+ fShaders.push_back(bm.makeShader(SkSamplingOptions(SkFilterMode::kLinear),
+ SkMatrix::RectToRect(src, dst)));
}
}
this->setBGColor(0xFFDDDDDD);
@@ -61,7 +61,6 @@
SkPaint paint;
paint.setAntiAlias(true);
paint.setShader(fShaders[fShaderIndex]);
- paint.setFilterQuality(kLow_SkFilterQuality);
SkRect r = { -150, -150, 150, 150 };
canvas->drawRoundRect(r, 30, 30, paint);
}
diff --git a/third_party/skia/samplecode/SampleChart.cpp b/third_party/skia/samplecode/SampleChart.cpp
index 448e1d7..37b9d06 100644
--- a/third_party/skia/samplecode/SampleChart.cpp
+++ b/third_party/skia/samplecode/SampleChart.cpp
@@ -7,7 +7,7 @@
#include "include/core/SkCanvas.h"
#include "include/core/SkPaint.h"
-#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
#include "include/utils/SkRandom.h"
#include "samplecode/Sample.h"
@@ -30,9 +30,7 @@
SkScalar yBase,
SkScalar xLeft, SkScalar xDelta,
int leftShift,
- SkPath* plot, SkPath* fill) {
- plot->rewind();
- fill->rewind();
+ SkPathBuilder* plot, SkPathBuilder* fill) {
plot->incReserve(topData.count());
if (nullptr == bottomData) {
fill->incReserve(topData.count() + 2);
@@ -81,9 +79,9 @@
// A set of scrolling line plots with the area between each plot filled. Stresses out GPU path
// filling
class ChartView : public Sample {
- static constexpr int kNumGraphs = 5;
- static constexpr int kPixelsPerTick = 3;
- static constexpr int kShiftPerFrame = 1;
+ inline static constexpr int kNumGraphs = 5;
+ inline static constexpr int kPixelsPerTick = 3;
+ inline static constexpr int kShiftPerFrame = 1;
int fShift = 0;
SkISize fSize = {-1, -1};
SkTDArray<SkScalar> fData[kNumGraphs];
@@ -102,7 +100,7 @@
SkScalar height = SkIntToScalar(fSize.fHeight);
if (sizeChanged) {
- int dataPointCount = SkMax32(fSize.fWidth / kPixelsPerTick + 1, 2);
+ int dataPointCount = std::max(fSize.fWidth / kPixelsPerTick + 1, 2);
for (int i = 0; i < kNumGraphs; ++i) {
SkScalar y = (kNumGraphs - i) * (height - ySpread) / (kNumGraphs + 1);
@@ -121,9 +119,6 @@
}
}
- SkPath plotPath;
- SkPath fillPath;
-
static const SkScalar kStrokeWidth = SkIntToScalar(2);
SkPaint plotPaint;
SkPaint fillPaint;
@@ -135,7 +130,9 @@
fillPaint.setAntiAlias(true);
fillPaint.setStyle(SkPaint::kFill_Style);
+ SkPathBuilder plotPath, fillPath;
SkTDArray<SkScalar>* prevData = nullptr;
+
for (int i = 0; i < kNumGraphs; ++i) {
gen_paths(fData[i],
prevData,
@@ -148,10 +145,10 @@
// Make the fills partially transparent
fillPaint.setColor((gColors[i] & 0x00ffffff) | 0x80000000);
- canvas->drawPath(fillPath, fillPaint);
+ canvas->drawPath(fillPath.detach(), fillPaint);
plotPaint.setColor(gColors[i]);
- canvas->drawPath(plotPath, plotPaint);
+ canvas->drawPath(plotPath.detach(), plotPaint);
prevData = fData + i;
}
diff --git a/third_party/skia/samplecode/SampleChineseFling.cpp b/third_party/skia/samplecode/SampleChineseFling.cpp
index 1cdf784..0e62725 100644
--- a/third_party/skia/samplecode/SampleChineseFling.cpp
+++ b/third_party/skia/samplecode/SampleChineseFling.cpp
@@ -17,8 +17,8 @@
#include "include/utils/SkRandom.h"
#if SK_SUPPORT_GPU
-#include "include/gpu/GrContext.h"
-#include "src/gpu/GrContextPriv.h"
+#include "include/gpu/GrDirectContext.h"
+#include "src/gpu/GrDirectContextPriv.h"
#endif
static sk_sp<SkTypeface> chinese_typeface() {
@@ -38,8 +38,8 @@
}
class ChineseFlingView : public Sample {
- static constexpr int kNumBlobs = 200;
- static constexpr int kWordLength = 16;
+ inline static constexpr int kNumBlobs = 200;
+ inline static constexpr int kWordLength = 16;
sk_sp<SkTypeface> fTypeface;
SkFontMetrics fMetrics;
@@ -103,8 +103,8 @@
};
class ChineseZoomView : public Sample {
- static constexpr int kNumBlobs = 8;
- static constexpr int kParagraphLength = 175;
+ inline static constexpr int kNumBlobs = 8;
+ inline static constexpr int kParagraphLength = 175;
bool fAfterFirstFrame = false;
sk_sp<SkTypeface> fTypeface;
@@ -137,24 +137,28 @@
if (fAfterFirstFrame) {
#if SK_SUPPORT_GPU
- GrContext* grContext = canvas->getGrContext();
- if (grContext) {
- sk_sp<SkImage> image = grContext->priv().testingOnly_getFontAtlasImage(
+ auto direct = GrAsDirectContext(canvas->recordingContext());
+ if (direct) {
+ sk_sp<SkImage> image = direct->priv().testingOnly_getFontAtlasImage(
GrMaskFormat::kA8_GrMaskFormat, 0);
canvas->drawImageRect(image,
- SkRect::MakeXYWH(10.0f, 10.0f, 512.0f, 512.0), &paint);
- image = grContext->priv().testingOnly_getFontAtlasImage(
+ SkRect::MakeXYWH(10.0f, 10.0f, 512.0f, 512.0),
+ SkSamplingOptions(), &paint);
+ image = direct->priv().testingOnly_getFontAtlasImage(
GrMaskFormat::kA8_GrMaskFormat, 1);
canvas->drawImageRect(image,
- SkRect::MakeXYWH(522.0f, 10.0f, 512.f, 512.0f), &paint);
- image = grContext->priv().testingOnly_getFontAtlasImage(
+ SkRect::MakeXYWH(522.0f, 10.0f, 512.f, 512.0f),
+ SkSamplingOptions(), &paint);
+ image = direct->priv().testingOnly_getFontAtlasImage(
GrMaskFormat::kA8_GrMaskFormat, 2);
canvas->drawImageRect(image,
- SkRect::MakeXYWH(10.0f, 522.0f, 512.0f, 512.0f), &paint);
- image = grContext->priv().testingOnly_getFontAtlasImage(
+ SkRect::MakeXYWH(10.0f, 522.0f, 512.0f, 512.0f),
+ SkSamplingOptions(), &paint);
+ image = direct->priv().testingOnly_getFontAtlasImage(
GrMaskFormat::kA8_GrMaskFormat, 3);
canvas->drawImageRect(image,
- SkRect::MakeXYWH(522.0f, 522.0f, 512.0f, 512.0f), &paint);
+ SkRect::MakeXYWH(522.0f, 522.0f, 512.0f, 512.0f),
+ SkSamplingOptions(), &paint);
}
#endif
}
@@ -191,7 +195,7 @@
auto paragraphLength = kParagraphLength;
SkScalar y = 0;
while (paragraphLength - 45 > 0) {
- auto currentLineLength = SkTMin(45, paragraphLength - 45);
+ auto currentLineLength = std::min(45, paragraphLength - 45);
this->createRandomLine(glyphs, currentLineLength);
ToolUtils::add_to_text_blob_w_len(&builder,
diff --git a/third_party/skia/samplecode/SampleCircle.cpp b/third_party/skia/samplecode/SampleCircle.cpp
index c4126f9..3cd7c0b 100644
--- a/third_party/skia/samplecode/SampleCircle.cpp
+++ b/third_party/skia/samplecode/SampleCircle.cpp
@@ -35,7 +35,7 @@
paint.setStrokeWidth(SkIntToScalar(width));
}
canvas->drawCircle(0, 0, 9.0f, paint);
- if (false) { // avoid bit rot, suppress warning
+ if ((false)) { // avoid bit rot, suppress warning
test_circlebounds(canvas);
}
}
diff --git a/third_party/skia/samplecode/SampleClip.cpp b/third_party/skia/samplecode/SampleClip.cpp
index bff7704..358e3f8 100644
--- a/third_party/skia/samplecode/SampleClip.cpp
+++ b/third_party/skia/samplecode/SampleClip.cpp
@@ -9,10 +9,11 @@
#include "include/core/SkColorPriv.h"
#include "include/core/SkFont.h"
#include "include/core/SkPaint.h"
-#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
#include "include/utils/SkRandom.h"
#include "samplecode/Sample.h"
-#include "src/core/SkClipOpPriv.h"
+#include "src/core/SkPathPriv.h"
+#include "tools/Resources.h"
constexpr int W = 150;
constexpr int H = 200;
@@ -37,7 +38,6 @@
for (int i = 0; i < 50; ++i) {
SkRect r;
- SkPath p;
r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H,
rand.nextUScalar1() * W, rand.nextUScalar1() * H);
@@ -47,8 +47,7 @@
r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H,
rand.nextUScalar1() * W, rand.nextUScalar1() * H);
paint.setColor(rand.nextU());
- p.addOval(r);
- canvas->drawPath(p, paint);
+ canvas->drawOval(r, paint);
}
}
@@ -66,7 +65,6 @@
for (int i = 0; i < n; ++i) {
SkRect r;
- SkPath p;
r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H,
rand.nextUScalar1() * W, rand.nextUScalar1() * H);
@@ -76,8 +74,7 @@
r.setXYWH(rand.nextSScalar1() * W, rand.nextSScalar1() * H,
rand.nextUScalar1() * W, rand.nextUScalar1() * H);
paint.setColor(rand.nextU());
- p.addOval(r);
- canvas->drawPath(p, paint);
+ canvas->drawOval(r, paint);
const SkScalar minx = -SkIntToScalar(W)/4;
const SkScalar maxx = 5*SkIntToScalar(W)/4;
@@ -112,9 +109,8 @@
};
SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
- SkPath clipPath;
r.inset(SK_Scalar1 / 4, SK_Scalar1 / 4);
- clipPath.addRoundRect(r, SkIntToScalar(20), SkIntToScalar(20));
+ SkPath clipPath = SkPathBuilder().addRRect(SkRRect::MakeRectXY(r, 20, 20)).detach();
// clipPath.toggleInverseFillType();
@@ -122,7 +118,7 @@
canvas->save();
for (size_t i = 0; i < SK_ARRAY_COUNT(gProc); ++i) {
canvas->save();
- canvas->clipPath(clipPath, kIntersect_SkClipOp, SkToBool(aa));
+ canvas->clipPath(clipPath, SkClipOp::kIntersect, SkToBool(aa));
// canvas->drawColor(SK_ColorWHITE);
gProc[i](canvas, SkToBool(aa));
canvas->restore();
@@ -211,7 +207,7 @@
#include "src/core/SkEdgeClipper.h"
-static void clip(const SkPath& path, SkPoint p0, SkPoint p1, SkPath* clippedPath) {
+static SkPath clip(const SkPath& path, SkPoint p0, SkPoint p1) {
SkMatrix mx, inv;
SkVector v = p1 - p0;
mx.setAll(v.fX, -v.fY, p0.fX,
@@ -226,9 +222,9 @@
SkRect clip = {-big, 0, big, big };
struct Rec {
- SkPath* fResult;
- SkPoint fPrev;
- } rec = { clippedPath, {0, 0} };
+ SkPathBuilder fResult;
+ SkPoint fPrev = {0, 0};
+ } rec;
SkEdgeClipper::ClipPath(rotated, clip, false,
[](SkEdgeClipper* clipper, bool newCtr, void* ctx) {
@@ -239,26 +235,26 @@
SkPath::Verb verb;
while ((verb = clipper->next(pts)) != SkPath::kDone_Verb) {
if (newCtr) {
- rec->fResult->moveTo(pts[0]);
+ rec->fResult.moveTo(pts[0]);
rec->fPrev = pts[0];
newCtr = false;
}
if (addLineTo || pts[0] != rec->fPrev) {
- rec->fResult->lineTo(pts[0]);
+ rec->fResult.lineTo(pts[0]);
}
switch (verb) {
case SkPath::kLine_Verb:
- rec->fResult->lineTo(pts[1]);
+ rec->fResult.lineTo(pts[1]);
rec->fPrev = pts[1];
break;
case SkPath::kQuad_Verb:
- rec->fResult->quadTo(pts[1], pts[2]);
+ rec->fResult.quadTo(pts[1], pts[2]);
rec->fPrev = pts[2];
break;
case SkPath::kCubic_Verb:
- rec->fResult->cubicTo(pts[1], pts[2], pts[3]);
+ rec->fResult.cubicTo(pts[1], pts[2], pts[3]);
rec->fPrev = pts[3];
break;
default: break;
@@ -267,27 +263,7 @@
}
}, &rec);
- rec.fResult->transform(mx);
-}
-
-// true means use clippedPath.
-// false means there was no clipping -- use the original path
-static bool clip(const SkPath& path, const SkHalfPlane& plane, SkPath* clippedPath) {
- switch (plane.test(path.getBounds())) {
- case SkHalfPlane::kAllPositive:
- return false;
- case SkHalfPlane::kMixed: {
- SkPoint pts[2];
- if (plane.twoPts(pts)) {
- clip(path, pts[0], pts[1], clippedPath);
- return true;
- }
- } break;
- default: break; // handled outside of the switch
- }
- // clipped out (or failed)
- clippedPath->reset();
- return true;
+ return rec.fResult.detach().makeTransform(mx);
}
static void draw_halfplane(SkCanvas* canvas, SkPoint p0, SkPoint p1, SkColor c) {
@@ -302,14 +278,21 @@
static SkPath make_path() {
SkRandom rand;
- auto rand_pt = [&rand]() { return SkPoint{rand.nextF() * 400, rand.nextF() * 400}; };
+ auto rand_pt = [&rand]() {
+ auto x = rand.nextF();
+ auto y = rand.nextF();
+ return SkPoint{x * 400, y * 400};
+ };
- SkPath path;
+ SkPathBuilder path;
for (int i = 0; i < 4; ++i) {
- path.moveTo(rand_pt()).quadTo(rand_pt(), rand_pt())
- .quadTo(rand_pt(), rand_pt()).lineTo(rand_pt());
+ SkPoint pts[6];
+ for (auto& p : pts) {
+ p = rand_pt();
+ }
+ path.moveTo(pts[0]).quadTo(pts[1], pts[2]).quadTo(pts[3], pts[4]).lineTo(pts[5]);
}
- return path;
+ return path.detach();
}
class HalfPlaneView : public Sample {
@@ -332,9 +315,7 @@
paint.setColor({0, 0, 0, 1}, nullptr);
- SkPath clippedPath;
- clip(fPath, fPts[0], fPts[1], &clippedPath);
- canvas->drawPath(clippedPath, paint);
+ canvas->drawPath(clip(fPath, fPts[0], fPts[1]), paint);
draw_halfplane(canvas, fPts[0], fPts[1], SK_ColorRED);
}
@@ -357,16 +338,16 @@
draw_halfplane(canvas, pts[0], pts[1], c);
}
-static void compute_half_planes(const SkMatrix& mx, SkScalar W, SkScalar H,
+static void compute_half_planes(const SkMatrix& mx, SkScalar width, SkScalar height,
SkHalfPlane planes[4]) {
SkScalar a = mx[0], b = mx[1], c = mx[2],
d = mx[3], e = mx[4], f = mx[5],
g = mx[6], h = mx[7], i = mx[8];
- planes[0] = { 2*g - 2*a/W, 2*h - 2*b/W, 2*i - 2*c/W };
- planes[1] = { 2*a/W, 2*b/W, 2*c/W };
- planes[2] = { 2*g - 2*d/H, 2*h - 2*e/H, 2*i - 2*f/H };
- planes[3] = { 2*d/H, 2*e/H, 2*f/H };
+ planes[0] = { 2*g - 2*a/width, 2*h - 2*b/width, 2*i - 2*c/width };
+ planes[1] = { 2*a/width, 2*b/width, 2*c/width };
+ planes[2] = { 2*g - 2*d/height, 2*h - 2*e/height, 2*i - 2*f/height };
+ planes[3] = { 2*d/height, 2*e/height, 2*f/height };
}
class HalfPlaneView2 : public Sample {
@@ -435,55 +416,78 @@
};
DEF_SAMPLE( return new HalfPlaneView2(); )
-#include "include/core/SkMatrix44.h"
-#include "include/utils/Sk3D.h"
-#include "tools/Resources.h"
-
-static SkMatrix44 inv(const SkMatrix44& m) {
- SkMatrix44 inverse;
+static SkM44 inv(const SkM44& m) {
+ SkM44 inverse;
SkAssertResult(m.invert(&inverse));
return inverse;
}
-#if 0 // Jim's general half-planes math
-static void half_planes(const SkMatrix44& m44, SkScalar W, SkScalar H, SkHalfPlane planes[6]) {
- float mx[16];
- m44.asColMajorf(mx);
-
- SkScalar a = mx[0], b = mx[4], /* c = mx[ 8], */ d = mx[12],
- e = mx[1], f = mx[5], /* g = mx[ 9], */ h = mx[13],
- i = mx[2], j = mx[6], /* k = mx[10], */ l = mx[14],
- m = mx[3], n = mx[7], /* o = mx[11], */ p = mx[15];
-
- a = 2*a/W - m; b = 2*b/W - n; d = 2*d/W - p;
- e = 2*e/H - m; f = 2*f/H - n; h = 2*h/H - p;
-// i = 2*i - m; j = 2*j - n; l = 2*l - p;
-
- planes[0] = { m - a, n - b, p - d }; // w - x
- planes[1] = { m + a, n + b, p + d }; // w + x
- planes[2] = { m - e, n - f, p - h }; // w - y
- planes[3] = { m + e, n + f, p + h }; // w + y
- planes[4] = { m - i, n - j, p - l }; // w - z
- planes[5] = { m + i, n + j, p + l }; // w + z
-}
-#endif
-
static SkHalfPlane half_plane_w0(const SkMatrix& m) {
return { m[SkMatrix::kMPersp0], m[SkMatrix::kMPersp1], m[SkMatrix::kMPersp2] - 0.05f };
}
-class HalfPlaneView3 : public Sample {
+class SampleCameraView : public Sample {
float fNear = 0.05f;
float fFar = 4;
float fAngle = SK_ScalarPI / 4;
- SkPoint3 fEye { 0, 0, 1.0f/tan(fAngle/2) - 1 };
- SkPoint3 fCOA { 0, 0, 0 };
- SkPoint3 fUp { 0, 1, 0 };
+ SkV3 fEye { 0, 0, 1.0f/tan(fAngle/2) - 1 };
+ SkV3 fCOA { 0, 0, 0 };
+ SkV3 fUp { 0, 1, 0 };
- SkMatrix44 fRot;
- SkPoint3 fTrans;
+ SkM44 fRot;
+ SkV3 fTrans;
+ void rotate(float x, float y, float z) {
+ SkM44 r;
+ if (x) {
+ r.setRotateUnit({1, 0, 0}, x);
+ } else if (y) {
+ r.setRotateUnit({0, 1, 0}, y);
+ } else {
+ r.setRotateUnit({0, 0, 1}, z);
+ }
+ fRot = r * fRot;
+ }
+
+public:
+ SkM44 get44(const SkRect& r) const {
+ SkScalar w = r.width();
+ SkScalar h = r.height();
+
+ SkM44 camera = SkM44::LookAt(fEye, fCOA, fUp),
+ perspective = SkM44::Perspective(fNear, fFar, fAngle),
+ translate = SkM44::Translate(fTrans.x, fTrans.y, fTrans.z),
+ viewport = SkM44::Translate(r.centerX(), r.centerY(), 0) *
+ SkM44::Scale(w*0.5f, h*0.5f, 1);
+
+ return viewport * perspective * camera * translate * fRot * inv(viewport);
+ }
+
+ bool onChar(SkUnichar uni) override {
+ float delta = SK_ScalarPI / 30;
+ switch (uni) {
+ case '8': this->rotate( delta, 0, 0); return true;
+ case '2': this->rotate(-delta, 0, 0); return true;
+ case '4': this->rotate(0, delta, 0); return true;
+ case '6': this->rotate(0, -delta, 0); return true;
+ case '-': this->rotate(0, 0, delta); return true;
+ case '+': this->rotate(0, 0, -delta); return true;
+
+ case 'i': fTrans.z += 0.1f; SkDebugf("z %g\n", fTrans.z); return true;
+ case 'k': fTrans.z -= 0.1f; SkDebugf("z %g\n", fTrans.z); return true;
+
+ case 'n': fNear += 0.1f; SkDebugf("near %g\n", fNear); return true;
+ case 'N': fNear -= 0.1f; SkDebugf("near %g\n", fNear); return true;
+ case 'f': fFar += 0.1f; SkDebugf("far %g\n", fFar); return true;
+ case 'F': fFar -= 0.1f; SkDebugf("far %g\n", fFar); return true;
+ default: break;
+ }
+ return false;
+ }
+};
+
+class HalfPlaneView3 : public SampleCameraView {
SkPath fPath;
sk_sp<SkShader> fShader;
bool fShowUnclipped = false;
@@ -493,37 +497,19 @@
void onOnceBeforeDraw() override {
fPath = make_path();
fShader = GetResourceAsImage("images/mandrill_128.png")
- ->makeShader(SkMatrix::MakeScale(3, 3));
+ ->makeShader(SkSamplingOptions(), SkMatrix::Scale(3, 3));
}
- void rotate(float x, float y, float z) {
- SkMatrix44 r;
- if (x) {
- r.setRotateAboutUnit(1, 0, 0, x);
- } else if (y) {
- r.setRotateAboutUnit(0, 1, 0, y);
- } else {
- r.setRotateAboutUnit(0, 0, 1, z);
+ bool onChar(SkUnichar uni) override {
+ switch (uni) {
+ case 'u': fShowUnclipped = !fShowUnclipped; return true;
+ default: break;
}
- fRot.postConcat(r);
- }
-
- SkMatrix44 get44() const {
- SkMatrix44 camera,
- perspective,
- translate,
- viewport;
-
- Sk3Perspective(&perspective, fNear, fFar, fAngle);
- Sk3LookAt(&camera, fEye, fCOA, fUp);
- translate.setTranslate(fTrans.fX, fTrans.fY, fTrans.fZ);
- viewport.setScale(200, 200, 1).postTranslate( 200, 200, 0);
-
- return viewport * perspective * camera * translate * fRot * inv(viewport);
+ return this->SampleCameraView::onChar(uni);
}
void onDrawContent(SkCanvas* canvas) override {
- SkMatrix mx = this->get44();
+ SkM44 mx = this->get44({0, 0, 400, 400});
SkPaint paint;
paint.setColor({0.75, 0.75, 0.75, 1});
@@ -540,11 +526,10 @@
canvas->restore();
}
- SkHalfPlane hpw = half_plane_w0(mx);
SkColor planeColor = SK_ColorBLUE;
SkPath clippedPath, *path = &fPath;
- if (clip(fPath, hpw, &clippedPath)) {
+ if (SkPathPriv::PerspectiveClip(fPath, mx.asM33(), &clippedPath)) {
path = &clippedPath;
planeColor = SK_ColorRED;
}
@@ -553,38 +538,97 @@
canvas->drawPath(*path, paint);
canvas->restore();
+ SkHalfPlane hpw = half_plane_w0(mx.asM33());
draw_halfplane(canvas, hpw, planeColor);
}
-
- bool onChar(SkUnichar uni) override {
- float delta = SK_ScalarPI / 30;
- switch (uni) {
- case '8': this->rotate( delta, 0, 0); return true;
- case '2': this->rotate(-delta, 0, 0); return true;
- case '4': this->rotate(0, delta, 0); return true;
- case '6': this->rotate(0, -delta, 0); return true;
- case '-': this->rotate(0, 0, delta); return true;
- case '+': this->rotate(0, 0, -delta); return true;
-
- case 'i': fTrans.fZ += 0.1f; SkDebugf("z %g\n", fTrans.fZ); return true;
- case 'k': fTrans.fZ -= 0.1f; SkDebugf("z %g\n", fTrans.fZ); return true;
-
- case 'n': fNear += 0.1f; SkDebugf("near %g\n", fNear); return true;
- case 'N': fNear -= 0.1f; SkDebugf("near %g\n", fNear); return true;
- case 'f': fFar += 0.1f; SkDebugf("far %g\n", fFar); return true;
- case 'F': fFar -= 0.1f; SkDebugf("far %g\n", fFar); return true;
-
- case 'u': fShowUnclipped = !fShowUnclipped; return true;
- default: break;
- }
- return false;
- }
- Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
- return nullptr;
- }
-
- bool onClick(Click* click) override {
- return false;
- }
};
DEF_SAMPLE( return new HalfPlaneView3(); )
+
+class HalfPlaneCoons : public SampleCameraView {
+ SkPoint fPatch[12];
+ SkColor fColors[4] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorBLACK };
+ SkPoint fTex[4] = {{0, 0}, {256, 0}, {256, 256}, {0, 256}};
+ sk_sp<SkShader> fShader;
+
+ bool fShowHandles = false;
+ bool fShowSkeleton = false;
+ bool fShowTex = false;
+
+ SkString name() override { return SkString("halfplane-coons"); }
+
+ void onOnceBeforeDraw() override {
+ fPatch[0] = { 0, 0 };
+ fPatch[1] = { 100, 0 };
+ fPatch[2] = { 200, 0 };
+ fPatch[3] = { 300, 0 };
+ fPatch[4] = { 300, 100 };
+ fPatch[5] = { 300, 200 };
+ fPatch[6] = { 300, 300 };
+ fPatch[7] = { 200, 300 };
+ fPatch[8] = { 100, 300 };
+ fPatch[9] = { 0, 300 };
+ fPatch[10] = { 0, 200 };
+ fPatch[11] = { 0, 100 };
+
+ fShader = GetResourceAsImage("images/mandrill_256.png")->makeShader(SkSamplingOptions());
+ }
+
+ void onDrawContent(SkCanvas* canvas) override {
+ SkPaint paint;
+
+ canvas->save();
+ canvas->concat(this->get44({0, 0, 300, 300}));
+
+ const SkPoint* tex = nullptr;
+ const SkColor* col = nullptr;
+ if (!fShowSkeleton) {
+ if (fShowTex) {
+ paint.setShader(fShader);
+ tex = fTex;
+ } else {
+ col = fColors;
+ }
+ }
+ canvas->drawPatch(fPatch, col, tex, SkBlendMode::kSrc, paint);
+ paint.setShader(nullptr);
+
+ if (fShowHandles) {
+ paint.setAntiAlias(true);
+ paint.setStrokeCap(SkPaint::kRound_Cap);
+ paint.setStrokeWidth(8);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 12, fPatch, paint);
+ paint.setColor(SK_ColorWHITE);
+ paint.setStrokeWidth(6);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 12, fPatch, paint);
+ }
+
+ canvas->restore();
+ }
+
+ Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
+ auto dist = [](SkPoint a, SkPoint b) { return (b - a).length(); };
+
+ const float tol = 15;
+ for (int i = 0; i < 12; ++i) {
+ if (dist({x,y}, fPatch[i]) <= tol) {
+ return new Click([this, i](Click* c) {
+ fPatch[i] = c->fCurr;
+ return true;
+ });
+ }
+ }
+ return nullptr;
+ }
+
+ bool onChar(SkUnichar uni) override {
+ switch (uni) {
+ case 'h': fShowHandles = !fShowHandles; return true;
+ case 'k': fShowSkeleton = !fShowSkeleton; return true;
+ case 't': fShowTex = !fShowTex; return true;
+ default: break;
+ }
+ return this->SampleCameraView::onChar(uni);
+ }
+
+};
+DEF_SAMPLE( return new HalfPlaneCoons(); )
diff --git a/third_party/skia/samplecode/SampleClipDrawMatch.cpp b/third_party/skia/samplecode/SampleClipDrawMatch.cpp
deleted file mode 100644
index bdbb54b..0000000
--- a/third_party/skia/samplecode/SampleClipDrawMatch.cpp
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- * Copyright 2015 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/SkPath.h"
-#include "include/core/SkRRect.h"
-#include "include/core/SkTime.h"
-#include "include/utils/SkInterpolator.h"
-#include "samplecode/Sample.h"
-
-// This slide tests out the match up between BW clipping and rendering. It can
-// draw a large rect through some clip geometry and draw the same geometry
-// normally. Which one is drawn first can be toggled. The pair of objects is translated
-// fractionally (via an animator) to expose snapping bugs. The key bindings are:
-// 1-9: the different geometries
-// t: toggle which is drawn first the clip or the normal geometry
-// f: flip-flops which corner the bottom AA clip rect occupies in the complex clip cases
-
-// The possible geometric combinations to test
-enum Geometry {
- kRect_Geometry,
- kRRect_Geometry,
- kCircle_Geometry,
- kConvexPath_Geometry,
- kConcavePath_Geometry,
- kRectAndRect_Geometry,
- kRectAndRRect_Geometry,
- kRectAndConvex_Geometry,
- kRectAndConcave_Geometry
-};
-
-// The basic rect used is [kMin,kMin]..[kMax,kMax]
-static const float kMin = 100.5f;
-static const float kMid = 200.0f;
-static const float kMax = 299.5f;
-
-// The translation applied to the base AA rect in the combination cases
-// (i.e., kRectAndRect through kRectAndConcave)
-static const float kXlate = 100.0f;
-
-SkRect create_rect(const SkPoint& offset) {
- SkRect r = SkRect::MakeLTRB(kMin, kMin, kMax, kMax);
- r.offset(offset);
- return r;
-}
-
-SkRRect create_rrect(const SkPoint& offset) {
- SkRRect rrect;
- rrect.setRectXY(create_rect(offset), 10, 10);
- return rrect;
-}
-
-SkRRect create_circle(const SkPoint& offset) {
- SkRRect circle;
- circle.setOval(create_rect(offset));
- return circle;
-}
-
-SkPath create_convex_path(const SkPoint& offset) {
- SkPath convexPath;
- convexPath.moveTo(kMin, kMin);
- convexPath.lineTo(kMax, kMax);
- convexPath.lineTo(kMin, kMax);
- convexPath.close();
- convexPath.offset(offset.fX, offset.fY);
- return convexPath;
-}
-
-SkPath create_concave_path(const SkPoint& offset) {
- SkPath concavePath;
- concavePath.moveTo(kMin, kMin);
- concavePath.lineTo(kMid, 105.0f);
- concavePath.lineTo(kMax, kMin);
- concavePath.lineTo(295.0f, kMid);
- concavePath.lineTo(kMax, kMax);
- concavePath.lineTo(kMid, 295.0f);
- concavePath.lineTo(kMin, kMax);
- concavePath.lineTo(105.0f, kMid);
- concavePath.close();
-
- concavePath.offset(offset.fX, offset.fY);
- return concavePath;
-}
-
-static void draw_normal_geom(SkCanvas* canvas, const SkPoint& offset, int geom, bool useAA) {
- SkPaint p;
- p.setAntiAlias(useAA);
- p.setColor(SK_ColorBLACK);
-
- switch (geom) {
- case kRect_Geometry: // fall thru
- case kRectAndRect_Geometry:
- canvas->drawRect(create_rect(offset), p);
- break;
- case kRRect_Geometry: // fall thru
- case kRectAndRRect_Geometry:
- canvas->drawRRect(create_rrect(offset), p);
- break;
- case kCircle_Geometry:
- canvas->drawRRect(create_circle(offset), p);
- break;
- case kConvexPath_Geometry: // fall thru
- case kRectAndConvex_Geometry:
- canvas->drawPath(create_convex_path(offset), p);
- break;
- case kConcavePath_Geometry: // fall thru
- case kRectAndConcave_Geometry:
- canvas->drawPath(create_concave_path(offset), p);
- break;
- }
-}
-
-class ClipDrawMatchView : public Sample {
- SkInterpolator fTrans;
- Geometry fGeom;
- bool fClipFirst = true;
- int fSign = 1;
- const double fStart = SkTime::GetMSecs();
-
-public:
- ClipDrawMatchView() : fTrans(2, 5), fGeom(kRect_Geometry) {}
-
-private:
- void onOnceBeforeDraw() override {
- SkScalar values[2];
-
- fTrans.setRepeatCount(999);
- values[0] = values[1] = 0;
- fTrans.setKeyFrame(0, GetMSecs() + 1000, values);
- values[1] = 1;
- fTrans.setKeyFrame(1, GetMSecs() + 2000, values);
- values[0] = values[1] = 1;
- fTrans.setKeyFrame(2, GetMSecs() + 3000, values);
- values[1] = 0;
- fTrans.setKeyFrame(3, GetMSecs() + 4000, values);
- values[0] = 0;
- fTrans.setKeyFrame(4, GetMSecs() + 5000, values);
- }
-
- SkString name() override { return SkString("ClipDrawMatch"); }
-
- bool onChar(SkUnichar uni) override {
- switch (uni) {
- case '1': fGeom = kRect_Geometry; return true;
- case '2': fGeom = kRRect_Geometry; return true;
- case '3': fGeom = kCircle_Geometry; return true;
- case '4': fGeom = kConvexPath_Geometry; return true;
- case '5': fGeom = kConcavePath_Geometry; return true;
- case '6': fGeom = kRectAndRect_Geometry; return true;
- case '7': fGeom = kRectAndRRect_Geometry; return true;
- case '8': fGeom = kRectAndConvex_Geometry; return true;
- case '9': fGeom = kRectAndConcave_Geometry; return true;
- case 'f': fSign = -fSign; return true;
- case 't': fClipFirst = !fClipFirst; return true;
- default: break;
- }
- return false;
- }
-
- void drawClippedGeom(SkCanvas* canvas, const SkPoint& offset, bool useAA) {
-
- int count = canvas->save();
-
- switch (fGeom) {
- case kRect_Geometry:
- canvas->clipRect(create_rect(offset), useAA);
- break;
- case kRRect_Geometry:
- canvas->clipRRect(create_rrect(offset), useAA);
- break;
- case kCircle_Geometry:
- canvas->clipRRect(create_circle(offset), useAA);
- break;
- case kConvexPath_Geometry:
- canvas->clipPath(create_convex_path(offset), useAA);
- break;
- case kConcavePath_Geometry:
- canvas->clipPath(create_concave_path(offset), useAA);
- break;
- case kRectAndRect_Geometry: {
- SkRect r = create_rect(offset);
- r.offset(fSign * kXlate, fSign * kXlate);
- canvas->clipRect(r, true); // AA here forces shader clips
- canvas->clipRect(create_rect(offset), useAA);
- } break;
- case kRectAndRRect_Geometry: {
- SkRect r = create_rect(offset);
- r.offset(fSign * kXlate, fSign * kXlate);
- canvas->clipRect(r, true); // AA here forces shader clips
- canvas->clipRRect(create_rrect(offset), useAA);
- } break;
- case kRectAndConvex_Geometry: {
- SkRect r = create_rect(offset);
- r.offset(fSign * kXlate, fSign * kXlate);
- canvas->clipRect(r, true); // AA here forces shader clips
- canvas->clipPath(create_convex_path(offset), useAA);
- } break;
- case kRectAndConcave_Geometry: {
- SkRect r = create_rect(offset);
- r.offset(fSign * kXlate, fSign * kXlate);
- canvas->clipRect(r, true); // AA here forces shader clips
- canvas->clipPath(create_concave_path(offset), useAA);
- } break;
- }
-
- SkISize size = canvas->getBaseLayerSize();
- SkRect bigR = SkRect::MakeWH(SkIntToScalar(size.width()), SkIntToScalar(size.height()));
-
- SkPaint p;
- p.setColor(SK_ColorRED);
-
- canvas->drawRect(bigR, p);
- canvas->restoreToCount(count);
- }
-
- // Draw a big red rect through some clip geometry and also draw that same
- // geometry in black. The order in which they are drawn can be swapped.
- // This tests whether the clip and normally drawn geometry match up.
- void drawGeometry(SkCanvas* canvas, const SkPoint& offset, bool useAA) {
- if (fClipFirst) {
- this->drawClippedGeom(canvas, offset, useAA);
- }
-
- draw_normal_geom(canvas, offset, fGeom, useAA);
-
- if (!fClipFirst) {
- this->drawClippedGeom(canvas, offset, useAA);
- }
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- SkScalar trans[2];
- fTrans.timeToValues(GetMSecs(), trans);
-
- SkPoint offset;
- offset.set(trans[0], trans[1]);
-
- int saveCount = canvas->save();
- this->drawGeometry(canvas, offset, false);
- canvas->restoreToCount(saveCount);
- }
-
- SkMSec GetMSecs() const {
- return static_cast<SkMSec>(SkTime::GetMSecs() - fStart);
- }
-};
-
-DEF_SAMPLE( return new ClipDrawMatchView(); )
diff --git a/third_party/skia/samplecode/SampleColorFilter.cpp b/third_party/skia/samplecode/SampleColorFilter.cpp
deleted file mode 100644
index 7f57a32..0000000
--- a/third_party/skia/samplecode/SampleColorFilter.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * Copyright 2011 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/SkPaint.h"
-#include "include/core/SkShader.h"
-#include "samplecode/Sample.h"
-#include "tools/ToolUtils.h"
-
-static int inflate5To8(int x) {
- return (x << 3) | (x >> 2);
-}
-
-static int trunc5(int x) {
- return x >> 3;
-}
-
-#define SK_R16_BITS 5
-
-#ifdef SK_DEBUG
-static int round5_slow(int x) {
- int orig = x & 7;
- int fake = x >> 5;
- int trunc = x >> 3;
-
- int diff = fake - orig;
-
- int bias = 0;
- if (diff > 4) {
- bias = -1;
- } else if (diff < -4) {
- bias = 1;
- }
- return trunc + bias;
-}
-#endif
-
-static int round5_fast(int x) {
- int result = x + 3 - (x >> 5) + (x >> 7);
- result >>= 3;
-#ifdef SK_DEBUG
- {
- int r2 = round5_slow(x);
- SkASSERT(r2 == result);
- }
-#endif
- return result;
-}
-
-static void test_5bits() {
- int e0 = 0;
- int e1 = 0;
- int e2 = 0;
- int ae0 = 0;
- int ae1 = 0;
- int ae2 = 0;
- for (int i = 0; i < 256; i++) {
- int t0 = trunc5(i);
- int t1 = round5_fast(i);
- int t2 = trunc5(i);
- int v0 = inflate5To8(t0);
- int v1 = inflate5To8(t1);
- int v2 = inflate5To8(t2);
- int err0 = i - v0;
- int err1 = i - v1;
- int err2 = i - v2;
- SkDebugf("--- %3d : trunc=%3d (%2d) round:%3d (%2d) \n"/*new:%d (%2d)\n"*/, i,
- v0, err0, v1, err1, v2, err2);
-
-
- e0 += err0;
- e1 += err1;
- e2 += err2;
- ae0 += SkAbs32(err0);
- ae1 += SkAbs32(err1);
- ae2 += SkAbs32(err2);
- }
- SkDebugf("--- trunc: %d %d round: %d %d new: %d %d\n", e0, ae0, e1, ae1, e2, ae2);
-}
-
-static SkBitmap createBitmap(int n) {
- SkBitmap bitmap;
- bitmap.allocN32Pixels(n, n);
- bitmap.eraseColor(SK_ColorTRANSPARENT);
-
- SkCanvas canvas(bitmap);
- SkRect r;
- r.setWH(SkIntToScalar(n), SkIntToScalar(n));
- r.inset(SK_Scalar1, SK_Scalar1);
-
- SkPaint paint;
- paint.setAntiAlias(true);
-
- paint.setColor(SK_ColorRED);
- canvas.drawOval(r, paint);
-
- r.inset(SK_Scalar1*n/4, SK_Scalar1*n/4);
- paint.setBlendMode(SkBlendMode::kSrc);
- paint.setColor(0x800000FF);
- canvas.drawOval(r, paint);
-
- return bitmap;
-}
-
-class ColorFilterView : public Sample {
- SkBitmap fBitmap;
- sk_sp<SkShader> fShader;
- enum {
- N = 64
- };
-
- void onOnceBeforeDraw() override {
- fBitmap = createBitmap(N);
- fShader = ToolUtils::create_checkerboard_shader(0xFFCCCCCC, 0xFFFFFFFF, 12);
-
- if (false) { // avoid bit rot, suppress warning
- test_5bits();
- }
- }
-
- SkString name() override { return SkString("ColorFilter"); }
-
- void onDrawBackground(SkCanvas* canvas) override {
- SkPaint paint;
- paint.setShader(fShader);
- canvas->drawPaint(paint);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- if (false) {
- SkPaint p;
- p.setAntiAlias(true);
- SkRect r = { 20.4f, 10, 20.6f, 20 };
- canvas->drawRect(r, p);
- r.setLTRB(30.9f, 10, 31.1f, 20);
- canvas->drawRect(r, p);
- return;
- }
-
- static const SkBlendMode gModes[] = {
- SkBlendMode::kClear,
- SkBlendMode::kSrc,
- SkBlendMode::kDst,
- SkBlendMode::kSrcOver,
- SkBlendMode::kDstOver,
- SkBlendMode::kSrcIn,
- SkBlendMode::kDstIn,
- SkBlendMode::kSrcOut,
- SkBlendMode::kDstOut,
- SkBlendMode::kSrcATop,
- SkBlendMode::kDstATop,
- SkBlendMode::kXor,
- SkBlendMode::kPlus,
- SkBlendMode::kModulate,
- };
-
- static const SkColor gColors[] = {
- 0xFF000000,
- 0x80000000,
- 0xFF00FF00,
- 0x8000FF00,
- 0x00000000,
- };
-
- float scale = 1.5f;
- SkPaint paint;
- canvas->translate(N / 8, N / 8);
-
- for (size_t y = 0; y < SK_ARRAY_COUNT(gColors); y++) {
- for (size_t x = 0; x < SK_ARRAY_COUNT(gModes); x++) {
- paint.setColorFilter(SkColorFilters::Blend(gColors[y], gModes[x]));
- canvas->drawBitmap(fBitmap, x * N * 1.25f, y * N * scale, &paint);
- }
- }
-
- }
-};
-
-DEF_SAMPLE( return new ColorFilterView(); )
diff --git a/third_party/skia/samplecode/SampleComplexClip.cpp b/third_party/skia/samplecode/SampleComplexClip.cpp
index d903148..64e7af5 100644
--- a/third_party/skia/samplecode/SampleComplexClip.cpp
+++ b/third_party/skia/samplecode/SampleComplexClip.cpp
@@ -9,7 +9,6 @@
#include "include/core/SkFont.h"
#include "include/core/SkPath.h"
#include "samplecode/Sample.h"
-#include "src/core/SkClipOpPriv.h"
class ComplexClipView : public Sample {
void onOnceBeforeDraw() override {
@@ -78,11 +77,8 @@
SkClipOp fOp;
const char* fName;
} gOps[] = { //extra spaces in names for measureText
- {kIntersect_SkClipOp, "Isect "},
- {kDifference_SkClipOp, "Diff " },
- {kUnion_SkClipOp, "Union "},
- {kXOR_SkClipOp, "Xor " },
- {kReverseDifference_SkClipOp, "RDiff "}
+ {SkClipOp::kIntersect, "Isect "},
+ {SkClipOp::kDifference, "Diff " },
};
canvas->translate(0, SkIntToScalar(40));
diff --git a/third_party/skia/samplecode/SampleCowboy.cpp b/third_party/skia/samplecode/SampleCowboy.cpp
index 6ba3177..2ed47cb 100644
--- a/third_party/skia/samplecode/SampleCowboy.cpp
+++ b/third_party/skia/samplecode/SampleCowboy.cpp
@@ -7,12 +7,13 @@
#include "include/core/SkTypes.h"
-#ifdef SK_XML
+#if defined(SK_ENABLE_SVG)
-#include "experimental/svg/model/SkSVGDOM.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkRect.h"
#include "include/core/SkStream.h"
+#include "modules/svg/include/SkSVGDOM.h"
+#include "modules/svg/include/SkSVGNode.h"
#include "samplecode/Sample.h"
#include "src/core/SkOSFile.h"
#include "src/utils/SkOSPath.h"
@@ -21,7 +22,7 @@
namespace {
class AnimatedSVGSample : public Sample {
- static constexpr auto kAnimationIterations = 5;
+ inline static constexpr auto kAnimationIterations = 5;
enum State {
kZoomIn,
kScroll,
@@ -47,13 +48,7 @@
}
SkMemoryStream svgStream(std::move(data));
- SkDOM xmlDom;
- if (!xmlDom.build(svgStream)) {
- SkDebugf("XML parsing failed: \"%s\"\n", fResource);
- return;
- }
-
- fDom = SkSVGDOM::MakeFromDOM(xmlDom);
+ fDom = SkSVGDOM::MakeFromStream(svgStream);
if (fDom) {
fDom->setContainerSize(SkSize::Make(this->width(), this->height()));
}
@@ -61,12 +56,12 @@
void onDrawContent(SkCanvas* canvas) override {
if (fDom) {
- canvas->setMatrix(SkMatrix::MakeScale(3));
+ canvas->setMatrix(SkMatrix::Scale(3, 3));
canvas->clipRect(SkRect::MakeLTRB(0, 0, 400, 400));
switch (fState) {
case kZoomIn:
fDelta += 0.2f;
- canvas->concat(SkMatrix::MakeScale(fDelta));
+ canvas->scale(fDelta, fDelta);
break;
case kScroll:
if (fAnimationLoop > kAnimationIterations/2) {
@@ -74,12 +69,12 @@
} else {
fDelta -= 80.f;
}
- canvas->concat(SkMatrix::MakeScale(fDelta));
+ canvas->scale(fDelta, fDelta);
canvas->translate(fDelta, 0);
break;
case kZoomOut:
fDelta += 0.2f;
- canvas->concat(SkMatrix::MakeScale(fDelta));
+ canvas->scale(fDelta, fDelta);
break;
}
@@ -125,4 +120,4 @@
DEF_SAMPLE( return new AnimatedSVGSample("Cowboy.svg", "SampleCowboy"); )
-#endif // SK_XML
+#endif // defined(SK_ENABLE_SVG)
diff --git a/third_party/skia/samplecode/SampleCusp.cpp b/third_party/skia/samplecode/SampleCusp.cpp
index 28b1233..543a3a3 100644
--- a/third_party/skia/samplecode/SampleCusp.cpp
+++ b/third_party/skia/samplecode/SampleCusp.cpp
@@ -144,12 +144,14 @@
bool split;
path = cusp(pts, pp, split, 8000, .125);
auto debugOutCubic = [](const SkPoint* pts) {
- return false; // comment out to capture stream of cusp'd cubics in stdout
- SkDebugf("{{");
- for (int i = 0; i < 4; ++i) {
- SkDebugf("{0x%08x,0x%08x},", SkFloat2Bits(pts[i].fX), SkFloat2Bits(pts[i].fY));
+ if ((false)) { // enable to capture stream of cusp'd cubics in stdout
+ SkDebugf("{{");
+ for (int i = 0; i < 4; ++i) {
+ SkDebugf("{0x%08x,0x%08x},", SkFloat2Bits(pts[i].fX), SkFloat2Bits(pts[i].fY));
+ }
+ SkDebugf("}},\n");
}
- SkDebugf("}},\n");
+ return false;
};
if (split) {
debugOutCubic(&pp[0]);
@@ -162,7 +164,6 @@
// draw time to make it easier to guess when the bad cubic was drawn
std::string timeStr = std::to_string((float) (curTime - start) / 1000.f);
canvas->drawSimpleText(timeStr.c_str(), timeStr.size(), SkTextEncoding::kUTF8, 20, 20, SkFont(), SkPaint());
- SkDebugf("");
}
bool onAnimate(double nanos) override {
@@ -175,7 +176,7 @@
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new CuspView(); )
diff --git a/third_party/skia/samplecode/SampleDegenerateQuads.cpp b/third_party/skia/samplecode/SampleDegenerateQuads.cpp
index 3d48cec..e3ab138 100644
--- a/third_party/skia/samplecode/SampleDegenerateQuads.cpp
+++ b/third_party/skia/samplecode/SampleDegenerateQuads.cpp
@@ -8,12 +8,18 @@
#include "samplecode/Sample.h"
#include "src/gpu/geometry/GrQuad.h"
-#include "src/gpu/ops/GrQuadPerEdgeAA.h"
+#include "src/gpu/ops/QuadPerEdgeAA.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkPaint.h"
#include "include/effects/SkDashPathEffect.h"
#include "include/pathops/SkPathOps.h"
+#include "include/private/SkTPin.h"
+
+using VertexSpec = skgpu::v1::QuadPerEdgeAA::VertexSpec;
+using ColorType = skgpu::v1::QuadPerEdgeAA::ColorType;
+using Subset = skgpu::v1::QuadPerEdgeAA::Subset;
+using IndexBufferOption = skgpu::v1::QuadPerEdgeAA::IndexBufferOption;
// Draw a line through the two points, outset by a fixed length in screen space
static void draw_extended_line(SkCanvas* canvas, const SkPaint paint,
@@ -216,11 +222,11 @@
SkScalar coverage = bary[0] * c0 + bary[1] * c1 + bary[2] * c2;
if (coverage < 0.5f) {
// Check distances to domain
- SkScalar l = SkScalarPin(point.fX - geomDomain.fLeft, 0.f, 1.f);
- SkScalar t = SkScalarPin(point.fY - geomDomain.fTop, 0.f, 1.f);
- SkScalar r = SkScalarPin(geomDomain.fRight - point.fX, 0.f, 1.f);
- SkScalar b = SkScalarPin(geomDomain.fBottom - point.fY, 0.f, 1.f);
- coverage = SkMinScalar(coverage, l * t * r * b);
+ SkScalar l = SkTPin(point.fX - geomDomain.fLeft, 0.f, 1.f);
+ SkScalar t = SkTPin(point.fY - geomDomain.fTop, 0.f, 1.f);
+ SkScalar r = SkTPin(geomDomain.fRight - point.fX, 0.f, 1.f);
+ SkScalar b = SkTPin(geomDomain.fBottom - point.fY, 0.f, 1.f);
+ coverage = std::min(coverage, l * t * r * b);
}
return coverage;
}
@@ -406,10 +412,10 @@
void getTessellatedPoints(SkPoint inset[4], SkScalar insetCoverage[4], SkPoint outset[4],
SkScalar outsetCoverage[4], SkRect* domain) const {
// Fixed vertex spec for extracting the picture frame geometry
- static const GrQuadPerEdgeAA::VertexSpec kSpec =
- {GrQuad::Type::kGeneral, GrQuadPerEdgeAA::ColorType::kNone,
- GrQuad::Type::kAxisAligned, false, GrQuadPerEdgeAA::Domain::kNo,
- GrAAType::kCoverage, false, GrQuadPerEdgeAA::IndexBufferOption::kPictureFramed};
+ static const VertexSpec kSpec =
+ {GrQuad::Type::kGeneral, ColorType::kNone,
+ GrQuad::Type::kAxisAligned, false, Subset::kNo,
+ GrAAType::kCoverage, false, IndexBufferOption::kPictureFramed};
static const GrQuad kIgnored(SkRect::MakeEmpty());
GrQuadAAFlags flags = GrQuadAAFlags::kNone;
@@ -421,7 +427,7 @@
GrQuad quad = GrQuad::MakeFromSkQuad(fCorners, SkMatrix::I());
float vertices[56]; // 2 quads, with x, y, coverage, and geometry domain (7 floats x 8 vert)
- GrQuadPerEdgeAA::Tessellator tessellator(kSpec, (char*) vertices);
+ skgpu::v1::QuadPerEdgeAA::Tessellator tessellator(kSpec, (char*) vertices);
tessellator.append(&quad, nullptr, {1.f, 1.f, 1.f, 1.f},
SkRect::MakeEmpty(), flags);
@@ -448,7 +454,7 @@
*domain = {vertices[52], vertices[53], vertices[54], vertices[55]};
}
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
class DegenerateQuadSample::Click : public Sample::Click {
@@ -474,8 +480,8 @@
void drag(SkPoint* point) {
SkPoint delta = fCurr - fPrev;
*point += SkPoint::Make(delta.x() / kViewScale, delta.y() / kViewScale);
- point->fX = SkMinScalar(fOuterRect.fRight, SkMaxScalar(point->fX, fOuterRect.fLeft));
- point->fY = SkMinScalar(fOuterRect.fBottom, SkMaxScalar(point->fY, fOuterRect.fTop));
+ point->fX = std::min(fOuterRect.fRight, std::max(point->fX, fOuterRect.fLeft));
+ point->fY = std::min(fOuterRect.fBottom, std::max(point->fY, fOuterRect.fTop));
}
};
diff --git a/third_party/skia/samplecode/SampleDegenerateTwoPtRadials.cpp b/third_party/skia/samplecode/SampleDegenerateTwoPtRadials.cpp
index f26403e..f0c74be 100644
--- a/third_party/skia/samplecode/SampleDegenerateTwoPtRadials.cpp
+++ b/third_party/skia/samplecode/SampleDegenerateTwoPtRadials.cpp
@@ -73,7 +73,7 @@
private:
SkScalar fTime;
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleEffects.cpp b/third_party/skia/samplecode/SampleEffects.cpp
index f22aea1..5a49ded 100644
--- a/third_party/skia/samplecode/SampleEffects.cpp
+++ b/third_party/skia/samplecode/SampleEffects.cpp
@@ -86,9 +86,9 @@
}
protected:
- virtual SkString name() { return SkString("Effects"); }
+ SkString name() override { return SkString("Effects"); }
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) override {
canvas->scale(3, 3);
canvas->translate(10, 30);
for (size_t i = 0; i < SK_ARRAY_COUNT(fPaint); i++) {
@@ -98,7 +98,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleEmboss.cpp b/third_party/skia/samplecode/SampleEmboss.cpp
index beacecb..0c49a85 100644
--- a/third_party/skia/samplecode/SampleEmboss.cpp
+++ b/third_party/skia/samplecode/SampleEmboss.cpp
@@ -33,9 +33,9 @@
}
protected:
- virtual SkString name() { return SkString("Emboss"); }
+ SkString name() override { return SkString("Emboss"); }
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
@@ -51,7 +51,7 @@
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleFatBits.cpp b/third_party/skia/samplecode/SampleFatBits.cpp
index f1dcd29..f80fb25 100644
--- a/third_party/skia/samplecode/SampleFatBits.cpp
+++ b/third_party/skia/samplecode/SampleFatBits.cpp
@@ -21,7 +21,6 @@
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
#include "samplecode/Sample.h"
-#include "src/core/SkClipOpPriv.h"
#include "src/core/SkPointPriv.h"
#include "tools/ToolUtils.h"
@@ -172,7 +171,7 @@
SkCanvas* canvas = fMaxSurface->getCanvas();
canvas->save();
canvas->concat(fMatrix);
- fMinSurface->draw(canvas, 0, 0, nullptr);
+ fMinSurface->draw(canvas, 0, 0);
canvas->restore();
SkPaint paint;
@@ -271,7 +270,7 @@
fMinSurface->getCanvas()->save();
SkRect r = fClipRect;
r.inset(SK_Scalar1/3, SK_Scalar1/3);
- fMinSurface->getCanvas()->clipRect(r, kIntersect_SkClipOp, true);
+ fMinSurface->getCanvas()->clipRect(r, SkClipOp::kIntersect, true);
}
fMinSurface->getCanvas()->drawLine(pts[0], pts[1], paint);
if (fUseClip) {
@@ -284,7 +283,7 @@
fMatrix.mapPoints(pts, 2);
this->drawLineSkeleton(max, pts);
- fMaxSurface->draw(canvas, 0, 0, nullptr);
+ fMaxSurface->draw(canvas, 0, 0);
}
void FatBits::drawRect(SkCanvas* canvas, SkPoint pts[2]) {
@@ -314,7 +313,7 @@
r.setBounds(pts, 2);
this->drawRectSkeleton(max, r);
- fMaxSurface->draw(canvas, 0, 0, nullptr);
+ fMaxSurface->draw(canvas, 0, 0);
}
void FatBits::drawTriangleSkeleton(SkCanvas* max, const SkPoint pts[]) {
@@ -356,7 +355,7 @@
fMatrix.mapPoints(pts, 3);
this->drawTriangleSkeleton(max, pts);
- fMaxSurface->draw(canvas, 0, 0, nullptr);
+ fMaxSurface->draw(canvas, 0, 0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -382,7 +381,7 @@
fPts[0].set(1, 1);
fPts[1].set(5, 4);
fPts[2].set(2, 6);
- SkMatrix::MakeScale(SkIntToScalar(fZoom)).mapPoints(fPts, 3);
+ SkMatrix::Scale(fZoom, fZoom).mapPoints(fPts, 3);
fIsRect = false;
}
@@ -499,7 +498,7 @@
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleFillType.cpp b/third_party/skia/samplecode/SampleFillType.cpp
index 230f41b..7330549 100644
--- a/third_party/skia/samplecode/SampleFillType.cpp
+++ b/third_party/skia/samplecode/SampleFillType.cpp
@@ -25,7 +25,7 @@
}
protected:
- virtual SkString name() { return SkString("FillType"); }
+ SkString name() override{ return SkString("FillType"); }
void showPath(SkCanvas* canvas, int x, int y, SkPathFillType ft,
SkScalar scale, const SkPaint& paint) {
@@ -55,7 +55,7 @@
scale, paint);
}
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
SkPaint paint;
@@ -77,7 +77,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleFilter2.cpp b/third_party/skia/samplecode/SampleFilter2.cpp
deleted file mode 100644
index 453bfa7..0000000
--- a/third_party/skia/samplecode/SampleFilter2.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright 2011 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/SkFont.h"
-#include "include/core/SkString.h"
-#include "include/utils/SkTextUtils.h"
-#include "samplecode/DecodeFile.h"
-#include "samplecode/Sample.h"
-#include "tools/Resources.h"
-
-#include <vector>
-
-static const char* gNames[] = {
- "images/mandrill_512_q075.jpg",
- "images/dog.jpg",
-};
-
-struct Filter2View : public Sample {
- std::vector<SkBitmap> fBitmaps;
-
- void onOnceBeforeDraw() override {
- SkASSERT(fBitmaps.empty());
- fBitmaps.reserve(SK_ARRAY_COUNT(gNames) * 2);
- for (const char* name : gNames) {
- SkBitmap bitmap;
- (void)decode_file(GetResourceAsData(name), &bitmap);
- fBitmaps.push_back(std::move(bitmap));
- }
- for (const char* name : gNames) {
- SkBitmap bitmap;
- (void)decode_file(GetResourceAsData(name), &bitmap, kRGB_565_SkColorType);
- fBitmaps.push_back(std::move(bitmap));
- }
- this->setBGColor(SK_ColorGRAY);
- }
-
- SkString name() override { return SkString("Filter/Dither"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->translate(SkIntToScalar(10), SkIntToScalar(50));
-
- const SkScalar W = SkIntToScalar(fBitmaps[0].width() + 1);
- const SkScalar H = SkIntToScalar(fBitmaps[0].height() + 1);
- SkPaint paint;
-
- const SkScalar scale = 0.897917f;
- canvas->scale(SK_Scalar1, scale);
-
- for (int k = 0; k < 2; k++) {
- paint.setFilterQuality(k == 1 ? kLow_SkFilterQuality : kNone_SkFilterQuality);
- for (int j = 0; j < 2; j++) {
- paint.setDither(j == 1);
- for (int i = 0; i < (int)fBitmaps.size(); i++) {
- SkScalar x = (k * (int)fBitmaps.size() + j) * W;
- SkScalar y = i * H;
- x = SkScalarRoundToScalar(x);
- y = SkScalarRoundToScalar(y);
- canvas->drawBitmap(fBitmaps[i], x, y, &paint);
- SkFont font;
- font.setSize(SkIntToScalar(18));
- if (i == 0) {
- SkString s("dither=");
- s.appendS32(paint.isDither());
- s.append(" filter=");
- s.appendS32(paint.getFilterQuality() != kNone_SkFilterQuality);
- SkTextUtils::DrawString(canvas, s.c_str(), x + W/2, y - font.getSize(), font, SkPaint(),
- SkTextUtils::kCenter_Align);
- }
- if (k+j == 2) {
- SkString s;
- s.append(" depth=");
- s.appendS32(fBitmaps[i].colorType() == kRGB_565_SkColorType ? 16 : 32);
- SkTextUtils::DrawString(canvas, s.c_str(), x + W + SkIntToScalar(4), y + H/2, font, SkPaint());
- }
- }
- }
- }
- }
-};
-DEF_SAMPLE( return new Filter2View(); )
diff --git a/third_party/skia/samplecode/SampleFilterBounds.cpp b/third_party/skia/samplecode/SampleFilterBounds.cpp
new file mode 100644
index 0000000..682891c
--- /dev/null
+++ b/third_party/skia/samplecode/SampleFilterBounds.cpp
@@ -0,0 +1,259 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "samplecode/Sample.h"
+
+#include "include/core/SkBitmap.h"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRect.h"
+#include "include/effects/SkDashPathEffect.h"
+#include "include/effects/SkGradientShader.h"
+#include "include/effects/SkImageFilters.h"
+
+#include "src/core/SkImageFilterTypes.h"
+#include "src/core/SkImageFilter_Base.h"
+#include "src/core/SkMatrixPriv.h"
+
+#include "tools/ToolUtils.h"
+
+static constexpr float kLineHeight = 16.f;
+static constexpr float kLineInset = 8.f;
+
+static float print_size(SkCanvas* canvas, const char* prefix, const SkIRect& rect,
+ float x, float y, const SkFont& font, const SkPaint& paint) {
+ canvas->drawString(prefix, x, y, font, paint);
+ y += kLineHeight;
+ SkString sz;
+ sz.appendf("%d x %d", rect.width(), rect.height());
+ canvas->drawString(sz, x, y, font, paint);
+ return y + kLineHeight;
+}
+
+static float print_info(SkCanvas* canvas,
+ const SkIRect& layerContentBounds,
+ const SkIRect& outputBounds,
+ const SkIRect& hintedOutputBounds,
+ const SkIRect& unhintedLayerBounds) {
+ SkFont font(nullptr, 12);
+ SkPaint text;
+ text.setAntiAlias(true);
+
+ float y = kLineHeight;
+
+ text.setColor(SK_ColorRED);
+ y = print_size(canvas, "Content (in layer)", layerContentBounds, kLineInset, y, font, text);
+ text.setColor(SK_ColorDKGRAY);
+ y = print_size(canvas, "Target (in device)", outputBounds, kLineInset, y, font, text);
+ text.setColor(SK_ColorBLUE);
+ y = print_size(canvas, "Output (w/ hint)", hintedOutputBounds, kLineInset, y, font, text);
+ text.setColor(SK_ColorGREEN);
+ y = print_size(canvas, "Input (w/ no hint)", unhintedLayerBounds, kLineInset, y, font, text);
+
+ return y;
+}
+
+static void print_label(SkCanvas* canvas, float x, float y, float value) {
+ SkFont font(nullptr, 12);
+ SkPaint text;
+ text.setAntiAlias(true);
+
+ SkString label;
+ label.printf("%.3f", value);
+
+ canvas->drawString(label, x, y + kLineHeight / 2.f, font, text);
+}
+
+static SkPaint line_paint(SkColor color, bool dashed = false) {
+ SkPaint paint;
+ paint.setColor(color);
+ paint.setStrokeWidth(0.f);
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setAntiAlias(true);
+ if (dashed) {
+ SkScalar dash[2] = {10.f, 10.f};
+ paint.setPathEffect(SkDashPathEffect::Make(dash, 2, 0.f));
+ }
+ return paint;
+}
+
+static SkPath create_axis_path(const SkRect& rect, float axisSpace) {
+ SkPath localSpace;
+ for (float y = rect.fTop + axisSpace; y <= rect.fBottom; y += axisSpace) {
+ localSpace.moveTo(rect.fLeft, y);
+ localSpace.lineTo(rect.fRight, y);
+ }
+ for (float x = rect.fLeft + axisSpace; x <= rect.fRight; x += axisSpace) {
+ localSpace.moveTo(x, rect.fTop);
+ localSpace.lineTo(x, rect.fBottom);
+ }
+ return localSpace;
+}
+
+static const SkColor4f kScaleGradientColors[] =
+ { { 0.05f, 0.0f, 6.f, 1.f }, // Severe downscaling, s < 1/8, log(s) < -3
+ { 0.6f, 0.6f, 0.8f, 0.6f }, // Okay downscaling, s < 1/2, log(s) < -1
+ { 1.f, 1.f, 1.f, 0.2f }, // No scaling, s = 1, log(s) = 0
+ { 0.95f, 0.6f, 0.5f, 0.6f }, // Okay upscaling, s > 2, log(s) > 1
+ { 0.8f, 0.1f, 0.f, 1.f } }; // Severe upscaling, s > 8, log(s) > 3
+static const SkScalar kLogScaleFactors[] = { -3.f, -1.f, 0.f, 1.f, 3.f };
+static const SkScalar kGradientStops[] = { 0.f, 0.33333f, 0.5f, 0.66667f, 1.f };
+static const int kStopCount = (int) SK_ARRAY_COUNT(kScaleGradientColors);
+
+static void draw_scale_key(SkCanvas* canvas, float y) {
+ SkRect key = SkRect::MakeXYWH(15.f, y + 30.f, 15.f, 100.f);
+ SkPoint pts[] = {{key.centerX(), key.fTop}, {key.centerX(), key.fBottom}};
+ sk_sp<SkShader> gradient = SkGradientShader::MakeLinear(
+ pts, kScaleGradientColors, nullptr, kGradientStops, kStopCount, SkTileMode::kClamp,
+ SkGradientShader::kInterpolateColorsInPremul_Flag, nullptr);
+ SkPaint keyPaint;
+ keyPaint.setShader(gradient);
+ canvas->drawRect(key, keyPaint);
+ for (int i = 0; i < kStopCount; ++i) {
+ print_label(canvas, key.fRight + 5.f, key.fTop + kGradientStops[i] * key.height(),
+ SkScalarPow(2.f, kLogScaleFactors[i]));
+ }
+}
+
+static void draw_scale_factors(SkCanvas* canvas, const skif::Mapping& mapping, const SkRect& rect) {
+ SkPoint testPoints[5];
+ testPoints[0] = {rect.centerX(), rect.centerY()};
+ rect.toQuad(testPoints + 1);
+ for (int i = 0; i < 5; ++i) {
+ float scale = SkMatrixPriv::DifferentialAreaScale(
+ mapping.deviceMatrix(),
+ SkPoint(mapping.paramToLayer(skif::ParameterSpace<SkPoint>(testPoints[i]))));
+ SkColor4f color = {0.f, 0.f, 0.f, 1.f};
+
+ if (SkScalarIsFinite(scale)) {
+ float logScale = SkScalarLog2(scale);
+ for (int j = 0; j <= kStopCount; ++j) {
+ if (j == kStopCount) {
+ color = kScaleGradientColors[j - 1];
+ break;
+ } else if (kLogScaleFactors[j] >= logScale) {
+ if (j == 0) {
+ color = kScaleGradientColors[0];
+ } else {
+ SkScalar t = (logScale - kLogScaleFactors[j - 1]) /
+ (kLogScaleFactors[j] - kLogScaleFactors[j - 1]);
+
+ SkColor4f a = kScaleGradientColors[j - 1] * (1.f - t);
+ SkColor4f b = kScaleGradientColors[j] * t;
+ color = {a.fR + b.fR, a.fG + b.fG, a.fB + b.fB, a.fA + b.fA};
+ }
+ break;
+ }
+ }
+ }
+
+ SkPaint p;
+ p.setAntiAlias(true);
+ p.setColor4f(color, nullptr);
+ canvas->drawRect(SkRect::MakeLTRB(testPoints[i].fX - 4.f, testPoints[i].fY - 4.f,
+ testPoints[i].fX + 4.f, testPoints[i].fY + 4.f), p);
+ }
+}
+
+class FilterBoundsSample : public Sample {
+public:
+ FilterBoundsSample() {}
+
+ void onOnceBeforeDraw() override {
+ fBlur = SkImageFilters::Blur(8.f, 8.f, nullptr);
+ fImage = ToolUtils::create_checkerboard_image(
+ 300, 300, SK_ColorMAGENTA, SK_ColorLTGRAY, 50);
+ }
+
+ void onDrawContent(SkCanvas* canvas) override {
+ // The local content, e.g. what would be submitted to drawRect or the bounds to saveLayer
+ const SkRect localContentRect = SkRect::MakeLTRB(100.f, 20.f, 180.f, 140.f);
+ SkMatrix ctm = canvas->getLocalToDeviceAs3x3();
+
+ // Base rendering of a filter
+ SkPaint blurPaint;
+ blurPaint.setImageFilter(fBlur);
+ canvas->saveLayer(&localContentRect, &blurPaint);
+ canvas->drawImageRect(fImage.get(), localContentRect, localContentRect,
+ SkSamplingOptions(SkFilterMode::kLinear),
+ nullptr, SkCanvas::kFast_SrcRectConstraint);
+ canvas->restore();
+
+ // Now visualize the underlying bounds calculations used to determine the layer for the blur
+ SkIRect target = ctm.mapRect(localContentRect).roundOut();
+ if (!target.intersect(SkIRect::MakeWH(canvas->imageInfo().width(),
+ canvas->imageInfo().height()))) {
+ return;
+ }
+ skif::DeviceSpace<SkIRect> targetOutput(target);
+ skif::ParameterSpace<SkRect> contentBounds(localContentRect);
+ skif::ParameterSpace<SkPoint> contentCenter({localContentRect.centerX(),
+ localContentRect.centerY()});
+ skif::Mapping mapping;
+ SkAssertResult(mapping.decomposeCTM(ctm, fBlur.get(), contentCenter));
+
+ // Add axis lines, to show perspective distortion
+ canvas->save();
+ canvas->setMatrix(mapping.deviceMatrix());
+ canvas->drawPath(create_axis_path(SkRect(mapping.paramToLayer(contentBounds)), 20.f),
+ line_paint(SK_ColorGRAY));
+ canvas->restore();
+
+ // Visualize scale factors at the four corners and center of the local rect
+ draw_scale_factors(canvas, mapping, localContentRect);
+
+ // The device content rect, e.g. the clip bounds if 'localContentRect' were used as a clip
+ // before the draw or saveLayer, representing what the filter must cover if it affects
+ // transparent black or doesn't have a local content hint.
+ canvas->setMatrix(SkMatrix::I());
+ canvas->drawRect(ctm.mapRect(localContentRect), line_paint(SK_ColorDKGRAY));
+
+ // Layer bounds for the filter, in the layer space compatible with the filter's matrix
+ // type requirements.
+ skif::LayerSpace<SkIRect> targetOutputInLayer = mapping.deviceToLayer(targetOutput);
+ skif::LayerSpace<SkIRect> hintedLayerBounds = as_IFB(fBlur)->getInputBounds(
+ mapping, targetOutput, &contentBounds);
+ skif::LayerSpace<SkIRect> unhintedLayerBounds = as_IFB(fBlur)->getInputBounds(
+ mapping, targetOutput, nullptr);
+
+ canvas->setMatrix(mapping.deviceMatrix());
+ canvas->drawRect(SkRect::Make(SkIRect(targetOutputInLayer)),
+ line_paint(SK_ColorDKGRAY, true));
+ canvas->drawRect(SkRect::Make(SkIRect(hintedLayerBounds)), line_paint(SK_ColorRED));
+ canvas->drawRect(SkRect::Make(SkIRect(unhintedLayerBounds)), line_paint(SK_ColorGREEN));
+
+ // For visualization purposes, we want to show the layer-space output, this is what we get
+ // when contentBounds is provided as a hint in local/parameter space.
+ skif::Mapping layerOnly{mapping.layerMatrix()};
+ skif::DeviceSpace<SkIRect> hintedOutputBounds = as_IFB(fBlur)->getOutputBounds(
+ layerOnly, contentBounds);
+ canvas->drawRect(SkRect::Make(SkIRect(hintedOutputBounds)), line_paint(SK_ColorBLUE));
+
+ canvas->resetMatrix();
+ float y = print_info(canvas, SkIRect(mapping.paramToLayer(contentBounds).roundOut()),
+ SkIRect(targetOutput),
+ SkIRect(hintedOutputBounds),
+ SkIRect(unhintedLayerBounds));
+
+ // Draw color key for layer visualization
+ draw_scale_key(canvas, y);
+ }
+
+ SkString name() override { return SkString("FilterBounds"); }
+
+private:
+ sk_sp<SkImageFilter> fBlur;
+ sk_sp<SkImage> fImage;
+
+ using INHERITED = Sample;
+};
+
+DEF_SAMPLE(return new FilterBoundsSample();)
diff --git a/third_party/skia/samplecode/SampleFilterQuality.cpp b/third_party/skia/samplecode/SampleFilterQuality.cpp
deleted file mode 100644
index f18a1a6..0000000
--- a/third_party/skia/samplecode/SampleFilterQuality.cpp
+++ /dev/null
@@ -1,292 +0,0 @@
-/*
- * Copyright 2015 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/SkData.h"
-#include "include/core/SkFont.h"
-#include "include/core/SkPath.h"
-#include "include/core/SkSurface.h"
-#include "include/core/SkTime.h"
-#include "include/effects/SkGradientShader.h"
-#include "include/utils/SkInterpolator.h"
-#include "include/utils/SkRandom.h"
-#include "samplecode/Sample.h"
-#include "tools/Resources.h"
-#include "tools/timer/TimeUtils.h"
-
-static sk_sp<SkSurface> make_surface(SkCanvas* canvas, const SkImageInfo& info) {
- auto surface = canvas->makeSurface(info);
- if (!surface) {
- surface = SkSurface::MakeRaster(info);
- }
- return surface;
-}
-
-static sk_sp<SkShader> make_shader(const SkRect& bounds) {
- sk_sp<SkImage> image(GetResourceAsImage("images/mandrill_128.png"));
- return image ? image->makeShader() : nullptr;
-}
-
-#define N 128
-#define ANGLE_DELTA 3
-#define SCALE_DELTA (SK_Scalar1 / 32)
-
-static sk_sp<SkImage> make_image() {
- SkImageInfo info = SkImageInfo::MakeN32(N, N, kOpaque_SkAlphaType);
- auto surface(SkSurface::MakeRaster(info));
- SkCanvas* canvas = surface->getCanvas();
- canvas->drawColor(SK_ColorWHITE);
-
- SkPath path;
- path.setFillType(SkPathFillType::kEvenOdd);
-
- path.addRect(SkRect::MakeWH(N/2, N));
- path.addRect(SkRect::MakeWH(N, N/2));
- path.moveTo(0, 0); path.lineTo(N, 0); path.lineTo(0, N); path.close();
-
- SkPaint paint;
- paint.setShader(make_shader(SkRect::MakeWH(N, N)));
-
- canvas->drawPath(path, paint);
- return surface->makeImageSnapshot();
-}
-
-static sk_sp<SkImage> zoom_up(SkSurface* origSurf, SkImage* orig) {
- const SkScalar S = 16; // amount to scale up
- const int D = 2; // dimension scaling for the offscreen
- // since we only view the center, don't need to produce the entire thing
-
- SkImageInfo info = SkImageInfo::MakeN32(orig->width() * D, orig->height() * D,
- kOpaque_SkAlphaType);
- auto surface(origSurf->makeSurface(info));
- SkCanvas* canvas = surface->getCanvas();
- canvas->drawColor(SK_ColorWHITE);
- canvas->scale(S, S);
- canvas->translate(-SkScalarHalf(orig->width()) * (S - D) / S,
- -SkScalarHalf(orig->height()) * (S - D) / S);
- canvas->drawImage(orig, 0, 0, nullptr);
-
- if (S > 3) {
- SkPaint paint;
- paint.setColor(SK_ColorWHITE);
- for (int i = 1; i < orig->height(); ++i) {
- SkScalar y = SkIntToScalar(i);
- canvas->drawLine(0, y, SkIntToScalar(orig->width()), y, paint);
- }
- for (int i = 1; i < orig->width(); ++i) {
- SkScalar x = SkIntToScalar(i);
- canvas->drawLine(x, 0, x, SkIntToScalar(orig->height()), paint);
- }
- }
- return surface->makeImageSnapshot();
-}
-
-struct AnimValue {
- SkScalar fValue;
- SkScalar fMin;
- SkScalar fMax;
- SkScalar fMod;
-
- operator SkScalar() const { return fValue; }
-
- void set(SkScalar value, SkScalar min, SkScalar max) {
- fValue = value;
- fMin = min;
- fMax = max;
- fMod = 0;
- }
-
- void setMod(SkScalar value, SkScalar mod) {
- fValue = value;
- fMin = 0;
- fMax = 0;
- fMod = mod;
- }
-
- SkScalar inc(SkScalar delta) {
- fValue += delta;
- return this->fixUp();
- }
-
- SkScalar fixUp() {
- if (fMod) {
- fValue = SkScalarMod(fValue, fMod);
- } else {
- if (fValue > fMax) {
- fValue = fMax;
- } else if (fValue < fMin) {
- fValue = fMin;
- }
- }
- return fValue;
- }
-};
-
-static void draw_box_frame(SkCanvas* canvas, int width, int height) {
- SkPaint p;
- p.setStyle(SkPaint::kStroke_Style);
- p.setColor(SK_ColorRED);
- SkRect r = SkRect::MakeIWH(width, height);
- r.inset(0.5f, 0.5f);
- canvas->drawRect(r, p);
- canvas->drawLine(r.left(), r.top(), r.right(), r.bottom(), p);
- canvas->drawLine(r.left(), r.bottom(), r.right(), r.top(), p);
-}
-
-class FilterQualityView : public Sample {
- sk_sp<SkImage> fImage;
- AnimValue fScale, fAngle;
- SkSize fCell;
- SkInterpolator fTrans;
- SkMSec fCurrTime;
- bool fShowFatBits;
-
-public:
- FilterQualityView() : fTrans(2, 2), fShowFatBits(true) {
- fCell.set(256, 256);
-
- fScale.set(1, SK_Scalar1 / 8, 1);
- fAngle.setMod(0, 360);
-
- SkScalar values[2];
- fTrans.setMirror(true);
- fTrans.setReset(true);
-
- fCurrTime = 0;
-
- fTrans.setRepeatCount(999);
- values[0] = values[1] = 0;
- fTrans.setKeyFrame(0, fCurrTime, values);
- values[0] = values[1] = 1;
- fTrans.setKeyFrame(1, fCurrTime + 2000, values);
- }
-
-protected:
- SkString name() override { return SkString("FilterQuality"); }
-
- bool onChar(SkUnichar uni) override {
- switch (uni) {
- case '1': fAngle.inc(-ANGLE_DELTA); return true;
- case '2': fAngle.inc( ANGLE_DELTA); return true;
- case '3': fScale.inc(-SCALE_DELTA); return true;
- case '4': fScale.inc( SCALE_DELTA); return true;
- case '5': fShowFatBits = !fShowFatBits; return true;
- default: break;
- }
- return false;
- }
-
- void drawTheImage(SkCanvas* canvas, const SkISize& size, SkFilterQuality filter,
- SkScalar dx, SkScalar dy) {
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setFilterQuality(filter);
-
- SkAutoCanvasRestore acr(canvas, true);
-
- canvas->translate(dx, dy);
-
- canvas->translate(SkScalarHalf(size.width()), SkScalarHalf(size.height()));
- canvas->scale(fScale, fScale);
- canvas->rotate(fAngle);
- canvas->drawImage(fImage.get(), -SkScalarHalf(fImage->width()), -SkScalarHalf(fImage->height()),
- &paint);
-
- if (false) {
- acr.restore();
- draw_box_frame(canvas, size.width(), size.height());
- }
- }
-
- void drawHere(SkCanvas* canvas, SkFilterQuality filter, SkScalar dx, SkScalar dy) {
- SkCanvas* origCanvas = canvas;
- SkAutoCanvasRestore acr(canvas, true);
-
- SkISize size = SkISize::Make(fImage->width(), fImage->height());
-
- sk_sp<SkSurface> surface;
- if (fShowFatBits) {
- // scale up so we don't clip rotations
- SkImageInfo info = SkImageInfo::MakeN32(fImage->width() * 2, fImage->height() * 2,
- kOpaque_SkAlphaType);
- surface = make_surface(canvas, info);
- canvas = surface->getCanvas();
- canvas->drawColor(SK_ColorWHITE);
- size.set(info.width(), info.height());
- } else {
- canvas->translate(SkScalarHalf(fCell.width() - fImage->width()),
- SkScalarHalf(fCell.height() - fImage->height()));
- }
- this->drawTheImage(canvas, size, filter, dx, dy);
-
- if (surface) {
- sk_sp<SkImage> orig(surface->makeImageSnapshot());
- sk_sp<SkImage> zoomed(zoom_up(surface.get(), orig.get()));
- origCanvas->drawImage(zoomed.get(),
- SkScalarHalf(fCell.width() - zoomed->width()),
- SkScalarHalf(fCell.height() - zoomed->height()));
- }
- }
-
- void drawBorders(SkCanvas* canvas) {
- SkPaint p;
- p.setStyle(SkPaint::kStroke_Style);
- p.setColor(SK_ColorBLUE);
-
- SkRect r = SkRect::MakeWH(fCell.width() * 2, fCell.height() * 2);
- r.inset(SK_ScalarHalf, SK_ScalarHalf);
- canvas->drawRect(r, p);
- canvas->drawLine(r.left(), r.centerY(), r.right(), r.centerY(), p);
- canvas->drawLine(r.centerX(), r.top(), r.centerX(), r.bottom(), p);
- }
-
- void onOnceBeforeDraw() override {
- fImage = make_image();
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- fCell.set(this->height() / 2, this->height() / 2);
-
- SkScalar trans[2];
- fTrans.timeToValues(fCurrTime, trans);
-
- for (int y = 0; y < 2; ++y) {
- for (int x = 0; x < 2; ++x) {
- int index = y * 2 + x;
- SkAutoCanvasRestore acr(canvas, true);
- canvas->translate(fCell.width() * x, fCell.height() * y);
- SkRect r = SkRect::MakeWH(fCell.width(), fCell.height());
- r.inset(4, 4);
- canvas->clipRect(r);
- this->drawHere(canvas, SkFilterQuality(index), trans[0], trans[1]);
- }
- }
-
- this->drawBorders(canvas);
-
- const SkScalar textX = fCell.width() * 2 + 30;
-
- SkFont font(nullptr, 36);
- SkPaint paint;
- canvas->drawString(SkStringPrintf("%.8g", (float)fScale), textX, 100, font, paint);
- canvas->drawString(SkStringPrintf("%.8g", (float)fAngle), textX, 150, font, paint);
- canvas->drawString(SkStringPrintf("%.8g", trans[0] ), textX, 200, font, paint);
- canvas->drawString(SkStringPrintf("%.8g", trans[1] ), textX, 250, font, paint);
- }
-
- bool onAnimate(double nanos) override {
- fCurrTime = TimeUtils::NanosToMSec(nanos);
- return true;
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new FilterQualityView(); )
diff --git a/third_party/skia/samplecode/SampleFitCubicToCircle.cpp b/third_party/skia/samplecode/SampleFitCubicToCircle.cpp
new file mode 100644
index 0000000..84042e5
--- /dev/null
+++ b/third_party/skia/samplecode/SampleFitCubicToCircle.cpp
@@ -0,0 +1,257 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "samplecode/Sample.h"
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPath.h"
+#include <tuple>
+
+// Math constants are not always defined.
+#ifndef M_PI
+#define M_PI 3.14159265358979323846264338327950288
+#endif
+
+#ifndef M_SQRT2
+#define M_SQRT2 1.41421356237309504880168872420969808
+#endif
+
+constexpr static int kCenterX = 300;
+constexpr static int kCenterY = 325;
+constexpr static int kRadius = 250;
+
+// This sample fits a cubic to the arc between two interactive points on a circle. It also finds the
+// T-coordinate of max error, and outputs it and its value in pixels. (It turns out that max error
+// always occurs at T=0.21132486540519.)
+//
+// Press 'E' to iteratively cut the arc in half and report the improvement in max error after each
+// halving. (It turns out that max error improves by exactly 64x on every halving.)
+class SampleFitCubicToCircle : public Sample {
+ SkString name() override { return SkString("FitCubicToCircle"); }
+ void onOnceBeforeDraw() override { this->fitCubic(); }
+ void fitCubic();
+ void onDrawContent(SkCanvas*) override;
+ Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override;
+ bool onClick(Sample::Click*) override;
+ bool onChar(SkUnichar) override;
+
+ // Coordinates of two points on the unit circle. These are the two endpoints of the arc we fit.
+ double fEndptsX[2] = {0, 1};
+ double fEndptsY[2] = {-1, 0};
+
+ // Fitted cubic and info, set by fitCubic().
+ double fControlLength; // Length of (p1 - p0) and/or (p3 - p2) in unit circle space.
+ double fMaxErrorT; // T value where the cubic diverges most from the true arc.
+ std::array<double, 4> fCubicX; // Screen space cubic control points.
+ std::array<double, 4> fCubicY;
+ double fMaxError; // Max error (in pixels) between the cubic and the screen-space arc.
+ double fTheta; // Angle of the arc. This is only used for informational purposes.
+ SkTArray<SkString> fInfoStrings;
+
+ class Click;
+};
+
+// Fits a cubic to an arc on the unit circle with endpoints (x0, y0) and (x1, y1). Using the
+// following 3 constraints, we arrive at the formula used in the method:
+//
+// 1) The endpoints and tangent directions at the endpoints must match the arc.
+// 2) The cubic must be symmetric (i.e., length(p1 - p0) == length(p3 - p2)).
+// 3) The height of the cubic must match the height of the arc.
+//
+// Returns the "control length", or length of (p1 - p0) and/or (p3 - p2).
+static float fit_cubic_to_unit_circle(double x0, double y0, double x1, double y1,
+ std::array<double, 4>* X, std::array<double, 4>* Y) {
+ constexpr static double kM = -4.0/3;
+ constexpr static double kA = 4*M_SQRT2/3;
+ double d = x0*x1 + y0*y1;
+ double c = (std::sqrt(1 + d) * kM + kA) / std::sqrt(1 - d);
+ *X = {x0, x0 - y0*c, x1 + y1*c, x1};
+ *Y = {y0, y0 + x0*c, y1 - x1*c, y1};
+ return c;
+}
+
+static double lerp(double x, double y, double T) {
+ return x + T*(y - x);
+}
+
+// Evaluates the cubic and 1st and 2nd derivatives at T.
+static std::tuple<double, double, double> eval_cubic(double x[], double T) {
+ // Use De Casteljau's algorithm for better accuracy and stability.
+ double ab = lerp(x[0], x[1], T);
+ double bc = lerp(x[1], x[2], T);
+ double cd = lerp(x[2], x[3], T);
+ double abc = lerp(ab, bc, T);
+ double bcd = lerp(bc, cd, T);
+ double abcd = lerp(abc, bcd, T);
+ return {abcd, 3 * (bcd - abc) /*1st derivative.*/, 6 * (cd - 2*bc + ab) /*2nd derivative.*/};
+}
+
+// Uses newton-raphson convergence to find the point where the provided cubic diverges most from the
+// unit circle. i.e., the point where the derivative of error == 0. For error we use:
+//
+// error = x^2 + y^2 - 1
+// error' = 2xx' + 2yy'
+// error'' = 2xx'' + 2yy'' + 2x'^2 + 2y'^2
+//
+double find_max_error_T(double cubicX[4], double cubicY[4]) {
+ constexpr static double kInitialT = .25;
+ double T = kInitialT;
+ for (int i = 0; i < 64; ++i) {
+ auto [x, dx, ddx] = eval_cubic(cubicX, T);
+ auto [y, dy, ddy] = eval_cubic(cubicY, T);
+ double dError = 2*(x*dx + y*dy);
+ double ddError = 2*(x*ddx + y*ddy + dx*dx + dy*dy);
+ T -= dError / ddError;
+ }
+ return T;
+}
+
+void SampleFitCubicToCircle::fitCubic() {
+ fInfoStrings.reset();
+
+ std::array<double, 4> X, Y;
+ // "Control length" is the length of (p1 - p0) and/or (p3 - p2) in unit circle space.
+ fControlLength = fit_cubic_to_unit_circle(fEndptsX[0], fEndptsY[0], fEndptsX[1], fEndptsY[1],
+ &X, &Y);
+ fInfoStrings.push_back().printf("control length=%0.14f", fControlLength);
+
+ fMaxErrorT = find_max_error_T(X.data(), Y.data());
+ fInfoStrings.push_back().printf("max error T=%0.14f", fMaxErrorT);
+
+ for (int i = 0; i < 4; ++i) {
+ fCubicX[i] = X[i] * kRadius + kCenterX;
+ fCubicY[i] = Y[i] * kRadius + kCenterY;
+ }
+ double errX = std::get<0>(eval_cubic(fCubicX.data(), fMaxErrorT)) - kCenterX;
+ double errY = std::get<0>(eval_cubic(fCubicY.data(), fMaxErrorT)) - kCenterY;
+ fMaxError = std::sqrt(errX*errX + errY*errY) - kRadius;
+ fInfoStrings.push_back().printf("max error=%.5gpx", fMaxError);
+
+ fTheta = std::atan2(fEndptsY[1], fEndptsX[1]) - std::atan2(fEndptsY[0], fEndptsX[0]);
+ fTheta = std::abs(fTheta * 180/M_PI);
+ if (fTheta > 180) {
+ fTheta = 360 - fTheta;
+ }
+ fInfoStrings.push_back().printf("(theta=%.2f)", fTheta);
+
+ SkDebugf("\n");
+ for (const SkString& infoString : fInfoStrings) {
+ SkDebugf("%s\n", infoString.c_str());
+ }
+}
+
+void SampleFitCubicToCircle::onDrawContent(SkCanvas* canvas) {
+ canvas->clear(SK_ColorBLACK);
+
+ SkPaint circlePaint;
+ circlePaint.setColor(0x80ffffff);
+ circlePaint.setStyle(SkPaint::kStroke_Style);
+ circlePaint.setStrokeWidth(0);
+ circlePaint.setAntiAlias(true);
+ canvas->drawArc(SkRect::MakeXYWH(kCenterX - kRadius, kCenterY - kRadius, kRadius * 2,
+ kRadius * 2), 0, 360, false, circlePaint);
+
+ SkPaint cubicPaint;
+ cubicPaint.setColor(SK_ColorGREEN);
+ cubicPaint.setStyle(SkPaint::kStroke_Style);
+ cubicPaint.setStrokeWidth(10);
+ cubicPaint.setAntiAlias(true);
+ SkPath cubicPath;
+ cubicPath.moveTo(fCubicX[0], fCubicY[0]);
+ cubicPath.cubicTo(fCubicX[1], fCubicY[1], fCubicX[2], fCubicY[2], fCubicX[3], fCubicY[3]);
+ canvas->drawPath(cubicPath, cubicPaint);
+
+ SkPaint endpointsPaint;
+ endpointsPaint.setColor(SK_ColorBLUE);
+ endpointsPaint.setStrokeWidth(8);
+ endpointsPaint.setAntiAlias(true);
+ SkPoint points[2] = {{(float)fCubicX[0], (float)fCubicY[0]},
+ {(float)fCubicX[3], (float)fCubicY[3]}};
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, points, endpointsPaint);
+
+ SkPaint textPaint;
+ textPaint.setColor(SK_ColorWHITE);
+ constexpr static float kInfoTextSize = 16;
+ SkFont font(nullptr, kInfoTextSize);
+ int infoY = 10 + kInfoTextSize;
+ for (const SkString& infoString : fInfoStrings) {
+ canvas->drawString(infoString.c_str(), 10, infoY, font, textPaint);
+ infoY += kInfoTextSize * 3/2;
+ }
+}
+
+class SampleFitCubicToCircle::Click : public Sample::Click {
+public:
+ Click(int ptIdx) : fPtIdx(ptIdx) {}
+
+ void doClick(SampleFitCubicToCircle* that) {
+ double dx = fCurr.fX - kCenterX;
+ double dy = fCurr.fY - kCenterY;
+ double l = std::sqrt(dx*dx + dy*dy);
+ that->fEndptsX[fPtIdx] = dx/l;
+ that->fEndptsY[fPtIdx] = dy/l;
+ if (that->fEndptsX[0] * that->fEndptsY[1] - that->fEndptsY[0] * that->fEndptsX[1] < 0) {
+ std::swap(that->fEndptsX[0], that->fEndptsX[1]);
+ std::swap(that->fEndptsY[0], that->fEndptsY[1]);
+ fPtIdx = 1 - fPtIdx;
+ }
+ that->fitCubic();
+ }
+
+private:
+ int fPtIdx;
+};
+
+Sample::Click* SampleFitCubicToCircle::onFindClickHandler(SkScalar x, SkScalar y,
+ skui::ModifierKey) {
+ double dx0 = x - fCubicX[0];
+ double dy0 = y - fCubicY[0];
+ double dx3 = x - fCubicX[3];
+ double dy3 = y - fCubicY[3];
+ if (dx0*dx0 + dy0*dy0 < dx3*dx3 + dy3*dy3) {
+ return new Click(0);
+ } else {
+ return new Click(1);
+ }
+}
+
+bool SampleFitCubicToCircle::onClick(Sample::Click* click) {
+ Click* myClick = (Click*)click;
+ myClick->doClick(this);
+ return true;
+}
+
+bool SampleFitCubicToCircle::onChar(SkUnichar unichar) {
+ if (unichar == 'E') {
+ constexpr static double kMaxErrorT = 0.21132486540519; // Always the same.
+ // Split the arc in half until error =~0, and report the improvement after each halving.
+ double lastError = -1;
+ for (double theta = fTheta; lastError != 0; theta /= 2) {
+ double rads = theta * M_PI/180;
+ std::array<double, 4> X, Y;
+ fit_cubic_to_unit_circle(1, 0, std::cos(rads), std::sin(rads), &X, &Y);
+ auto [x, dx, ddx] = eval_cubic(X.data(), kMaxErrorT);
+ auto [y, dy, ddy] = eval_cubic(Y.data(), kMaxErrorT);
+ double error = std::sqrt(x*x + y*y) * kRadius - kRadius;
+ if ((float)error <= 0) {
+ error = 0;
+ }
+ SkDebugf("%6.2f degrees: error= %10.5gpx", theta, error);
+ if (lastError > 0) {
+ SkDebugf(" (%17.14fx improvement)", lastError / error);
+ }
+ SkDebugf("\n");
+ lastError = error;
+ }
+ return true;
+ }
+ return false;
+}
+
+DEF_SAMPLE(return new SampleFitCubicToCircle;)
diff --git a/third_party/skia/samplecode/SampleFlutterAnimate.cpp b/third_party/skia/samplecode/SampleFlutterAnimate.cpp
index e3e53e0..48198bf 100644
--- a/third_party/skia/samplecode/SampleFlutterAnimate.cpp
+++ b/third_party/skia/samplecode/SampleFlutterAnimate.cpp
@@ -16,10 +16,6 @@
#include "samplecode/Sample.h"
#include "tools/timer/Timer.h"
-#if SK_SUPPORT_GPU
-#include "include/gpu/GrContext.h"
-#endif
-
// Create an animation of a bunch of letters that rotate in place. This is intended to stress
// the glyph atlas and test that we don't see corruption or bad slowdowns.
class FlutterAnimateView : public Sample {
@@ -37,7 +33,6 @@
void onDrawContent(SkCanvas* canvas) override {
SkFont font(fTypeface, 50);
SkPaint paint;
- paint.setFilterQuality(kMedium_SkFilterQuality);
// rough center of each glyph
static constexpr auto kMidX = 35;
@@ -79,7 +74,7 @@
}
}
- static constexpr double kDuration = 5.0;
+ inline static constexpr double kDuration = 5.0;
double fCurrTime;
double fResetTime;
SkRandom fRand;
@@ -91,10 +86,10 @@
SkScalar fEndRotation;
};
sk_sp<SkTypeface> fTypeface;
- static constexpr int kNumChars = 40;
+ inline static constexpr int kNumChars = 40;
AnimatedChar fChars[kNumChars];
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleFontCache.cpp b/third_party/skia/samplecode/SampleFontCache.cpp
deleted file mode 100644
index 9f39e9c..0000000
--- a/third_party/skia/samplecode/SampleFontCache.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright 2011 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/SkGraphics.h"
-#include "include/utils/SkRandom.h"
-#include "samplecode/Sample.h"
-
-#include <pthread.h>
-
-static void call_measure() {
- SkPaint paint;
- uint16_t text[32];
- SkRandom rand;
-
- paint.setAntiAlias(true);
- paint.setTextEncoding(SkTextEncoding::kUTF16);
- for (int j = 0; j < SK_ARRAY_COUNT(text); j++)
- text[j] = (uint16_t)((rand.nextU() & 0xFF) + 32);
-
- for (int i = 9; i < 36; i++) {
- SkFontMetrics m;
-
- paint.setTextSize(SkIntToScalar(i));
- paint.getFontMetrics(&m);
- paint.measureText(text, sizeof(text));
- }
-}
-
-static void call_draw(SkCanvas* canvas) {
- SkPaint paint;
- uint16_t text[32];
- SkRandom rand;
-
- paint.setAntiAlias(true);
- paint.setTextEncoding(SkTextEncoding::kUTF16);
- for (int j = 0; j < SK_ARRAY_COUNT(text); j++)
- text[j] = (uint16_t)((rand.nextU() & 0xFF) + 32);
-
- SkScalar x = SkIntToScalar(10);
- SkScalar y = SkIntToScalar(20);
-
- canvas->drawColor(SK_ColorWHITE);
- for (int i = 9; i < 36; i++)
- {
- SkFontMetrics m;
-
- paint.setTextSize(SkIntToScalar(i));
- paint.getFontMetrics(&m);
- canvas->drawText(text, sizeof(text), x, y, paint);
- y += m.fDescent - m.fAscent;
- }
-}
-
-static bool gDone;
-
-static void* measure_proc(void* context) {
- while (!gDone) {
- call_measure();
- }
- return nullptr;
-}
-
-static void* draw_proc(void* context) {
- SkBitmap* bm = (SkBitmap*)context;
- SkCanvas canvas(*bm);
-
- while (!gDone) {
- call_draw(&canvas);
- }
- return nullptr;
-}
-
-class FontCacheView : public Sample {
-public:
- enum { N = 4 };
-
- pthread_t fMThreads[N];
- pthread_t fDThreads[N];
- SkBitmap fBitmaps[N];
-
- FontCacheView() {
- gDone = false;
- for (int i = 0; i < N; i++) {
- int status;
-
- status = pthread_create(&fMThreads[i], nullptr, measure_proc, nullptr);
- SkASSERT(0 == status);
-
- fBitmaps[i].allocPixels(SkImageInfo::Make(320, 240,
- kRGB_565_SkColorType,
- kOpaque_SkAlphaType));
- status = pthread_create(&fDThreads[i], nullptr, draw_proc, &fBitmaps[i]);
- SkASSERT(0 == status);
- }
- this->setBGColor(0xFFDDDDDD);
- }
-
- virtual ~FontCacheView() {
- gDone = true;
- for (int i = 0; i < N; i++) {
- void* ret;
- int status = pthread_join(fMThreads[i], &ret);
- SkASSERT(0 == status);
- status = pthread_join(fDThreads[i], &ret);
- SkASSERT(0 == status);
- }
- }
-
-protected:
- SkString name() override { return SkString("FontCache"); }
-
- virtual void onDrawContent(SkCanvas* canvas) {
- SkScalar x = 0;
- SkScalar y = 0;
- for (int i = 0; i < N; i++) {
- canvas->drawBitmap(fBitmaps[i], x, y);
- x += SkIntToScalar(fBitmaps[i].width());
- }
- this->inval(nullptr);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-static Sample* MyFactory() { return new FontCacheView; }
-static SampleRegister reg(MyFactory);
diff --git a/third_party/skia/samplecode/SampleGlyphTransform.cpp b/third_party/skia/samplecode/SampleGlyphTransform.cpp
index 2260a1a..cd7191b 100644
--- a/third_party/skia/samplecode/SampleGlyphTransform.cpp
+++ b/third_party/skia/samplecode/SampleGlyphTransform.cpp
@@ -1,4 +1,4 @@
-/*
+/*
* Copyright 2018 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
@@ -75,7 +75,7 @@
SkScalar fScale;
SkScalar fRotate;
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleGradients.cpp b/third_party/skia/samplecode/SampleGradients.cpp
index 9eb4e71..a101ec3 100644
--- a/third_party/skia/samplecode/SampleGradients.cpp
+++ b/third_party/skia/samplecode/SampleGradients.cpp
@@ -149,13 +149,13 @@
canvas->restore();
canvas->translate(0, SkIntToScalar(370));
- if (false) { // avoid bit rot, suppress warning
+ if ((false)) { // avoid bit rot, suppress warning
test_alphagradients(canvas);
}
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleHT.cpp b/third_party/skia/samplecode/SampleHT.cpp
deleted file mode 100644
index bec4a7d..0000000
--- a/third_party/skia/samplecode/SampleHT.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * Copyright 2014 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/SkDrawable.h"
-#include "include/core/SkPictureRecorder.h"
-#include "include/utils/SkInterpolator.h"
-#include "include/utils/SkRandom.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkPointPriv.h"
-#include "tools/timer/TimeUtils.h"
-
-const SkRect gUnitSquare = { -1, -1, 1, 1 };
-
-static void color_to_floats(SkColor c, SkScalar f[4]) {
- f[0] = SkIntToScalar(SkColorGetA(c));
- f[1] = SkIntToScalar(SkColorGetR(c));
- f[2] = SkIntToScalar(SkColorGetG(c));
- f[3] = SkIntToScalar(SkColorGetB(c));
-}
-
-static SkColor floats_to_color(const SkScalar f[4]) {
- return SkColorSetARGB(SkScalarRoundToInt(f[0]),
- SkScalarRoundToInt(f[1]),
- SkScalarRoundToInt(f[2]),
- SkScalarRoundToInt(f[3]));
-}
-
-static bool oval_contains(const SkRect& r, SkScalar x, SkScalar y) {
- SkMatrix m;
- m.setRectToRect(r, gUnitSquare, SkMatrix::kFill_ScaleToFit);
- SkPoint pt;
- m.mapXY(x, y, &pt);
- return SkPointPriv::LengthSqd(pt) <= 1;
-}
-
-static SkColor rand_opaque_color(uint32_t seed) {
- SkRandom rand(seed);
- return rand.nextU() | (0xFF << 24);
-}
-
-class HTDrawable : public SkDrawable {
- SkRect fR;
- SkColor fColor;
- SkInterpolator* fInterp;
- SkMSec fTime;
-
-public:
- HTDrawable(SkRandom& rand) {
- fR = SkRect::MakeXYWH(rand.nextRangeF(0, 640), rand.nextRangeF(0, 480),
- rand.nextRangeF(20, 200), rand.nextRangeF(20, 200));
- fColor = rand_opaque_color(rand.nextU());
- fInterp = nullptr;
- fTime = 0;
- }
-
- void spawnAnimation(SkMSec now) {
- this->setTime(now);
-
- delete fInterp;
- fInterp = new SkInterpolator(5, 3);
- SkScalar values[5];
- color_to_floats(fColor, values); values[4] = 0;
- fInterp->setKeyFrame(0, now, values);
- values[0] = 0; values[4] = 180;
- fInterp->setKeyFrame(1, now + 1000, values);
- color_to_floats(rand_opaque_color(fColor), values); values[4] = 360;
- fInterp->setKeyFrame(2, now + 2000, values);
-
- fInterp->setMirror(true);
- fInterp->setRepeatCount(3);
-
- this->notifyDrawingChanged();
- }
-
- bool hitTest(SkScalar x, SkScalar y) {
- return oval_contains(fR, x, y);
- }
-
- void setTime(SkMSec time) { fTime = time; }
-
- void onDraw(SkCanvas* canvas) override {
- SkAutoCanvasRestore acr(canvas, false);
-
- SkPaint paint;
- paint.setAntiAlias(true);
-
- if (fInterp) {
- SkScalar values[5];
- SkInterpolator::Result res = fInterp->timeToValues(fTime, values);
- fColor = floats_to_color(values);
-
- canvas->save();
- canvas->rotate(values[4], fR.centerX(), fR.centerY());
-
- switch (res) {
- case SkInterpolator::kFreezeEnd_Result:
- delete fInterp;
- fInterp = nullptr;
- break;
- default:
- break;
- }
- }
- paint.setColor(fColor);
- canvas->drawRect(fR, paint);
- }
-
- SkRect onGetBounds() override { return fR; }
-};
-
-class HTView : public Sample {
-public:
- enum {
- N = 50,
- W = 640,
- H = 480,
- };
-
- struct Rec {
- HTDrawable* fDrawable;
- };
- Rec fArray[N];
- sk_sp<SkDrawable> fRoot;
- SkMSec fTime;
-
- HTView() {
- SkRandom rand;
-
- SkPictureRecorder recorder;
- SkCanvas* canvas = recorder.beginRecording(SkRect::MakeWH(W, H));
- for (int i = 0; i < N; ++i) {
- fArray[i].fDrawable = new HTDrawable(rand);
- canvas->drawDrawable(fArray[i].fDrawable);
- fArray[i].fDrawable->unref();
- }
- fRoot = recorder.finishRecordingAsDrawable();
- }
-
-protected:
- SkString name() override { return SkString("HT"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawDrawable(fRoot.get());
- }
-
- bool onAnimate(double nanos) override {
- fTime = TimeUtils::NanosToMSec(nanos);
- for (int i = 0; i < N; ++i) {
- fArray[i].fDrawable->setTime(fTime);
- }
- return true;
- }
-
- Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
- // search backwards to find the top-most
- for (int i = N - 1; i >= 0; --i) {
- if (fArray[i].fDrawable->hitTest(x, y)) {
- fArray[i].fDrawable->spawnAnimation(fTime);
- break;
- }
- }
- return nullptr;
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new HTView(); )
diff --git a/third_party/skia/samplecode/SampleHairCurves.cpp b/third_party/skia/samplecode/SampleHairCurves.cpp
index 73a6aee..cdb8ed8 100644
--- a/third_party/skia/samplecode/SampleHairCurves.cpp
+++ b/third_party/skia/samplecode/SampleHairCurves.cpp
@@ -114,7 +114,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleHairModes.cpp b/third_party/skia/samplecode/SampleHairModes.cpp
index 5df28f5..6e05fbc 100644
--- a/third_party/skia/samplecode/SampleHairModes.cpp
+++ b/third_party/skia/samplecode/SampleHairModes.cpp
@@ -61,10 +61,8 @@
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC, 0xCC, 0xCC);
- SkMatrix m;
- m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-
- return bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
+ return bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, SkSamplingOptions(),
+ SkMatrix::Scale(6, 6));
}
class HairModesView : public Sample {
@@ -108,7 +106,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleHairline.cpp b/third_party/skia/samplecode/SampleHairline.cpp
deleted file mode 100644
index a43ac44..0000000
--- a/third_party/skia/samplecode/SampleHairline.cpp
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- * Copyright 2011 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/SkBitmap.h"
-#include "include/core/SkCanvas.h"
-#include "include/core/SkColorFilter.h"
-#include "include/core/SkColorPriv.h"
-#include "include/core/SkGraphics.h"
-#include "include/core/SkPath.h"
-#include "include/core/SkRegion.h"
-#include "include/core/SkShader.h"
-#include "include/core/SkStream.h"
-#include "include/core/SkTime.h"
-#include "include/core/SkTypeface.h"
-#include "include/effects/SkCornerPathEffect.h"
-#include "include/effects/SkGradientShader.h"
-#include "include/private/SkTo.h"
-#include "include/utils/SkRandom.h"
-#include "samplecode/Sample.h"
-#include "src/utils/SkUTF.h"
-
-static SkRandom gRand;
-
-static void generate_pts(SkPoint pts[], int count, int w, int h) {
- for (int i = 0; i < count; i++) {
- pts[i].set(gRand.nextUScalar1() * 3 * w - SkIntToScalar(w),
- gRand.nextUScalar1() * 3 * h - SkIntToScalar(h));
- }
-}
-
-static bool check_zeros(const SkPMColor pixels[], int count, int skip) {
- for (int i = 0; i < count; i++) {
- if (*pixels) {
- return false;
- }
- pixels += skip;
- }
- return true;
-}
-
-static bool check_bitmap_margin(const SkBitmap& bm, int margin) {
- size_t rb = bm.rowBytes();
- for (int i = 0; i < margin; i++) {
- if (!check_zeros(bm.getAddr32(0, i), bm.width(), 1)) {
- return false;
- }
- int bottom = bm.height() - i - 1;
- if (!check_zeros(bm.getAddr32(0, bottom), bm.width(), 1)) {
- return false;
- }
- // left column
- if (!check_zeros(bm.getAddr32(i, 0), bm.height(), SkToInt(rb >> 2))) {
- return false;
- }
- int right = bm.width() - margin + i;
- if (!check_zeros(bm.getAddr32(right, 0), bm.height(),
- SkToInt(rb >> 2))) {
- return false;
- }
- }
- return true;
-}
-
-#define WIDTH 620
-#define HEIGHT 460
-#define MARGIN 10
-
-static void line_proc(SkCanvas* canvas, const SkPaint& paint,
- const SkBitmap& bm) {
- const int N = 2;
- SkPoint pts[N];
- for (int i = 0; i < 400; i++) {
- generate_pts(pts, N, WIDTH, HEIGHT);
-
- canvas->drawLine(pts[0], pts[1], paint);
- if (!check_bitmap_margin(bm, MARGIN)) {
- SkDebugf("---- hairline failure (%g %g) (%g %g)\n",
- pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY);
- break;
- }
- }
-}
-
-static void poly_proc(SkCanvas* canvas, const SkPaint& paint,
- const SkBitmap& bm) {
- const int N = 8;
- SkPoint pts[N];
- for (int i = 0; i < 50; i++) {
- generate_pts(pts, N, WIDTH, HEIGHT);
-
- SkPath path;
- path.moveTo(pts[0]);
- for (int j = 1; j < N; j++) {
- path.lineTo(pts[j]);
- }
- canvas->drawPath(path, paint);
- }
-}
-
-static SkPoint ave(const SkPoint& a, const SkPoint& b) {
- SkPoint c = a + b;
- c.fX = SkScalarHalf(c.fX);
- c.fY = SkScalarHalf(c.fY);
- return c;
-}
-
-static void quad_proc(SkCanvas* canvas, const SkPaint& paint,
- const SkBitmap& bm) {
- const int N = 30;
- SkPoint pts[N];
- for (int i = 0; i < 10; i++) {
- generate_pts(pts, N, WIDTH, HEIGHT);
-
- SkPath path;
- path.moveTo(pts[0]);
- for (int j = 1; j < N - 2; j++) {
- path.quadTo(pts[j], ave(pts[j], pts[j+1]));
- }
- path.quadTo(pts[N - 2], pts[N - 1]);
-
- canvas->drawPath(path, paint);
- }
-}
-
-static void add_cubic(SkPath* path, const SkPoint& mid, const SkPoint& end) {
- SkPoint start;
- path->getLastPt(&start);
- path->cubicTo(ave(start, mid), ave(mid, end), end);
-}
-
-static void cube_proc(SkCanvas* canvas, const SkPaint& paint,
- const SkBitmap& bm) {
- const int N = 30;
- SkPoint pts[N];
- for (int i = 0; i < 10; i++) {
- generate_pts(pts, N, WIDTH, HEIGHT);
-
- SkPath path;
- path.moveTo(pts[0]);
- for (int j = 1; j < N - 2; j++) {
- add_cubic(&path, pts[j], ave(pts[j], pts[j+1]));
- }
- add_cubic(&path, pts[N - 2], pts[N - 1]);
-
- canvas->drawPath(path, paint);
- }
-}
-
-typedef void (*HairProc)(SkCanvas*, const SkPaint&, const SkBitmap&);
-
-static const struct {
- const char* fName;
- HairProc fProc;
-} gProcs[] = {
- { "line", line_proc },
- { "poly", poly_proc },
- { "quad", quad_proc },
- { "cube", cube_proc },
-};
-
-static int cycle_hairproc_index(int index) {
- return (index + 1) % SK_ARRAY_COUNT(gProcs);
-}
-
-class HairlineView : public Sample {
- SkMSec fNow;
- int fProcIndex;
- bool fDoAA;
-public:
- HairlineView() {
- fProcIndex = 0;
- fDoAA = true;
- fNow = 0;
- }
-
-protected:
- SkString name() override { return SkStringPrintf("Hair-%s", gProcs[fProcIndex].fName); }
-
- void show_bitmaps(SkCanvas* canvas, const SkBitmap& b0, const SkBitmap& b1,
- const SkIRect& inset) {
- canvas->drawBitmap(b0, 0, 0, nullptr);
- canvas->drawBitmap(b1, SkIntToScalar(b0.width()), 0, nullptr);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- gRand.setSeed(fNow);
-
- SkBitmap bm, bm2;
- bm.allocN32Pixels(WIDTH + MARGIN*2, HEIGHT + MARGIN*2);
- // this will erase our margin, which we want to always stay 0
- bm.eraseColor(SK_ColorTRANSPARENT);
-
- bm2.installPixels(SkImageInfo::MakeN32Premul(WIDTH, HEIGHT),
- bm.getAddr32(MARGIN, MARGIN), bm.rowBytes());
-
- SkCanvas c2(bm2);
- SkPaint paint;
- paint.setAntiAlias(fDoAA);
- paint.setStyle(SkPaint::kStroke_Style);
-
- bm2.eraseColor(SK_ColorTRANSPARENT);
- gProcs[fProcIndex].fProc(&c2, paint, bm);
- canvas->drawBitmap(bm2, SkIntToScalar(10), SkIntToScalar(10), nullptr);
- }
-
- bool onAnimate(double /*nanos*/) override {
- if (fDoAA) {
- fProcIndex = cycle_hairproc_index(fProcIndex);
- // todo: signal that we want to rebuild our TITLE
- }
- fDoAA = !fDoAA;
- return true;
- }
-
- Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
- fDoAA = !fDoAA;
- return this->INHERITED::onFindClickHandler(x, y, modi);
- }
-
-
-private:
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new HairlineView(); )
diff --git a/third_party/skia/samplecode/SampleIdentityScale.cpp b/third_party/skia/samplecode/SampleIdentityScale.cpp
deleted file mode 100644
index 4e7b1dd..0000000
--- a/third_party/skia/samplecode/SampleIdentityScale.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright 2014 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/SkColorPriv.h"
-#include "include/core/SkFont.h"
-#include "include/core/SkPath.h"
-#include "include/core/SkStream.h"
-#include "include/core/SkTime.h"
-#include "include/effects/SkBlurMaskFilter.h"
-#include "include/utils/SkRandom.h"
-#include "samplecode/DecodeFile.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkClipOpPriv.h"
-#include "tools/Resources.h"
-
-// Intended to exercise pixel snapping observed with scaled images (and
-// with non-scaled images, but for a different reason): Bug 1145
-
-class IdentityScaleView : public Sample {
-public:
- IdentityScaleView(const char imageFilename[]) {
- if (!DecodeDataToBitmap(GetResourceAsData(imageFilename), &fBM)) {
- fBM.allocN32Pixels(1, 1);
- *(fBM.getAddr32(0,0)) = 0xFF0000FF; // red == bad
- }
- }
-
-protected:
- SkBitmap fBM;
-
- SkString name() override { return SkString("IdentityScale"); }
-
- void onDrawContent(SkCanvas* canvas) override {
-
- SkFont font(nullptr, 48);
- SkPaint paint;
-
- paint.setAntiAlias(true);
- paint.setFilterQuality(kHigh_SkFilterQuality);
-
- SkTime::DateTime time;
- SkTime::GetDateTime(&time);
-
- bool use_scale = (time.fSecond % 2 == 1);
- const char *text;
-
- canvas->save();
- if (use_scale) {
- text = "Scaled = 1";
- } else {
-
- SkRect r = { 100, 100, 356, 356 };
- SkPath clipPath;
- clipPath.addRoundRect(r, SkIntToScalar(5), SkIntToScalar(5));
- canvas->clipPath(clipPath, kIntersect_SkClipOp, true);
- text = "Scaled = 0";
- }
- canvas->drawBitmap( fBM, 100, 100, &paint );
- canvas->restore();
- canvas->drawString(text, 100, 400, font, paint);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new IdentityScaleView("images/mandrill_256.png"); )
diff --git a/third_party/skia/samplecode/SampleImageFilterDAG.cpp b/third_party/skia/samplecode/SampleImageFilterDAG.cpp
index 41340b6..3c925d1 100644
--- a/third_party/skia/samplecode/SampleImageFilterDAG.cpp
+++ b/third_party/skia/samplecode/SampleImageFilterDAG.cpp
@@ -42,224 +42,89 @@
int fDepth;
// The source content rect (this is the same for all nodes, but is stored here for convenience)
- SkRect fContent;
- // The portion of the original CTM that is kept as the local matrix/ctm when filtering
- SkMatrix fLocalCTM;
- // The portion of the original CTM that the results should be drawn with (or given current
- // canvas impl., the portion of the CTM that is baked into a new DAG)
- SkMatrix fRemainingCTM;
+ skif::ParameterSpace<SkRect> fContent;
+ // The mapping for the filter dag (same for all nodes, but stored here for convenience)
+ skif::Mapping fMapping;
- // Cached reverse bounds using device-space clip bounds (e.g. SkCanvas::clipRectBounds with
- // null first argument). This represents the layer calculated in SkCanvas for the filtering.
- // FIXME: SkCanvas (and this sample), this is seeded with the device-space clip bounds so that
- // the implicit matrix node's reverse bounds are updated appropriately when it recurses to the
- // original root node.
- SkIRect fLayerBounds;
+ // Cached reverse bounds using device-space clip bounds (e.g. no local bounds hint passed to
+ // saveLayer). This represents the layer calculated in SkCanvas for the filtering.
+ skif::LayerSpace<SkIRect> fUnhintedLayerBounds;
- // Cached reverse bounds using the local draw bounds (e.g. SkCanvas::clipRectBounds with the
- // draw bounds provided as first argument). For intermediate nodes in a DAG, this is calculated
- // to match what the filter would compute when being evaluated as part of the original DAG
- // (i.e. if the implicit matrix filter node were not inserted at the beginning).
- // fReverseLocalIsolatedBounds is the same, except it represents what would be calculated if
- // only this node were being applied as the image filter.
- SkIRect fReverseLocalBounds;
- SkIRect fReverseLocalIsolatedBounds;
+ // Cached input bounds using the local draw bounds (e.g. saveLayer with a bounds rect, or
+ // an auto-layer for a draw with image filter). This represents the layer bounds up to this
+ // point of the DAG.
+ skif::LayerSpace<SkIRect> fHintedLayerBounds;
- // Cached forward bounds based on local draw bounds. For intermediate nodes in a DAG, this is
- // calculated to match what the filter computes as part of the whole DAG. fForwardIsolatedBounds
- // is the same but represents what would be calculated if only this node were applied.
- SkIRect fForwardBounds;
- SkIRect fForwardIsolatedBounds;
+ // Cached output bounds based on local draw bounds. This represents the output up to this
+ // point of the DAG.
+ skif::LayerSpace<SkIRect> fOutputBounds;
- // Should be called after the input nodes have been created since this will complete the
- // entire tree.
- void computeBounds() {
- // In normal usage, forward bounds are filter-space bounds of the geometry content, so
- // fContent mapped by the local matrix, since we assume the layer content is made by
- // concat(localCTM) -> clipRect(content) -> drawRect(content).
- // Similarly, in normal usage, reverse bounds are the filter-space bounds of the space to
- // be filled by image filter results. Since the clip rect is set to the same as the content,
- // it's the same bounds forward or reverse in this contrived case.
- SkIRect inputRect;
- fLocalCTM.mapRect(fContent).roundOut(&inputRect);
-
- this->computeForwardBounds(inputRect);
-
- // The layer bounds (matching what SkCanvas computes), use the content rect mapped by the
- // entire CTM as its input rect. If this is an implicit matrix node, the computeReverseX
- // functions will switch to using the local-mapped bounds for children in order to simulate
- // what would happen if the last step were done as a draw. When there's no implicit matrix
- // node, this calculated rectangle is the same as inputRect.
- SkIRect deviceRect;
- SkMatrix ctm = SkMatrix::Concat(fRemainingCTM, fLocalCTM);
- ctm.mapRect(fContent).roundOut(&deviceRect);
-
- SkASSERT(this->isImplicitMatrixNode() || inputRect == deviceRect);
- this->computeReverseLocalIsolatedBounds(deviceRect);
- this->computeReverseBounds(deviceRect, false);
- // Unlike the above two calls, calculating layer bounds will keep the device bounds for
- // intermediate nodes to show the current SkCanvas behavior vs. the ideal
- this->computeReverseBounds(deviceRect, true);
- }
-
- bool isImplicitMatrixNode() const {
- // In the future we wish to replace the implicit matrix node with direct draws to the final
- // destination (instead of using an SkMatrixImageFilter). Visualizing the DAG correctly
- // requires handling these nodes differently since it has part of the canvas CTM built in.
- return fDepth == 1 && !fRemainingCTM.isIdentity();
+ FilterNode(const SkImageFilter* filter,
+ const skif::Mapping& mapping,
+ const skif::ParameterSpace<SkRect>& content,
+ int depth)
+ : fFilter(sk_ref_sp(filter))
+ , fDepth(depth)
+ , fContent(content)
+ , fMapping(mapping) {
+ this->computeInputBounds();
+ this->computeOutputBounds();
+ if (fFilter) {
+ fInputNodes.reserve_back(fFilter->countInputs());
+ for (int i = 0; i < fFilter->countInputs(); ++i) {
+ fInputNodes.emplace_back(fFilter->getInput(i), mapping, content, depth + 1);
+ }
+ }
}
private:
- void computeForwardBounds(const SkIRect srcRect) {
+ void computeOutputBounds() {
if (fFilter) {
- // For forward filtering, the leaves of the DAG are evaluated first and are then
- // propagated to the root. This means that every filter's filterBounds() function sees
- // the original src rect. It is never dependent on the parent node (unlike reverse
- // filtering), so calling filterBounds() on an intermediate node gives us the correct
- // intermediate values.
- fForwardBounds = fFilter->filterBounds(
- srcRect, fLocalCTM, SkImageFilter::kForward_MapDirection, nullptr);
-
- // For isolated forward filtering, it uses the same input but should not be propagated
- // to the inputs, so get the filter node bounds directly.
- fForwardIsolatedBounds = as_IFB(fFilter)->filterNodeBounds(
- srcRect, fLocalCTM, SkImageFilter::kForward_MapDirection, nullptr);
+ // For visualization purposes, we want the output bounds in layer space, before it's
+ // been transformed to device space. To achieve that, we mock a new mapping with the
+ // identity matrix transform.
+ skif::Mapping layerOnly{fMapping.layerMatrix()};
+ skif::DeviceSpace<SkIRect> pseudoDeviceBounds =
+ as_IFB(fFilter)->getOutputBounds(layerOnly, fContent);
+ // Since layerOnly's device matrix is I, this is effectively a cast to layer space
+ fOutputBounds = layerOnly.deviceToLayer(pseudoDeviceBounds);
} else {
- fForwardBounds = srcRect;
- fForwardIsolatedBounds = srcRect;
+ fOutputBounds = fMapping.paramToLayer(fContent).roundOut();
}
// Fill in children
for (int i = 0; i < fInputNodes.count(); ++i) {
- fInputNodes[i].computeForwardBounds(srcRect);
+ fInputNodes[i].computeOutputBounds();
}
}
- void computeReverseLocalIsolatedBounds(const SkIRect& srcRect) {
- if (fFilter) {
- fReverseLocalIsolatedBounds = as_IFB(fFilter)->filterNodeBounds(
- srcRect, fLocalCTM, SkImageFilter::kReverse_MapDirection, &srcRect);
- } else {
- fReverseLocalIsolatedBounds = srcRect;
- }
-
- SkIRect childSrcRect = srcRect;
- if (this->isImplicitMatrixNode()) {
- // Switch srcRect from the device-space bounds to what would be used when the draw is
- // the final step of filtering, as if the implicit node weren't needed
- fLocalCTM.mapRect(fContent).roundOut(&childSrcRect);
- }
-
- // Fill in children. Unlike regular reverse bounds mapping, the input nodes see the original
- // bounds. Normally, the bounds that the child nodes see have already been mapped processed
- // by this node.
- for (int i = 0; i < fInputNodes.count(); ++i) {
- fInputNodes[i].computeReverseLocalIsolatedBounds(childSrcRect);
- }
- }
-
- // fReverseLocalBounds and fLayerBounds are computed the same, except they differ in what the
- // initial bounding rectangle was. It is assumed that the 'srcRect' has already been processed
- // by the parent node's onFilterNodeBounds() function, as in SkImageFilter::filterBounds().
- void computeReverseBounds(const SkIRect& srcRect, bool writeToLayerBounds) {
- SkIRect reverseBounds = srcRect;
+ void computeInputBounds() {
+ // As a proxy for what the base device had, use the content rect mapped to device space
+ // (e.g. clipRect() was called with the same coords prior to the draw).
+ skif::DeviceSpace<SkIRect> targetOutput(fMapping.totalMatrix()
+ .mapRect(SkRect(fContent))
+ .roundOut());
if (fFilter) {
- // Since srcRect has been through parent's onFilterNodeBounds(), calling filterBounds()
- // directly on this node will calculate the same rectangle that this filter would report
- // during the parent node's onFilterBounds() recursion.
- reverseBounds = fFilter->filterBounds(
- srcRect, fLocalCTM, SkImageFilter::kReverse_MapDirection, &srcRect);
-
- SkIRect nextSrcRect;
- if (this->isImplicitMatrixNode() && !writeToLayerBounds) {
- // When not writing to the layer bounds, and we're the implicit matrix node
- // we reset the src rect to be what it should be if no implicit node was necessary.
- fLocalCTM.mapRect(fContent).roundOut(&nextSrcRect);
- } else {
- // To calculate the appropriate intermediate reverse bounds for the children, we
- // need this node's onFilterNodeBounds() results based on its parents' bounds (the
- // current 'srcRect').
- nextSrcRect = as_IFB(fFilter)->filterNodeBounds(
- srcRect, fLocalCTM, SkImageFilter::kReverse_MapDirection, &srcRect);
- }
-
- // Fill in the children. The union of these bounds should equal the value calculated
- // for reverseBounds already.
- SkDEBUGCODE(SkIRect netReverseBounds = SkIRect::MakeEmpty();)
- for (int i = 0; i < fInputNodes.count(); ++i) {
- fInputNodes[i].computeReverseBounds(nextSrcRect, writeToLayerBounds);
- SkDEBUGCODE(netReverseBounds.join(
- writeToLayerBounds ? fInputNodes[i].fLayerBounds
- : fInputNodes[i].fReverseLocalBounds);)
- }
- // Because of the resetting done when not computing layer bounds for the implicit
- // matrix node, this assertion doesn't hold in that particular scenario.
- SkASSERT(netReverseBounds == reverseBounds ||
- (this->isImplicitMatrixNode() && !writeToLayerBounds));
- }
-
- if (writeToLayerBounds) {
- fLayerBounds = reverseBounds;
+ fHintedLayerBounds = as_IFB(fFilter)->getInputBounds(fMapping, targetOutput, &fContent);
+ fUnhintedLayerBounds = as_IFB(fFilter)->getInputBounds(fMapping, targetOutput, nullptr);
} else {
- fReverseLocalBounds = reverseBounds;
+ fHintedLayerBounds = fMapping.paramToLayer(fContent).roundOut();
+ fUnhintedLayerBounds = fMapping.deviceToLayer(targetOutput);
}
}
};
} // anonymous namespace
-static FilterNode build_dag(const SkMatrix& local, const SkMatrix& remainder, const SkRect& rect,
- const SkImageFilter* filter, int depth) {
- FilterNode node;
- node.fFilter = sk_ref_sp(filter);
- node.fDepth = depth;
- node.fContent = rect;
-
- node.fLocalCTM = local;
- node.fRemainingCTM = remainder;
-
- if (node.fFilter) {
- if (depth > 0) {
- // We don't visit children when at the root because the real child filters are replaced
- // with the internalSaveLayer decomposition emulation, which then cycles back to the
- // original filter but with an updated matrix (and then we process the children).
- node.fInputNodes.reserve(node.fFilter->countInputs());
- for (int i = 0; i < node.fFilter->countInputs(); ++i) {
- node.fInputNodes.push_back() =
- build_dag(local, remainder, rect, node.fFilter->getInput(i), depth + 1);
- }
- }
- }
-
- return node;
-}
-
static FilterNode build_dag(const SkMatrix& ctm, const SkRect& rect,
const SkImageFilter* rootFilter) {
// Emulate SkCanvas::internalSaveLayer's decomposition of the CTM.
- SkMatrix local;
- sk_sp<SkImageFilter> finalFilter = as_IFB(rootFilter)->applyCTM(ctm, &local);
-
- // In ApplyCTMToFilter, the CTM is decomposed such that CTM = remainder * local. The matrix
- // that is embedded in 'finalFilter' is actually local^-1*remainder*local to account for
- // how SkMatrixImageFilter is specified, but we want the true remainder since it is what should
- // transform the results to put in the correct place after filtering.
- SkMatrix invLocal, remaining;
- if (as_IFB(rootFilter)->uniqueID() != as_IFB(finalFilter)->uniqueID()) {
- remaining = SkMatrix::Concat(ctm, invLocal);
- } else {
- remaining = SkMatrix::I();
- }
-
- // Create a root node that represents the full result
- FilterNode rootNode = build_dag(ctm, SkMatrix::I(), rect, rootFilter, 0);
- // Set its only child as the modified DAG that handles the CTM decomposition
- rootNode.fInputNodes.push_back() =
- build_dag(local, remaining, rect, finalFilter.get(), 1);
- // Fill in bounds information that requires the entire node DAG to have been extracted first.
- rootNode.fInputNodes[0].computeBounds();
- return rootNode;
+ skif::ParameterSpace<SkRect> content(rect);
+ skif::ParameterSpace<SkPoint> center({rect.centerX(), rect.centerY()});
+ skif::Mapping mapping;
+ SkAssertResult(mapping.decomposeCTM(ctm, rootFilter, center));
+ return FilterNode(rootFilter, mapping, content, 0);
}
static void draw_node(SkCanvas* canvas, const FilterNode& node) {
@@ -268,10 +133,11 @@
SkPaint filterPaint;
filterPaint.setImageFilter(node.fFilter);
+ SkRect content = SkRect(node.fContent);
SkPaint paint;
static const SkColor kColors[2] = {SK_ColorGREEN, SK_ColorWHITE};
- SkPoint points[2] = { {node.fContent.fLeft + 15.f, node.fContent.fTop + 15.f},
- {node.fContent.fRight - 15.f, node.fContent.fBottom - 15.f} };
+ SkPoint points[2] = { {content.fLeft + 15.f, content.fTop + 15.f},
+ {content.fRight - 15.f, content.fBottom - 15.f} };
paint.setShader(SkGradientShader::MakeLinear(points, kColors, nullptr, SK_ARRAY_COUNT(kColors),
SkTileMode::kRepeat));
@@ -279,77 +145,40 @@
line.setStrokeWidth(0.f);
line.setStyle(SkPaint::kStroke_Style);
- if (node.fDepth == 0) {
- // The root node, so draw this one the canonical way through SkCanvas to show current
- // net behavior. Will not include bounds visualization.
- canvas->save();
- canvas->concat(node.fLocalCTM);
- SkASSERT(node.fRemainingCTM.isIdentity());
+ canvas->save();
+ canvas->concat(node.fMapping.deviceMatrix());
+ canvas->save();
+ canvas->concat(node.fMapping.layerMatrix());
- canvas->clipRect(node.fContent, /* aa */ true);
- canvas->saveLayer(nullptr, &filterPaint);
- canvas->drawRect(node.fContent, paint);
- canvas->restore(); // Completes the image filter
- canvas->restore(); // Undoes matrix and clip
+ canvas->saveLayer(&content, &filterPaint);
+ canvas->drawRect(content, paint);
+ canvas->restore(); // Completes the image filter
- // Draw content rect (no clipping)
- canvas->save();
- canvas->concat(node.fLocalCTM);
- line.setColor(SK_ColorBLACK);
- canvas->drawRect(node.fContent, line);
- canvas->restore();
- } else {
- canvas->save();
- if (!node.isImplicitMatrixNode()) {
- canvas->concat(node.fRemainingCTM);
- }
- canvas->concat(node.fLocalCTM);
+ // Draw content-rect bounds
+ line.setColor(SK_ColorBLACK);
+ canvas->drawRect(content, line);
- canvas->saveLayer(nullptr, &filterPaint);
- canvas->drawRect(node.fContent, paint);
- canvas->restore(); // Completes the image filter
+ // Bounding boxes have all been mapped by the layer matrix from local to layer space, so undo
+ // the layer matrix, leaving just the device matrix.
+ canvas->restore();
- // Draw content-rect bounds
- line.setColor(SK_ColorBLACK);
- if (node.isImplicitMatrixNode()) {
- canvas->setMatrix(SkMatrix::Concat(node.fRemainingCTM, node.fLocalCTM));
- }
- canvas->drawRect(node.fContent, line);
- canvas->restore(); // Undoes the matrix
+ // The hinted bounds of the layer saved for the filtering
+ line.setColor(SK_ColorRED);
+ canvas->drawRect(SkRect::Make(SkIRect(node.fHintedLayerBounds)).makeOutset(3.f, 3.f), line);
+ // The bounds of the layer if there was no local content hint
+ line.setColor(SK_ColorGREEN);
+ canvas->drawRect(SkRect::Make(SkIRect(node.fUnhintedLayerBounds)).makeOutset(2.f, 2.f), line);
- // Bounding boxes have all been mapped by the local matrix already, so drawing them with
- // the remaining CTM should align everything to the already drawn filter outputs. The
- // exception is forward bounds of the implicit matrix node, which also have been mapped
- // by the remainder matrix.
- canvas->save();
- canvas->concat(node.fRemainingCTM);
-
- // The bounds of the layer saved for the filtering as currently implemented
- line.setColor(SK_ColorRED);
- canvas->drawRect(SkRect::Make(node.fLayerBounds).makeOutset(5.f, 5.f), line);
- // The bounds of the layer that could be saved if the last step were a draw
- line.setColor(SK_ColorMAGENTA);
- canvas->drawRect(SkRect::Make(node.fReverseLocalBounds).makeOutset(4.f, 4.f), line);
-
- // Dashed lines for the isolated shapes
- static const SkScalar kDashParams[] = {6.f, 12.f};
- line.setPathEffect(SkDashPathEffect::Make(kDashParams, 2, 0.f));
- // The bounds of the layer if it were the only filter in the DAG
- canvas->drawRect(SkRect::Make(node.fReverseLocalIsolatedBounds).makeOutset(3.f, 3.f), line);
-
- if (node.isImplicitMatrixNode()) {
- canvas->resetMatrix();
- }
- // The output bounds calculated as if the node were the only filter in the DAG
- line.setColor(SK_ColorBLUE);
- canvas->drawRect(SkRect::Make(node.fForwardIsolatedBounds).makeOutset(1.f, 1.f), line);
-
- // The output bounds calculated for the node
- line.setPathEffect(nullptr);
- canvas->drawRect(SkRect::Make(node.fForwardBounds).makeOutset(2.f, 2.f), line);
-
- canvas->restore();
- }
+ // The output bounds in layer space
+ line.setColor(SK_ColorBLUE);
+ canvas->drawRect(SkRect::Make(SkIRect(node.fOutputBounds)).makeOutset(1.f, 1.f), line);
+ // Device-space bounding box of the output bounds (e.g. what legacy DAG manipulation via
+ // MatrixTransform would produce).
+ static const SkScalar kDashParams[] = {6.f, 12.f};
+ line.setPathEffect(SkDashPathEffect::Make(kDashParams, 2, 0.f));
+ SkRect devOutputBounds = SkRect::Make(SkIRect(node.fMapping.layerToDevice(node.fOutputBounds)));
+ canvas->restore(); // undoes device matrix
+ canvas->drawRect(devOutputBounds, line);
}
static constexpr float kLineHeight = 16.f;
@@ -385,21 +214,23 @@
text.setAntiAlias(true);
float y = kLineHeight;
- if (node.fDepth == 0) {
- canvas->drawString("Final Results", kLineInset, y, font, text);
- // The actual interesting matrices are in the root node's first child
- y = print_matrix(canvas, "Local", node.fInputNodes[0].fLocalCTM,
- kLineInset, y + kLineHeight, font, text);
- y = print_matrix(canvas, "Embedded", node.fInputNodes[0].fRemainingCTM,
- kLineInset, y, font, text);
- } else if (node.fFilter) {
+ if (node.fFilter) {
canvas->drawString(node.fFilter->getTypeName(), kLineInset, y, font, text);
- print_size(canvas, "Layer Size", node.fLayerBounds, kLineInset, y + kLineHeight,
- font, text);
- y = print_size(canvas, "Ideal Size", node.fReverseLocalBounds, 10 * kLineInset,
- y + kLineHeight, font, text);
+ y += kLineHeight;
+ if (node.fDepth == 0) {
+ // The mapping is the same for all nodes, so only print at the root
+ y = print_matrix(canvas, "Param->Layer", node.fMapping.layerMatrix(),
+ kLineInset, y, font, text);
+ y = print_matrix(canvas, "Layer->Device", node.fMapping.deviceMatrix(),
+ kLineInset, y, font, text);
+ }
+
+ y = print_size(canvas, "Layer Size", SkIRect(node.fUnhintedLayerBounds),
+ kLineInset, y, font, text);
+ y = print_size(canvas, "Layer Size (hinted)", SkIRect(node.fHintedLayerBounds),
+ kLineInset, y, font, text);
} else {
- canvas->drawString("Source Input", kLineInset, kLineHeight, font, text);
+ canvas->drawString("Source Input", kLineInset, y, font, text);
y += kLineHeight;
}
@@ -448,7 +279,7 @@
y = draw_dag(canvas, nodeSurface, node.fInputNodes[i]);
canvas->restore();
}
- return SkMaxScalar(y, nodeResults->height() + textHeight + kPad);
+ return std::max(y, nodeResults->height() + textHeight + kPad);
}
static void draw_dag(SkCanvas* canvas, sk_sp<SkImageFilter> filter,
@@ -509,7 +340,7 @@
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE(return new ImageFilterDAGSample();)
diff --git a/third_party/skia/samplecode/SampleLCD.cpp b/third_party/skia/samplecode/SampleLCD.cpp
index 3c71415..0fd46a1 100644
--- a/third_party/skia/samplecode/SampleLCD.cpp
+++ b/third_party/skia/samplecode/SampleLCD.cpp
@@ -49,7 +49,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleLayerMask.cpp b/third_party/skia/samplecode/SampleLayerMask.cpp
deleted file mode 100644
index 546c6c4..0000000
--- a/third_party/skia/samplecode/SampleLayerMask.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright 2011 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/SkBitmap.h"
-#include "include/core/SkCanvas.h"
-#include "include/core/SkPaint.h"
-#include "include/core/SkPath.h"
-#include "samplecode/Sample.h"
-
-///////////////////////////////////////////////////////////////////////////////
-
-class LayerMaskView : public Sample {
-public:
- LayerMaskView() {
- this->setBGColor(0xFFDDDDDD);
- }
-
-protected:
- virtual SkString name() { return SkString("LayerMask"); }
-
- void drawMask(SkCanvas* canvas, const SkRect& r) {
- SkPaint paint;
- paint.setAntiAlias(true);
-
- if (true) {
- SkBitmap mask;
- int w = SkScalarRoundToInt(r.width());
- int h = SkScalarRoundToInt(r.height());
- mask.allocN32Pixels(w, h);
- mask.eraseColor(SK_ColorTRANSPARENT);
- SkCanvas c(mask);
- SkRect bounds = r;
- bounds.offset(-bounds.fLeft, -bounds.fTop);
- c.drawOval(bounds, paint);
-
- paint.setBlendMode(SkBlendMode::kDstIn);
- canvas->drawBitmap(mask, r.fLeft, r.fTop, &paint);
- } else {
- SkPath p;
- p.addOval(r);
- p.setFillType(SkPathFillType::kInverseWinding);
- paint.setBlendMode(SkBlendMode::kDstOut);
- canvas->drawPath(p, paint);
- }
- }
-
- virtual void onDrawContent(SkCanvas* canvas) {
- SkRect r;
- r.setLTRB(20, 20, 120, 120);
- canvas->saveLayer(&r, nullptr);
- canvas->drawColor(SK_ColorRED);
- drawMask(canvas, r);
- canvas->restore();
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new LayerMaskView(); )
diff --git a/third_party/skia/samplecode/SampleLayers.cpp b/third_party/skia/samplecode/SampleLayers.cpp
index aeddc46..c228578 100644
--- a/third_party/skia/samplecode/SampleLayers.cpp
+++ b/third_party/skia/samplecode/SampleLayers.cpp
@@ -15,12 +15,9 @@
#include "include/core/SkShader.h"
#include "include/core/SkTime.h"
#include "include/core/SkTypeface.h"
-#include "include/effects/SkBlurMaskFilter.h"
#include "include/effects/SkGradientShader.h"
#include "include/utils/SkCamera.h"
-#include "include/utils/SkInterpolator.h"
#include "samplecode/Sample.h"
-#include "src/core/SkClipOpPriv.h"
#include "src/utils/SkUTF.h"
static void make_paint(SkPaint* paint, const SkMatrix& localMatrix) {
@@ -37,9 +34,6 @@
SkRect r;
- SkPaint p;
- p.setAlpha(0x88);
-
SkAutoCanvasRestore ar2(canvas, false);
// create the layers
@@ -56,7 +50,7 @@
// now draw the "content"
- if (true) {
+ if ((true)) {
r.setWH(100, 100);
canvas->saveLayerAlpha(&r, 0x80);
@@ -109,7 +103,7 @@
void onDrawContent(SkCanvas* canvas) override {
this->drawBG(canvas);
- if (true) {
+ if ((true)) {
SkRect r;
r.setWH(220, 120);
SkPaint p;
@@ -122,7 +116,7 @@
return;
}
- if (false) {
+ if ((false)) {
SkRect r;
r.setWH(220, 120);
SkPaint p;
@@ -141,7 +135,7 @@
canvas->drawOval(r, p);
}
- if (false) {
+ if ((false)) {
SkPaint p;
p.setAlpha(0x88);
p.setAntiAlias(true);
@@ -164,7 +158,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new LayersView; )
@@ -191,7 +185,7 @@
SkString name() override { return SkString("Backdrop"); }
void onDrawContent(SkCanvas* canvas) override {
- canvas->drawImage(fImage.get(), 0, 0, nullptr);
+ canvas->drawImage(fImage.get(), 0, 0);
const SkScalar w = 250;
const SkScalar h = 150;
@@ -202,12 +196,12 @@
m.postTranslate(fCenter.x(), fCenter.y());
path.transform(m);
- canvas->clipPath(path, kIntersect_SkClipOp, true);
+ canvas->clipPath(path, SkClipOp::kIntersect, true);
const SkRect bounds = path.getBounds();
SkPaint paint;
paint.setAlpha(0xCC);
- canvas->saveLayer({ &bounds, &paint, fFilter.get(), nullptr, nullptr, 0 });
+ canvas->saveLayer(SkCanvas::SaveLayerRec(&bounds, &paint, fFilter.get(), 0));
canvas->restore();
}
@@ -227,6 +221,6 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new BackdropView; )
diff --git a/third_party/skia/samplecode/SampleLighting.cpp b/third_party/skia/samplecode/SampleLighting.cpp
deleted file mode 100644
index 24a0a64..0000000
--- a/third_party/skia/samplecode/SampleLighting.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright 2015 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/SkPoint3.h"
-#include "samplecode/DecodeFile.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkNormalSource.h"
-#include "src/shaders/SkLightingShader.h"
-#include "tools/Resources.h"
-
-static sk_sp<SkLights> create_lights(SkScalar angle, SkScalar blue) {
-
- const SkVector3 dir = SkVector3::Make(SkScalarSin(angle)*SkScalarSin(SK_ScalarPI*0.25f),
- SkScalarCos(angle)*SkScalarSin(SK_ScalarPI*0.25f),
- SkScalarCos(SK_ScalarPI*0.25f));
-
- SkLights::Builder builder;
-
- builder.add(SkLights::Light::MakeDirectional(SkColor3f::Make(1.0f, 1.0f, blue), dir));
- builder.setAmbientLightColor(SkColor3f::Make(0.1f, 0.1f, 0.1f));
-
- return builder.finish();
-}
-
-////////////////////////////////////////////////////////////////////////////
-
-class LightingView : public Sample {
-public:
- LightingView() : fLightAngle(0.0f), fColorFactor(0.0f) {}
-
-protected:
- SkString name() override { return SkString("Lighting"); }
-
- void onOnceBeforeDraw() override {
- {
- SkBitmap diffuseBitmap;
- SkAssertResult(GetResourceAsBitmap("images/brickwork-texture.jpg", &diffuseBitmap));
-
- fRect = SkRect::MakeIWH(diffuseBitmap.width(), diffuseBitmap.height());
-
- fDiffuseShader = diffuseBitmap.makeShader();
- }
-
- {
- SkBitmap normalBitmap;
- SkAssertResult(GetResourceAsBitmap("images/brickwork_normal-map.jpg", &normalBitmap));
-
- sk_sp<SkShader> normalMap = normalBitmap.makeShader();
- fNormalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap), SkMatrix::I());
- }
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- sk_sp<SkLights> lights(create_lights(fLightAngle, fColorFactor));
-
- SkPaint paint;
- paint.setShader(SkLightingShader::Make(fDiffuseShader,
- fNormalSource,
- std::move(lights)));
- paint.setColor(SK_ColorBLACK);
-
- canvas->drawRect(fRect, paint);
- }
-
- Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
- return this->INHERITED::onFindClickHandler(x, y, modi);
- }
-
- bool onAnimate(double nanos) override {
- fLightAngle += 0.015f;
- fColorFactor += 0.01f;
- if (fColorFactor > 1.0f) {
- fColorFactor = 0.0f;
- }
-
- return true;
- }
-
-private:
- SkRect fRect;
- sk_sp<SkShader> fDiffuseShader;
- sk_sp<SkNormalSource> fNormalSource;
-
- SkScalar fLightAngle;
- SkScalar fColorFactor;
-
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new LightingView(); )
diff --git a/third_party/skia/samplecode/SampleLitAtlas.cpp b/third_party/skia/samplecode/SampleLitAtlas.cpp
deleted file mode 100644
index d43e6d7..0000000
--- a/third_party/skia/samplecode/SampleLitAtlas.cpp
+++ /dev/null
@@ -1,488 +0,0 @@
-/*
- * Copyright 2016 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/SkDrawable.h"
-#include "include/core/SkRSXform.h"
-#include "include/utils/SkRandom.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkNormalSource.h"
-#include "src/shaders/SkBitmapProcShader.h"
-#include "src/shaders/SkLightingShader.h"
-#include "src/shaders/SkLights.h"
-
-#include "tools/ToolUtils.h"
-
-// A crude normal mapped asteroids-like sample
-class DrawLitAtlasDrawable : public SkDrawable {
-public:
- DrawLitAtlasDrawable(const SkRect& r)
- : fBounds(r)
- , fUseColors(false)
- , fLightDir(SkVector3::Make(1.0f, 0.0f, 0.0f)) {
- fAtlas = MakeAtlas();
-
- SkRandom rand;
- for (int i = 0; i < kNumAsteroids; ++i) {
- fAsteroids[i].initAsteroid(&rand, fBounds, &fDiffTex[i], &fNormTex[i]);
- }
-
- fShip.initShip(fBounds, &fDiffTex[kNumAsteroids], &fNormTex[kNumAsteroids]);
-
- this->updateLights();
- }
-
- void toggleUseColors() {
- fUseColors = !fUseColors;
- }
-
- void rotateLight() {
- SkScalar r = SK_ScalarPI / 6.0f,
- s = SkScalarSin(r),
- c = SkScalarCos(r);
-
- SkScalar newX = c * fLightDir.fX - s * fLightDir.fY;
- SkScalar newY = s * fLightDir.fX + c * fLightDir.fY;
-
- fLightDir.set(newX, newY, 0.0f);
-
- this->updateLights();
- }
-
- void left() {
- SkScalar newRot = SkScalarMod(fShip.rot() + (2*SK_ScalarPI - SK_ScalarPI/32.0f),
- 2 * SK_ScalarPI);
- fShip.setRot(newRot);
- }
-
- void right() {
- SkScalar newRot = SkScalarMod(fShip.rot() + SK_ScalarPI/32.0f, 2 * SK_ScalarPI);
- fShip.setRot(newRot);
- }
-
- void thrust() {
- SkScalar s = SkScalarSin(fShip.rot()),
- c = SkScalarCos(fShip.rot());
-
- SkVector newVel = fShip.velocity();
- newVel.fX += s;
- newVel.fY += -c;
-
- SkScalar len = newVel.length();
- if (len > kMaxShipSpeed) {
- newVel.setLength(SkIntToScalar(kMaxShipSpeed));
- }
-
- fShip.setVelocity(newVel);
- }
-
-protected:
- void onDraw(SkCanvas* canvas) override {
- SkRSXform xforms[kNumAsteroids+kNumShips];
- SkColor colors[kNumAsteroids+kNumShips];
-
- for (int i = 0; i < kNumAsteroids; ++i) {
- fAsteroids[i].advance(fBounds);
- xforms[i] = fAsteroids[i].asRSXform();
- if (fUseColors) {
- colors[i] = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
- }
- }
-
- fShip.advance(fBounds);
- xforms[kNumAsteroids] = fShip.asRSXform();
- if (fUseColors) {
- colors[kNumAsteroids] = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
- }
-
-#ifdef SK_DEBUG
- canvas->drawBitmap(fAtlas, 0, 0); // just to see the atlas
-
- this->drawLightDir(canvas, fBounds.centerX(), fBounds.centerY());
-#endif
-
-#if 0
- // TODO: revitalize when drawLitAtlas API lands
- SkPaint paint;
- paint.setFilterQuality(kLow_SkFilterQuality);
-
- const SkRect cull = this->getBounds();
- const SkColor* colorsPtr = fUseColors ? colors : NULL;
-
- canvas->drawLitAtlas(fAtlas, xforms, fDiffTex, fNormTex, colorsPtr, kNumAsteroids+1,
- SkXfermode::kModulate_Mode, &cull, &paint, fLights);
-#else
- SkMatrix diffMat, normalMat;
-
- for (int i = 0; i < kNumAsteroids+1; ++i) {
- colors[i] = colors[i] & 0xFF000000; // to silence compilers
- SkPaint paint;
-
- SkRect r = fDiffTex[i];
- r.offsetTo(0, 0);
-
- diffMat.setRectToRect(fDiffTex[i], r, SkMatrix::kFill_ScaleToFit);
- normalMat.setRectToRect(fNormTex[i], r, SkMatrix::kFill_ScaleToFit);
-
- SkMatrix m;
- m.setRSXform(xforms[i]);
-
- sk_sp<SkShader> normalMap = fAtlas.makeShader(&normalMat);
- sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(
- std::move(normalMap), m);
- sk_sp<SkShader> diffuseShader = fAtlas.makeShader(&diffMat);
- paint.setShader(SkLightingShader::Make(std::move(diffuseShader),
- std::move(normalSource), fLights));
-
- canvas->save();
- canvas->setMatrix(m);
- canvas->drawRect(r, paint);
- canvas->restore();
- }
-#endif
-
-#ifdef SK_DEBUG
- {
- SkPaint paint;
- paint.setColor(SK_ColorRED);
-
- for (int i = 0; i < kNumAsteroids; ++i) {
- canvas->drawCircle(fAsteroids[i].pos().x(), fAsteroids[i].pos().y(), 2, paint);
- }
- canvas->drawCircle(fShip.pos().x(), fShip.pos().y(), 2, paint);
-
- paint.setStyle(SkPaint::kStroke_Style);
- canvas->drawRect(this->getBounds(), paint);
- }
-#endif
- }
-
- SkRect onGetBounds() override {
- return fBounds;
- }
-
-private:
-
- enum ObjType {
- kBigAsteroid_ObjType = 0,
- kMedAsteroid_ObjType,
- kSmAsteroid_ObjType,
- kShip_ObjType,
-
- kLast_ObjType = kShip_ObjType
- };
-
- static const int kObjTypeCount = kLast_ObjType + 1;
-
- void updateLights() {
- SkLights::Builder builder;
-
- builder.add(SkLights::Light::MakeDirectional(
- SkColor3f::Make(1.0f, 1.0f, 1.0f), fLightDir));
- builder.setAmbientLightColor(SkColor3f::Make(0.2f, 0.2f, 0.2f));
-
- fLights = builder.finish();
- }
-
-#ifdef SK_DEBUG
- // Draw a vector to the light
- void drawLightDir(SkCanvas* canvas, SkScalar centerX, SkScalar centerY) {
- static const int kBgLen = 30;
- static const int kSmLen = 5;
-
- // TODO: change the lighting coordinate system to be right handed
- SkPoint p1 = SkPoint::Make(centerX + kBgLen * fLightDir.fX,
- centerY - kBgLen * fLightDir.fY);
- SkPoint p2 = SkPoint::Make(centerX + (kBgLen-kSmLen) * fLightDir.fX,
- centerY - (kBgLen-kSmLen) * fLightDir.fY);
-
- SkPaint p;
- canvas->drawLine(centerX, centerY, p1.fX, p1.fY, p);
- canvas->drawLine(p1.fX, p1.fY,
- p2.fX - kSmLen * fLightDir.fY, p2.fY - kSmLen * fLightDir.fX, p);
- canvas->drawLine(p1.fX, p1.fY,
- p2.fX + kSmLen * fLightDir.fY, p2.fY + kSmLen * fLightDir.fX, p);
- }
-#endif
-
- // Create the mixed diffuse & normal atlas
- //
- // big color circle | big normal hemi
- // ------------------------------------
- // med color circle | med normal pyra
- // ------------------------------------
- // sm color circle | sm normal hemi
- // ------------------------------------
- // big ship | big tetra normal
- static SkBitmap MakeAtlas() {
-
- SkBitmap atlas;
- atlas.allocN32Pixels(kAtlasWidth, kAtlasHeight);
-
- for (int y = 0; y < kAtlasHeight; ++y) {
- int x = 0;
- for ( ; x < kBigSize+kPad; ++x) {
- *atlas.getAddr32(x, y) = SK_ColorTRANSPARENT;
- }
- for ( ; x < kAtlasWidth; ++x) {
- *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0x88, 0x88, 0xFF);
- }
- }
-
- // big asteroid
- {
- SkPoint bigCenter = SkPoint::Make(kDiffXOff + kBigSize/2.0f, kBigYOff + kBigSize/2.0f);
-
- for (int y = kBigYOff; y < kBigYOff+kBigSize; ++y) {
- for (int x = kDiffXOff; x < kDiffXOff+kBigSize; ++x) {
- SkScalar distSq = (x - bigCenter.fX) * (x - bigCenter.fX) +
- (y - bigCenter.fY) * (y - bigCenter.fY);
- if (distSq > kBigSize*kBigSize/4.0f) {
- *atlas.getAddr32(x, y) = SkPreMultiplyARGB(0, 0, 0, 0);
- } else {
- *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0xFF, 0, 0);
- }
- }
- }
-
- ToolUtils::create_hemi_normal_map(
- &atlas, SkIRect::MakeXYWH(kNormXOff, kBigYOff, kBigSize, kBigSize));
- }
-
- // medium asteroid
- {
- for (int y = kMedYOff; y < kMedYOff+kMedSize; ++y) {
- for (int x = kDiffXOff; x < kDiffXOff+kMedSize; ++x) {
- *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0, 0xFF, 0);
- }
- }
-
- ToolUtils::create_frustum_normal_map(
- &atlas, SkIRect::MakeXYWH(kNormXOff, kMedYOff, kMedSize, kMedSize));
- }
-
- // small asteroid
- {
- SkPoint smCenter = SkPoint::Make(kDiffXOff + kSmSize/2.0f, kSmYOff + kSmSize/2.0f);
-
- for (int y = kSmYOff; y < kSmYOff+kSmSize; ++y) {
- for (int x = kDiffXOff; x < kDiffXOff+kSmSize; ++x) {
- SkScalar distSq = (x - smCenter.fX) * (x - smCenter.fX) +
- (y - smCenter.fY) * (y - smCenter.fY);
- if (distSq > kSmSize*kSmSize/4.0f) {
- *atlas.getAddr32(x, y) = SkPreMultiplyARGB(0, 0, 0, 0);
- } else {
- *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0, 0, 0xFF);
- }
- }
- }
-
- ToolUtils::create_hemi_normal_map(
- &atlas, SkIRect::MakeXYWH(kNormXOff, kSmYOff, kSmSize, kSmSize));
- }
-
- // ship
- {
- SkScalar shipMidLine = kDiffXOff + kMedSize/2.0f;
-
- for (int y = kShipYOff; y < kShipYOff+kMedSize; ++y) {
- SkScalar scaledY = (y - kShipYOff)/(float)kMedSize; // 0..1
-
- for (int x = kDiffXOff; x < kDiffXOff+kMedSize; ++x) {
- SkScalar scaledX;
-
- if (x < shipMidLine) {
- scaledX = 1.0f - (x - kDiffXOff)/(kMedSize/2.0f); // 0..1
- } else {
- scaledX = (x - shipMidLine)/(kMedSize/2.0f); // 0..1
- }
-
- if (scaledX < scaledY) {
- *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0, 0xFF, 0xFF);
- } else {
- *atlas.getAddr32(x, y) = SkPackARGB32(0, 0, 0, 0);
- }
- }
- }
-
- ToolUtils::create_tetra_normal_map(
- &atlas, SkIRect::MakeXYWH(kNormXOff, kShipYOff, kMedSize, kMedSize));
- }
-
- return atlas;
- }
-
- class ObjectRecord {
- public:
- void initAsteroid(SkRandom *rand, const SkRect& bounds,
- SkRect* diffTex, SkRect* normTex) {
- static const SkScalar gMaxSpeeds[3] = { 1, 2, 5 }; // smaller asteroids can go faster
- static const SkScalar gYOffs[3] = { kBigYOff, kMedYOff, kSmYOff };
- static const SkScalar gSizes[3] = { kBigSize, kMedSize, kSmSize };
-
- static unsigned int asteroidType = 0;
- fObjType = static_cast<ObjType>(asteroidType++ % 3);
-
- fPosition.set(bounds.fLeft + rand->nextUScalar1() * bounds.width(),
- bounds.fTop + rand->nextUScalar1() * bounds.height());
- fVelocity.fX = rand->nextSScalar1();
- fVelocity.fY = sqrt(1.0f - fVelocity.fX * fVelocity.fX);
- SkASSERT(SkScalarNearlyEqual(fVelocity.length(), 1.0f));
- fVelocity *= gMaxSpeeds[fObjType];
- fRot = 0;
- fDeltaRot = rand->nextSScalar1() / 32;
-
- diffTex->setXYWH(SkIntToScalar(kDiffXOff), gYOffs[fObjType],
- gSizes[fObjType], gSizes[fObjType]);
- normTex->setXYWH(SkIntToScalar(kNormXOff), gYOffs[fObjType],
- gSizes[fObjType], gSizes[fObjType]);
- }
-
- void initShip(const SkRect& bounds, SkRect* diffTex, SkRect* normTex) {
- fObjType = kShip_ObjType;
- fPosition.set(bounds.centerX(), bounds.centerY());
- fVelocity = SkVector::Make(0.0f, 0.0f);
- fRot = 0.0f;
- fDeltaRot = 0.0f;
-
- diffTex->setXYWH(SkIntToScalar(kDiffXOff), SkIntToScalar(kShipYOff),
- SkIntToScalar(kMedSize), SkIntToScalar(kMedSize));
- normTex->setXYWH(SkIntToScalar(kNormXOff), SkIntToScalar(kShipYOff),
- SkIntToScalar(kMedSize), SkIntToScalar(kMedSize));
- }
-
- void advance(const SkRect& bounds) {
- fPosition += fVelocity;
- if (fPosition.fX > bounds.right()) {
- SkASSERT(fVelocity.fX > 0);
- fVelocity.fX = -fVelocity.fX;
- } else if (fPosition.fX < bounds.left()) {
- SkASSERT(fVelocity.fX < 0);
- fVelocity.fX = -fVelocity.fX;
- }
- if (fPosition.fY > bounds.bottom()) {
- if (fVelocity.fY > 0) {
- fVelocity.fY = -fVelocity.fY;
- }
- } else if (fPosition.fY < bounds.top()) {
- if (fVelocity.fY < 0) {
- fVelocity.fY = -fVelocity.fY;
- }
- }
-
- fRot += fDeltaRot;
- fRot = SkScalarMod(fRot, 2 * SK_ScalarPI);
- }
-
- const SkPoint& pos() const { return fPosition; }
-
- SkScalar rot() const { return fRot; }
- void setRot(SkScalar rot) { fRot = rot; }
-
- const SkPoint& velocity() const { return fVelocity; }
- void setVelocity(const SkPoint& velocity) { fVelocity = velocity; }
-
- SkRSXform asRSXform() const {
- static const SkScalar gHalfSizes[kObjTypeCount] = {
- SkScalarHalf(kBigSize),
- SkScalarHalf(kMedSize),
- SkScalarHalf(kSmSize),
- SkScalarHalf(kMedSize),
- };
-
- return SkRSXform::MakeFromRadians(1.0f, fRot, fPosition.x(), fPosition.y(),
- gHalfSizes[fObjType],
- gHalfSizes[fObjType]);
- }
-
- private:
- ObjType fObjType;
- SkPoint fPosition;
- SkVector fVelocity;
- SkScalar fRot; // In radians.
- SkScalar fDeltaRot; // In radiands. Not used by ship.
- };
-
-private:
- static const int kNumLights = 2;
- static const int kNumAsteroids = 6;
- static const int kNumShips = 1;
-
- static const int kBigSize = 128;
- static const int kMedSize = 64;
- static const int kSmSize = 32;
- static const int kPad = 1;
- static const int kAtlasWidth = kBigSize + kBigSize + 2 * kPad; // 2 pads in the middle
- static const int kAtlasHeight = kBigSize + kMedSize + kSmSize + kMedSize + 3 * kPad;
-
- static const int kDiffXOff = 0;
- static const int kNormXOff = kBigSize + 2 * kPad;
-
- static const int kBigYOff = 0;
- static const int kMedYOff = kBigSize + kPad;
- static const int kSmYOff = kMedYOff + kMedSize + kPad;
- static const int kShipYOff = kSmYOff + kSmSize + kPad;
- static const int kMaxShipSpeed = 5;
-
- SkBitmap fAtlas;
- ObjectRecord fAsteroids[kNumAsteroids];
- ObjectRecord fShip;
- SkRect fDiffTex[kNumAsteroids+kNumShips];
- SkRect fNormTex[kNumAsteroids+kNumShips];
- SkRect fBounds;
- bool fUseColors;
- SkVector3 fLightDir;
- sk_sp<SkLights> fLights;
-
- typedef SkDrawable INHERITED;
-};
-
-class DrawLitAtlasView : public Sample {
-public:
- DrawLitAtlasView() : fDrawable(new DrawLitAtlasDrawable(SkRect::MakeWH(640, 480))) {}
-
-protected:
- SkString name() override { return SkString("DrawLitAtlas"); }
-
- bool onChar(SkUnichar uni) override {
- switch (uni) {
- case 'C':
- fDrawable->toggleUseColors();
- return true;
- case 'j':
- fDrawable->left();
- return true;
- case 'k':
- fDrawable->thrust();
- return true;
- case 'l':
- fDrawable->right();
- return true;
- case 'o':
- fDrawable->rotateLight();
- return true;
- default:
- break;
- }
- return false;
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawDrawable(fDrawable.get());
- }
-
- bool onAnimate(double nanos) override { return true; }
-
-private:
- sk_sp<DrawLitAtlasDrawable> fDrawable;
-
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new DrawLitAtlasView(); )
diff --git a/third_party/skia/samplecode/SampleLua.cpp b/third_party/skia/samplecode/SampleLua.cpp
deleted file mode 100644
index 1a094bb..0000000
--- a/third_party/skia/samplecode/SampleLua.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * Copyright 2013 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/SkData.h"
-#include "include/utils/SkLua.h"
-#include "samplecode/Sample.h"
-#include "tools/Resources.h"
-
-extern "C" {
-#include "lua.h"
-#include "lualib.h"
-#include "lauxlib.h"
-}
-
-//#define LUA_FILENAME "lua/test.lua"
-#define LUA_FILENAME "lua/slides.lua"
-
-static const char gDrawName[] = "onDrawContent";
-static const char gClickName[] = "onClickHandler";
-static const char gUnicharName[] = "onCharHandler";
-
-static const char gMissingCode[] = ""
- "local paint = Sk.newPaint()"
- "paint:setAntiAlias(true)"
- "paint:setTextSize(30)"
- ""
- "function onDrawContent(canvas)"
- " canvas:drawText('missing \"test.lua\"', 20, 50, paint)"
- "end"
- ;
-
-class LuaView : public Sample {
-public:
- LuaView() : fLua(nullptr) {}
-
- ~LuaView() override { delete fLua; }
-
- void setImageFilename(lua_State* L) {
- SkString str = GetResourcePath("images/mandrill_256.png");
-
- lua_getglobal(L, "setImageFilename");
- if (lua_isfunction(L, -1)) {
- fLua->pushString(str.c_str());
- if (lua_pcall(L, 1, 0, 0) != LUA_OK) {
- SkDebugf("lua err: %s\n", lua_tostring(L, -1));
- }
- }
- }
-
- lua_State* ensureLua() {
- if (nullptr == fLua) {
- fLua = new SkLua;
-
- sk_sp<SkData> data = GetResourceAsData(LUA_FILENAME);
- if (data) {
- fLua->runCode(data->data(), data->size());
- this->setImageFilename(fLua->get());
- } else {
- fLua->runCode(gMissingCode);
- }
- }
- return fLua->get();
- }
-
-protected:
- SkString name() override { return SkString("Lua"); }
-
- bool onChar(SkUnichar uni) override {
- lua_State* L = this->ensureLua();
- lua_getglobal(L, gUnicharName);
- if (lua_isfunction(L, -1)) {
- SkString str;
- str.appendUnichar(uni);
- fLua->pushString(str.c_str());
- if (lua_pcall(L, 1, 1, 0) != LUA_OK) {
- SkDebugf("lua err: %s\n", lua_tostring(L, -1));
- } else {
- if (lua_isboolean(L, -1) && lua_toboolean(L, -1)) {
- return true;
- }
- }
- }
- return false;
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- lua_State* L = this->ensureLua();
-
- lua_getglobal(L, gDrawName);
- if (!lua_isfunction(L, -1)) {
- int t = lua_type(L, -1);
- SkDebugf("--- expected %s function %d, ignoring.\n", gDrawName, t);
- lua_pop(L, 1);
- } else {
- // does it make sense to try to "cache" the lua version of this
- // canvas between draws?
- fLua->pushCanvas(canvas);
- fLua->pushScalar(this->width());
- fLua->pushScalar(this->height());
- if (lua_pcall(L, 3, 1, 0) != LUA_OK) {
- SkDebugf("lua err: %s\n", lua_tostring(L, -1));
- }
- }
- }
-
- virtual Sample::Click* onFindClickHandler(SkScalar x, SkScalar y,
- skui::ModifierKey modi) override {
- lua_State* L = this->ensureLua();
- lua_getglobal(L, gClickName);
- if (lua_isfunction(L, -1)) {
- fLua->pushScalar(x);
- fLua->pushScalar(y);
- fLua->pushString("down");
- if (lua_pcall(L, 3, 1, 0) != LUA_OK) {
- SkDebugf("lua err: %s\n", lua_tostring(L, -1));
- } else {
- if (lua_isboolean(L, -1) && lua_toboolean(L, -1)) {
- return new Click();
- }
- }
- }
- return this->INHERITED::onFindClickHandler(x, y, modi);
- }
-
- bool onClick(Click* click) override {
- const char* state = nullptr;
- switch (click->fState) {
- case skui::InputState::kMove:
- state = "moved";
- break;
- case skui::InputState::kUp:
- state = "up";
- break;
- default:
- break;
- }
- if (state) {
- lua_State* L = fLua->get();
- lua_getglobal(L, gClickName);
- fLua->pushScalar(click->fCurr.x());
- fLua->pushScalar(click->fCurr.y());
- fLua->pushString(state);
- lua_pcall(L, 3, 1, 0);
- return lua_isboolean(L, -1) && lua_toboolean(L, -1);
- }
- return true;
- }
-
-private:
- SkLua* fLua;
-
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new LuaView(); )
diff --git a/third_party/skia/samplecode/SampleManyRects.cpp b/third_party/skia/samplecode/SampleManyRects.cpp
index cfd66c9..ba3bdb1 100644
--- a/third_party/skia/samplecode/SampleManyRects.cpp
+++ b/third_party/skia/samplecode/SampleManyRects.cpp
@@ -38,7 +38,7 @@
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
// Uncomment to test rotated rect draw combining.
- if (false) {
+ if ((false)) {
SkMatrix rotate;
rotate.setRotate(fRandom.nextUScalar1() * 360,
SkIntToScalar(x) + SkScalarHalf(rect.fRight),
@@ -59,7 +59,7 @@
private:
SkRandom fRandom;
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleMaterialShadows.cpp b/third_party/skia/samplecode/SampleMaterialShadows.cpp
new file mode 100644
index 0000000..8cb951f
--- /dev/null
+++ b/third_party/skia/samplecode/SampleMaterialShadows.cpp
@@ -0,0 +1,147 @@
+
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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"
+#include "tools/timer/TimeUtils.h"
+
+////////////////////////////////////////////////////////////////////////////
+
+class MaterialShadowsView : public Sample {
+ SkPath fCirclePath;
+ SkPath fCapsulePath;
+ SkPath fLargeRRPath;
+ SkPath fSmallRRPath;
+
+ SkPoint3 fLightPos;
+
+ void onOnceBeforeDraw() override {
+ fCirclePath.addCircle(0, 0, 56/2);
+ fCapsulePath.addRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(-64, -24, 128, 48), 24, 24));
+ fLargeRRPath.addRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(-64, -64, 128, 128), 4, 4));
+ fSmallRRPath.addRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(-40, -40, 80, 80), 4, 4));
+
+ fLightPos = SkPoint3::Make(0, -700, 700);
+ }
+
+ SkString name() override { return SkString("MaterialShadows"); }
+
+ void drawShadowedPath(SkCanvas* canvas, const SkPath& path,
+ const SkPoint3& zPlaneParams,
+ const SkPaint& paint, SkScalar ambientAlpha,
+ const SkPoint3& lightPos, SkScalar lightRadius, SkScalar spotAlpha) {
+ uint32_t flags = 0;
+ flags |= SkShadowFlags::kDirectionalLight_ShadowFlag;
+
+ SkColor ambientColor = SkColorSetARGB(ambientAlpha * 255, 0, 0, 0);
+ SkColor spotColor = SkColorSetARGB(spotAlpha * 255, 0, 0, 0);
+ SkShadowUtils::DrawShadow(canvas, path, zPlaneParams, lightPos, lightRadius,
+ ambientColor, spotColor, flags);
+
+ canvas->drawPath(path, paint);
+ }
+
+ void onDrawContent(SkCanvas* canvas) override {
+ canvas->drawColor(0xFFFFFFFF);
+
+ const SkScalar kLightRadius = 1.1f;
+ const SkScalar kAmbientAlpha = 0.05f;
+ const SkScalar kSpotAlpha = 0.35f;
+
+ const SkScalar elevations[] = { 1, 3, 6, 8, 12, 24 };
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ SkPoint3 lightPos = fLightPos;
+ SkPoint3 zPlaneParams = SkPoint3::Make(0, 0, 0);
+
+ paint.setColor(SK_ColorWHITE);
+ canvas->save();
+ canvas->translate(80, 80);
+ for (unsigned int i = 0; i < SK_ARRAY_COUNT(elevations); ++i) {
+ zPlaneParams.fZ = elevations[i];
+ this->drawShadowedPath(canvas, fCirclePath, zPlaneParams, paint, kAmbientAlpha,
+ lightPos, kLightRadius, kSpotAlpha);
+ canvas->translate(80, 0);
+ }
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(120, 175);
+ for (unsigned int i = 0; i < SK_ARRAY_COUNT(elevations); ++i) {
+ zPlaneParams.fZ = elevations[i];
+ this->drawShadowedPath(canvas, fCapsulePath, zPlaneParams, paint, kAmbientAlpha,
+ lightPos, kLightRadius, kSpotAlpha);
+ canvas->translate(160, 0);
+ }
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(120, 320);
+ for (unsigned int i = 0; i < SK_ARRAY_COUNT(elevations); ++i) {
+ zPlaneParams.fZ = elevations[i];
+ this->drawShadowedPath(canvas, fLargeRRPath, zPlaneParams, paint, kAmbientAlpha,
+ lightPos, kLightRadius, kSpotAlpha);
+ canvas->translate(160, 0);
+ }
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(100, 475);
+ for (unsigned int i = 0; i < SK_ARRAY_COUNT(elevations); ++i) {
+ zPlaneParams.fZ = elevations[i];
+ this->drawShadowedPath(canvas, fSmallRRPath, zPlaneParams, paint, kAmbientAlpha,
+ lightPos, kLightRadius, kSpotAlpha);
+ canvas->translate(160, 0);
+ }
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(100, 600);
+ for (unsigned int i = 0; i < SK_ARRAY_COUNT(elevations); ++i) {
+ canvas->save();
+ zPlaneParams.fZ = elevations[i];
+ canvas->rotate(10);
+ this->drawShadowedPath(canvas, fSmallRRPath, zPlaneParams, paint, kAmbientAlpha,
+ lightPos, kLightRadius, kSpotAlpha);
+ canvas->restore();
+ canvas->translate(160, 0);
+ }
+ canvas->restore();
+
+ canvas->save();
+ canvas->translate(100, 725);
+ for (unsigned int i = 0; i < SK_ARRAY_COUNT(elevations); ++i) {
+ canvas->save();
+ zPlaneParams.fZ = elevations[i];
+ canvas->rotate(45);
+ this->drawShadowedPath(canvas, fSmallRRPath, zPlaneParams, paint, kAmbientAlpha,
+ lightPos, kLightRadius, kSpotAlpha);
+ canvas->restore();
+ canvas->translate(160, 0);
+ }
+ canvas->restore();
+
+ }
+
+private:
+ using INHERITED = Sample;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+DEF_SAMPLE( return new MaterialShadowsView(); )
diff --git a/third_party/skia/samplecode/SampleMegaStroke.cpp b/third_party/skia/samplecode/SampleMegaStroke.cpp
index 33fa431..15579d9 100644
--- a/third_party/skia/samplecode/SampleMegaStroke.cpp
+++ b/third_party/skia/samplecode/SampleMegaStroke.cpp
@@ -76,7 +76,7 @@
SkRect fClip;
int fAngle;
int fPlusMinus;
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleMixer.cpp b/third_party/skia/samplecode/SampleMixer.cpp
index 7e39ab1..aa164b4 100644
--- a/third_party/skia/samplecode/SampleMixer.cpp
+++ b/third_party/skia/samplecode/SampleMixer.cpp
@@ -40,13 +40,14 @@
void dodraw(SkCanvas* canvas, sk_sp<SkColorFilter> cf0, sk_sp<SkColorFilter> cf1, float gap) {
SkPaint paint;
paint.setColorFilter(cf0);
- canvas->drawImage(fImg, 0, 0, &paint);
+ canvas->drawImage(fImg, 0, 0, SkSamplingOptions(), &paint);
paint.setColorFilter(SkColorFilters::Lerp(fWeight, cf0, cf1));
- canvas->drawImage(fImg, fImg->width() + gap * fWeight, 0, &paint);
+ canvas->drawImage(fImg, fImg->width() + gap * fWeight, 0,
+ SkSamplingOptions(), &paint);
paint.setColorFilter(cf1);
- canvas->drawImage(fImg, 2*fImg->width() + gap, 0, &paint);
+ canvas->drawImage(fImg, 2*fImg->width() + gap, 0, SkSamplingOptions(), &paint);
}
void onDrawContent(SkCanvas* canvas) override {
@@ -71,7 +72,7 @@
}
}
- virtual Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override {
+ Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override {
return fRect.contains(SkScalarRoundToInt(x),
SkScalarRoundToInt(y)) ? new Click() : nullptr;
}
@@ -85,94 +86,6 @@
private:
SkIRect fRect;
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new MixerView; )
-
-//////////////////////////////////////////////////////////////////////////////
-
-#include "include/core/SkMaskFilter.h"
-#include "include/core/SkSurface.h"
-
-static sk_sp<SkShader> make_resource_shader(const char path[], int size) {
- auto img = GetResourceAsImage(path);
- if (!img) {
- return nullptr;
- }
- SkRect src = SkRect::MakeIWH(img->width(), img->height());
- SkRect dst = SkRect::MakeIWH(size, size);
- SkMatrix m;
- m.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
- return img->makeShader(&m);
-}
-
-class ShaderMixerView : public Sample {
- sk_sp<SkShader> fSH0;
- sk_sp<SkShader> fSH1;
- sk_sp<SkSurface> fSurface;
- SkBlendMode fMode = SkBlendMode::kClear;
-
- enum { SIZE = 256 };
-
- const SkRect fRect = SkRect::MakeXYWH(10, 10 + SIZE + 10, SIZE, SIZE);
-
-public:
- ShaderMixerView() {}
-
- void onOnceBeforeDraw() override {
- fSH0 = make_resource_shader("images/mandrill_256.png", SIZE);
- fSH1 = make_resource_shader("images/baby_tux.png", SIZE);
- }
-
-protected:
- SkString name() override { return SkString("ShaderMixer"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- if (!fSurface) {
- fSurface = canvas->makeSurface(SkImageInfo::MakeN32Premul(SIZE, SIZE));
- }
-
- SkPaint paint;
- const SkRect r = SkRect::MakeIWH(SIZE, SIZE);
-
- canvas->translate(10, 10);
-
- canvas->save();
- paint.setShader(fSH0); canvas->drawRect(r, paint);
- canvas->translate(SIZE + 10.f, 0);
- paint.setShader(fSH1); canvas->drawRect(r, paint);
- canvas->restore();
-
- canvas->translate(0, SIZE + 10.f);
-
- auto sh = fSurface->makeImageSnapshot()->makeShader();
-
- canvas->save();
- paint.setShader(sh); canvas->drawRect(r, paint);
- canvas->translate(SIZE + 10.f, 0);
- paint.setShader(SkShaders::Lerp(sh, fSH0, fSH1)); canvas->drawRect(r, paint);
- canvas->restore();
- }
-
- virtual Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override {
- fMode = (fMode == SkBlendMode::kSrcOver) ? SkBlendMode::kClear : SkBlendMode::kSrcOver;
- return fRect.contains(SkScalarRoundToInt(x),
- SkScalarRoundToInt(y)) ? new Click() : nullptr;
- }
-
- bool onClick(Click* click) override {
- SkPaint p;
- p.setAntiAlias(true);
- p.setColor(SK_ColorRED);
- p.setBlendMode(fMode);
- p.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 12));
- SkScalar x = click->fCurr.fX - fRect.fLeft;
- SkScalar y = click->fCurr.fY - fRect.fTop;
- fSurface->getCanvas()->drawCircle(x, y, 10, p);
- return true;
- }
-
-private:
- typedef Sample INHERITED;
-};
-DEF_SAMPLE( return new ShaderMixerView; )
diff --git a/third_party/skia/samplecode/SampleParagraph.cpp b/third_party/skia/samplecode/SampleParagraph.cpp
deleted file mode 100644
index cc10e03..0000000
--- a/third_party/skia/samplecode/SampleParagraph.cpp
+++ /dev/null
@@ -1,1720 +0,0 @@
-// Copyright 2019 Google LLC.
-#include "include/core/SkCanvas.h"
-#include "include/core/SkColorFilter.h"
-#include "include/core/SkColorPriv.h"
-#include "include/core/SkGraphics.h"
-#include "include/core/SkPath.h"
-#include "include/core/SkRegion.h"
-#include "include/core/SkShader.h"
-#include "include/core/SkStream.h"
-#include "include/core/SkTextBlob.h"
-#include "include/core/SkTime.h"
-#include "include/core/SkTypeface.h"
-#include "include/effects/SkBlurMaskFilter.h"
-#include "include/effects/SkGradientShader.h"
-#include "include/utils/SkRandom.h"
-#include "modules/skparagraph/include/Paragraph.h"
-#include "modules/skparagraph/include/TypefaceFontProvider.h"
-#include "modules/skparagraph/src/ParagraphBuilderImpl.h"
-#include "modules/skparagraph/src/ParagraphImpl.h"
-#include "modules/skparagraph/utils/TestFontCollection.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkOSFile.h"
-#include "src/shaders/SkColorShader.h"
-#include "src/utils/SkOSPath.h"
-#include "src/utils/SkUTF.h"
-#include "tools/Resources.h"
-
-using namespace skia::textlayout;
-namespace {
-
-class ParagraphView_Base : public Sample {
-protected:
- sk_sp<TestFontCollection> getFontCollection() {
- // If we reset font collection we need to reset paragraph cache
- static sk_sp<TestFontCollection> fFC = nullptr;
- if (fFC == nullptr) {
- fFC = sk_make_sp<TestFontCollection>(GetResourcePath("fonts").c_str(), false, true);
- }
- return fFC;
- }
-};
-
-sk_sp<SkShader> setgrad(const SkRect& r, SkColor c0, SkColor c1) {
- SkColor colors[] = {c0, c1};
- SkPoint pts[] = {{r.fLeft, r.fTop}, {r.fRight, r.fTop}};
- return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
-}
-/*
-void writeHtml(const char* name, Paragraph* paragraph) {
- SkString tmpDir = skiatest::GetTmpDir();
- if (!tmpDir.isEmpty()) {
- SkString path = SkOSPath::Join(tmpDir.c_str(), name);
- SkFILEWStream file(path.c_str());
- file.write(nullptr, 0);
- }
-}
-*/
-} // namespace
-
-class ParagraphView1 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph1"); }
-
- void drawTest(SkCanvas* canvas, SkScalar w, SkScalar h, SkColor fg, SkColor bg) {
- const std::vector<
- std::tuple<std::string, bool, bool, int, SkColor, SkColor, bool, TextDecorationStyle>>
- gParagraph = {{"monospace", true, false, 14, SK_ColorWHITE, SK_ColorRED, true,
- TextDecorationStyle::kDashed},
- {"Assyrian", false, false, 20, SK_ColorWHITE, SK_ColorBLUE, false,
- TextDecorationStyle::kDotted},
- {"serif", true, true, 10, SK_ColorWHITE, SK_ColorRED, true,
- TextDecorationStyle::kDouble},
- {"Arial", false, true, 16, SK_ColorGRAY, SK_ColorGREEN, true,
- TextDecorationStyle::kSolid},
- {"sans-serif", false, false, 8, SK_ColorWHITE, SK_ColorRED, false,
- TextDecorationStyle::kWavy}};
- SkAutoCanvasRestore acr(canvas, true);
-
- canvas->clipRect(SkRect::MakeWH(w, h));
- canvas->drawColor(SK_ColorWHITE);
-
- SkScalar margin = 20;
-
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setColor(fg);
-
- SkPaint blue;
- blue.setColor(SK_ColorBLUE);
-
- TextStyle defaultStyle;
- defaultStyle.setBackgroundColor(blue);
- defaultStyle.setForegroundColor(paint);
- ParagraphStyle paraStyle;
-
- auto fontCollection = sk_make_sp<FontCollection>();
- fontCollection->setDefaultFontManager(SkFontMgr::RefDefault());
- for (auto i = 1; i < 5; ++i) {
- defaultStyle.setFontSize(24 * i);
- paraStyle.setTextStyle(defaultStyle);
- ParagraphBuilderImpl builder(paraStyle, fontCollection);
- std::string name = "Paragraph: " + std::to_string(24 * i);
- builder.addText(name.c_str(), name.length());
- for (auto para : gParagraph) {
- TextStyle style;
- style.setFontFamilies({SkString(std::get<0>(para).c_str())});
- SkFontStyle fontStyle(std::get<1>(para) ? SkFontStyle::Weight::kBold_Weight
- : SkFontStyle::Weight::kNormal_Weight,
- SkFontStyle::Width::kNormal_Width,
- std::get<2>(para) ? SkFontStyle::Slant::kItalic_Slant
- : SkFontStyle::Slant::kUpright_Slant);
- style.setFontStyle(fontStyle);
- style.setFontSize(std::get<3>(para) * i);
- SkPaint background;
- background.setColor(std::get<4>(para));
- style.setBackgroundColor(background);
- SkPaint foreground;
- foreground.setColor(std::get<5>(para));
- foreground.setAntiAlias(true);
- style.setForegroundColor(foreground);
- if (std::get<6>(para)) {
- style.addShadow(TextShadow(SK_ColorBLACK, SkPoint::Make(5, 5), 2));
- }
-
- auto decoration = (i % 4);
- if (decoration == 3) {
- decoration = 4;
- }
-
- bool test = (TextDecoration)decoration != TextDecoration::kNoDecoration;
- std::string deco = std::to_string((int)decoration);
- if (test) {
- style.setDecoration((TextDecoration)decoration);
- style.setDecorationStyle(std::get<7>(para));
- style.setDecorationColor(std::get<5>(para));
- }
- builder.pushStyle(style);
- std::string name = " " + std::get<0>(para) + " " +
- (std::get<1>(para) ? ", bold" : "") +
- (std::get<2>(para) ? ", italic" : "") + " " +
- std::to_string(std::get<3>(para) * i) +
- (std::get<4>(para) != bg ? ", background" : "") +
- (std::get<5>(para) != fg ? ", foreground" : "") +
- (std::get<6>(para) ? ", shadow" : "") +
- (test ? ", decorations " + deco : "") + ";";
- builder.addText(name.c_str(), name.length());
- builder.pop();
- }
-
- auto paragraph = builder.Build();
- paragraph->layout(w - margin * 2);
- paragraph->paint(canvas, margin, margin);
-
- canvas->translate(0, paragraph->getHeight());
- }
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- drawTest(canvas, this->width(), this->height(), SK_ColorRED, SK_ColorWHITE);
- }
-
-private:
-
- typedef Sample INHERITED;
-};
-
-class ParagraphView2 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph2"); }
-
- void drawCode(SkCanvas* canvas, SkScalar w, SkScalar h) {
- SkPaint comment;
- comment.setColor(SK_ColorGRAY);
- SkPaint constant;
- constant.setColor(SK_ColorMAGENTA);
- SkPaint null;
- null.setColor(SK_ColorMAGENTA);
- SkPaint literal;
- literal.setColor(SK_ColorGREEN);
- SkPaint code;
- code.setColor(SK_ColorDKGRAY);
- SkPaint number;
- number.setColor(SK_ColorBLUE);
- SkPaint name;
- name.setColor(SK_ColorRED);
-
- SkPaint white;
- white.setColor(SK_ColorWHITE);
-
- TextStyle defaultStyle;
- defaultStyle.setBackgroundColor(white);
- defaultStyle.setForegroundColor(code);
- defaultStyle.setFontFamilies({SkString("monospace")});
- defaultStyle.setFontSize(30);
- ParagraphStyle paraStyle;
- paraStyle.setTextStyle(defaultStyle);
-
- auto fontCollection = sk_make_sp<FontCollection>();
- fontCollection->setDefaultFontManager(SkFontMgr::RefDefault());
- ParagraphBuilderImpl builder(paraStyle, fontCollection);
-
- const char* text1 = "RaisedButton";
- const char* text2 = "(\n";
- const char* text3 = " child: ";
- const char* text4 = "const";
- const char* text5 = "Text";
- const char* text6 = "'BUTTON TITLE'";
- const char* text7 = "),\n";
-
- builder.pushStyle(style(name));
- builder.addText(text1, strlen(text1));
- builder.pop();
- builder.addText(text2, strlen(text2));
- builder.addText(text3, strlen(text3));
- builder.pushStyle(style(constant));
- builder.addText(text4, strlen(text4));
- builder.pop();
- builder.addText(" ", 1);
- builder.pushStyle(style(name));
- builder.addText(text5, strlen(text5));
- builder.pop();
- builder.addText("(", 1);
- builder.pushStyle(style(literal));
- builder.addText(text6, strlen(text6));
- builder.pop();
- builder.addText(text7, strlen(text7));
-
- auto paragraph = builder.Build();
- paragraph->layout(w - 20);
-
- paragraph->paint(canvas, 20, 20);
- }
-
- TextStyle style(SkPaint paint) {
- TextStyle style;
- paint.setAntiAlias(true);
- style.setForegroundColor(paint);
- style.setFontFamilies({SkString("monospace")});
- style.setFontSize(30);
-
- return style;
- }
-
- void drawText(SkCanvas* canvas, SkScalar w, SkScalar h, std::vector<const char*>& text,
- SkColor fg = SK_ColorDKGRAY, SkColor bg = SK_ColorWHITE,
- const char* ff = "sans-serif", SkScalar fs = 24,
- size_t lineLimit = 30,
- const std::u16string& ellipsis = u"\u2026") {
- SkAutoCanvasRestore acr(canvas, true);
-
- canvas->clipRect(SkRect::MakeWH(w, h));
- canvas->drawColor(bg);
-
- SkScalar margin = 20;
-
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setColor(fg);
-
- SkPaint blue;
- blue.setColor(SK_ColorBLUE);
-
- SkPaint background;
- background.setColor(bg);
-
- TextStyle style;
- style.setBackgroundColor(blue);
- style.setForegroundColor(paint);
- style.setFontFamilies({SkString(ff)});
- style.setFontStyle(SkFontStyle(SkFontStyle::kMedium_Weight,
- SkFontStyle::kNormal_Width,
- SkFontStyle::kUpright_Slant));
- style.setFontSize(fs);
- ParagraphStyle paraStyle;
- paraStyle.setTextStyle(style);
- paraStyle.setMaxLines(lineLimit);
-
- paraStyle.setEllipsis(ellipsis);
- TextStyle defaultStyle;
- defaultStyle.setFontSize(20);
- paraStyle.setTextStyle(defaultStyle);
- ParagraphBuilderImpl builder(paraStyle, getFontCollection());
-
- SkPaint foreground;
- foreground.setColor(fg);
- style.setForegroundColor(foreground);
- style.setBackgroundColor(background);
-
- for (auto& part : text) {
- builder.pushStyle(style);
- builder.addText(part, strlen(part));
- builder.pop();
- }
-
- auto paragraph = builder.Build();
- paragraph->layout(w - margin * 2);
- paragraph->paint(canvas, margin, margin);
-
- canvas->translate(0, paragraph->getHeight() + margin);
- }
-
- void drawLine(SkCanvas* canvas, SkScalar w, SkScalar h, const std::string& text,
- TextAlign align) {
- SkAutoCanvasRestore acr(canvas, true);
-
- canvas->clipRect(SkRect::MakeWH(w, h));
- canvas->drawColor(SK_ColorWHITE);
-
- SkScalar margin = 20;
-
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setColor(SK_ColorBLUE);
-
- SkPaint gray;
- gray.setColor(SK_ColorLTGRAY);
-
- TextStyle style;
- style.setBackgroundColor(gray);
- style.setForegroundColor(paint);
- style.setFontFamilies({SkString("Arial")});
- style.setFontSize(30);
- ParagraphStyle paraStyle;
- paraStyle.setTextStyle(style);
- paraStyle.setTextAlign(align);
-
- auto fontCollection = sk_make_sp<FontCollection>();
- fontCollection->setDefaultFontManager(SkFontMgr::RefDefault());
- ParagraphBuilderImpl builder(paraStyle, fontCollection);
- builder.addText(text.c_str(), text.length());
-
- auto paragraph = builder.Build();
- paragraph->layout(w - margin * 2);
- paragraph->layout(w - margin);
- paragraph->paint(canvas, margin, margin);
-
- canvas->translate(0, paragraph->getHeight() + margin);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- std::vector<const char*> cupertino = {
- "google_logogoogle_gsuper_g_logo 1 "
- "google_logogoogle_gsuper_g_logo 12 "
- "google_logogoogle_gsuper_g_logo 123 "
- "google_logogoogle_gsuper_g_logo 1234 "
- "google_logogoogle_gsuper_g_logo 12345 "
- "google_logogoogle_gsuper_g_logo 123456 "
- "google_logogoogle_gsuper_g_logo 1234567 "
- "google_logogoogle_gsuper_g_logo 12345678 "
- "google_logogoogle_gsuper_g_logo 123456789 "
- "google_logogoogle_gsuper_g_logo 1234567890 "
- "google_logogoogle_gsuper_g_logo 123456789 "
- "google_logogoogle_gsuper_g_logo 12345678 "
- "google_logogoogle_gsuper_g_logo 1234567 "
- "google_logogoogle_gsuper_g_logo 123456 "
- "google_logogoogle_gsuper_g_logo 12345 "
- "google_logogoogle_gsuper_g_logo 1234 "
- "google_logogoogle_gsuper_g_logo 123 "
- "google_logogoogle_gsuper_g_logo 12 "
- "google_logogoogle_gsuper_g_logo 1 "
- "google_logogoogle_gsuper_g_logo "
- "google_logogoogle_gsuper_g_logo "
- "google_logogoogle_gsuper_g_logo "
- "google_logogoogle_gsuper_g_logo "
- "google_logogoogle_gsuper_g_logo "
- "google_logogoogle_gsuper_g_logo"};
- std::vector<const char*> text = {
- "My neighbor came over to say,\n"
- "Although not in a neighborly way,\n\n"
- "That he'd knock me around,\n\n\n"
- "If I didn't stop the sound,\n\n\n\n"
- "Of the classical music I play."};
-
- std::vector<const char*> long_word = {
- "A_very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
- "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
- "very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_very_"
- "very_very_very_very_very_very_very_long_text"};
-
- std::vector<const char*> very_long = {
- "A very very very very very very very very very very very very very very very very "
- "very very very very very very very very very very very very very very very very "
- "very very very very very very very very very very very very very very very very "
- "very very very very very very very long text"};
-
- std::vector<const char*> very_word = {
- "A very_very_very_very_very_very_very_very_very_very "
- "very_very_very_very_very_very_very_very_very_very very very very very very very "
- "very very very very very very very very very very very very very very very very "
- "very very very very very very very very very very very very very long text"};
-
- SkScalar width = this->width() / 5;
- SkScalar height = this->height();
- drawText(canvas, width, height, long_word, SK_ColorBLACK, SK_ColorWHITE, "Google Sans", 30);
- canvas->translate(width, 0);
- drawText(canvas, width, height, very_long, SK_ColorBLACK, SK_ColorWHITE, "Google Sans", 30);
- canvas->translate(width, 0);
- drawText(canvas, width, height, very_word, SK_ColorBLACK, SK_ColorWHITE, "Google Sans", 30);
- canvas->translate(width, 0);
- drawText(canvas, width, height / 2, text, SK_ColorBLACK, SK_ColorWHITE, "Roboto", 20, 100,
- u"\u2026");
- canvas->translate(0, height / 2);
- drawCode(canvas, width, height / 2);
- canvas->translate(width, -height / 2);
-
- drawText(canvas, width, height, cupertino, SK_ColorBLACK, SK_ColorWHITE, "Google Sans", 30);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView3 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph3"); }
-
- void drawLine(SkCanvas* canvas, SkScalar w, SkScalar h, const std::string& text,
- TextAlign align, size_t lineLimit = std::numeric_limits<size_t>::max(),
- bool RTL = false, SkColor background = SK_ColorGRAY,
- const std::u16string& ellipsis = u"\u2026") {
- SkAutoCanvasRestore acr(canvas, true);
-
- canvas->clipRect(SkRect::MakeWH(w, h));
- canvas->drawColor(SK_ColorWHITE);
-
- SkScalar margin = 20;
-
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setColor(SK_ColorBLACK);
-
- SkPaint gray;
- gray.setColor(background);
-
- SkPaint yellow;
- yellow.setColor(SK_ColorYELLOW);
-
- TextStyle style;
- style.setBackgroundColor(gray);
- style.setForegroundColor(paint);
- style.setFontFamilies({SkString("sans-serif")});
- style.setFontSize(30);
- ParagraphStyle paraStyle;
- paraStyle.setTextStyle(style);
- paraStyle.setTextAlign(align);
- paraStyle.setMaxLines(lineLimit);
- paraStyle.setEllipsis(ellipsis);
- // paraStyle.setTextDirection(RTL ? SkTextDirection::rtl : SkTextDirection::ltr);
-
- auto fontCollection = sk_make_sp<FontCollection>();
- fontCollection->setDefaultFontManager(SkFontMgr::RefDefault());
- ParagraphBuilderImpl builder(paraStyle, fontCollection);
- if (RTL) {
- builder.addText(mirror(text));
- } else {
- builder.addText(normal(text));
- }
-
- canvas->drawRect(SkRect::MakeXYWH(margin, margin, w - margin * 2, h - margin * 2), yellow);
- auto paragraph = builder.Build();
- paragraph->layout(w - margin * 2);
- paragraph->paint(canvas, margin, margin);
- }
-
- std::u16string mirror(const std::string& text) {
- std::u16string result;
- result += u"\u202E";
- // for (auto i = text.size(); i > 0; --i) {
- // result += text[i - 1];
- //}
-
- for (auto i = text.size(); i > 0; --i) {
- auto ch = text[i - 1];
- if (ch == ',') {
- result += u"!";
- } else if (ch == '.') {
- result += u"!";
- } else {
- result += ch;
- }
- }
-
- result += u"\u202C";
- return result;
- }
-
- std::u16string normal(const std::string& text) {
- std::u16string result;
- result += u"\u202D";
- for (auto ch : text) {
- result += ch;
- }
- result += u"\u202C";
- return result;
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- const std::string options = // { "open-source open-source open-source open-source" };
- {"Flutter is an open-source project to help developers "
- "build high-performance, high-fidelity, mobile apps for "
- "iOS and Android "
- "from a single codebase. This design lab is a playground "
- "and showcase of Flutter's many widgets, behaviors, "
- "animations, layouts, and more."};
-
- canvas->drawColor(SK_ColorDKGRAY);
- SkScalar width = this->width() / 4;
- SkScalar height = this->height() / 2;
-
- const std::string line =
- "World domination is such an ugly phrase - I prefer to call it world optimisation";
-
- drawLine(canvas, width, height, line, TextAlign::kLeft, 1, false, SK_ColorLTGRAY);
- canvas->translate(width, 0);
- drawLine(canvas, width, height, line, TextAlign::kRight, 2, false, SK_ColorLTGRAY);
- canvas->translate(width, 0);
- drawLine(canvas, width, height, line, TextAlign::kCenter, 3, false, SK_ColorLTGRAY);
- canvas->translate(width, 0);
- drawLine(canvas, width, height, line, TextAlign::kJustify, 4, false, SK_ColorLTGRAY);
- canvas->translate(-width * 3, height);
-
- drawLine(canvas, width, height, line, TextAlign::kLeft, 1, true, SK_ColorLTGRAY);
- canvas->translate(width, 0);
- drawLine(canvas, width, height, line, TextAlign::kRight, 2, true, SK_ColorLTGRAY);
- canvas->translate(width, 0);
- drawLine(canvas, width, height, line, TextAlign::kCenter, 3, true, SK_ColorLTGRAY);
- canvas->translate(width, 0);
- drawLine(canvas, width, height, line, TextAlign::kJustify, 4, true, SK_ColorLTGRAY);
- canvas->translate(width, 0);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView4 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph4"); }
-
- void drawFlutter(SkCanvas* canvas, SkScalar w, SkScalar h,
- const char* ff = "Google Sans", SkScalar fs = 30,
- size_t lineLimit = std::numeric_limits<size_t>::max(),
- const std::u16string& ellipsis = u"\u2026") {
- SkAutoCanvasRestore acr(canvas, true);
-
- canvas->clipRect(SkRect::MakeWH(w, h));
-
- SkScalar margin = 20;
-
- SkPaint black;
- black.setAntiAlias(true);
- black.setColor(SK_ColorBLACK);
-
- SkPaint blue;
- blue.setAntiAlias(true);
- blue.setColor(SK_ColorBLUE);
-
- SkPaint red;
- red.setAntiAlias(true);
- red.setColor(SK_ColorRED);
-
- SkPaint green;
- green.setAntiAlias(true);
- green.setColor(SK_ColorGREEN);
-
- SkPaint gray;
- gray.setColor(SK_ColorLTGRAY);
-
- SkPaint yellow;
- yellow.setColor(SK_ColorYELLOW);
-
- SkPaint magenta;
- magenta.setAntiAlias(true);
- magenta.setColor(SK_ColorMAGENTA);
-
- TextStyle style;
- style.setFontFamilies({SkString(ff)});
- style.setFontSize(fs);
-
- TextStyle style0;
- style0.setForegroundColor(black);
- style0.setBackgroundColor(gray);
- style0.setFontFamilies({SkString(ff)});
- style0.setFontSize(fs);
- style0.setDecoration(TextDecoration::kUnderline);
- style0.setDecorationStyle(TextDecorationStyle::kDouble);
- style0.setDecorationColor(SK_ColorBLACK);
-
- TextStyle style1;
- style1.setForegroundColor(blue);
- style1.setBackgroundColor(yellow);
- style1.setFontFamilies({SkString(ff)});
- style1.setFontSize(fs);
- style1.setDecoration(TextDecoration::kOverline);
- style1.setDecorationStyle(TextDecorationStyle::kWavy);
- style1.setDecorationColor(SK_ColorBLACK);
-
- TextStyle style2;
- style2.setForegroundColor(red);
- style2.setFontFamilies({SkString(ff)});
- style2.setFontSize(fs);
-
- TextStyle style3;
- style3.setForegroundColor(green);
- style3.setFontFamilies({SkString(ff)});
- style3.setFontSize(fs);
-
- TextStyle style4;
- style4.setForegroundColor(magenta);
- style4.setFontFamilies({SkString(ff)});
- style4.setFontSize(fs);
-
- ParagraphStyle paraStyle;
- paraStyle.setTextStyle(style);
- paraStyle.setMaxLines(lineLimit);
-
- paraStyle.setEllipsis(ellipsis);
-
- const char* logo1 = "google_";
- const char* logo2 = "logo";
- const char* logo3 = "go";
- const char* logo4 = "ogle_logo";
- const char* logo5 = "google_lo";
- const char* logo6 = "go";
- {
- ParagraphBuilderImpl builder(paraStyle, getFontCollection());
-
- builder.pushStyle(style0);
- builder.addText(logo1, strlen(logo1));
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(logo2, strlen(logo2));
- builder.pop();
-
- builder.addText(" ", 1);
-
- builder.pushStyle(style0);
- builder.addText(logo3, strlen(logo3));
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(logo4, strlen(logo4));
- builder.pop();
-
- builder.addText(" ", 1);
-
- builder.pushStyle(style0);
- builder.addText(logo5, strlen(logo5));
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(logo6, strlen(logo6));
- builder.pop();
-
- auto paragraph = builder.Build();
- paragraph->layout(w - margin * 2);
- paragraph->paint(canvas, margin, margin);
- canvas->translate(0, h + margin);
- }
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
- SkScalar width = this->width();
- SkScalar height = this->height();
-
- drawFlutter(canvas, width, height / 2);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView5 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph5"); }
-
- void bidi(SkCanvas* canvas, SkScalar w, SkScalar h, const std::u16string& text,
- const std::u16string& expected, size_t lineLimit = std::numeric_limits<size_t>::max(),
- const char* ff = "Roboto", SkScalar fs = 30,
- const std::u16string& ellipsis = u"\u2026") {
- SkAutoCanvasRestore acr(canvas, true);
-
- canvas->clipRect(SkRect::MakeWH(w, h));
-
- SkScalar margin = 20;
-
- SkPaint black;
- black.setColor(SK_ColorBLACK);
- SkPaint gray;
- gray.setColor(SK_ColorLTGRAY);
-
- TextStyle style;
- style.setForegroundColor(black);
- style.setFontFamilies({SkString(ff)});
- style.setFontSize(fs);
-
- TextStyle style0;
- style0.setForegroundColor(black);
- style0.setFontFamilies({SkString(ff)});
- style0.setFontSize(fs);
- style0.setFontStyle(SkFontStyle(SkFontStyle::kNormal_Weight, SkFontStyle::kNormal_Width,
- SkFontStyle::kItalic_Slant));
-
- TextStyle style1;
- style1.setForegroundColor(gray);
- style1.setFontFamilies({SkString(ff)});
- style1.setFontSize(fs);
- style1.setFontStyle(SkFontStyle(SkFontStyle::kBold_Weight, SkFontStyle::kNormal_Width,
- SkFontStyle::kUpright_Slant));
-
- ParagraphStyle paraStyle;
- paraStyle.setTextStyle(style);
- paraStyle.setMaxLines(lineLimit);
-
- paraStyle.setEllipsis(ellipsis);
-
- ParagraphBuilderImpl builder(paraStyle, getFontCollection());
-
- if (text.empty()) {
- const std::u16string text0 = u"\u202Dabc";
- const std::u16string text1 = u"\u202EFED";
- const std::u16string text2 = u"\u202Dghi";
- const std::u16string text3 = u"\u202ELKJ";
- const std::u16string text4 = u"\u202Dmno";
- builder.pushStyle(style0);
- builder.addText(text0);
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(text1);
- builder.pop();
- builder.pushStyle(style0);
- builder.addText(text2);
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(text3);
- builder.pop();
- builder.pushStyle(style0);
- builder.addText(text4);
- builder.pop();
- } else {
- // icu::UnicodeString unicode((UChar*) text.data(), SkToS32(text.size()));
- // std::string str;
- // unicode.toUTF8String(str);
- // SkDebugf("Text: %s\n", str.c_str());
- builder.addText(text + expected);
- }
-
- auto paragraph = builder.Build();
- paragraph->layout(w - margin * 2);
- paragraph->paint(canvas, margin, margin);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
- SkScalar width = this->width();
- SkScalar height = this->height() / 8;
-
- const std::u16string text1 =
- u"A \u202ENAC\u202Cner, exceedingly \u202ENAC\u202Cny,\n"
- "One morning remarked to his granny:\n"
- "A \u202ENAC\u202Cner \u202ENAC\u202C \u202ENAC\u202C,\n"
- "Anything that he \u202ENAC\u202C,\n"
- "But a \u202ENAC\u202Cner \u202ENAC\u202C't \u202ENAC\u202C a \u202ENAC\u202C, "
- "\u202ENAC\u202C he?";
- bidi(canvas, width, height * 3, text1, u"", 5);
- canvas->translate(0, height * 3);
-
- bidi(canvas, width, height, u"\u2067DETALOSI\u2069", u"");
- canvas->translate(0, height);
-
- bidi(canvas, width, height, u"\u202BDEDDEBME\u202C", u"");
- canvas->translate(0, height);
-
- bidi(canvas, width, height, u"\u202EEDIRREVO\u202C", u"");
- canvas->translate(0, height);
-
- bidi(canvas, width, height, u"\u200FTICILPMI\u200E", u"");
- canvas->translate(0, height);
-
- bidi(canvas, width, height, u"123 456 7890 \u202EZYXWV UTS RQP ONM LKJ IHG FED CBA\u202C.",
- u"", 2);
- canvas->translate(0, height);
-
- // bidi(canvas, width, height, u"", u"");
- // canvas->translate(0, height);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView6 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph6"); }
-
- void hangingS(SkCanvas* canvas, SkScalar w, SkScalar h, SkScalar fs = 60.0) {
- auto ff = "HangingS";
-
- canvas->drawColor(SK_ColorLTGRAY);
-
- SkPaint black;
- black.setAntiAlias(true);
- black.setColor(SK_ColorBLACK);
-
- SkPaint blue;
- blue.setAntiAlias(true);
- blue.setColor(SK_ColorBLUE);
-
- SkPaint red;
- red.setAntiAlias(true);
- red.setColor(SK_ColorRED);
-
- SkPaint green;
- green.setAntiAlias(true);
- green.setColor(SK_ColorGREEN);
-
- SkPaint gray;
- gray.setColor(SK_ColorCYAN);
-
- SkPaint yellow;
- yellow.setColor(SK_ColorYELLOW);
-
- SkPaint magenta;
- magenta.setAntiAlias(true);
- magenta.setColor(SK_ColorMAGENTA);
-
- SkFontStyle fontStyle(SkFontStyle::kBold_Weight, SkFontStyle::kNormal_Width,
- SkFontStyle::kItalic_Slant);
-
- TextStyle style;
- style.setFontFamilies({SkString(ff)});
- style.setFontSize(fs);
- style.setFontStyle(fontStyle);
-
- TextStyle style0;
- style0.setForegroundColor(black);
- style0.setBackgroundColor(gray);
- style0.setFontFamilies({SkString(ff)});
- style0.setFontSize(fs);
- style0.setFontStyle(fontStyle);
-
- TextStyle style1;
- style1.setForegroundColor(blue);
- style1.setBackgroundColor(yellow);
- style1.setFontFamilies({SkString(ff)});
- style1.setFontSize(fs);
- style1.setFontStyle(fontStyle);
-
- TextStyle style2;
- style2.setForegroundColor(red);
- style2.setFontFamilies({SkString(ff)});
- style2.setFontSize(fs);
- style2.setFontStyle(fontStyle);
-
- TextStyle style3;
- style3.setForegroundColor(green);
- style3.setFontFamilies({SkString(ff)});
- style3.setFontSize(fs);
- style3.setFontStyle(fontStyle);
-
- TextStyle style4;
- style4.setForegroundColor(magenta);
- style4.setFontFamilies({SkString(ff)});
- style4.setFontSize(fs);
- style4.setFontStyle(fontStyle);
-
- ParagraphStyle paraStyle;
- paraStyle.setTextStyle(style);
-
- const char* logo1 = "S";
- const char* logo2 = "kia";
- const char* logo3 = "Sk";
- const char* logo4 = "ia";
- const char* logo5 = "Ski";
- const char* logo6 = "a";
- {
- ParagraphBuilderImpl builder(paraStyle, getFontCollection());
-
- builder.pushStyle(style0);
- builder.addText(logo1, strlen(logo1));
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(logo2, strlen(logo2));
- builder.pop();
-
- builder.addText(" ", 3);
-
- builder.pushStyle(style0);
- builder.addText(logo3, strlen(logo3));
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(logo4, strlen(logo4));
- builder.pop();
-
- builder.addText(" ", 3);
-
- builder.pushStyle(style0);
- builder.addText(logo5, strlen(logo5));
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(logo6, strlen(logo6));
- builder.pop();
-
- auto paragraph = builder.Build();
- paragraph->layout(w);
- paragraph->paint(canvas, 40, 40);
- canvas->translate(0, h);
- }
-
- const char* logo11 = "S";
- const char* logo12 = "S";
- const char* logo13 = "S";
- const char* logo14 = "S";
- const char* logo15 = "S";
- const char* logo16 = "S";
- {
- ParagraphBuilderImpl builder(paraStyle, getFontCollection());
-
- builder.pushStyle(style0);
- builder.addText(logo11, strlen(logo1));
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(logo12, strlen(logo2));
- builder.pop();
-
- builder.addText(" ", 3);
-
- builder.pushStyle(style0);
- builder.addText(logo13, strlen(logo3));
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(logo14, strlen(logo4));
- builder.pop();
-
- builder.addText(" ", 3);
-
- builder.pushStyle(style0);
- builder.addText(logo15, strlen(logo5));
- builder.pop();
- builder.pushStyle(style1);
- builder.addText(logo16, strlen(logo6));
- builder.pop();
-
- auto paragraph = builder.Build();
- paragraph->layout(w);
- paragraph->paint(canvas, 40, h);
- canvas->translate(0, h);
- }
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
- SkScalar width = this->width();
- SkScalar height = this->height() / 4;
-
- hangingS(canvas, width, height);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView7 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph7"); }
-
- void drawText(SkCanvas* canvas, SkColor background, SkScalar letterSpace, SkScalar w,
- SkScalar h) {
- SkAutoCanvasRestore acr(canvas, true);
- canvas->clipRect(SkRect::MakeWH(w, h));
- canvas->drawColor(background);
-
- const char* line =
- "World domination is such an ugly phrase - I prefer to call it world optimisation.";
-
- ParagraphStyle paragraphStyle;
- paragraphStyle.setTextAlign(TextAlign::kLeft);
- paragraphStyle.setMaxLines(10);
- paragraphStyle.turnHintingOff();
- TextStyle textStyle;
- textStyle.setFontFamilies({SkString("Roboto")});
- textStyle.setFontSize(30);
- textStyle.setLetterSpacing(letterSpace);
- textStyle.setColor(SK_ColorBLACK);
- textStyle.setFontStyle(SkFontStyle(SkFontStyle::kMedium_Weight, SkFontStyle::kNormal_Width,
- SkFontStyle::kUpright_Slant));
-
- ParagraphBuilderImpl builder(paragraphStyle, getFontCollection());
- builder.pushStyle(textStyle);
- builder.addText(line, strlen(line));
- builder.pop();
-
- auto paragraph = builder.Build();
- paragraph->layout(w - 20);
- paragraph->paint(canvas, 10, 10);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- auto h = this->height() / 4;
- auto w = this->width() / 2;
-
- drawText(canvas, SK_ColorGRAY, 1, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorLTGRAY, 2, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorCYAN, 3, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorGRAY, 4, w, h);
- canvas->translate(w, -3 * h);
-
- drawText(canvas, SK_ColorYELLOW, 5, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorGREEN, 10, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorRED, 15, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorBLUE, 20, w, h);
- canvas->translate(0, h);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView8 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph8"); }
-
- void drawText(SkCanvas* canvas, SkColor background, SkScalar wordSpace, SkScalar w,
- SkScalar h) {
- SkAutoCanvasRestore acr(canvas, true);
- canvas->clipRect(SkRect::MakeWH(w, h));
- canvas->drawColor(background);
-
- const char* line =
- "World domination is such an ugly phrase - I prefer to call it world optimisation.";
-
- ParagraphStyle paragraphStyle;
- paragraphStyle.setTextAlign(TextAlign::kLeft);
- paragraphStyle.setMaxLines(10);
- paragraphStyle.turnHintingOff();
- TextStyle textStyle;
- textStyle.setFontFamilies({SkString("Roboto")});
- textStyle.setFontSize(30);
- textStyle.setWordSpacing(wordSpace);
- textStyle.setColor(SK_ColorBLACK);
- textStyle.setFontStyle(SkFontStyle(SkFontStyle::kMedium_Weight, SkFontStyle::kNormal_Width,
- SkFontStyle::kUpright_Slant));
-
- ParagraphBuilderImpl builder(paragraphStyle, getFontCollection());
- builder.pushStyle(textStyle);
- builder.addText(line, strlen(line));
- builder.pop();
-
- auto paragraph = builder.Build();
- paragraph->layout(w - 20);
- paragraph->paint(canvas, 10, 10);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- auto h = this->height() / 4;
- auto w = this->width() / 2;
-
- drawText(canvas, SK_ColorGRAY, 1, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorLTGRAY, 2, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorCYAN, 3, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorGRAY, 4, w, h);
- canvas->translate(w, -3 * h);
-
- drawText(canvas, SK_ColorYELLOW, 5, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorGREEN, 10, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorRED, 15, w, h);
- canvas->translate(0, h);
-
- drawText(canvas, SK_ColorBLUE, 20, w, h);
- canvas->translate(0, h);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView9 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph9"); }
-
- bool onChar(SkUnichar uni) override {
- switch (uni) {
- case 'w':
- ++wordSpacing;
- return true;
- case 'q':
- if (wordSpacing > 0) --wordSpacing;
- return true;
- case 'l':
- ++letterSpacing;
- return true;
- case 'k':
- if (letterSpacing > 0) --letterSpacing;
- return true;
- default:
- break;
- }
- return false;
- }
-
- void drawText(SkCanvas* canvas, SkColor background, SkScalar w, SkScalar h) {
- SkAutoCanvasRestore acr(canvas, true);
- canvas->clipRect(SkRect::MakeWH(w, h));
- canvas->drawColor(background);
-
- auto fontCollection = sk_make_sp<FontCollection>();
- fontCollection->setDefaultFontManager(SkFontMgr::RefDefault());
- fontCollection->enableFontFallback();
-
- const char* text =
- "( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)("
- " ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)("
- " ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)( ´･‿･｀)";
- auto multiplier = 5.67;
- ParagraphStyle paragraphStyle;
- paragraphStyle.setTextAlign(TextAlign::kLeft);
- paragraphStyle.setMaxLines(10);
- paragraphStyle.turnHintingOff();
- TextStyle textStyle;
- textStyle.setFontFamilies({SkString("Roboto")});
- textStyle.setFontSize(5 * multiplier);
- textStyle.setHeight(1.3f);
- textStyle.setColor(SK_ColorBLACK);
- textStyle.setFontStyle(SkFontStyle(SkFontStyle::kMedium_Weight, SkFontStyle::kNormal_Width,
- SkFontStyle::kUpright_Slant));
-
- ParagraphBuilderImpl builder(paragraphStyle, fontCollection);
- builder.pushStyle(textStyle);
- builder.addText(text, strlen(text));
- builder.pop();
-
- auto paragraph = builder.Build();
- paragraph->layout(200 * multiplier);
-
- std::vector<size_t> sizes = {0, 1, 2, 8, 19, 21, 22, 30, 150};
-
- std::vector<size_t> colors = {SK_ColorBLUE, SK_ColorCYAN, SK_ColorLTGRAY, SK_ColorGREEN,
- SK_ColorRED, SK_ColorWHITE, SK_ColorYELLOW, SK_ColorMAGENTA};
-
- RectHeightStyle rect_height_style = RectHeightStyle::kTight;
- RectWidthStyle rect_width_style = RectWidthStyle::kTight;
-
- for (size_t i = 0; i < sizes.size() - 1; ++i) {
- size_t from = sizes[i];
- size_t to = sizes[i + 1];
- auto boxes = paragraph->getRectsForRange(from, to, rect_height_style, rect_width_style);
- if (boxes.empty()) {
- continue;
- }
- for (auto& box : boxes) {
- SkPaint paint;
- paint.setColor(colors[i % colors.size()]);
- paint.setShader(setgrad(box.rect, colors[i % colors.size()], SK_ColorWHITE));
- canvas->drawRect(box.rect, paint);
- }
- }
-
- paragraph->paint(canvas, 0, 0);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- auto h = this->height();
- auto w = this->width();
-
- drawText(canvas, SK_ColorGRAY, w, h);
- }
-
-private:
- typedef Sample INHERITED;
- SkScalar letterSpacing;
- SkScalar wordSpacing;
-};
-
-class ParagraphView10 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph10"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
- auto multiplier = 5.67;
- const char* text = "English English 字典 字典 😀😃😄 😀😃😄";
-
- auto fontCollection = sk_make_sp<FontCollection>();
- fontCollection->setDefaultFontManager(SkFontMgr::RefDefault());
- fontCollection->enableFontFallback();
-
- ParagraphStyle paragraph_style;
- paragraph_style.turnHintingOff();
- ParagraphBuilderImpl builder(paragraph_style, fontCollection);
-
- TextStyle text_style;
- text_style.setFontFamilies({SkString("Roboto"),
- SkString("Noto Color Emoji"),
- SkString("Noto Serif CJK JP")});
- text_style.setFontSize(10 * multiplier);
- text_style.setLetterSpacing(0);
- text_style.setWordSpacing(0);
- text_style.setColor(SK_ColorBLACK);
- text_style.setHeight(1);
- builder.pushStyle(text_style);
- builder.addText(text, strlen(text));
- builder.pop();
-
- auto paragraph = builder.Build();
- paragraph->layout(width());
-
- paragraph->paint(canvas, 0, 0);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView11 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph11"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- auto text = "\U0001f469\U0000200D\U0001f469\U0000200D\U0001f466\U0001f469\U0000200D\U0001f469\U0000200D\U0001f467\U0000200D\U0001f467\U0001f1fa\U0001f1f8";
-
- TextStyle text_style;
- text_style.setFontFamilies({SkString("Ahem")});
- text_style.setColor(SK_ColorBLACK);
- text_style.setFontSize(60);
- text_style.setLetterSpacing(0);
- text_style.setWordSpacing(0);
- ParagraphStyle paragraph_style;
- paragraph_style.setTextStyle(text_style);
-
- auto fontCollection = sk_make_sp<TestFontCollection>(GetResourcePath("fonts").c_str(), true, true);
- ParagraphBuilderImpl builder(paragraph_style, fontCollection);
- builder.addText(text, strlen(text));
- auto paragraph = builder.Build();
- paragraph->layout(1000);
- paragraph->paint(canvas, 0, 0);
-
- struct pair {
- unsigned fX;
- unsigned fY;
- };
-
- pair hit1[] =
- {{ 0, 8},{1, 33}, {2, 34}, { 3, 19}, {4, 20},
- { 5, 21}, { 6, 22 }, { 7, 23 }, {8, 24 }, { 9, 25},
- { 10, 26}, { 11, 27}, {12, 28}, { 13, 21}, {14, 22 },
- { 15, 23}, {16, 24}, {17, 21}, { 18, 22}, {19, 21},
- { 20, 24}, { 21, 23}, };
-
- pair miss[] =
- {{ 0, 4},{1, 17}, {2, 18}, { 3, 11}, {4, 12},
- { 5, 13}, { 6, 14 }, { 7, 15 }, {8, 16 }, { 9, 17},
- { 10, 18}, { 11, 19}, {12, 20}, { 13, 17}, {14, 18 },
- { 15, 19}, {16, 20}, {17, 19}, { 18, 20},
- { 20, 22}, };
-
- auto rects = paragraph->getRectsForRange(7, 9, RectHeightStyle::kTight, RectWidthStyle::kTight);
- SkPaint paint;
- paint.setColor(SK_ColorRED);
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setAntiAlias(true);
- paint.setStrokeWidth(1);
- if (!rects.empty()) {
- canvas->drawRect(rects[0].rect, paint);
- }
-
- for (auto& query : hit1) {
- auto rects = paragraph->getRectsForRange(query.fX, query.fY, RectHeightStyle::kTight, RectWidthStyle::kTight);
- if (rects.size() >= 1 && rects[0].rect.width() > 0) {
- } else {
- SkDebugf("+[%d:%d): Bad\n", query.fX, query.fY);
- }
- }
-
- for (auto& query : miss) {
- auto miss = paragraph->getRectsForRange(query.fX, query.fY, RectHeightStyle::kTight, RectWidthStyle::kTight);
- if (miss.empty()) {
- } else {
- SkDebugf("-[%d:%d): Bad\n", query.fX, query.fY);
- }
- }
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView12 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph12"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- const char* text = "Atwater Peel Sherbrooke Bonaventure Angrignon Peel Côte-des-Neiges";
- TextStyle text_style;
- text_style.setFontFamilies({SkString("Ahem")});
- text_style.setColor(SK_ColorBLACK);
- text_style.setFontSize(16);
- //text_style.setLetterSpacing(-0.41);
- StrutStyle strut_style;
- strut_style.setStrutEnabled(false);
- ParagraphStyle paragraph_style;
- paragraph_style.setStrutStyle(strut_style);
- paragraph_style.setTextStyle(text_style);
- ParagraphBuilderImpl builder(paragraph_style, getFontCollection());
- builder.addText(text);
- auto paragraph = builder.Build();
- paragraph->layout(1095.000000);
- auto result = paragraph->getRectsForRange(65, 66, RectHeightStyle::kTight, RectWidthStyle::kTight);
- paragraph->paint(canvas, 0, 0);
-
- SkPaint paint;
- paint.setColor(SK_ColorRED);
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setAntiAlias(true);
- paint.setStrokeWidth(1);
- canvas->drawRect(result.front().rect, paint);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView14 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph14"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
- TextStyle text_style;
- text_style.setFontFamilies({SkString("Ahem")});
- text_style.setColor(SK_ColorBLACK);
- text_style.setFontSize(25);
- text_style.setDecoration((TextDecoration)(TextDecoration::kUnderline | TextDecoration::kOverline | TextDecoration::kLineThrough));
- text_style.setDecorationColor(SK_ColorBLUE);
- text_style.setDecorationStyle(TextDecorationStyle::kWavy);
- text_style.setDecorationThicknessMultiplier(4.0f);
- ParagraphStyle paragraph_style;
- paragraph_style.setTextStyle(text_style);
- paragraph_style.setTextDirection(TextDirection::kRtl);
- ParagraphBuilderImpl builder(paragraph_style, getFontCollection());
- builder.pushStyle(text_style);
- builder.addText("Hello, wor!\nabcd.");
- auto paragraph = builder.Build();
- paragraph->layout(300);
- paragraph->paint(canvas, 0, 0);
- SkPaint paint;
- paint.setColor(SK_ColorRED);
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setAntiAlias(true);
- paint.setStrokeWidth(1);
- canvas->drawRect(SkRect::MakeXYWH(0, 0, 300, 100), paint);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView15 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph15"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- TextStyle text_style;
- text_style.setFontFamilies({SkString("abc.ttf")});
- text_style.setFontSize(50);
-
- auto fontCollection = sk_make_sp<TestFontCollection>(GetResourcePath("fonts").c_str(), false);
-
- fontCollection->addFontFromFile("abc/abc.ttf", "abc");
- fontCollection->addFontFromFile("abc/abc+grave.ttf", "abc+grave");
- fontCollection->addFontFromFile("abc/abc+agrave.ttf", "abc+agrave");
-
- ParagraphStyle paragraph_style;
- ParagraphBuilderImpl builder(paragraph_style, fontCollection);
-
- text_style.setFontFamilies({SkString("abc"), SkString("abc+grave")});
- text_style.setColor(SK_ColorBLUE);
- builder.pushStyle(text_style);
- builder.addText(u"a\u0300");
- text_style.setColor(SK_ColorMAGENTA);
- builder.pushStyle(text_style);
- builder.addText(u"à");
-
- text_style.setFontFamilies({SkString("abc"), SkString("abc+agrave")});
-
- text_style.setColor(SK_ColorRED);
- builder.pushStyle(text_style);
- builder.addText(u"a\u0300");
- text_style.setColor(SK_ColorGREEN);
- builder.pushStyle(text_style);
- builder.addText(u"à");
-
- auto paragraph = builder.Build();
- paragraph->layout(800);
- paragraph->paint(canvas, 50, 50);
-
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView16 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph16"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- const char* text = "content";
-
- ParagraphStyle paragraph_style;
- paragraph_style.setMaxLines(1);
- paragraph_style.setEllipsis(u"\u2026");
- //auto fontCollection = sk_make_sp<TestFontCollection>(GetResourcePath("fonts").c_str(), false, true);
- auto fontCollection = sk_make_sp<FontCollection>();
- fontCollection->setDefaultFontManager(SkFontMgr::RefDefault());
- fontCollection->enableFontFallback();
- ParagraphBuilderImpl builder(paragraph_style, fontCollection);
-
- TextStyle text_style;
- text_style.setFontFamilies({SkString(".SF Pro Text")});
- text_style.setColor(SK_ColorBLACK);
- text_style.setFontSize(17.0f * 99.0f);
- text_style.setLetterSpacing(0.41f);
- builder.pushStyle(text_style);
- builder.addText(text);
-
- auto paragraph = builder.Build();
- paragraph->layout(800);
- paragraph->paint(canvas, 0, 0);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView17 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph17"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- auto fontCollection = sk_make_sp<FontCollection>();
- fontCollection->setDefaultFontManager(SkFontMgr::RefDefault());
- fontCollection->enableFontFallback();
- auto navy = SkColorSetRGB(0, 0, 139);
- auto ltgray = SkColorSetRGB(211, 211, 211);
- auto multiplier = 5.67;
-
- const char* text = ">Sͬ͑̀͐̈͒̈́̋̎ͮͩ̽̓ͬ̂̆̔͗́̓ͣͧ͊ͫ͛̉͌̐̑ͪ͗̚͝҉̴͉͢k̡̊̓ͫͭͩ͂͊ͨͪͬ̑ͫ̍̌̄͛̌̂̑̂̋̊̔ͫ͛̽̑ͨ̍ͭ̓̀ͪͪ̉͐͗̌̓̃̚͟͝҉̢͏̫̞̙͇͖̮͕̗̟͕͇͚̻͈̣̻̪͉̰̲̣̫ͅͅP̴̅̍͒̿͗͗̇ͩ̃͆͌̀̽͏̧̡͕͖̝̖̼̺̰̣̬͔͖͔̼͙̞̦̫͓̘͜a̸̴̸̴̢̢̨̨̫͍͓̥̼̭̼̻̤̯̙̤̻̠͚̍̌͋̂ͦͨ̽̇͌͌͆̀̽̎͒̄ͪ̐ͦ̈ͫ͐͗̓̚̚͜ͅr͐͐ͤͫ̐ͥ͂̈́̿́ͮ̃͗̓̏ͫ̀̿͏̸̵̧́͘̕͟͝͠͞͠҉̷̧͚͢͟a̓̽̎̄͗̔͛̄̐͊͛ͫ͂͌̂̂̈̈̓̔̅̅̄͊̉́ͪ̑̄͆ͬ̍͆ͭ͋̐ͬ͏̷̵̨̢̩̹̖͓̥̳̰͔̱̬͖̙͓̙͇̀̀̕͜͟͟͢͟͜͠͡g̨̅̇ͦ͋̂ͦͨͭ̓͐͆̏̂͛̉ͧ̑ͫ̐̒͛ͫ̍̒͛́̚҉̷̨̛̛̀͜͢͞҉̩̘̲͍͎̯̹̝̭̗̱͇͉̲̱͔̯̠̹̥̻͉̲̜̤̰̪̗̺̖̺r̷͌̓̇̅ͭ̀̐̃̃ͭ͑͗̉̈̇̈́ͥ̓ͣ́ͤ͂ͤ͂̏͌̆̚҉̴̸̧̢̢̛̫͉̦̥̤̙͈͉͈͉͓̙̗̟̳̜͈̗̺̟̠̠͖͓̖̪͕̠̕̕͝ͅả̸̴̡̡̧͠͞͡͞҉̛̕͟͏̷̘̪̱͈̲͉̞̠̞̪̫͎̲̬̖̀̀͟͝͞͞͠p̛͂̈͐̚͠҉̵̸̡̢̢̩̹͙̯͖̙̙̮̥̙͚̠͔̥̭̮̞̣̪̬̥̠̖̝̥̪͎́̀̕͜͡͡ͅͅh̵̷̵̡̛ͤ̂͌̐̓̐̋̋͊̒̆̽́̀̀̀͢͠͞͞҉̷̸̢̕҉͚̯͖̫̜̞̟̠̱͉̝̲̹̼͉̟͉̩̮͔̤͖̞̭̙̹̬ͅ<";
-
- ParagraphStyle paragraph_style;
- ParagraphBuilderImpl builder(paragraph_style, fontCollection);
- SkPaint paint;
- paint.setColor(ltgray);
- TextStyle text_style;
- text_style.setBackgroundColor(paint);
- text_style.setColor(navy);
- text_style.setFontFamilies({SkString("Roboto")});
- text_style.setFontSize(20 * multiplier);
- builder.pushStyle(text_style);
- builder.addText(text);
- auto paragraph = builder.Build();
- paragraph->layout(10000);
- paragraph->paint(canvas, 0, 0);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class Zalgo {
- private:
- std::u16string COMBINING_DOWN = u"\u0316\u0317\u0318\u0319\u031c\u031d\u031e\u031f\u0320\u0324\u0325\u0326\u0329\u032a\u032b\u032c\u032d\u032e\u032f\u0330\u0331\u0332\u0333\u0339\u033a\u033b\u033c\u0345\u0347\u0348\u0349\u034d\u034e\u0353\u0354\u0355\u0356\u0359\u035a\u0323";
- std::u16string COMBINING_UP = u"\u030d\u030e\u0304\u0305\u033f\u0311\u0306\u0310\u0352\u0357\u0351\u0307\u0308\u030a\u0342\u0343\u0344\u034a\u034b\u034c\u0303\u0302\u030c\u0350\u0300\u0301\u030b\u030f\u0312\u0313\u0314\u033d\u0309\u0363\u0364\u0365\u0366\u0367\u0368\u0369\u036a\u036b\u036c\u036d\u036e\u035b\u0346\u031a";
- std::u16string COMBINING_MIDDLE = u"\u0315\u031b\u0340\u0341\u0358\u0321\u0322\u0327\u0328\u0334\u0335\u0336\u034f\u035c\u035d\u035e\u035f\u0360\u0362\u0338\u0337\u0361\u0489";
-
- std::u16string randomMarks(std::u16string& combiningMarks) {
- std::u16string result;
- auto num = std::rand() % (combiningMarks.size() / 1);
- for (size_t i = 0; i < num; ++i) {
- auto index = std::rand() % combiningMarks.size();
- result += combiningMarks[index];
- }
- return result;
- }
-
-public:
- std::u16string zalgo(std::string victim) {
- std::u16string result;
- for (auto& c : victim) {
- result += c;
- result += randomMarks(COMBINING_UP);
- result += randomMarks(COMBINING_MIDDLE);
- result += randomMarks(COMBINING_DOWN);
- }
- return result;
- }
-};
-
-class ParagraphView18 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph18"); }
-
- bool onChar(SkUnichar uni) override {
- switch (uni) {
- case ' ':
- fLimit = 400;
- return true;
- case 's':
- fLimit += 10;
- return true;
- case 'f':
- if (fLimit > 10) {
- fLimit -= 10;
- }
- return true;
- default:
- break;
- }
- return false;
- }
-
- bool onAnimate(double nanos) override {
- if (++fIndex > fLimit) {
- fRedraw = true;
- fIndex = 0;
- } else {
- fRepeat = true;
- }
- return true;
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- auto navy = SkColorSetRGB(0, 0, 139);
- auto ltgray = SkColorSetRGB(211, 211, 211);
-
- auto multiplier = 5.67;
- auto fontCollection = sk_make_sp<FontCollection>();
- fontCollection->setDefaultFontManager(SkFontMgr::RefDefault());
- fontCollection->enableFontFallback();
-
- ParagraphStyle paragraph_style;
- TextStyle text_style;
- text_style.setFontFamilies({SkString("Roboto")});
- text_style.setFontSize(20 * multiplier);
- text_style.setColor(navy);
- SkPaint paint;
- paint.setColor(ltgray);
- text_style.setBackgroundColor(paint);
-
- Zalgo zalgo;
-
- if (fRedraw || fRepeat) {
-
- if (fRedraw || fParagraph.get() == nullptr) {
- ParagraphBuilderImpl builder(paragraph_style, fontCollection);
- builder.pushStyle(text_style);
- auto utf16text = zalgo.zalgo("SkParagraph");
- icu::UnicodeString unicode((UChar*)utf16text.data(), SkToS32(utf16text.size()));
- std::string str;
- unicode.toUTF8String(str);
- SkDebugf("Text:>%s<\n", str.data());
- builder.addText(utf16text);
- fParagraph = builder.Build();
- }
-
- auto impl = static_cast<ParagraphImpl*>(fParagraph.get());
- impl->setState(InternalState::kUnknown);
- fParagraph->layout(1000);
- fParagraph->paint(canvas, 300, 200);
-
- for (auto& run : impl->runs()) {
- SkString fontFamily("unresolved");
- if (run.font().getTypeface() != nullptr) {
- run.font().getTypeface()->getFamilyName(&fontFamily);
- }
- if (run.font().getTypeface() != nullptr) {
- for (size_t i = 0; i < run.size(); ++i) {
- auto glyph = run.glyphs().begin() + i;
- if (*glyph == 0) {
- SkDebugf("Run[%d] @pos=%d\n", run.index(), i);
- SkASSERT(false);
- }
- }
- } else {
- SkDebugf("Run[%d]: %s\n", run.index(), fontFamily.c_str());
- SkASSERT(false);
- }
- }
- fRedraw = false;
- fRepeat = false;
- }
- }
-
-private:
- bool fRedraw = true;
- bool fRepeat = false;
- size_t fIndex = 0;
- size_t fLimit = 20;
- std::unique_ptr<Paragraph> fParagraph;
- typedef Sample INHERITED;
-};
-
-class ParagraphView19 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph19"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- auto fontCollection = sk_make_sp<TestFontCollection>(GetResourcePath("fonts").c_str(), false, true);
-
- const char* text = "World domination is such an ugly phrase - I prefer to call it world optimisation";
- ParagraphStyle paragraph_style;
- paragraph_style.setMaxLines(7);
- paragraph_style.setEllipsis(u"\u2026");
- ParagraphBuilderImpl builder(paragraph_style, fontCollection);
- TextStyle text_style;
- text_style.setColor(SK_ColorBLACK);
- text_style.setFontFamilies({SkString("Roboto")});
- text_style.setFontSize(40);
- builder.pushStyle(text_style);
- builder.addText(text);
- auto paragraph = builder.Build();
- paragraph->layout(this->width());
-
- paragraph->paint(canvas, 0, 0);
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-class ParagraphView20 : public ParagraphView_Base {
-protected:
- SkString name() override { return SkString("Paragraph20"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawColor(SK_ColorWHITE);
-
- auto fontCollection = sk_make_sp<TestFontCollection>(GetResourcePath("fonts").c_str(), false, true);
-
- const char* text = "";
- ParagraphStyle paragraph_style;
- paragraph_style.setMaxLines(std::numeric_limits<size_t>::max());
- //paragraph_style.setEllipsis(u"\u2026");
- ParagraphBuilderImpl builder(paragraph_style, fontCollection);
- TextStyle text_style;
- text_style.setColor(SK_ColorBLACK);
- text_style.setFontFamilies({SkString("Roboto")});
- text_style.setFontSize(40);
- builder.pushStyle(text_style);
- builder.addText(text);
- auto paragraph = builder.Build();
- paragraph->layout(this->width());
-
- paragraph->paint(canvas, 0, 0);
- }
-
-private:
- typedef Sample INHERITED;
-};
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE(return new ParagraphView1();)
-DEF_SAMPLE(return new ParagraphView2();)
-DEF_SAMPLE(return new ParagraphView3();)
-DEF_SAMPLE(return new ParagraphView4();)
-DEF_SAMPLE(return new ParagraphView5();)
-DEF_SAMPLE(return new ParagraphView6();)
-DEF_SAMPLE(return new ParagraphView7();)
-DEF_SAMPLE(return new ParagraphView8();)
-DEF_SAMPLE(return new ParagraphView9();)
-DEF_SAMPLE(return new ParagraphView10();)
-DEF_SAMPLE(return new ParagraphView11();)
-DEF_SAMPLE(return new ParagraphView12();)
-DEF_SAMPLE(return new ParagraphView14();)
-DEF_SAMPLE(return new ParagraphView15();)
-DEF_SAMPLE(return new ParagraphView16();)
-DEF_SAMPLE(return new ParagraphView17();)
-DEF_SAMPLE(return new ParagraphView18();)
-DEF_SAMPLE(return new ParagraphView19();)
-DEF_SAMPLE(return new ParagraphView20();)
diff --git a/third_party/skia/samplecode/SamplePatch.cpp b/third_party/skia/samplecode/SamplePatch.cpp
index 3fd7d3d..98dde31 100644
--- a/third_party/skia/samplecode/SamplePatch.cpp
+++ b/third_party/skia/samplecode/SamplePatch.cpp
@@ -34,7 +34,7 @@
SkBitmap bm;
decode_file(GetResourceAsData("images/dog.jpg"), &bm);
*size = SkIPoint{bm.width(), bm.height()};
- return bm.makeShader();
+ return bm.makeShader(SkSamplingOptions(SkFilterMode::kLinear));
}
static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
@@ -241,7 +241,6 @@
SkPaint paint;
paint.setDither(true);
- paint.setFilterQuality(kLow_SkFilterQuality);
canvas->translate(DX, DY);
@@ -314,7 +313,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
} // namespace
DEF_SAMPLE( return new PatchView(); )
@@ -345,8 +344,7 @@
int vertCount = pts.count();
int indexCount = 0; // no texture
- unsigned flags = SkVertices::kHasColors_BuilderFlag |
- SkVertices::kIsNonVolatile_BuilderFlag;
+ unsigned flags = SkVertices::kHasColors_BuilderFlag;
SkVertices::Builder builder(SkVertices::kTriangleStrip_VertexMode,
vertCount, indexCount, flags);
memcpy(builder.positions(), pts.begin(), vertCount * sizeof(SkPoint));
@@ -416,7 +414,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
} // namespace
DEF_SAMPLE( return new PseudoInkView(); )
@@ -503,7 +501,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
} // namespace
DEF_SAMPLE( return new ManyStrokesView(); )
diff --git a/third_party/skia/samplecode/SamplePath.cpp b/third_party/skia/samplecode/SamplePath.cpp
index 478f6a0..ac725d9 100644
--- a/third_party/skia/samplecode/SamplePath.cpp
+++ b/third_party/skia/samplecode/SamplePath.cpp
@@ -11,7 +11,7 @@
#include "include/core/SkColorPriv.h"
#include "include/core/SkFont.h"
#include "include/core/SkGraphics.h"
-#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
#include "include/core/SkRegion.h"
#include "include/core/SkShader.h"
#include "include/core/SkTime.h"
@@ -195,7 +195,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new PathView; )
@@ -279,38 +279,29 @@
canvas->drawPath(path, fSkeletonPaint);
}
- bool onClick(Click* click) override {
- int32_t index;
- if (click->fMeta.findS32("index", &index)) {
- SkASSERT((unsigned)index < N);
- fPts[index] = click->fCurr;
- return true;
- }
- return false;
- }
-
Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
const SkScalar tol = 4;
const SkRect r = SkRect::MakeXYWH(x - tol, y - tol, tol * 2, tol * 2);
for (int i = 0; i < N; ++i) {
if (r.intersects(SkRect::MakeXYWH(fPts[i].fX, fPts[i].fY, 1, 1))) {
- Click* click = new Click();
- click->fMeta.setS32("index", i);
- return click;
+ return new Click([this, i](Click* c) {
+ fPts[i] = c->fCurr;
+ return true;
+ });
}
}
return nullptr;
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new ArcToView; )
/////////////
class FatStroke : public Sample {
- bool fClosed, fShowStroke, fShowHidden, fShowSkeleton;
+ bool fClosed, fShowStroke, fShowHidden, fShowSkeleton, fAsCurves = false;
int fJoinType, fCapType;
float fWidth = 30;
SkPaint fPtsPaint, fHiddenPaint, fSkeletonPaint, fStrokePaint;
@@ -366,6 +357,7 @@
case '4': this->toggle3(fJoinType); return true;
case '5': this->toggle3(fCapType); return true;
case '6': this->toggle(fClosed); return true;
+ case 'c': this->toggle(fAsCurves); return true;
case '-': fWidth -= 5; return true;
case '=': fWidth += 5; return true;
default: break;
@@ -375,8 +367,15 @@
void makePath(SkPath* path) {
path->moveTo(fPts[0]);
- for (int i = 1; i < N; ++i) {
- path->lineTo(fPts[i]);
+ if (fAsCurves) {
+ for (int i = 1; i < N-2; ++i) {
+ path->quadTo(fPts[i], (fPts[i+1] + fPts[i]) * 0.5f);
+ }
+ path->quadTo(fPts[N-2], fPts[N-1]);
+ } else {
+ for (int i = 1; i < N; ++i) {
+ path->lineTo(fPts[i]);
+ }
}
if (fClosed) {
path->close();
@@ -407,31 +406,22 @@
canvas->drawPoints(SkCanvas::kPoints_PointMode, N, fPts, fPtsPaint);
}
- bool onClick(Click* click) override {
- int32_t index;
- if (click->fMeta.findS32("index", &index)) {
- SkASSERT((unsigned)index < N);
- fPts[index] = click->fCurr;
- return true;
- }
- return false;
- }
-
Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
const SkScalar tol = 4;
const SkRect r = SkRect::MakeXYWH(x - tol, y - tol, tol * 2, tol * 2);
for (int i = 0; i < N; ++i) {
if (r.intersects(SkRect::MakeXYWH(fPts[i].fX, fPts[i].fY, 1, 1))) {
- Click* click = new Click();
- click->fMeta.setS32("index", i);
- return click;
+ return new Click([this, i](Click* c) {
+ fPts[i] = c->fCurr;
+ return true;
+ });
}
}
return nullptr;
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new FatStroke; )
@@ -524,31 +514,22 @@
}
}
- bool onClick(Click* click) override {
- int32_t index;
- if (click->fMeta.findS32("index", &index)) {
- SkASSERT((unsigned)index < N);
- fPts[index] = click->fCurr;
- return true;
- }
- return false;
- }
-
Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
const SkScalar tol = 8;
const SkRect r = SkRect::MakeXYWH(x - tol, y - tol, tol * 2, tol * 2);
for (int i = 0; i < N; ++i) {
if (r.intersects(SkRect::MakeXYWH(fPts[i].fX, fPts[i].fY, 1, 1))) {
- Click* click = new Click();
- click->fMeta.setS32("index", i);
- return click;
+ return new Click([this, i](Click* c) {
+ fPts[i] = c->fCurr;
+ return true;
+ });
}
}
return this->INHERITED::onFindClickHandler(x, y, modi);
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new CubicCurve; )
@@ -581,6 +562,7 @@
SkScalar fT = 0.5f;
bool fShowSub = false;
bool fShowFlatness = false;
+ bool fShowInnerQuads = false;
SkScalar fScale = 0.75;
CubicCurve2() {
@@ -603,18 +585,25 @@
case 'f': fShowFlatness = !fShowFlatness; break;
case '-': fT -= 1.0f / 32; break;
case '=': fT += 1.0f / 32; break;
+ case 'q': fShowInnerQuads = !fShowInnerQuads; break;
default: return false;
}
fT = std::min(1.0f, std::max(0.0f, fT));
return true;
}
+ static void Dot(SkCanvas* canvas, SkPoint p, SkScalar radius, SkColor c) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setColor(c);
+ canvas->drawCircle(p.fX, p.fY, radius, paint);
+ }
+
void showFrame(SkCanvas* canvas, const SkPoint pts[], int count, const SkPaint& p) {
SkPaint paint(p);
SkPoint storage[3 + 2 + 1];
SkPoint* tmp = storage;
const SkPoint* prev = pts;
- int n = count;
for (int n = count; n > 0; --n) {
for (int i = 0; i < n; ++i) {
canvas->drawLine(prev[i], prev[i+1], paint);
@@ -626,9 +615,9 @@
paint.setColor(SK_ColorBLUE);
paint.setStyle(SkPaint::kFill_Style);
- n = tmp - storage;
+ int n = tmp - storage;
for (int i = 0; i < n; ++i) {
- canvas->drawCircle(storage[i].fX, storage[i].fY, 4, paint);
+ Dot(canvas, storage[i], 4, SK_ColorBLUE);
}
}
@@ -672,6 +661,33 @@
// not sure we can get here
}
+ void showInnerQuads(SkCanvas* canvas) {
+ auto draw_quad = [canvas](SkPoint a, SkPoint b, SkPoint c, SkColor color) {
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStroke(true);
+ paint.setColor(color);
+
+ canvas->drawPath(SkPathBuilder().moveTo(a).quadTo(b, c).detach(), paint);
+ };
+
+ SkPoint p0 = SkEvalQuadAt(&fPts[0], fT),
+ p1 = SkEvalQuadAt(&fPts[1], fT),
+ p2 = lerp(p0, p1, fT);
+
+ draw_quad(fPts[0], fPts[1], fPts[2], SK_ColorRED);
+ Dot(canvas, p0, 4, SK_ColorRED);
+
+ draw_quad(fPts[1], fPts[2], fPts[3], SK_ColorBLUE);
+ Dot(canvas, p1, 4, SK_ColorBLUE);
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setColor(0xFF008800);
+ canvas->drawLine(p0, p1, paint);
+ Dot(canvas, p2, 4, 0xFF00AA00);
+ }
+
void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
@@ -702,13 +718,20 @@
this->showFlattness(canvas);
}
- paint.setStyle(SkPaint::kFill_Style);
- paint.setColor(SK_ColorRED);
- for (SkPoint p : fPts) {
- canvas->drawCircle(p.fX, p.fY, 7, paint);
+ if (fShowInnerQuads) {
+ this->showInnerQuads(canvas);
}
- {
+ paint.setColor(SK_ColorGRAY);
+ paint.setStroke(true);
+ canvas->drawPath(SkPathBuilder().addPolygon(fPts, 4, false).detach(), paint);
+ canvas->drawPath(SkPathBuilder().addPolygon(fQuad, 3, false).detach(), paint);
+
+ for (SkPoint p : fPts) {
+ Dot(canvas, p, 7, SK_ColorBLACK);
+ }
+
+ if ((false)) {
SkScalar ts[2];
int n = SkFindCubicInflections(fPts, ts);
for (int i = 0; i < n; ++i) {
@@ -720,31 +743,22 @@
}
- bool onClick(Click* click) override {
- int32_t index;
- if (click->fMeta.findS32("index", &index)) {
- SkASSERT((unsigned)index < N);
- fPts[index] = click->fCurr;
- return true;
- }
- return false;
- }
-
Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
const SkScalar tol = 8;
const SkRect r = SkRect::MakeXYWH(x - tol, y - tol, tol * 2, tol * 2);
for (int i = 0; i < N; ++i) {
if (r.intersects(SkRect::MakeXYWH(fPts[i].fX, fPts[i].fY, 1, 1))) {
- Click* click = new Click();
- click->fMeta.setS32("index", i);
- return click;
+ return new Click([this, i](Click* c) {
+ fPts[i] = c->fCurr;
+ return true;
+ });
}
}
return this->INHERITED::onFindClickHandler(x, y, modi);
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new CubicCurve2; )
diff --git a/third_party/skia/samplecode/SamplePathClip.cpp b/third_party/skia/samplecode/SamplePathClip.cpp
index c7852ab..8db008d 100644
--- a/third_party/skia/samplecode/SamplePathClip.cpp
+++ b/third_party/skia/samplecode/SamplePathClip.cpp
@@ -53,16 +53,14 @@
}
Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override {
- return new Click();
- }
-
- bool onClick(Click* click) override {
- fCenter.set(click->fCurr.fX, click->fCurr.fY);
- return false;
+ return new Click([&](Click* c) {
+ fCenter = c->fCurr;
+ return false;
+ });
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new PathClipView; )
@@ -298,11 +296,11 @@
bool onClick(Click* click) override {
((MyClick*)click)->handleMove();
- return false;
+ return true;
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
DEF_SAMPLE( return new EdgeClipView; )
diff --git a/third_party/skia/samplecode/SamplePathEffects.cpp b/third_party/skia/samplecode/SamplePathEffects.cpp
index ccdc541..5ed3241 100644
--- a/third_party/skia/samplecode/SamplePathEffects.cpp
+++ b/third_party/skia/samplecode/SamplePathEffects.cpp
@@ -137,7 +137,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SamplePathOverstroke.cpp b/third_party/skia/samplecode/SamplePathOverstroke.cpp
index a01562b..9ebf1d4 100644
--- a/third_party/skia/samplecode/SamplePathOverstroke.cpp
+++ b/third_party/skia/samplecode/SamplePathOverstroke.cpp
@@ -191,7 +191,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SamplePathTessellators.cpp b/third_party/skia/samplecode/SamplePathTessellators.cpp
new file mode 100644
index 0000000..30f4383
--- /dev/null
+++ b/third_party/skia/samplecode/SamplePathTessellators.cpp
@@ -0,0 +1,367 @@
+/*
+ * Copyright 2019 Google LLC.
+ *
+ * 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 "samplecode/Sample.h"
+#include "src/core/SkPathPriv.h"
+
+#if SK_SUPPORT_GPU
+
+#include "src/core/SkCanvasPriv.h"
+#include "src/gpu/GrOpFlushState.h"
+#include "src/gpu/GrRecordingContextPriv.h"
+#include "src/gpu/ops/GrDrawOp.h"
+#include "src/gpu/ops/GrSimpleMeshDrawOpHelper.h"
+#include "src/gpu/ops/TessellationPathRenderer.h"
+#include "src/gpu/tessellate/AffineMatrix.h"
+#include "src/gpu/tessellate/MiddleOutPolygonTriangulator.h"
+#include "src/gpu/tessellate/PathCurveTessellator.h"
+#include "src/gpu/tessellate/PathWedgeTessellator.h"
+#include "src/gpu/tessellate/shaders/GrPathTessellationShader.h"
+#include "src/gpu/v1/SurfaceDrawContext_v1.h"
+
+namespace skgpu {
+
+namespace {
+
+enum class Mode {
+ kWedgeMiddleOut,
+ kCurveMiddleOut,
+ kWedgeTessellate,
+ kCurveTessellate
+};
+
+static const char* ModeName(Mode mode) {
+ switch (mode) {
+ case Mode::kWedgeMiddleOut:
+ return "MiddleOutShader (kWedges)";
+ case Mode::kCurveMiddleOut:
+ return "MiddleOutShader (kCurves)";
+ case Mode::kWedgeTessellate:
+ return "HardwareWedgeShader";
+ case Mode::kCurveTessellate:
+ return "HardwareCurveShader";
+ }
+ SkUNREACHABLE;
+}
+
+// Draws a path directly to the screen using a specific tessellator.
+class SamplePathTessellatorOp : public GrDrawOp {
+private:
+ DEFINE_OP_CLASS_ID
+
+ SamplePathTessellatorOp(const SkRect& drawBounds, const SkPath& path, const SkMatrix& m,
+ GrPipeline::InputFlags pipelineFlags, Mode mode)
+ : GrDrawOp(ClassID())
+ , fPath(path)
+ , fMatrix(m)
+ , fPipelineFlags(pipelineFlags)
+ , fMode(mode) {
+ this->setBounds(drawBounds, HasAABloat::kNo, IsHairline::kNo);
+ }
+ const char* name() const override { return "SamplePathTessellatorOp"; }
+ void visitProxies(const GrVisitProxyFunc&) const override {}
+ FixedFunctionFlags fixedFunctionFlags() const override {
+ return FixedFunctionFlags::kUsesHWAA;
+ }
+ GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
+ GrClampType clampType) override {
+ SkPMColor4f color;
+ return fProcessors.finalize(SK_PMColor4fWHITE, GrProcessorAnalysisCoverage::kNone, clip,
+ nullptr, caps, clampType, &color);
+ }
+ void onPrePrepare(GrRecordingContext*, const GrSurfaceProxyView&, GrAppliedClip*,
+ const GrDstProxyView&, GrXferBarrierFlags, GrLoadOp colorLoadOp) override {}
+ void onPrepare(GrOpFlushState* flushState) override {
+ constexpr static SkPMColor4f kCyan = {0,1,1,1};
+ auto alloc = flushState->allocator();
+ const SkMatrix& shaderMatrix = SkMatrix::I();
+ const SkMatrix& pathMatrix = fMatrix;
+ const GrCaps& caps = flushState->caps();
+ const GrShaderCaps& shaderCaps = *caps.shaderCaps();
+ int numVerbsToGetMiddleOut = 0;
+ int numVerbsToGetTessellation = caps.minPathVerbsForHwTessellation();
+ auto pipeline = GrSimpleMeshDrawOpHelper::CreatePipeline(flushState, std::move(fProcessors),
+ fPipelineFlags);
+ int numVerbs;
+ bool needsInnerFan;
+ switch (fMode) {
+ case Mode::kWedgeMiddleOut:
+ fTessellator = PathWedgeTessellator::Make(alloc, shaderCaps.infinitySupport());
+ numVerbs = numVerbsToGetMiddleOut;
+ needsInnerFan = false;
+ break;
+ case Mode::kCurveMiddleOut:
+ fTessellator = PathCurveTessellator::Make(alloc,
+ shaderCaps.infinitySupport());
+ numVerbs = numVerbsToGetMiddleOut;
+ needsInnerFan = true;
+ break;
+ case Mode::kWedgeTessellate:
+ fTessellator = PathWedgeTessellator::Make(alloc, shaderCaps.infinitySupport());
+ numVerbs = numVerbsToGetTessellation;
+ needsInnerFan = false;
+ break;
+ case Mode::kCurveTessellate:
+ fTessellator = PathCurveTessellator::Make(alloc,
+ shaderCaps.infinitySupport());
+ numVerbs = numVerbsToGetTessellation;
+ needsInnerFan = true;
+ break;
+ }
+ auto* tessShader = GrPathTessellationShader::Make(alloc,
+ shaderMatrix,
+ kCyan,
+ numVerbs,
+ *pipeline,
+ fTessellator->patchAttribs(),
+ caps);
+ fProgram = GrTessellationShader::MakeProgram({alloc, flushState->writeView(),
+ flushState->usesMSAASurface(),
+ &flushState->dstProxyView(),
+ flushState->renderPassBarriers(),
+ GrLoadOp::kClear, &flushState->caps()},
+ tessShader,
+ pipeline,
+ &GrUserStencilSettings::kUnused);
+
+
+ int patchPreallocCount = fTessellator->patchPreallocCount(fPath.countVerbs());
+ if (needsInnerFan) {
+ patchPreallocCount += fPath.countVerbs() - 1;
+ }
+ PatchWriter patchWriter(flushState,
+ fTessellator,
+ tessShader->maxTessellationSegments(*caps.shaderCaps()),
+ patchPreallocCount);
+
+ if (needsInnerFan) {
+ // Write out inner fan triangles.
+ AffineMatrix m(pathMatrix);
+ for (PathMiddleOutFanIter it(fPath); !it.done();) {
+ for (auto [p0, p1, p2] : it.nextStack()) {
+ auto [mp0, mp1] = m.map2Points(p0, p1);
+ auto mp2 = m.map1Point(&p2);
+ patchWriter.writeTriangle(mp0, mp1, mp2);
+ }
+ }
+ }
+
+ // Write out the curves.
+ fTessellator->writePatches(patchWriter, shaderMatrix, {pathMatrix, fPath, kCyan});
+
+ if (!tessShader->willUseTessellationShaders()) {
+ fTessellator->prepareFixedCountBuffers(flushState);
+ }
+
+ }
+ void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
+ flushState->bindPipeline(*fProgram, chainBounds);
+ fTessellator->draw(flushState, fProgram->geomProc().willUseTessellationShaders());
+ }
+
+ const SkPath fPath;
+ const SkMatrix fMatrix;
+ const GrPipeline::InputFlags fPipelineFlags;
+ const Mode fMode;
+ PathTessellator* fTessellator = nullptr;
+ GrProgramInfo* fProgram;
+ GrProcessorSet fProcessors{SkBlendMode::kSrcOver};
+
+ friend class GrOp; // For ctor.
+};
+
+} // namespace
+
+// This sample enables wireframe and visualizes the triangles generated by path tessellators.
+class SamplePathTessellators : public Sample {
+public:
+ SamplePathTessellators() {
+#if 0
+ // For viewing middle-out triangulations of the inner fan.
+ fPath.moveTo(1, 0);
+ int numSides = 32 * 3;
+ for (int i = 1; i < numSides; ++i) {
+ float theta = 2*3.1415926535897932384626433832785 * i / numSides;
+ fPath.lineTo(std::cos(theta), std::sin(theta));
+ }
+ fPath.transform(SkMatrix::Scale(200, 200));
+ fPath.transform(SkMatrix::Translate(300, 300));
+#else
+ fPath.moveTo(100, 500);
+ fPath.cubicTo(300, 400, -100, 300, 100, 200);
+ fPath.quadTo(250, 0, 400, 200);
+ fPath.conicTo(600, 350, 400, 500, fConicWeight);
+ fPath.close();
+#endif
+ }
+
+private:
+ void onDrawContent(SkCanvas*) override;
+ Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override;
+ bool onClick(Sample::Click*) override;
+ bool onChar(SkUnichar) override;
+
+ SkString name() override { return SkString("PathTessellators"); }
+
+ SkPath fPath;
+ GrPipeline::InputFlags fPipelineFlags = GrPipeline::InputFlags::kWireframe;
+ Mode fMode = Mode::kWedgeMiddleOut;
+
+ float fConicWeight = .5;
+
+ class Click;
+};
+
+void SamplePathTessellators::onDrawContent(SkCanvas* canvas) {
+ canvas->clear(SK_ColorBLACK);
+
+ auto ctx = canvas->recordingContext();
+ auto sdc = SkCanvasPriv::TopDeviceSurfaceDrawContext(canvas);
+
+ SkString error;
+ if (!sdc || !ctx) {
+ error = "GPU Only.";
+ } else if (!skgpu::v1::TessellationPathRenderer::IsSupported(*ctx->priv().caps())) {
+ error = "TessellationPathRenderer not supported.";
+ } else if (fMode >= Mode::kWedgeTessellate &&
+ !ctx->priv().caps()->shaderCaps()->tessellationSupport()) {
+ error.printf("%s requires hardware tessellation support.", ModeName(fMode));
+ }
+ if (!error.isEmpty()) {
+ canvas->clear(SK_ColorRED);
+ SkFont font(nullptr, 20);
+ SkPaint captionPaint;
+ captionPaint.setColor(SK_ColorWHITE);
+ canvas->drawString(error.c_str(), 10, 30, font, captionPaint);
+ return;
+ }
+
+ sdc->addDrawOp(GrOp::Make<SamplePathTessellatorOp>(ctx,
+ sdc->asRenderTargetProxy()->getBoundsRect(),
+ fPath, canvas->getTotalMatrix(),
+ fPipelineFlags, fMode));
+
+ // Draw the path points.
+ SkPaint pointsPaint;
+ pointsPaint.setColor(SK_ColorBLUE);
+ pointsPaint.setStrokeWidth(8);
+ SkPath devPath = fPath;
+ devPath.transform(canvas->getTotalMatrix());
+ {
+ SkAutoCanvasRestore acr(canvas, true);
+ canvas->setMatrix(SkMatrix::I());
+ SkString caption(ModeName(fMode));
+ caption.appendf(" (w=%g)", fConicWeight);
+ SkFont font(nullptr, 20);
+ SkPaint captionPaint;
+ captionPaint.setColor(SK_ColorWHITE);
+ canvas->drawString(caption, 10, 30, font, captionPaint);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, devPath.countPoints(),
+ SkPathPriv::PointData(devPath), pointsPaint);
+ }
+}
+
+class SamplePathTessellators::Click : public Sample::Click {
+public:
+ Click(int ptIdx) : fPtIdx(ptIdx) {}
+
+ void doClick(SkPath* path) {
+ SkPoint pt = path->getPoint(fPtIdx);
+ SkPathPriv::UpdatePathPoint(path, fPtIdx, pt + fCurr - fPrev);
+ }
+
+private:
+ int fPtIdx;
+};
+
+Sample::Click* SamplePathTessellators::onFindClickHandler(SkScalar x, SkScalar y,
+ skui::ModifierKey) {
+ const SkPoint* pts = SkPathPriv::PointData(fPath);
+ float fuzz = 30;
+ for (int i = 0; i < fPath.countPoints(); ++i) {
+ if (fabs(x - pts[i].x()) < fuzz && fabsf(y - pts[i].y()) < fuzz) {
+ return new Click(i);
+ }
+ }
+ return nullptr;
+}
+
+bool SamplePathTessellators::onClick(Sample::Click* click) {
+ Click* myClick = (Click*)click;
+ myClick->doClick(&fPath);
+ return true;
+}
+
+static SkPath update_weight(const SkPath& path, float w) {
+ SkPath path_;
+ for (auto [verb, pts, _] : SkPathPriv::Iterate(path)) {
+ switch (verb) {
+ case SkPathVerb::kMove:
+ path_.moveTo(pts[0]);
+ break;
+ case SkPathVerb::kLine:
+ path_.lineTo(pts[1]);
+ break;
+ case SkPathVerb::kQuad:
+ path_.quadTo(pts[1], pts[2]);
+ break;
+ case SkPathVerb::kCubic:
+ path_.cubicTo(pts[1], pts[2], pts[3]);
+ break;
+ case SkPathVerb::kConic:
+ path_.conicTo(pts[1], pts[2], (w != 1) ? w : .99f);
+ break;
+ case SkPathVerb::kClose:
+ break;
+ }
+ }
+ return path_;
+}
+
+bool SamplePathTessellators::onChar(SkUnichar unichar) {
+ switch (unichar) {
+ case 'w':
+ fPipelineFlags = (GrPipeline::InputFlags)(
+ (int)fPipelineFlags ^ (int)GrPipeline::InputFlags::kWireframe);
+ return true;
+ case 'D': {
+ fPath.dump();
+ return true;
+ }
+ case '+':
+ fConicWeight *= 2;
+ fPath = update_weight(fPath, fConicWeight);
+ return true;
+ case '=':
+ fConicWeight *= 5/4.f;
+ fPath = update_weight(fPath, fConicWeight);
+ return true;
+ case '_':
+ fConicWeight *= .5f;
+ fPath = update_weight(fPath, fConicWeight);
+ return true;
+ case '-':
+ fConicWeight *= 4/5.f;
+ fPath = update_weight(fPath, fConicWeight);
+ return true;
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ fMode = (Mode)(unichar - '1');
+ return true;
+ }
+ return false;
+}
+
+Sample* MakeTessellatedPathSample() { return new SamplePathTessellators; }
+static SampleRegistry gTessellatedPathSample(MakeTessellatedPathSample);
+
+} // namespace skgpu
+
+#endif // SK_SUPPORT_GPU
diff --git a/third_party/skia/samplecode/SamplePathText.cpp b/third_party/skia/samplecode/SamplePathText.cpp
index 0b8ef02..1f5cd82 100644
--- a/third_party/skia/samplecode/SamplePathText.cpp
+++ b/third_party/skia/samplecode/SamplePathText.cpp
@@ -10,7 +10,8 @@
#include "include/core/SkPath.h"
#include "include/utils/SkRandom.h"
#include "samplecode/Sample.h"
-#include "src/core/SkStrike.h"
+#include "src/core/SkPathPriv.h"
+#include "src/core/SkScalerCache.h"
#include "src/core/SkStrikeCache.h"
#include "src/core/SkStrikeSpec.h"
#include "src/core/SkTaskGroup.h"
@@ -29,18 +30,24 @@
for (Glyph& glyph : fGlyphs) {
glyph.reset(fRand, this->width(), this->height());
}
+ fGlyphAnimator->reset(&fRand, this->width(), this->height());
}
void onOnceBeforeDraw() final {
SkFont defaultFont;
SkStrikeSpec strikeSpec = SkStrikeSpec::MakeWithNoDevice(defaultFont);
- auto cache = strikeSpec.findOrCreateExclusiveStrike();
+ auto strike = strikeSpec.findOrCreateStrike();
+ SkArenaAlloc alloc(1 << 12); // This is a mock SkStrikeCache.
SkPath glyphPaths[52];
for (int i = 0; i < 52; ++i) {
// I and l are rects on OS X ...
char c = "aQCDEFGH7JKLMNOPBRZTUVWXYSAbcdefghijk1mnopqrstuvwxyz"[i];
SkPackedGlyphID id(defaultFont.unicharToGlyph(c));
- sk_ignore_unused_variable(cache->getScalerContext()->getPath(id, &glyphPaths[i]));
+ SkGlyph glyph = strike->getScalerContext()->makeGlyph(id, &alloc);
+ strike->getScalerContext()->getPath(glyph, &alloc);
+ if (glyph.path()) {
+ glyphPaths[i] = *glyph.path();
+ }
}
for (int i = 0; i < kNumPaths; ++i) {
@@ -48,43 +55,30 @@
fGlyphs[i].init(fRand, p);
}
- this->INHERITED::onOnceBeforeDraw();
+ this->Sample::onOnceBeforeDraw();
this->reset();
}
- void onSizeChange() final { this->INHERITED::onSizeChange(); this->reset(); }
+ void onSizeChange() final { this->Sample::onSizeChange(); this->reset(); }
SkString name() override { return SkString(this->getName()); }
- bool onChar(SkUnichar unichar) override {
- if (unichar == 'X') {
- fDoClip = !fDoClip;
- return true;
- }
- return false;
+ bool onChar(SkUnichar) override;
+
+ bool onAnimate(double nanos) final {
+ return fGlyphAnimator->animate(nanos, this->width(), this->height());
}
void onDrawContent(SkCanvas* canvas) override {
if (fDoClip) {
SkPath deviceSpaceClipPath = fClipPath;
- deviceSpaceClipPath.transform(SkMatrix::MakeScale(this->width(), this->height()));
+ deviceSpaceClipPath.transform(SkMatrix::Scale(this->width(), this->height()));
canvas->save();
canvas->clipPath(deviceSpaceClipPath, SkClipOp::kDifference, true);
canvas->clear(SK_ColorBLACK);
canvas->restore();
canvas->clipPath(deviceSpaceClipPath, SkClipOp::kIntersect, true);
}
- this->drawGlyphs(canvas);
- }
-
- virtual void drawGlyphs(SkCanvas* canvas) {
- for (Glyph& glyph : fGlyphs) {
- SkAutoCanvasRestore acr(canvas, true);
- canvas->translate(glyph.fPosition.x(), glyph.fPosition.y());
- canvas->scale(glyph.fZoom, glyph.fZoom);
- canvas->rotate(glyph.fSpin);
- canvas->translate(-glyph.fMidpt.x(), -glyph.fMidpt.y());
- canvas->drawPath(glyph.fPath, glyph.fPaint);
- }
+ fGlyphAnimator->draw(canvas);
}
protected:
@@ -100,12 +94,36 @@
SkPoint fMidpt;
};
- Glyph fGlyphs[kNumPaths];
- SkRandom fRand{25};
- SkPath fClipPath = ToolUtils::make_star(SkRect{0, 0, 1, 1}, 11, 3);
- bool fDoClip = false;
+ class GlyphAnimator {
+ public:
+ GlyphAnimator(Glyph* glyphs) : fGlyphs(glyphs) {}
+ virtual void reset(SkRandom*, int screenWidth, int screenHeight) {}
+ virtual bool animate(double nanos, int screenWidth, int screenHeight) { return false; }
+ virtual void draw(SkCanvas* canvas) {
+ for (int i = 0; i < kNumPaths; ++i) {
+ Glyph& glyph = fGlyphs[i];
+ SkAutoCanvasRestore acr(canvas, true);
+ canvas->translate(glyph.fPosition.x(), glyph.fPosition.y());
+ canvas->scale(glyph.fZoom, glyph.fZoom);
+ canvas->rotate(glyph.fSpin);
+ canvas->translate(-glyph.fMidpt.x(), -glyph.fMidpt.y());
+ canvas->drawPath(glyph.fPath, glyph.fPaint);
+ }
+ }
+ virtual ~GlyphAnimator() {}
- typedef Sample INHERITED;
+ protected:
+ Glyph* const fGlyphs;
+ };
+
+ class MovingGlyphAnimator;
+ class WavyGlyphAnimator;
+
+ Glyph fGlyphs[kNumPaths];
+ SkRandom fRand{25};
+ SkPath fClipPath = ToolUtils::make_star(SkRect{0, 0, 1, 1}, 11, 3);
+ bool fDoClip = false;
+ std::unique_ptr<GlyphAnimator> fGlyphAnimator = std::make_unique<GlyphAnimator>(fGlyphs);
};
void PathText::Glyph::init(SkRandom& rand, const SkPath& path) {
@@ -115,62 +133,60 @@
}
void PathText::Glyph::reset(SkRandom& rand, int w, int h) {
- int screensize = SkTMax(w, h);
+ int screensize = std::max(w, h);
const SkRect& bounds = fPath.getBounds();
SkScalar t;
fPosition = {rand.nextF() * w, rand.nextF() * h};
t = pow(rand.nextF(), 100);
fZoom = ((1 - t) * screensize / 50 + t * screensize / 3) /
- SkTMax(bounds.width(), bounds.height());
+ std::max(bounds.width(), bounds.height());
fSpin = rand.nextF() * 360;
fMidpt = {bounds.centerX(), bounds.centerY()};
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Text from paths with animated transformation matrices.
-class MovingPathText : public PathText {
+class PathText::MovingGlyphAnimator : public PathText::GlyphAnimator {
public:
- const char* getName() const override { return "MovingPathText"; }
-
- MovingPathText()
- : fFrontMatrices(kNumPaths)
- , fBackMatrices(kNumPaths) {
+ MovingGlyphAnimator(Glyph* glyphs)
+ : GlyphAnimator(glyphs)
+ , fFrontMatrices(kNumPaths)
+ , fBackMatrices(kNumPaths) {
}
- ~MovingPathText() override {
+ ~MovingGlyphAnimator() override {
fBackgroundAnimationTask.wait();
}
- void reset() override {
- const SkScalar screensize = static_cast<SkScalar>(SkTMax(this->width(), this->height()));
- this->INHERITED::reset();
+ void reset(SkRandom* rand, int screenWidth, int screenHeight) override {
+ const SkScalar screensize = static_cast<SkScalar>(std::max(screenWidth, screenHeight));
for (auto& v : fVelocities) {
for (SkScalar* d : {&v.fDx, &v.fDy}) {
- SkScalar t = pow(fRand.nextF(), 3);
- *d = ((1 - t) / 60 + t / 10) * (fRand.nextBool() ? screensize : -screensize);
+ SkScalar t = pow(rand->nextF(), 3);
+ *d = ((1 - t) / 60 + t / 10) * (rand->nextBool() ? screensize : -screensize);
}
- SkScalar t = pow(fRand.nextF(), 25);
- v.fDSpin = ((1 - t) * 360 / 7.5 + t * 360 / 1.5) * (fRand.nextBool() ? 1 : -1);
+ SkScalar t = pow(rand->nextF(), 25);
+ v.fDSpin = ((1 - t) * 360 / 7.5 + t * 360 / 1.5) * (rand->nextBool() ? 1 : -1);
}
// Get valid front data.
fBackgroundAnimationTask.wait();
- this->runAnimationTask(0, 0, this->width(), this->height());
- memcpy(fFrontMatrices, fBackMatrices, kNumPaths * sizeof(SkMatrix));
+ this->runAnimationTask(0, 0, screenWidth, screenHeight);
+ std::copy_n(fBackMatrices.get(), kNumPaths, fFrontMatrices.get());
fLastTick = 0;
}
- bool onAnimate(double nanos) final {
+ bool animate(double nanos, int screenWidth, int screenHeight) final {
fBackgroundAnimationTask.wait();
this->swapAnimationBuffers();
const double tsec = 1e-9 * nanos;
const double dt = fLastTick ? (1e-9 * nanos - fLastTick) : 0;
- fBackgroundAnimationTask.add(std::bind(&MovingPathText::runAnimationTask, this, tsec,
- dt, this->width(), this->height()));
+ fBackgroundAnimationTask.add(std::bind(&MovingGlyphAnimator::runAnimationTask, this, tsec,
+ dt, screenWidth, screenHeight));
fLastTick = 1e-9 * nanos;
return true;
}
@@ -215,7 +231,7 @@
std::swap(fFrontMatrices, fBackMatrices);
}
- void drawGlyphs(SkCanvas* canvas) override {
+ void draw(SkCanvas* canvas) override {
for (int i = 0; i < kNumPaths; ++i) {
SkAutoCanvasRestore acr(canvas, true);
canvas->concat(fFrontMatrices[i]);
@@ -229,42 +245,40 @@
SkScalar fDSpin;
};
- Velocity fVelocities[kNumPaths];
- SkAutoTMalloc<SkMatrix> fFrontMatrices;
- SkAutoTMalloc<SkMatrix> fBackMatrices;
- SkTaskGroup fBackgroundAnimationTask;
- double fLastTick;
-
- typedef PathText INHERITED;
+ Velocity fVelocities[kNumPaths];
+ SkAutoTArray<SkMatrix> fFrontMatrices;
+ SkAutoTArray<SkMatrix> fBackMatrices;
+ SkTaskGroup fBackgroundAnimationTask;
+ double fLastTick;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
// Text from paths with animated control points.
-class WavyPathText : public MovingPathText {
+class PathText::WavyGlyphAnimator : public PathText::MovingGlyphAnimator {
public:
- const char* getName() const override { return "WavyPathText"; }
+ WavyGlyphAnimator(Glyph* glyphs)
+ : MovingGlyphAnimator(glyphs)
+ , fFrontPaths(kNumPaths)
+ , fBackPaths(kNumPaths) {
+ }
- WavyPathText()
- : fFrontPaths(kNumPaths)
- , fBackPaths(kNumPaths) {}
-
- ~WavyPathText() override {
+ ~WavyGlyphAnimator() override {
fBackgroundAnimationTask.wait();
}
- void reset() override {
- fWaves.reset(fRand, this->width(), this->height());
- this->INHERITED::reset();
+ void reset(SkRandom* rand, int screenWidth, int screenHeight) override {
+ fWaves.reset(*rand, screenWidth, screenHeight);
+ this->MovingGlyphAnimator::reset(rand, screenWidth, screenHeight);
std::copy(fBackPaths.get(), fBackPaths.get() + kNumPaths, fFrontPaths.get());
}
/**
* Called on a background thread. Here we can only modify fBackPaths.
*/
- void runAnimationTask(double t, double dt, int w, int h) override {
+ void runAnimationTask(double t, double dt, int width, int height) override {
const float tsec = static_cast<float>(t);
- this->INHERITED::runAnimationTask(t, 0.5 * dt, w, h);
+ this->MovingGlyphAnimator::runAnimationTask(t, 0.5 * dt, width, height);
for (int i = 0; i < kNumPaths; ++i) {
const Glyph& glyph = fGlyphs[i];
@@ -280,35 +294,30 @@
backpath->reset();
backpath->setFillType(SkPathFillType::kEvenOdd);
- SkPath::RawIter iter(glyph.fPath);
- SkPath::Verb verb;
- SkPoint pts[4];
-
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+ for (auto [verb, pts, w] : SkPathPriv::Iterate(glyph.fPath)) {
switch (verb) {
- case SkPath::kMove_Verb: {
+ case SkPathVerb::kMove: {
SkPoint pt = fWaves.apply(tsec, matrix, pts[0]);
backpath->moveTo(pt.x(), pt.y());
break;
}
- case SkPath::kLine_Verb: {
+ case SkPathVerb::kLine: {
SkPoint endpt = fWaves.apply(tsec, matrix, pts[1]);
backpath->lineTo(endpt.x(), endpt.y());
break;
}
- case SkPath::kQuad_Verb: {
+ case SkPathVerb::kQuad: {
SkPoint controlPt = fWaves.apply(tsec, matrix, pts[1]);
SkPoint endpt = fWaves.apply(tsec, matrix, pts[2]);
backpath->quadTo(controlPt.x(), controlPt.y(), endpt.x(), endpt.y());
break;
}
- case SkPath::kClose_Verb: {
+ case SkPathVerb::kClose: {
backpath->close();
break;
}
- case SkPath::kCubic_Verb:
- case SkPath::kConic_Verb:
- case SkPath::kDone_Verb:
+ case SkPathVerb::kCubic:
+ case SkPathVerb::kConic:
SK_ABORT("Unexpected path verb");
break;
}
@@ -317,11 +326,11 @@
}
void swapAnimationBuffers() override {
- this->INHERITED::swapAnimationBuffers();
+ this->MovingGlyphAnimator::swapAnimationBuffers();
std::swap(fFrontPaths, fBackPaths);
}
- void drawGlyphs(SkCanvas* canvas) override {
+ void draw(SkCanvas* canvas) override {
for (int i = 0; i < kNumPaths; ++i) {
canvas->drawPath(fFrontPaths[i], fGlyphs[i].fPaint);
}
@@ -348,15 +357,13 @@
float fOffsets[4];
};
- SkAutoTArray<SkPath> fFrontPaths;
- SkAutoTArray<SkPath> fBackPaths;
- Waves fWaves;
-
- typedef MovingPathText INHERITED;
+ SkAutoTArray<SkPath> fFrontPaths;
+ SkAutoTArray<SkPath> fBackPaths;
+ Waves fWaves;
};
-void WavyPathText::Waves::reset(SkRandom& rand, int w, int h) {
- const double pixelsPerMeter = 0.06 * SkTMax(w, h);
+void PathText::WavyGlyphAnimator::Waves::reset(SkRandom& rand, int w, int h) {
+ const double pixelsPerMeter = 0.06 * std::max(w, h);
const double medianWavelength = 8 * pixelsPerMeter;
const double medianWaveAmplitude = 0.05 * 4 * pixelsPerMeter;
const double gravity = 9.8 * pixelsPerMeter;
@@ -375,7 +382,8 @@
}
}
-SkPoint WavyPathText::Waves::apply(float tsec, const Sk2f matrix[3], const SkPoint& pt) const {
+SkPoint PathText::WavyGlyphAnimator::Waves::apply(float tsec, const Sk2f matrix[3],
+ const SkPoint& pt) const {
constexpr static int kTablePeriod = 1 << 12;
static float sin2table[kTablePeriod + 1];
static SkOnce initTable;
@@ -422,8 +430,28 @@
return {devicePt[0] + offsetY[0] + offsetY[1], devicePt[1] - offsetX[0] - offsetX[1]};
}
+bool PathText::onChar(SkUnichar unichar) {
+ switch (unichar) {
+ case 'X':
+ fDoClip = !fDoClip;
+ return true;
+ case 'S':
+ fGlyphAnimator = std::make_unique<GlyphAnimator>(fGlyphs);
+ fGlyphAnimator->reset(&fRand, this->width(), this->height());
+ return true;
+ case 'M':
+ fGlyphAnimator = std::make_unique<MovingGlyphAnimator>(fGlyphs);
+ fGlyphAnimator->reset(&fRand, this->width(), this->height());
+ return true;
+ case 'W':
+ fGlyphAnimator = std::make_unique<WavyGlyphAnimator>(fGlyphs);
+ fGlyphAnimator->reset(&fRand, this->width(), this->height());
+ return true;
+ }
+ return false;
+}
+
////////////////////////////////////////////////////////////////////////////////////////////////////
-DEF_SAMPLE( return new WavyPathText; )
-DEF_SAMPLE( return new MovingPathText; )
-DEF_SAMPLE( return new PathText; )
+Sample* MakePathTextSample() { return new PathText; }
+static SampleRegistry gPathTextSample(MakePathTextSample);
diff --git a/third_party/skia/samplecode/SamplePolyToPoly.cpp b/third_party/skia/samplecode/SamplePolyToPoly.cpp
index f8caf38..41af4a0 100644
--- a/third_party/skia/samplecode/SamplePolyToPoly.cpp
+++ b/third_party/skia/samplecode/SamplePolyToPoly.cpp
@@ -50,26 +50,24 @@
(void) m2.setPolyToPoly((const SkPoint*)src1, (SkPoint*)dst1, 4);
- {
- const SkPoint src[] = {
- { SkIntToScalar(1), SkIntToScalar(0) },
- { SkIntToScalar(4), SkIntToScalar(7) },
- { SkIntToScalar(10), SkIntToScalar(2) }
- };
- const SkPoint dst[] = {
- { SkIntToScalar(4), SkIntToScalar(2) },
- { SkIntToScalar(45), SkIntToScalar(26) },
- { SkIntToScalar(32), SkIntToScalar(17) }
- };
+ const SkPoint src2[] = {
+ { SkIntToScalar(1), SkIntToScalar(0) },
+ { SkIntToScalar(4), SkIntToScalar(7) },
+ { SkIntToScalar(10), SkIntToScalar(2) }
+ };
+ const SkPoint dst2[] = {
+ { SkIntToScalar(4), SkIntToScalar(2) },
+ { SkIntToScalar(45), SkIntToScalar(26) },
+ { SkIntToScalar(32), SkIntToScalar(17) }
+ };
- SkMatrix m0;
- m0.setPolyToPoly(src, dst, 3);
- }
+ SkMatrix m0;
+ m0.setPolyToPoly(src2, dst2, 3);
}
}
protected:
- virtual SkString name() { return SkString("PolyToPolyView"); }
+ SkString name() override { return SkString("PolyToPolyView"); }
static void doDraw(SkCanvas* canvas, SkPaint* paint, const SkFont& font, const int isrc[],
const int idst[], int count) {
@@ -105,7 +103,7 @@
canvas->restore();
}
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStrokeWidth(SkIntToScalar(4));
@@ -147,7 +145,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleQuadStroker.cpp b/third_party/skia/samplecode/SampleQuadStroker.cpp
index 6b679e2..bd98ad7 100644
--- a/third_party/skia/samplecode/SampleQuadStroker.cpp
+++ b/third_party/skia/samplecode/SampleQuadStroker.cpp
@@ -28,6 +28,7 @@
#include "include/utils/SkTextUtils.h"
#include "samplecode/Sample.h"
#include "src/core/SkGeometry.h"
+#include "src/core/SkPathPriv.h"
#include "src/core/SkPointPriv.h"
#include "src/core/SkStroke.h"
#include "tools/ToolUtils.h"
@@ -42,18 +43,14 @@
}
static int getOnCurvePoints(const SkPath& path, SkPoint storage[]) {
- SkPath::RawIter iter(path);
- SkPoint pts[4];
- SkPath::Verb verb;
-
int count = 0;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+ for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
switch (verb) {
- case SkPath::kMove_Verb:
- case SkPath::kLine_Verb:
- case SkPath::kQuad_Verb:
- case SkPath::kConic_Verb:
- case SkPath::kCubic_Verb:
+ case SkPathVerb::kMove:
+ case SkPathVerb::kLine:
+ case SkPathVerb::kQuad:
+ case SkPathVerb::kConic:
+ case SkPathVerb::kCubic:
storage[count++] = pts[0];
break;
default:
@@ -64,25 +61,21 @@
}
static void getContourCounts(const SkPath& path, SkTArray<int>* contourCounts) {
- SkPath::RawIter iter(path);
- SkPoint pts[4];
- SkPath::Verb verb;
-
int count = 0;
- while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+ for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
switch (verb) {
- case SkPath::kMove_Verb:
- case SkPath::kLine_Verb:
+ case SkPathVerb::kMove:
+ case SkPathVerb::kLine:
count += 1;
break;
- case SkPath::kQuad_Verb:
- case SkPath::kConic_Verb:
+ case SkPathVerb::kQuad:
+ case SkPathVerb::kConic:
count += 2;
break;
- case SkPath::kCubic_Verb:
+ case SkPathVerb::kCubic:
count += 3;
break;
- case SkPath::kClose_Verb:
+ case SkPathVerb::kClose:
contourCounts->push_back(count);
count = 0;
break;
@@ -218,7 +211,7 @@
fText = "";
break;
case '-':
- fTextSize = SkTMax(1.0f, fTextSize - 1);
+ fTextSize = std::max(1.0f, fTextSize - 1);
break;
case '+':
case '=':
@@ -259,7 +252,7 @@
SkCanvas* canvas = fMaxSurface->getCanvas();
canvas->save();
canvas->concat(fMatrix);
- fMinSurface->draw(canvas, 0, 0, nullptr);
+ fMinSurface->draw(canvas, 0, 0);
canvas->restore();
SkPaint paint;
@@ -356,14 +349,14 @@
for (SkScalar dist = 0; dist <= total; dist += delta) {
++ribs;
}
- SkPath::RawIter iter(path);
- SkPoint pts[4];
- if (SkPath::kMove_Verb != iter.next(pts)) {
+ const uint8_t* verbs = SkPathPriv::VerbData(path);
+ if (path.countVerbs() < 2 || SkPath::kMove_Verb != verbs[0]) {
SkASSERT(0);
return;
}
- SkPath::Verb verb = iter.next(pts);
+ auto verb = static_cast<SkPath::Verb>(verbs[1]);
SkASSERT(SkPath::kLine_Verb <= verb && verb <= SkPath::kCubic_Verb);
+ const SkPoint* pts = SkPathPriv::PointData(path);
SkPoint pos, tan;
for (int index = 0; index < ribs; ++index) {
SkScalar t = (SkScalar) index / ribs;
@@ -379,7 +372,7 @@
tan = SkEvalQuadTangentAt(pts, t);
break;
case SkPath::kConic_Verb: {
- SkConic conic(pts, iter.conicWeight());
+ SkConic conic(pts, SkPathPriv::ConicWeightData(path)[0]);
pos = conic.evalAt(t);
tan = conic.evalTangentAt(t);
} break;
@@ -421,7 +414,7 @@
if (drawText) {
fMinSurface->getCanvas()->drawPath(path, paint);
this->copyMinToMax();
- fMaxSurface->draw(canvas, 0, 0, nullptr);
+ fMaxSurface->draw(canvas, 0, 0);
}
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
@@ -478,7 +471,7 @@
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(width);
SkPath path;
- SkScalar maxSide = SkTMax(rect.width(), rect.height()) / 2;
+ SkScalar maxSide = std::max(rect.width(), rect.height()) / 2;
SkPoint center = { rect.fLeft + maxSide, rect.fTop + maxSide };
path.addCircle(center.fX, center.fY, maxSide);
canvas->drawPath(path, paint);
@@ -721,8 +714,7 @@
MyClick(int index) : fIndex(index) {}
};
- virtual Sample::Click* onFindClickHandler(SkScalar x, SkScalar y,
- skui::ModifierKey modi) override {
+ Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); ++i) {
if (hittest(fPts[i], x, y)) {
return new MyClick((int)i);
@@ -793,13 +785,13 @@
}
#ifdef SK_DEBUG
else if (index == (int) SK_ARRAY_COUNT(fPts) + 3) {
- gDebugStrokerError = SkTMax(FLT_EPSILON, MapScreenYtoValue(click->fCurr.fY,
+ gDebugStrokerError = std::max(FLT_EPSILON, MapScreenYtoValue(click->fCurr.fY,
fErrorControl, kStrokerErrorMin, kStrokerErrorMax));
gDebugStrokerErrorSet = true;
}
#endif
else if (index == (int) SK_ARRAY_COUNT(fPts) + 4) {
- fWidth = SkTMax(FLT_EPSILON, MapScreenYtoValue(click->fCurr.fY, fWidthControl,
+ fWidth = std::max(FLT_EPSILON, MapScreenYtoValue(click->fCurr.fY, fWidthControl,
kWidthMin, kWidthMax));
fAnimate = fWidth <= kWidthMin;
}
@@ -807,7 +799,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleRectanizer.cpp b/third_party/skia/samplecode/SampleRectanizer.cpp
index c9faa78..2b81079 100644
--- a/third_party/skia/samplecode/SampleRectanizer.cpp
+++ b/third_party/skia/samplecode/SampleRectanizer.cpp
@@ -12,8 +12,8 @@
#include "samplecode/Sample.h"
#include "src/utils/SkUTF.h"
#if SK_SUPPORT_GPU
-#include "src/gpu/GrRectanizer_pow2.h"
-#include "src/gpu/GrRectanizer_skyline.h"
+#include "src/gpu/GrRectanizerPow2.h"
+#include "src/gpu/GrRectanizerSkyline.h"
// This slide visualizes the various GrRectanizer-derived classes behavior
// for various input sets
@@ -180,7 +180,7 @@
fCurRandRect = 0;
}
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleRegion.cpp b/third_party/skia/samplecode/SampleRegion.cpp
deleted file mode 100644
index 7c16c01..0000000
--- a/third_party/skia/samplecode/SampleRegion.cpp
+++ /dev/null
@@ -1,349 +0,0 @@
-/*
- * Copyright 2011 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/SkBitmap.h"
-#include "include/core/SkCanvas.h"
-#include "include/core/SkFont.h"
-#include "include/core/SkFontMetrics.h"
-#include "include/core/SkPath.h"
-#include "include/core/SkRegion.h"
-#include "include/core/SkShader.h"
-#include "include/effects/SkGradientShader.h"
-#include "samplecode/Sample.h"
-#include "src/utils/SkUTF.h"
-
-#include <math.h>
-
-static void test_strokerect(SkCanvas* canvas) {
- int width = 100;
- int height = 100;
-
- SkBitmap bitmap;
- bitmap.allocPixels(SkImageInfo::MakeA8(width*2, height*2));
- bitmap.eraseColor(SK_ColorTRANSPARENT);
-
- SkScalar dx = 20;
- SkScalar dy = 20;
-
- SkPath path;
- path.addRect(0.0f, 0.0f,
- SkIntToScalar(width), SkIntToScalar(height),
- SkPathDirection::kCW);
- SkRect r = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
-
- SkCanvas c(bitmap);
- c.translate(dx, dy);
-
- SkPaint paint;
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setStrokeWidth(1);
-
- // use the rect
- c.clear(SK_ColorTRANSPARENT);
- c.drawRect(r, paint);
- canvas->drawBitmap(bitmap, 0, 0, nullptr);
-
- // use the path
- c.clear(SK_ColorTRANSPARENT);
- c.drawPath(path, paint);
- canvas->drawBitmap(bitmap, SkIntToScalar(2*width), 0, nullptr);
-}
-
-static void drawFadingText(SkCanvas* canvas,
- const char* text, size_t len, SkScalar x, SkScalar y,
- const SkFont& font, const SkPaint& paint) {
- // Need a bounds for the text
- SkRect bounds;
- SkFontMetrics fm;
-
- font.getMetrics(&fm);
- bounds.setLTRB(x, y + fm.fTop,
- x + font.measureText(text, len, SkTextEncoding::kUTF8), y + fm.fBottom);
-
- // may need to outset bounds a little, to account for hinting and/or
- // antialiasing
- bounds.inset(-SkIntToScalar(2), -SkIntToScalar(2));
-
- canvas->saveLayer(&bounds, nullptr);
- canvas->drawSimpleText(text, len, SkTextEncoding::kUTF8, x, y, font, paint);
-
- const SkPoint pts[] = {
- { bounds.fLeft, y },
- { bounds.fRight, y }
- };
- const SkColor colors[] = { SK_ColorBLACK, SK_ColorBLACK, 0 };
-
- // pos[1] value is where we start to fade, relative to the width
- // of our pts[] array.
- const SkScalar pos[] = { 0, 0.9f, SK_Scalar1 };
-
- SkPaint p;
- p.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 3, SkTileMode::kClamp));
- p.setBlendMode(SkBlendMode::kDstIn);
- canvas->drawRect(bounds, p);
-
- canvas->restore();
-}
-
-static void test_text(SkCanvas* canvas) {
- SkPaint paint;
- paint.setAntiAlias(true);
-
- SkFont font;
- font.setSize(20);
-
- const char* str = "Hamburgefons";
- size_t len = strlen(str);
- SkScalar x = 20;
- SkScalar y = 20;
-
- canvas->drawSimpleText(str, len, SkTextEncoding::kUTF8, x, y, font, paint);
-
- y += 20;
-
- const SkPoint pts[] = { { x , y },
- { x + font.measureText(str, len, SkTextEncoding::kUTF8), y } };
- const SkColor colors[] = { SK_ColorBLACK, SK_ColorBLACK, 0 };
- const SkScalar pos[] = { 0, 0.9f, 1 };
- paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos,
- SK_ARRAY_COUNT(colors),
- SkTileMode::kClamp));
- canvas->drawSimpleText(str, len, SkTextEncoding::kUTF8, x, y, font, paint);
-
- y += 20;
- paint.setShader(nullptr);
- drawFadingText(canvas, str, len, x, y, font, paint);
-}
-
-static void scale_rect(SkIRect* dst, const SkIRect& src, float scale) {
- dst->fLeft = (int)::roundf(src.fLeft * scale);
- dst->fTop = (int)::roundf(src.fTop * scale);
- dst->fRight = (int)::roundf(src.fRight * scale);
- dst->fBottom = (int)::roundf(src.fBottom * scale);
-}
-
-static void scale_rgn(SkRegion* dst, const SkRegion& src, float scale) {
- SkRegion tmp;
- SkRegion::Iterator iter(src);
-
- for (; !iter.done(); iter.next()) {
- SkIRect r;
- scale_rect(&r, iter.rect(), scale);
- tmp.op(r, SkRegion::kUnion_Op);
- }
- dst->swap(tmp);
-}
-
-static void paint_rgn(SkCanvas* canvas, const SkRegion& rgn,
- const SkPaint& paint) {
- SkRegion scaled;
- scale_rgn(&scaled, rgn, 0.5f);
-
- SkRegion::Iterator iter(rgn);
-
- for (; !iter.done(); iter.next())
- {
- SkRect r;
- r.set(iter.rect());
- canvas->drawRect(r, paint);
- }
-}
-
-class RegionView : public Sample {
-public:
- RegionView() {
- fBase.setLTRB(100, 100, 150, 150);
- fRect = fBase;
- fRect.inset(5, 5);
- fRect.offset(25, 25);
- this->setBGColor(0xFFDDDDDD);
- }
-
- void build_base_rgn(SkRegion* rgn) {
- rgn->setRect(fBase);
- SkIRect r = fBase;
- r.offset(75, 20);
- rgn->op(r, SkRegion::kUnion_Op);
- }
-
- void build_rgn(SkRegion* rgn, SkRegion::Op op) {
- build_base_rgn(rgn);
- rgn->op(fRect, op);
- }
-
-
-protected:
- SkString name() override { return SkString("Regions"); }
-
- static void drawstr(SkCanvas* canvas, const char text[], const SkPoint& loc,
- bool hilite) {
- SkPaint paint;
- paint.setColor(hilite ? SK_ColorRED : 0x40FF0000);
- SkFont font;
- font.setSize(SkIntToScalar(20));
- canvas->drawSimpleText(text, strlen(text), SkTextEncoding::kUTF8, loc.fX, loc.fY, font, paint);
- }
-
- void drawPredicates(SkCanvas* canvas, const SkPoint pts[]) {
- SkRegion rgn;
- build_base_rgn(&rgn);
-
- drawstr(canvas, "Intersects", pts[0], rgn.intersects(fRect));
- drawstr(canvas, "Contains", pts[1], rgn.contains(fRect));
- }
-
- void drawOrig(SkCanvas* canvas, bool bg) {
- SkRect r;
- SkPaint paint;
-
- paint.setStyle(SkPaint::kStroke_Style);
- if (bg)
- paint.setColor(0xFFBBBBBB);
-
- SkRegion rgn;
- build_base_rgn(&rgn);
- paint_rgn(canvas, rgn, paint);
-
- r.set(fRect);
- canvas->drawRect(r, paint);
- }
-
- void drawRgnOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) {
- SkRegion rgn;
-
- this->build_rgn(&rgn, op);
-
- {
- SkRegion tmp, tmp2(rgn);
-
- tmp = tmp2;
- tmp.translate(5, -3);
-
- {
- char buffer[1000];
- SkDEBUGCODE(size_t size = ) tmp.writeToMemory(nullptr);
- SkASSERT(size <= sizeof(buffer));
- SkDEBUGCODE(size_t size2 = ) tmp.writeToMemory(buffer);
- SkASSERT(size == size2);
-
- SkRegion tmp3;
- SkDEBUGCODE(size2 = ) tmp3.readFromMemory(buffer, 1000);
- SkASSERT(size == size2);
-
- SkASSERT(tmp3 == tmp);
- }
-
- rgn.translate(20, 30, &tmp);
- SkASSERT(rgn.isEmpty() || tmp != rgn);
- tmp.translate(-20, -30);
- SkASSERT(tmp == rgn);
- }
-
- this->drawOrig(canvas, true);
-
- SkPaint paint;
- paint.setColor((color & ~(0xFF << 24)) | (0x44 << 24));
- paint_rgn(canvas, rgn, paint);
-
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setColor(color);
- paint_rgn(canvas, rgn, paint);
- }
-
- void drawPathOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) {
- SkRegion rgn;
- SkPath path;
-
- this->build_rgn(&rgn, op);
- rgn.getBoundaryPath(&path);
-
- this->drawOrig(canvas, true);
-
- SkPaint paint;
-
- paint.setStyle(SkPaint::kFill_Style);
- paint.setColor((color & ~(0xFF << 24)) | (0x44 << 24));
- canvas->drawPath(path, paint);
- paint.setColor(color);
- paint.setStyle(SkPaint::kStroke_Style);
- canvas->drawPath(path, paint);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- if (false) { // avoid bit rot, suppress warning
- test_strokerect(canvas);
- return;
- }
- if (false) { // avoid bit rot, suppress warning
- test_text(canvas);
- return;
- }
-
- const SkPoint origins[] = {
- { 30*SK_Scalar1, 50*SK_Scalar1 },
- { 150*SK_Scalar1, 50*SK_Scalar1 },
- };
- this->drawPredicates(canvas, origins);
-
- static const struct {
- SkColor fColor;
- const char* fName;
- SkRegion::Op fOp;
- } gOps[] = {
- { SK_ColorBLACK, "Difference", SkRegion::kDifference_Op },
- { SK_ColorRED, "Intersect", SkRegion::kIntersect_Op },
- { 0xFF008800, "Union", SkRegion::kUnion_Op },
- { SK_ColorBLUE, "XOR", SkRegion::kXOR_Op }
- };
-
- SkFont font;
- font.setSize(SK_Scalar1*24);
-
- this->drawOrig(canvas, false);
- canvas->save();
- canvas->translate(SkIntToScalar(200), 0);
- this->drawRgnOped(canvas, SkRegion::kUnion_Op, SK_ColorBLACK);
- canvas->restore();
-
- canvas->translate(0, SkIntToScalar(200));
-
- for (size_t op = 0; op < SK_ARRAY_COUNT(gOps); op++) {
- canvas->drawSimpleText(gOps[op].fName, strlen(gOps[op].fName), SkTextEncoding::kUTF8,
- SkIntToScalar(75), SkIntToScalar(50), font, SkPaint());
-
- this->drawRgnOped(canvas, gOps[op].fOp, gOps[op].fColor);
-
- canvas->save();
- canvas->translate(0, SkIntToScalar(200));
- this->drawPathOped(canvas, gOps[op].fOp, gOps[op].fColor);
- canvas->restore();
-
- canvas->translate(SkIntToScalar(200), 0);
- }
- }
-
- virtual Sample::Click* onFindClickHandler(SkScalar x, SkScalar y,
- skui::ModifierKey modi) override {
- return fRect.contains(SkScalarRoundToInt(x),
- SkScalarRoundToInt(y)) ? new Click() : nullptr;
- }
-
- bool onClick(Click* click) override {
- fRect.offset(click->fCurr.fX - click->fPrev.fX,
- click->fCurr.fY - click->fPrev.fY);
- return true;
- }
-
-private:
- SkIRect fBase, fRect;
-
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new RegionView(); )
diff --git a/third_party/skia/samplecode/SampleRepeatTile.cpp b/third_party/skia/samplecode/SampleRepeatTile.cpp
index 3b7dea0..4022db6 100644
--- a/third_party/skia/samplecode/SampleRepeatTile.cpp
+++ b/third_party/skia/samplecode/SampleRepeatTile.cpp
@@ -35,7 +35,7 @@
SkBitmap bm;
make_bitmap(&bm);
- paint->setShader(bm.makeShader(tm, tm));
+ paint->setShader(bm.makeShader(tm, tm, SkSamplingOptions()));
}
class RepeatTileView : public Sample {
@@ -57,7 +57,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleSG.cpp b/third_party/skia/samplecode/SampleSG.cpp
index bb2bf89..1fa8994 100644
--- a/third_party/skia/samplecode/SampleSG.cpp
+++ b/third_party/skia/samplecode/SampleSG.cpp
@@ -52,7 +52,7 @@
SampleSG() {
fGroup = sksg::Group::Make();
- fScene = sksg::Scene::Make(fGroup, sksg::AnimatorList());
+ fScene = sksg::Scene::Make(fGroup);
auto r = sksg::Rect::Make({20, 20, 400, 300});
auto p = sksg::Color::Make(SK_ColorRED);
@@ -101,7 +101,7 @@
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleSVGFile.cpp b/third_party/skia/samplecode/SampleSVGFile.cpp
index 9fb62ed..b607d9a 100644
--- a/third_party/skia/samplecode/SampleSVGFile.cpp
+++ b/third_party/skia/samplecode/SampleSVGFile.cpp
@@ -7,11 +7,12 @@
#include "include/core/SkTypes.h"
-#ifdef SK_XML
+#if defined(SK_ENABLE_SVG)
-#include "experimental/svg/model/SkSVGDOM.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkStream.h"
+#include "modules/svg/include/SkSVGDOM.h"
+#include "modules/svg/include/SkSVGNode.h"
#include "samplecode/Sample.h"
#include "src/core/SkOSFile.h"
#include "src/utils/SkOSPath.h"
@@ -29,17 +30,11 @@
void onOnceBeforeDraw() override {
SkFILEStream svgStream(fPath.c_str());
if (!svgStream.isValid()) {
- SkDebugf("file not found: \"path\"\n", fPath.c_str());
+ SkDebugf("file not found: \"%s\"\n", fPath.c_str());
return;
}
- SkDOM xmlDom;
- if (!xmlDom.build(svgStream)) {
- SkDebugf("XML parsing failed: \"path\"\n", fPath.c_str());
- return;
- }
-
- fDom = SkSVGDOM::MakeFromDOM(xmlDom);
+ fDom = SkSVGDOM::MakeFromStream(svgStream);
if (fDom) {
fDom->setContainerSize(SkSize::Make(this->width(), this->height()));
}
@@ -66,7 +61,7 @@
SkString fPath;
SkString fLabel;
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
} // anonymous namespace
@@ -75,4 +70,4 @@
Sample* CreateSampleSVGFileView(const SkString& filename) {
return new SVGFileView(filename);
}
-#endif // SK_XML
+#endif // defined(SK_ENABLE_SVG)
diff --git a/third_party/skia/samplecode/SampleShaders.cpp b/third_party/skia/samplecode/SampleShaders.cpp
deleted file mode 100644
index fb3fec9..0000000
--- a/third_party/skia/samplecode/SampleShaders.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright 2011 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/SkShader.h"
-#include "include/effects/SkGradientShader.h"
-#include "samplecode/DecodeFile.h"
-#include "samplecode/Sample.h"
-#include "tools/Resources.h"
-
-namespace {
-static sk_sp<SkShader> make_bitmapfade(const SkBitmap& bm) {
- SkPoint pts[2] = {
- {0, 0},
- {0, (float)bm.height()},
- };
- SkColor colors[2] = {
- SkColorSetARGB(255, 0, 0, 0),
- SkColorSetARGB(0, 0, 0, 0),
- };
- return SkShaders::Blend(SkBlendMode::kDstIn,
- bm.makeShader(),
- SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
- SkTileMode::kClamp));
-}
-
-static sk_sp<SkShader> make_blend_shader() {
- SkPoint pts[2];
- SkColor colors[2];
-
- pts[0].set(0, 0);
- pts[1].set(SkIntToScalar(100), 0);
- colors[0] = SK_ColorRED;
- colors[1] = SK_ColorBLUE;
- auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
-
- pts[0].set(0, 0);
- pts[1].set(0, SkIntToScalar(100));
- colors[0] = SK_ColorBLACK;
- colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
- auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
-
- return SkShaders::Blend(SkBlendMode::kDstIn, std::move(shaderA), std::move(shaderB));
-}
-
-struct ShaderView : public Sample {
- sk_sp<SkShader> fShader;
- sk_sp<SkShader> fShaderFade;
- SkBitmap fBitmap;
-
- void onOnceBeforeDraw() override {
- decode_file(GetResourceAsData("images/dog.jpg"), &fBitmap);
- fShader = make_blend_shader();
- fShaderFade = make_bitmapfade(fBitmap);
- }
-
- SkString name() override { return SkString("Shaders"); }
-
- void onDrawContent(SkCanvas* canvas) override {
- canvas->drawBitmap(fBitmap, 0, 0);
- canvas->translate(20, 120);
-
- SkPaint paint;
- paint.setColor(SK_ColorGREEN);
- canvas->drawRect(SkRect{0, 0, 100, 100}, paint);
- paint.setShader(fShader);
- canvas->drawRect(SkRect{0, 0, 100, 100}, paint);
-
- canvas->translate(SkIntToScalar(110), 0);
-
- paint.setShader(nullptr);
- canvas->drawRect(SkRect{0, 0, 120, 80}, paint);
- paint.setShader(fShaderFade);
- canvas->drawRect(SkRect{0, 0, 120, 80}, paint);
- }
-};
-} // namespace
-DEF_SAMPLE( return new ShaderView(); )
diff --git a/third_party/skia/samplecode/SampleShadowColor.cpp b/third_party/skia/samplecode/SampleShadowColor.cpp
index e0dd7fe..7313bda 100644
--- a/third_party/skia/samplecode/SampleShadowColor.cpp
+++ b/third_party/skia/samplecode/SampleShadowColor.cpp
@@ -74,11 +74,11 @@
handled = true;
break;
case '>':
- fZIndex = SkTMin(9, fZIndex+1);
+ fZIndex = std::min(9, fZIndex+1);
handled = true;
break;
case '<':
- fZIndex = SkTMax(0, fZIndex-1);
+ fZIndex = std::max(0, fZIndex-1);
handled = true;
break;
default:
@@ -115,9 +115,9 @@
if (paint.getColor() != SK_ColorBLACK) {
SkColor color = paint.getColor();
- uint8_t max = SkTMax(SkTMax(SkColorGetR(color), SkColorGetG(color)),
+ uint8_t max = std::max(std::max(SkColorGetR(color), SkColorGetG(color)),
SkColorGetB(color));
- uint8_t min = SkTMin(SkTMin(SkColorGetR(color), SkColorGetG(color)),
+ uint8_t min = std::min(std::min(SkColorGetR(color), SkColorGetG(color)),
SkColorGetB(color));
SkScalar luminance = 0.5f*(max + min) / 255.f;
SkScalar alpha = (.6 - .4*luminance)*luminance*luminance + 0.3f;
@@ -221,7 +221,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleShadowReference.cpp b/third_party/skia/samplecode/SampleShadowReference.cpp
index db8e9db..76439fb 100644
--- a/third_party/skia/samplecode/SampleShadowReference.cpp
+++ b/third_party/skia/samplecode/SampleShadowReference.cpp
@@ -191,7 +191,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleShadowUtils.cpp b/third_party/skia/samplecode/SampleShadowUtils.cpp
index 86151c1..e313875 100644
--- a/third_party/skia/samplecode/SampleShadowUtils.cpp
+++ b/third_party/skia/samplecode/SampleShadowUtils.cpp
@@ -9,7 +9,6 @@
#include "include/core/SkColorFilter.h"
#include "include/core/SkPath.h"
#include "include/core/SkPoint3.h"
-#include "include/effects/SkBlurMaskFilter.h"
#include "include/pathops/SkPathOps.h"
#include "include/utils/SkCamera.h"
#include "include/utils/SkShadowUtils.h"
@@ -172,13 +171,11 @@
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, SkTMax(1.0f, kHeight + fZDelta));
+ matrices.push()->setRotate(33.f, 25.f, 25.f).postScale(1.2f, 0.8f, 25.f, 25.f);
+ SkPaint greenPaint;
+ greenPaint.setColor(SK_ColorGREEN);
+ greenPaint.setAntiAlias(true);
+ SkPoint3 zPlaneParams = SkPoint3::Make(0, 0, std::max(1.0f, kHeight + fZDelta));
// convex paths
for (auto& m : matrices) {
@@ -198,13 +195,13 @@
canvas->save();
canvas->concat(m);
- this->drawShadowedPath(canvas, path, zPlaneParams, paint, kAmbientAlpha,
+ this->drawShadowedPath(canvas, path, zPlaneParams, greenPaint, kAmbientAlpha,
lightPos, kLightR, kSpotAlpha, flags);
canvas->restore();
canvas->translate(dx, 0);
x += dx;
- dy = SkTMax(dy, postMBounds.height() + kPad + kHeight);
+ dy = std::max(dy, postMBounds.height() + kPad + kHeight);
}
}
}
@@ -224,13 +221,13 @@
canvas->save();
canvas->concat(m);
- this->drawShadowedPath(canvas, path, zPlaneParams, paint, kAmbientAlpha, lightPos,
- kLightR, kSpotAlpha, kNone_ShadowFlag);
+ this->drawShadowedPath(canvas, path, zPlaneParams, greenPaint, kAmbientAlpha,
+ lightPos, kLightR, kSpotAlpha, kNone_ShadowFlag);
canvas->restore();
canvas->translate(dx, 0);
x += dx;
- dy = SkTMax(dy, postMBounds.height() + kPad + kHeight);
+ dy = std::max(dy, postMBounds.height() + kPad + kHeight);
}
}
@@ -239,16 +236,16 @@
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);
+ SkPaint blackPaint;
+ blackPaint.setColor(SK_ColorBLACK);
+ blackPaint.setAntiAlias(true);
+ canvas->drawCircle(lightPos.fX, lightPos.fY, kLightR / 10.f, blackPaint);
canvas->restore();
}
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleShip.cpp b/third_party/skia/samplecode/SampleShip.cpp
index 8fdc9eb..a20f8b2 100644
--- a/third_party/skia/samplecode/SampleShip.cpp
+++ b/third_party/skia/samplecode/SampleShip.cpp
@@ -10,6 +10,7 @@
#include "include/core/SkRSXform.h"
#include "include/core/SkSurface.h"
#include "samplecode/Sample.h"
+#include "src/core/SkPaintPriv.h"
#include "tools/Resources.h"
#include "tools/timer/Timer.h"
@@ -20,25 +21,26 @@
static const int kHeight = 640;
typedef void (*DrawAtlasProc)(SkCanvas*, SkImage*, const SkRSXform[], const SkRect[],
-const SkColor[], int, const SkRect*, const SkPaint*);
+const SkColor[], int, const SkRect*, const SkSamplingOptions&, const SkPaint*);
static void draw_atlas(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
- const SkPaint* paint) {
- canvas->drawAtlas(atlas, xform, tex, colors, count, SkBlendMode::kModulate, cull, paint);
+ const SkSamplingOptions& sampling, const SkPaint* paint) {
+ canvas->drawAtlas(atlas, xform, tex, colors, count, SkBlendMode::kModulate, sampling,
+ cull, paint);
}
static void draw_atlas_sim(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
- const SkPaint* paint) {
+ const SkSamplingOptions& sampling, const SkPaint* paint) {
for (int i = 0; i < count; ++i) {
SkMatrix matrix;
matrix.setRSXform(xform[i]);
canvas->save();
canvas->concat(matrix);
- canvas->drawImageRect(atlas, tex[i], tex[i].makeOffset(-tex[i].x(), -tex[i].y()), paint,
- SkCanvas::kFast_SrcRectConstraint);
+ canvas->drawImageRect(atlas, tex[i], tex[i].makeOffset(-tex[i].x(), -tex[i].y()),
+ sampling, paint, SkCanvas::kFast_SrcRectConstraint);
canvas->restore();
}
}
@@ -96,7 +98,6 @@
}
SkPaint paint;
- paint.setFilterQuality(kLow_SkFilterQuality);
paint.setColor(SK_ColorWHITE);
SkScalar anchorX = fAtlas->width()*0.5f;
@@ -117,7 +118,8 @@
fXform[i].fTy += dy;
}
- fProc(canvas, fAtlas.get(), fXform, fTex, nullptr, kGrid*kGrid+1, nullptr, &paint);
+ fProc(canvas, fAtlas.get(), fXform, fTex, nullptr, kGrid*kGrid+1, nullptr,
+ SkSamplingOptions(SkFilterMode::kLinear), &paint);
}
bool onAnimate(double nanos) override {
@@ -135,7 +137,7 @@
SkRSXform fXform[kGrid*kGrid+1];
SkRect fTex[kGrid*kGrid+1];
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleSimpleStroker.cpp b/third_party/skia/samplecode/SampleSimpleStroker.cpp
new file mode 100644
index 0000000..651d2ed
--- /dev/null
+++ b/third_party/skia/samplecode/SampleSimpleStroker.cpp
@@ -0,0 +1,482 @@
+/*
+ * Copyright 2020 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/SkBitmap.h"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkPath.h"
+#include "include/utils/SkParsePath.h"
+#include "samplecode/Sample.h"
+
+#include "src/core/SkGeometry.h"
+
+namespace {
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkPoint rotate90(const SkPoint& p) { return {p.fY, -p.fX}; }
+static SkPoint rotate180(const SkPoint& p) { return p * -1; }
+static SkPoint setLength(SkPoint p, float len) {
+ if (!p.setLength(len)) {
+ SkDebugf("Failed to set point length\n");
+ }
+ return p;
+}
+static bool isClockwise(const SkPoint& a, const SkPoint& b) { return a.cross(b) > 0; }
+
+//////////////////////////////////////////////////////////////////////////////
+// Testing ground for a new stroker implementation
+
+/** Helper class for constructing paths, with undo support */
+class PathRecorder {
+public:
+ SkPath getPath() const {
+ return SkPath::Make(fPoints.data(), fPoints.size(), fVerbs.data(), fVerbs.size(), nullptr,
+ 0, SkPathFillType::kWinding);
+ }
+
+ void moveTo(SkPoint p) {
+ fVerbs.push_back(SkPath::kMove_Verb);
+ fPoints.push_back(p);
+ }
+
+ void lineTo(SkPoint p) {
+ fVerbs.push_back(SkPath::kLine_Verb);
+ fPoints.push_back(p);
+ }
+
+ void close() { fVerbs.push_back(SkPath::kClose_Verb); }
+
+ void rewind() {
+ fVerbs.clear();
+ fPoints.clear();
+ }
+
+ int countPoints() const { return fPoints.size(); }
+
+ int countVerbs() const { return fVerbs.size(); }
+
+ bool getLastPt(SkPoint* lastPt) const {
+ if (fPoints.empty()) {
+ return false;
+ }
+ *lastPt = fPoints.back();
+ return true;
+ }
+
+ void setLastPt(SkPoint lastPt) {
+ if (fPoints.empty()) {
+ moveTo(lastPt);
+ } else {
+ fPoints.back().set(lastPt.fX, lastPt.fY);
+ }
+ }
+
+ const std::vector<uint8_t>& verbs() const { return fVerbs; }
+
+ const std::vector<SkPoint>& points() const { return fPoints; }
+
+private:
+ std::vector<uint8_t> fVerbs;
+ std::vector<SkPoint> fPoints;
+};
+
+class SkPathStroker2 {
+public:
+ // Returns the fill path
+ SkPath getFillPath(const SkPath& path, const SkPaint& paint);
+
+private:
+ struct PathSegment {
+ SkPath::Verb fVerb;
+ SkPoint fPoints[4];
+ };
+
+ float fRadius;
+ SkPaint::Cap fCap;
+ SkPaint::Join fJoin;
+ PathRecorder fInner, fOuter;
+
+ // Initialize stroker state
+ void initForPath(const SkPath& path, const SkPaint& paint);
+
+ // Strokes a line segment
+ void strokeLine(const PathSegment& line, bool needsMove);
+
+ // Adds an endcap to fOuter
+ enum class CapLocation { Start, End };
+ void endcap(CapLocation loc);
+
+ // Adds a join between the two segments
+ void join(const PathSegment& prev, const PathSegment& curr);
+
+ // Appends path in reverse to result
+ static void appendPathReversed(const PathRecorder& path, PathRecorder* result);
+
+ // Returns the segment unit normal
+ static SkPoint unitNormal(const PathSegment& seg, float t);
+
+ // Returns squared magnitude of line segments.
+ static float squaredLineLength(const PathSegment& lineSeg);
+};
+
+void SkPathStroker2::initForPath(const SkPath& path, const SkPaint& paint) {
+ fRadius = paint.getStrokeWidth() / 2;
+ fCap = paint.getStrokeCap();
+ fJoin = paint.getStrokeJoin();
+ fInner.rewind();
+ fOuter.rewind();
+}
+
+SkPath SkPathStroker2::getFillPath(const SkPath& path, const SkPaint& paint) {
+ initForPath(path, paint);
+
+ // Trace the inner and outer paths simultaneously. Inner will therefore be
+ // recorded in reverse from how we trace the outline.
+ SkPath::Iter it(path, false);
+ PathSegment segment, prevSegment;
+ bool firstSegment = true;
+ while ((segment.fVerb = it.next(segment.fPoints)) != SkPath::kDone_Verb) {
+ // Join to the previous segment
+ if (!firstSegment) {
+ join(prevSegment, segment);
+ }
+
+ // Stroke the current segment
+ switch (segment.fVerb) {
+ case SkPath::kLine_Verb:
+ strokeLine(segment, firstSegment);
+ break;
+ case SkPath::kMove_Verb:
+ // Don't care about multiple contours currently
+ continue;
+ default:
+ SkDebugf("Unhandled path verb %d\n", segment.fVerb);
+ break;
+ }
+
+ std::swap(segment, prevSegment);
+ firstSegment = false;
+ }
+
+ // Open contour => endcap at the end
+ const bool isClosed = path.isLastContourClosed();
+ if (isClosed) {
+ SkDebugf("Unhandled closed contour\n");
+ } else {
+ endcap(CapLocation::End);
+ }
+
+ // Walk inner path in reverse, appending to result
+ appendPathReversed(fInner, &fOuter);
+ endcap(CapLocation::Start);
+
+ return fOuter.getPath();
+}
+
+void SkPathStroker2::strokeLine(const PathSegment& line, bool needsMove) {
+ const SkPoint tangent = line.fPoints[1] - line.fPoints[0];
+ const SkPoint normal = rotate90(tangent);
+ const SkPoint offset = setLength(normal, fRadius);
+ if (needsMove) {
+ fOuter.moveTo(line.fPoints[0] + offset);
+ fInner.moveTo(line.fPoints[0] - offset);
+ }
+ fOuter.lineTo(line.fPoints[1] + offset);
+ fInner.lineTo(line.fPoints[1] - offset);
+}
+
+void SkPathStroker2::endcap(CapLocation loc) {
+ const auto buttCap = [this](CapLocation loc) {
+ if (loc == CapLocation::Start) {
+ // Back at the start of the path: just close the stroked outline
+ fOuter.close();
+ } else {
+ // Inner last pt == first pt when appending in reverse
+ SkPoint innerLastPt;
+ fInner.getLastPt(&innerLastPt);
+ fOuter.lineTo(innerLastPt);
+ }
+ };
+
+ switch (fCap) {
+ case SkPaint::kButt_Cap:
+ buttCap(loc);
+ break;
+ default:
+ SkDebugf("Unhandled endcap %d\n", fCap);
+ buttCap(loc);
+ break;
+ }
+}
+
+void SkPathStroker2::join(const PathSegment& prev, const PathSegment& curr) {
+ const auto miterJoin = [this](const PathSegment& prev, const PathSegment& curr) {
+ // Common path endpoint of the two segments is the midpoint of the miter line.
+ const SkPoint miterMidpt = curr.fPoints[0];
+
+ SkPoint before = unitNormal(prev, 1);
+ SkPoint after = unitNormal(curr, 0);
+
+ // Check who's inside and who's outside.
+ PathRecorder *outer = &fOuter, *inner = &fInner;
+ if (!isClockwise(before, after)) {
+ std::swap(inner, outer);
+ before = rotate180(before);
+ after = rotate180(after);
+ }
+
+ const float cosTheta = before.dot(after);
+ if (SkScalarNearlyZero(1 - cosTheta)) {
+ // Nearly identical normals: don't bother.
+ return;
+ }
+
+ // Before and after have the same origin and magnitude, so before+after is the diagonal of
+ // their rhombus. Origin of this vector is the midpoint of the miter line.
+ SkPoint miterVec = before + after;
+
+ // Note the relationship (draw a right triangle with the miter line as its hypoteneuse):
+ // sin(theta/2) = strokeWidth / miterLength
+ // so miterLength = strokeWidth / sin(theta/2)
+ // where miterLength is the length of the miter from outer point to inner corner.
+ // miterVec's origin is the midpoint of the miter line, so we use strokeWidth/2.
+ // Sqrt is just an application of half-angle identities.
+ const float sinHalfTheta = sqrtf(0.5 * (1 + cosTheta));
+ const float halfMiterLength = fRadius / sinHalfTheta;
+ miterVec.setLength(halfMiterLength); // TODO: miter length limit
+
+ // Outer: connect to the miter point, and then to t=0 (on outside stroke) of next segment.
+ const SkPoint dest = setLength(after, fRadius);
+ outer->lineTo(miterMidpt + miterVec);
+ outer->lineTo(miterMidpt + dest);
+
+ // Inner miter is more involved. We're already at t=1 (on inside stroke) of 'prev'.
+ // Check 2 cases to see we can directly connect to the inner miter point
+ // (midpoint - miterVec), or if we need to add extra "loop" geometry.
+ const SkPoint prevUnitTangent = rotate90(before);
+ const float radiusSquared = fRadius * fRadius;
+ // 'alpha' is angle between prev tangent and the curr inwards normal
+ const float cosAlpha = prevUnitTangent.dot(-after);
+ // Solve triangle for len^2: radius^2 = len^2 + (radius * sin(alpha))^2
+ // This is the point at which the inside "corner" of curr at t=0 will lie on a
+ // line connecting the inner and outer corners of prev at t=0. If len is below
+ // this threshold, the inside corner of curr will "poke through" the start of prev,
+ // and we'll need the inner loop geometry.
+ const float threshold1 = radiusSquared * cosAlpha * cosAlpha;
+ // Solve triangle for len^2: halfMiterLen^2 = radius^2 + len^2
+ // This is the point at which the inner miter point will lie on the inner stroke
+ // boundary of the curr segment. If len is below this threshold, the miter point
+ // moves 'inside' of the stroked outline, and we'll need the inner loop geometry.
+ const float threshold2 = halfMiterLength * halfMiterLength - radiusSquared;
+ // If a segment length is smaller than the larger of the two thresholds,
+ // we'll have to add the inner loop geometry.
+ const float maxLenSqd = std::max(threshold1, threshold2);
+ const bool needsInnerLoop =
+ squaredLineLength(prev) < maxLenSqd || squaredLineLength(curr) < maxLenSqd;
+ if (needsInnerLoop) {
+ // Connect to the miter midpoint (common path endpoint of the two segments),
+ // and then to t=0 (on inside) of the next segment. This adds an interior "loop" of
+ // geometry that handles edge cases where segment lengths are shorter than the
+ // stroke width.
+ inner->lineTo(miterMidpt);
+ inner->lineTo(miterMidpt - dest);
+ } else {
+ // Directly connect to inner miter point.
+ inner->setLastPt(miterMidpt - miterVec);
+ }
+ };
+
+ switch (fJoin) {
+ case SkPaint::kMiter_Join:
+ miterJoin(prev, curr);
+ break;
+ default:
+ SkDebugf("Unhandled join %d\n", fJoin);
+ miterJoin(prev, curr);
+ break;
+ }
+}
+
+void SkPathStroker2::appendPathReversed(const PathRecorder& path, PathRecorder* result) {
+ const int numVerbs = path.countVerbs();
+ const int numPoints = path.countPoints();
+ const std::vector<uint8_t>& verbs = path.verbs();
+ const std::vector<SkPoint>& points = path.points();
+
+ for (int i = numVerbs - 1, j = numPoints; i >= 0; i--) {
+ auto verb = static_cast<SkPath::Verb>(verbs[i]);
+ switch (verb) {
+ case SkPath::kLine_Verb: {
+ j -= 1;
+ SkASSERT(j >= 1);
+ result->lineTo(points[j - 1]);
+ break;
+ }
+ case SkPath::kMove_Verb:
+ // Ignore
+ break;
+ default:
+ SkASSERT(false);
+ break;
+ }
+ }
+}
+
+SkPoint SkPathStroker2::unitNormal(const PathSegment& seg, float t) {
+ if (seg.fVerb != SkPath::kLine_Verb) {
+ SkDebugf("Unhandled verb for unit normal %d\n", seg.fVerb);
+ }
+
+ (void)t; // Not needed for lines
+ const SkPoint tangent = seg.fPoints[1] - seg.fPoints[0];
+ const SkPoint normal = rotate90(tangent);
+ return setLength(normal, 1);
+}
+
+float SkPathStroker2::squaredLineLength(const PathSegment& lineSeg) {
+ SkASSERT(lineSeg.fVerb == SkPath::kLine_Verb);
+ const SkPoint diff = lineSeg.fPoints[1] - lineSeg.fPoints[0];
+ return diff.dot(diff);
+}
+
+} // namespace
+
+//////////////////////////////////////////////////////////////////////////////
+
+class SimpleStroker : public Sample {
+ bool fShowSkiaStroke, fShowHidden, fShowSkeleton;
+ float fWidth = 175;
+ SkPaint fPtsPaint, fStrokePaint, fMirrorStrokePaint, fNewFillPaint, fHiddenPaint,
+ fSkeletonPaint;
+ inline static constexpr int kN = 3;
+
+public:
+ SkPoint fPts[kN];
+
+ SimpleStroker() : fShowSkiaStroke(true), fShowHidden(true), fShowSkeleton(true) {
+ fPts[0] = {500, 200};
+ fPts[1] = {300, 200};
+ fPts[2] = {100, 100};
+
+ fPtsPaint.setAntiAlias(true);
+ fPtsPaint.setStrokeWidth(10);
+ fPtsPaint.setStrokeCap(SkPaint::kRound_Cap);
+
+ fStrokePaint.setAntiAlias(true);
+ fStrokePaint.setStyle(SkPaint::kStroke_Style);
+ fStrokePaint.setColor(0x80FF0000);
+
+ fMirrorStrokePaint.setAntiAlias(true);
+ fMirrorStrokePaint.setStyle(SkPaint::kStroke_Style);
+ fMirrorStrokePaint.setColor(0x80FFFF00);
+
+ fNewFillPaint.setAntiAlias(true);
+ fNewFillPaint.setColor(0x8000FF00);
+
+ fHiddenPaint.setAntiAlias(true);
+ fHiddenPaint.setStyle(SkPaint::kStroke_Style);
+ fHiddenPaint.setColor(0xFF0000FF);
+
+ fSkeletonPaint.setAntiAlias(true);
+ fSkeletonPaint.setStyle(SkPaint::kStroke_Style);
+ fSkeletonPaint.setColor(SK_ColorRED);
+ }
+
+ void toggle(bool& value) { value = !value; }
+
+protected:
+ SkString name() override { return SkString("SimpleStroker"); }
+
+ bool onChar(SkUnichar uni) override {
+ switch (uni) {
+ case '1':
+ this->toggle(fShowSkeleton);
+ return true;
+ case '2':
+ this->toggle(fShowSkiaStroke);
+ return true;
+ case '3':
+ this->toggle(fShowHidden);
+ return true;
+ case '-':
+ fWidth -= 5;
+ return true;
+ case '=':
+ fWidth += 5;
+ return true;
+ default:
+ break;
+ }
+ return false;
+ }
+
+ void makePath(SkPath* path) {
+ path->moveTo(fPts[0]);
+ for (int i = 1; i < kN; ++i) {
+ path->lineTo(fPts[i]);
+ }
+ }
+
+ void onDrawContent(SkCanvas* canvas) override {
+ canvas->drawColor(0xFFEEEEEE);
+
+ SkPath path;
+ this->makePath(&path);
+
+ fStrokePaint.setStrokeWidth(fWidth);
+
+ // The correct result
+ if (fShowSkiaStroke) {
+ canvas->drawPath(path, fStrokePaint);
+ }
+
+ // Simple stroker result
+ SkPathStroker2 stroker;
+ SkPath fillPath = stroker.getFillPath(path, fStrokePaint);
+ canvas->drawPath(fillPath, fNewFillPaint);
+
+ if (fShowHidden) {
+ canvas->drawPath(fillPath, fHiddenPaint);
+ }
+ if (fShowSkeleton) {
+ canvas->drawPath(path, fSkeletonPaint);
+ }
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, kN, fPts, fPtsPaint);
+
+ // Draw a mirror but using Skia's stroker.
+ canvas->translate(0, 400);
+ fMirrorStrokePaint.setStrokeWidth(fWidth);
+ canvas->drawPath(path, fMirrorStrokePaint);
+ if (fShowHidden) {
+ SkPath hidden;
+ fStrokePaint.getFillPath(path, &hidden);
+ canvas->drawPath(hidden, fHiddenPaint);
+ }
+ if (fShowSkeleton) {
+ canvas->drawPath(path, fSkeletonPaint);
+ }
+ }
+
+ Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
+ const SkScalar tol = 4;
+ const SkRect r = SkRect::MakeXYWH(x - tol, y - tol, tol * 2, tol * 2);
+ for (int i = 0; i < kN; ++i) {
+ if (r.intersects(SkRect::MakeXYWH(fPts[i].fX, fPts[i].fY, 1, 1))) {
+ return new Click([this, i](Click* c) {
+ fPts[i] = c->fCurr;
+ return true;
+ });
+ }
+ }
+ return nullptr;
+ }
+
+private:
+ using INHERITED = Sample;
+};
+
+DEF_SAMPLE(return new SimpleStroker;)
diff --git a/third_party/skia/samplecode/SampleSlides.cpp b/third_party/skia/samplecode/SampleSlides.cpp
index d58f4f1..a17a674 100644
--- a/third_party/skia/samplecode/SampleSlides.cpp
+++ b/third_party/skia/samplecode/SampleSlides.cpp
@@ -7,7 +7,6 @@
#include "include/core/SkCanvas.h"
#include "include/core/SkPaint.h"
#include "include/core/SkVertices.h"
-#include "include/effects/SkBlurMaskFilter.h"
#include "include/effects/SkGradientShader.h"
#include "samplecode/Sample.h"
#include "src/core/SkBlurMask.h"
@@ -246,7 +245,7 @@
decode_file("/skimages/logo.gif", &bm);
size->set(bm.width(), bm.height());
- return bm.makeShader();
+ return bm.makeShader(SkSamplingOptions(SkFilterMode::kLinear));
}
static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
@@ -363,7 +362,6 @@
SkPaint paint;
paint.setDither(true);
- paint.setFilterQuality(kLow_SkFilterQuality);
for (size_t i = 0; i < SK_ARRAY_COUNT(fRecs); i++) {
auto verts = SkVertices::MakeCopy(fRecs[i].fMode, fRecs[i].fCount,
@@ -429,7 +427,7 @@
gProc[i](&canvas);
canvas.restore();
SkString str;
- str.printf("/skimages/slide_" SK_SIZE_T_SPECIFIER ".png", i);
+ str.printf("/skimages/slide_%zu.png", i);
ToolUtils::EncodeImageToFile(str.c_str(), bm, SkEncodedImageFormat::kPNG, 100);
}
this->setBGColor(BG_COLOR);
@@ -450,7 +448,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleStringArt.cpp b/third_party/skia/samplecode/SampleStringArt.cpp
index bda466c..9f2b3b1 100644
--- a/third_party/skia/samplecode/SampleStringArt.cpp
+++ b/third_party/skia/samplecode/SampleStringArt.cpp
@@ -32,7 +32,7 @@
SkPath path;
path.moveTo(center);
- while (length < (SkScalarHalf(SkMinScalar(this->width(), this->height())) - 10.f))
+ while (length < (SkScalarHalf(std::min(this->width(), this->height())) - 10.f))
{
SkPoint rp = SkPoint::Make(length*SkScalarCos(step) + center.fX,
length*SkScalarSin(step) + center.fY);
@@ -57,7 +57,7 @@
private:
SkScalar fAngle;
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleStrokePath.cpp b/third_party/skia/samplecode/SampleStrokePath.cpp
index b22ba8d..5feb87c 100644
--- a/third_party/skia/samplecode/SampleStrokePath.cpp
+++ b/third_party/skia/samplecode/SampleStrokePath.cpp
@@ -35,9 +35,7 @@
paint.setStrokeJoin(SkPaint::kRound_Join);
paint.setStyle(SkPaint::kStroke_Style);
- SkMatrix matrix;
- matrix.setRectToRect(srcR, dstR, SkMatrix::kCenter_ScaleToFit);
- canvas->concat(matrix);
+ canvas->concat(SkMatrix::RectToRect(srcR, dstR, SkMatrix::kCenter_ScaleToFit));
canvas->drawPath(path, paint);
}
@@ -140,7 +138,8 @@
}
void onDrawContent(SkCanvas* canvas) override {
- test_huge_stroke(canvas); return;
+ test_huge_stroke(canvas);
+#if 0
canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
SkPaint paint;
@@ -198,10 +197,11 @@
canvas->translate(0, fPath.getBounds().height() * 5 / 4);
fPath.setFillType(SkPathFillType::kEvenOdd);
drawSet(canvas, &paint);
+#endif
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleStrokeRect.cpp b/third_party/skia/samplecode/SampleStrokeRect.cpp
index 669a357..d4cc4ae 100644
--- a/third_party/skia/samplecode/SampleStrokeRect.cpp
+++ b/third_party/skia/samplecode/SampleStrokeRect.cpp
@@ -13,9 +13,9 @@
StrokeRectSample() {}
protected:
- virtual SkString name() { return SkString("Stroke Rects"); }
+ SkString name() override { return SkString("Stroke Rects"); }
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
@@ -56,7 +56,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleStrokeVerb.cpp b/third_party/skia/samplecode/SampleStrokeVerb.cpp
new file mode 100644
index 0000000..bb90ee3
--- /dev/null
+++ b/third_party/skia/samplecode/SampleStrokeVerb.cpp
@@ -0,0 +1,223 @@
+/*
+ * 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/SkTypes.h"
+
+#if SK_SUPPORT_GPU
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPath.h"
+#include "samplecode/Sample.h"
+#include "src/core/SkGeometry.h"
+
+enum class VerbType {
+ kTriangles,
+ kQuadratics,
+ kCubics,
+ kConics
+};
+
+static const char* verb_type_name(VerbType verbType) {
+ switch (verbType) {
+ case VerbType::kTriangles: return "kTriangles";
+ case VerbType::kQuadratics: return "kQuadratics";
+ case VerbType::kCubics: return "kCubics";
+ case VerbType::kConics: return "kConics";
+ }
+ SkUNREACHABLE;
+};
+
+/**
+ * This sample visualizes simple strokes.
+ */
+class StrokeVerbView : public Sample {
+ void onOnceBeforeDraw() override { this->updatePath(); }
+ void onDrawContent(SkCanvas*) override;
+
+ Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override;
+ bool onClick(Sample::Click*) override;
+ bool onChar(SkUnichar) override;
+ SkString name() override { return SkString("StrokeVerb"); }
+
+ class Click;
+
+ void updateAndInval() { this->updatePath(); }
+
+ void updatePath();
+
+ VerbType fVerbType = VerbType::kCubics;
+
+ SkPoint fPoints[4] = {
+ {100.05f, 100.05f}, {400.75f, 100.05f}, {400.75f, 300.95f}, {100.05f, 300.95f}};
+
+ float fConicWeight = .5;
+ float fStrokeWidth = 40;
+ SkPaint::Join fStrokeJoin = SkPaint::kMiter_Join;
+ SkPaint::Cap fStrokeCap = SkPaint::kButt_Cap;
+
+ SkPath fPath;
+};
+
+void StrokeVerbView::onDrawContent(SkCanvas* canvas) {
+ canvas->clear(SK_ColorBLACK);
+
+ SkPaint outlinePaint;
+ outlinePaint.setColor(0xff808080);
+ outlinePaint.setStyle(SkPaint::kStroke_Style);
+ outlinePaint.setStrokeWidth(fStrokeWidth);
+ outlinePaint.setStrokeJoin(fStrokeJoin);
+ outlinePaint.setStrokeCap(fStrokeCap);
+ outlinePaint.setAntiAlias(true);
+ canvas->drawPath(fPath, outlinePaint);
+
+ SkString caption;
+ caption.appendf("VerbType_%s", verb_type_name(fVerbType));
+ if (VerbType::kCubics == fVerbType) {
+ caption.appendf(" (%s)", SkCubicTypeName(SkClassifyCubic(fPoints)));
+ } else if (VerbType::kConics == fVerbType) {
+ caption.appendf(" (w=%f)", fConicWeight);
+ }
+
+ caption.appendf(" (stroke_width=%f)", fStrokeWidth);
+
+ SkPaint pointsPaint;
+ pointsPaint.setColor(SK_ColorBLUE);
+ pointsPaint.setStrokeWidth(8);
+ pointsPaint.setAntiAlias(true);
+
+ if (VerbType::kCubics == fVerbType) {
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, fPoints, pointsPaint);
+ } else {
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, fPoints, pointsPaint);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, 1, fPoints + 3, pointsPaint);
+ }
+
+ SkFont font(nullptr, 20);
+ SkPaint captionPaint;
+ captionPaint.setColor(SK_ColorWHITE);
+ canvas->drawString(caption, 10, 30, font, captionPaint);
+}
+
+void StrokeVerbView::updatePath() {
+ fPath.reset();
+ fPath.moveTo(fPoints[0]);
+ switch (fVerbType) {
+ case VerbType::kCubics:
+ fPath.cubicTo(fPoints[1], fPoints[2], fPoints[3]);
+ break;
+ case VerbType::kQuadratics:
+ fPath.quadTo(fPoints[1], fPoints[3]);
+ break;
+ case VerbType::kConics:
+ fPath.conicTo(fPoints[1], fPoints[3], fConicWeight);
+ break;
+ case VerbType::kTriangles:
+ fPath.lineTo(fPoints[1]);
+ fPath.lineTo(fPoints[3]);
+ fPath.close();
+ break;
+ }
+}
+
+class StrokeVerbView::Click : public Sample::Click {
+public:
+ Click(int ptIdx) : fPtIdx(ptIdx) {}
+
+ void doClick(SkPoint points[]) {
+ if (fPtIdx >= 0) {
+ points[fPtIdx] += fCurr - fPrev;
+ } else {
+ for (int i = 0; i < 4; ++i) {
+ points[i] += fCurr - fPrev;
+ }
+ }
+ }
+
+private:
+ int fPtIdx;
+};
+
+Sample::Click* StrokeVerbView::onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) {
+ for (int i = 0; i < 4; ++i) {
+ if (VerbType::kCubics != fVerbType && 2 == i) {
+ continue;
+ }
+ if (fabs(x - fPoints[i].x()) < 20 && fabsf(y - fPoints[i].y()) < 20) {
+ return new Click(i);
+ }
+ }
+ return new Click(-1);
+}
+
+bool StrokeVerbView::onClick(Sample::Click* click) {
+ Click* myClick = (Click*)click;
+ myClick->doClick(fPoints);
+ this->updateAndInval();
+ return true;
+}
+
+bool StrokeVerbView::onChar(SkUnichar unichar) {
+ if (unichar >= '1' && unichar <= '4') {
+ fVerbType = VerbType(unichar - '1');
+ this->updateAndInval();
+ return true;
+ }
+ float* valueToScale = nullptr;
+ if (VerbType::kConics == fVerbType) {
+ valueToScale = &fConicWeight;
+ } else {
+ valueToScale = &fStrokeWidth;
+ }
+ if (valueToScale) {
+ if (unichar == '+') {
+ *valueToScale *= 2;
+ this->updateAndInval();
+ return true;
+ }
+ if (unichar == '+' || unichar == '=') {
+ *valueToScale *= 5/4.f;
+ this->updateAndInval();
+ return true;
+ }
+ if (unichar == '-') {
+ *valueToScale *= 4/5.f;
+ this->updateAndInval();
+ return true;
+ }
+ if (unichar == '_') {
+ *valueToScale *= .5f;
+ this->updateAndInval();
+ return true;
+ }
+ }
+ if (unichar == 'D') {
+ SkDebugf(" SkPoint fPoints[4] = {\n");
+ SkDebugf(" {%ff, %ff},\n", fPoints[0].x(), fPoints[0].y());
+ SkDebugf(" {%ff, %ff},\n", fPoints[1].x(), fPoints[1].y());
+ SkDebugf(" {%ff, %ff},\n", fPoints[2].x(), fPoints[2].y());
+ SkDebugf(" {%ff, %ff}\n", fPoints[3].x(), fPoints[3].y());
+ SkDebugf(" };\n");
+ return true;
+ }
+ if (unichar == 'J') {
+ fStrokeJoin = (SkPaint::Join)((fStrokeJoin + 1) % 3);
+ this->updateAndInval();
+ return true;
+ }
+ if (unichar == 'C') {
+ fStrokeCap = (SkPaint::Cap)((fStrokeCap + 1) % 3);
+ this->updateAndInval();
+ return true;
+ }
+ return false;
+}
+
+DEF_SAMPLE(return new StrokeVerbView;)
+
+#endif // SK_SUPPORT_GPU
diff --git a/third_party/skia/samplecode/SampleSubpixelTranslate.cpp b/third_party/skia/samplecode/SampleSubpixelTranslate.cpp
deleted file mode 100644
index b658bc3..0000000
--- a/third_party/skia/samplecode/SampleSubpixelTranslate.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright 2014 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "samplecode/Sample.h"
-
-#include "include/core/SkCanvas.h"
-#include "include/core/SkColorPriv.h"
-#include "include/core/SkFont.h"
-#include "include/core/SkStream.h"
-#include "include/effects/SkBlurMaskFilter.h"
-#include "include/utils/SkRandom.h"
-#include "samplecode/DecodeFile.h"
-#include "tools/Resources.h"
-
-// Intended to exercise pixel snapping observed with scaled images (and
-// with non-scaled images, but for a different reason): Bug 1145
-
-class SubpixelTranslateView : public Sample {
-public:
- SubpixelTranslateView(const char imageFilename[],
- float horizontalVelocity,
- float verticalVelocity)
- : fHorizontalVelocity(horizontalVelocity)
- , fVerticalVelocity(verticalVelocity)
- {
- if (!DecodeDataToBitmap(GetResourceAsData(imageFilename), &fBM)) {
- fBM.allocN32Pixels(1, 1);
- *(fBM.getAddr32(0,0)) = 0xFF0000FF; // red == bad
- }
- fCurPos = SkPoint::Make(0,0);
- fSize = 200;
- }
-
-protected:
- SkBitmap fBM;
- SkScalar fSize;
- float fHorizontalVelocity, fVerticalVelocity;
-
- SkPoint fCurPos;
-
- SkString name() override { return SkString("SubpixelTranslate"); }
-
- void onDrawContent(SkCanvas* canvas) override {
-
- static const SkFilterQuality gQualitys[] = {
- kNone_SkFilterQuality,
- kLow_SkFilterQuality,
- kMedium_SkFilterQuality,
- kHigh_SkFilterQuality
- };
-
- SkPaint paint;
- SkFont font(nullptr, 48);
- font.setSubpixel(true);
-
- paint.setAntiAlias(true);
- for (size_t i = 0; i < SK_ARRAY_COUNT(gQualitys); ++i) {
- paint.setFilterQuality(gQualitys[i]);
- SkRect r = SkRect::MakeXYWH( fCurPos.fX + i * (fSize + 10), fCurPos.fY, fSize, fSize );
- canvas->drawBitmapRect( fBM, r, &paint );
- }
-
- canvas->drawString("AA Scaled", fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fSize + 10),
- fCurPos.fY + fSize/2, font, paint);
-
- paint.setAntiAlias(false);
- font.setEdging(SkFont::Edging::kAlias);
- for (size_t i = 0; i < SK_ARRAY_COUNT(gQualitys); ++i) {
- paint.setFilterQuality(gQualitys[i]);
- SkRect r = SkRect::MakeXYWH( fCurPos.fX + i * (fSize + 10), fCurPos.fY + fSize + 10, fSize, fSize );
- canvas->drawBitmapRect( fBM, r, &paint );
- }
- canvas->drawString("Scaled", fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fSize + 10),
- fCurPos.fY + fSize + 10 + fSize/2, font, paint);
-
- paint.setAntiAlias(true);
- font.setEdging(SkFont::Edging::kAntiAlias);
- for (size_t i = 0; i < SK_ARRAY_COUNT(gQualitys); ++i) {
- paint.setFilterQuality(gQualitys[i]);
- canvas->drawBitmap( fBM, fCurPos.fX + i * (fBM.width() + 10), fCurPos.fY + 2*(fSize + 10), &paint );
- }
-
- canvas->drawString("AA No Scale",
- fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fBM.width() + 10),
- fCurPos.fY + 2*(fSize + 10) + fSize/2, font, paint);
-
- paint.setAntiAlias(false);
- font.setEdging(SkFont::Edging::kAlias);
- for (size_t i = 0; i < SK_ARRAY_COUNT(gQualitys); ++i) {
- paint.setFilterQuality(gQualitys[i]);
- canvas->drawBitmap( fBM, fCurPos.fX + i * (fBM.width() + 10), fCurPos.fY + 2*(fSize + 10) + fBM.height() + 10, &paint );
- }
-
- canvas->drawString("No Scale", fCurPos.fX + SK_ARRAY_COUNT(gQualitys) * (fBM.width() + 10),
- fCurPos.fY + 2*(fSize + 10) + fBM.height() + 10 + fSize/2, font, paint);
-
-
- fCurPos.fX += fHorizontalVelocity;
- fCurPos.fY += fVerticalVelocity;
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new SubpixelTranslateView("images/mandrill_256.png", .05f, .05f); )
diff --git a/third_party/skia/samplecode/SampleTextBox.cpp b/third_party/skia/samplecode/SampleTextBox.cpp
index 7aa1598..d929cad 100644
--- a/third_party/skia/samplecode/SampleTextBox.cpp
+++ b/third_party/skia/samplecode/SampleTextBox.cpp
@@ -17,7 +17,6 @@
#include "include/core/SkTextBlob.h"
#include "include/core/SkTime.h"
#include "include/core/SkTypeface.h"
-#include "include/effects/SkBlurMaskFilter.h"
#include "include/effects/SkGradientShader.h"
#include "include/utils/SkRandom.h"
#include "modules/skshaper/include/SkShaper.h"
@@ -25,6 +24,8 @@
#include "src/shaders/SkColorShader.h"
#include "src/utils/SkUTF.h"
+typedef std::unique_ptr<SkShaper> (*ShaperFactory)();
+
static const char gText[] =
"When in the Course of human events it becomes necessary for one people "
"to dissolve the political bands which have connected them with another "
@@ -34,11 +35,14 @@
"declare the causes which impel them to the separation.";
class TextBoxView : public Sample {
+ SkString fName;
public:
- TextBoxView() : fShaper(SkShaper::Make()) {}
+ TextBoxView(ShaperFactory fact, const char suffix[]) : fShaper(fact()) {
+ fName.printf("TextBox_%s", suffix);
+ }
protected:
- SkString name() override { return SkString("TextBox"); }
+ SkString name() override { return fName; }
void drawTest(SkCanvas* canvas, SkScalar w, SkScalar h, SkColor fg, SkColor bg) {
SkAutoCanvasRestore acr(canvas, true);
@@ -52,9 +56,11 @@
paint.setColor(fg);
for (int i = 9; i < 24; i += 2) {
+ SkShaper::PurgeCaches();
SkTextBlobBuilderRunHandler builder(gText, { margin, margin });
SkFont srcFont(nullptr, SkIntToScalar(i));
srcFont.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+ srcFont.setSubpixel(true);
const char* utf8 = gText;
size_t utf8Bytes = sizeof(gText) - 1;
@@ -105,9 +111,80 @@
private:
std::unique_ptr<SkShaper> fShaper;
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
-//////////////////////////////////////////////////////////////////////////////
+DEF_SAMPLE( return new TextBoxView([](){ return SkShaper::Make(); }, "default"); );
+#ifdef SK_SHAPER_CORETEXT_AVAILABLE
+DEF_SAMPLE( return new TextBoxView(SkShaper::MakeCoreText, "coretext"); );
+#endif
-DEF_SAMPLE( return new TextBoxView(); )
+class SampleShaper : public Sample {
+public:
+ SampleShaper() {}
+
+protected:
+ SkString name() override { return SkString("shaper"); }
+
+ void drawTest(SkCanvas* canvas, const char str[], SkScalar size,
+ std::unique_ptr<SkShaper> shaper) {
+ if (!shaper) return;
+
+ SkTextBlobBuilderRunHandler builder(str, {0, 0});
+ SkFont srcFont;
+ srcFont.setSize(size);
+ srcFont.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+ srcFont.setSubpixel(true);
+
+ size_t len = strlen(str);
+
+ std::unique_ptr<SkShaper::BiDiRunIterator> bidi(
+ SkShaper::MakeBiDiRunIterator(str, len, 0xfe));
+ if (!bidi) {
+ return;
+ }
+
+ std::unique_ptr<SkShaper::LanguageRunIterator> language(
+ SkShaper::MakeStdLanguageRunIterator(str, len));
+ if (!language) {
+ return;
+ }
+
+ SkFourByteTag undeterminedScript = SkSetFourByteTag('Z','y','y','y');
+ std::unique_ptr<SkShaper::ScriptRunIterator> script(
+ SkShaper::MakeScriptRunIterator(str, len, undeterminedScript));
+ if (!script) {
+ return;
+ }
+
+ std::unique_ptr<SkShaper::FontRunIterator> font(
+ SkShaper::MakeFontMgrRunIterator(str, len, srcFont, SkFontMgr::RefDefault(),
+ "Arial", SkFontStyle::Bold(), &*language));
+ if (!font) {
+ return;
+ }
+
+ shaper->shape(str, len, *font, *bidi, *script, *language, 2000, &builder);
+
+ canvas->drawTextBlob(builder.makeBlob(), 0, 0, SkPaint());
+ }
+
+ void onDrawContent(SkCanvas* canvas) override {
+ canvas->translate(10, 30);
+
+ const char text[] = "world";
+
+ for (SkScalar size = 30; size <= 30; size += 10) {
+ this->drawTest(canvas, text, size, SkShaper::Make());
+ canvas->translate(0, size + 5);
+ #ifdef SK_SHAPER_CORETEXT_AVAILABLE
+ this->drawTest(canvas, text, size, SkShaper::MakeCoreText());
+ #endif
+ canvas->translate(0, size*2);
+ }
+ }
+
+private:
+ using INHERITED = Sample;
+};
+DEF_SAMPLE( return new SampleShaper; );
diff --git a/third_party/skia/samplecode/SampleTextEffects.cpp b/third_party/skia/samplecode/SampleTextEffects.cpp
deleted file mode 100644
index 8e57750..0000000
--- a/third_party/skia/samplecode/SampleTextEffects.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright 2011 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/SkColorPriv.h"
-#include "include/core/SkPath.h"
-#include "include/core/SkRegion.h"
-#include "include/core/SkShader.h"
-#include "include/core/SkStrokeRec.h"
-#include "include/core/SkTypeface.h"
-#include "include/effects/SkGradientShader.h"
-#include "include/utils/SkTextUtils.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkReadBuffer.h"
-#include "src/core/SkWriteBuffer.h"
-#include "src/utils/SkUTF.h"
-
-#include "include/effects/SkBlurMaskFilter.h"
-#include "include/effects/SkGradientShader.h"
-
-#include "include/effects/Sk2DPathEffect.h"
-
-class Dot2DPathEffect : public Sk2DPathEffect {
-public:
- Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix,
- SkTDArray<SkPoint>* pts)
- : Sk2DPathEffect(matrix), fRadius(radius), fPts(pts) {}
-
- SK_FLATTENABLE_HOOKS(Dot2DPathEffect)
-protected:
- void begin(const SkIRect& uvBounds, SkPath* dst) const override {
- if (fPts) {
- fPts->reset();
- }
- this->INHERITED::begin(uvBounds, dst);
- }
-
- virtual void next(const SkPoint& loc, int u, int v,
- SkPath* dst) const override {
- if (fPts) {
- *fPts->append() = loc;
- }
- dst->addCircle(loc.fX, loc.fY, fRadius);
- }
-
- void flatten(SkWriteBuffer& buffer) const override {
- buffer.writeMatrix(this->getMatrix());
- buffer.writeScalar(fRadius);
- }
-
-private:
-
- SkScalar fRadius;
- SkTDArray<SkPoint>* fPts;
-
- typedef Sk2DPathEffect INHERITED;
-};
-
-// Register this path effect as deserializable before main().
-namespace {
- static struct Initializer {
- Initializer() {
- SK_REGISTER_FLATTENABLE(Dot2DPathEffect);
- }
- } initializer;
-}
-
-
-sk_sp<SkFlattenable> Dot2DPathEffect::CreateProc(SkReadBuffer& buffer) {
- SkMatrix matrix;
- buffer.readMatrix(&matrix);
- return sk_make_sp<Dot2DPathEffect>(buffer.readScalar(), matrix, nullptr);
-}
-
-class InverseFillPE : public SkPathEffect {
-public:
- InverseFillPE() {}
- virtual bool onFilterPath(SkPath* dst, const SkPath& src,
- SkStrokeRec*, const SkRect*) const override {
- *dst = src;
- dst->setFillType(SkPathFillType::kInverseWinding);
- return true;
- }
-
-private:
- SK_FLATTENABLE_HOOKS(InverseFillPE)
-
- typedef SkPathEffect INHERITED;
-};
-
-sk_sp<SkFlattenable> InverseFillPE::CreateProc(SkReadBuffer& buffer) {
- return sk_make_sp<InverseFillPE>();
-}
-
-static sk_sp<SkPathEffect> makepe(float interp, SkTDArray<SkPoint>* pts) {
- SkMatrix lattice;
- SkScalar rad = 3 + SkIntToScalar(4) * (1 - interp);
- lattice.setScale(rad*2, rad*2, 0, 0);
- lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
- return sk_make_sp<Dot2DPathEffect>(rad, lattice, pts);
-}
-
-class TextEffectsView : public Sample {
- sk_sp<SkTypeface> fFace;
- SkScalar fInterp;
- SkScalar fDx;
-
-public:
- TextEffectsView() {
- fFace = SkTypeface::MakeFromFile("/Users/reed/Downloads/p052024l.pfb");
- fInterp = 0;
- fDx = SK_Scalar1/64;
- }
-
-protected:
- SkString name() override { return SkString("Text Effects"); }
-
- void drawBG(SkCanvas* canvas) {
- canvas->drawColor(SK_ColorWHITE);
- }
-
- void drawdots(SkCanvas* canvas, SkString s, SkScalar x, SkScalar y, const SkFont& font) {
- SkTDArray<SkPoint> pts;
- auto pe = makepe(fInterp, &pts);
-
- SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
- SkPath path, dstPath;
- SkTextUtils::GetPath(s.c_str(), s.size(), SkTextEncoding::kUTF8, x, y, font, &path);
- pe->filterPath(&dstPath, path, &rec, nullptr);
-
- SkPaint paint;
- paint.setAntiAlias(true);
- paint.setStrokeWidth(10);
- paint.setColor(SK_ColorRED);
- canvas->drawPoints(SkCanvas::kPoints_PointMode, pts.count(), pts.begin(), paint);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- this->drawBG(canvas);
-
- SkScalar x = SkIntToScalar(20);
- SkScalar y = SkIntToScalar(300);
-
- SkFont font(SkTypeface::MakeFromName("sans-serif", SkFontStyle::Bold()), 240);
-
- SkString str("9");
-
- canvas->drawString(str, x, y, font, SkPaint());
- drawdots(canvas, str, x, y, font);
-
- if (false) {
- fInterp += fDx;
- if (fInterp > 1) {
- fInterp = 1;
- fDx = -fDx;
- } else if (fInterp < 0) {
- fInterp = 0;
- fDx = -fDx;
- }
- }
- }
-
-private:
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new TextEffectsView(); )
diff --git a/third_party/skia/samplecode/SampleTextureDomain.cpp b/third_party/skia/samplecode/SampleTextureDomain.cpp
deleted file mode 100644
index 3bac799..0000000
--- a/third_party/skia/samplecode/SampleTextureDomain.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright 2011 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/SkSurface.h"
-#include "include/effects/SkBlurMaskFilter.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkBlurMask.h"
-
-static SkBitmap make_bitmap() {
- SkBitmap bm;
- bm.allocN32Pixels(5, 5);
-
- for (int y = 0; y < bm.height(); y++) {
- uint32_t* p = bm.getAddr32(0, y);
- for (int x = 0; x < bm.width(); x++) {
- p[x] = ((x + y) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
- }
- }
- return bm;
-}
-
-class TextureDomainView : public Sample {
- SkBitmap fBM;
-
-public:
- TextureDomainView(){
- fBM = make_bitmap();
- }
-
-protected:
- virtual SkString name() { return SkString("Texture Domain"); }
-
- virtual void onDrawContent(SkCanvas* canvas) {
- SkRect srcRect;
- SkRect dstRect;
- SkPaint paint;
- paint.setFilterQuality(kLow_SkFilterQuality);
-
- // Test that bitmap draws from malloc-backed bitmaps respect
- // the constrained texture domain.
- srcRect.setXYWH(1, 1, 3, 3);
- dstRect.setXYWH(5, 5, 305, 305);
- canvas->drawBitmapRect(fBM, srcRect, dstRect, &paint, SkCanvas::kStrict_SrcRectConstraint);
-
- // Test that bitmap draws across separate devices also respect
- // the constrainted texture domain.
- // Note: GPU-backed bitmaps follow a different rendering path
- // when copying from one GPU device to another.
- SkImageInfo info = SkImageInfo::MakeN32(5, 5, kOpaque_SkAlphaType);
- auto surface(canvas->makeSurface(info));
-
- srcRect.setXYWH(1, 1, 3, 3);
- dstRect.setXYWH(1, 1, 3, 3);
- surface->getCanvas()->drawBitmapRect(fBM, srcRect, dstRect, &paint,
- SkCanvas::kStrict_SrcRectConstraint);
-
- sk_sp<SkImage> image(surface->makeImageSnapshot());
-
- srcRect.setXYWH(1, 1, 3, 3);
- dstRect.setXYWH(405, 5, 305, 305);
- canvas->drawImageRect(image, srcRect, dstRect, &paint);
-
- // Test that bitmap blurring using a subrect
- // renders correctly
- srcRect.setXYWH(1, 1, 3, 3);
- dstRect.setXYWH(5, 405, 305, 305);
- paint.setMaskFilter(SkMaskFilter::MakeBlur(
- kNormal_SkBlurStyle, SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)), false));
- canvas->drawImageRect(image, srcRect, dstRect, &paint);
-
- // Blur and a rotation + nullptr src rect
- // This should not trigger the texture domain code
- // but it will test a code path in SkGpuDevice::drawBitmap
- // that handles blurs with rects transformed to non-
- // orthogonal rects. It also tests the nullptr src rect handling
- paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
- SkBlurMask::ConvertRadiusToSigma(5)));
-
- dstRect.setXYWH(-150, -150, 300, 300);
- canvas->translate(550, 550);
- canvas->rotate(45);
- canvas->drawBitmapRect(fBM, dstRect, &paint);
- }
-private:
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new TextureDomainView(); )
diff --git a/third_party/skia/samplecode/SampleTextureUpload.cpp b/third_party/skia/samplecode/SampleTextureUpload.cpp
index a33d1d9..933748c 100644
--- a/third_party/skia/samplecode/SampleTextureUpload.cpp
+++ b/third_party/skia/samplecode/SampleTextureUpload.cpp
@@ -9,7 +9,7 @@
#include "include/core/SkPaint.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
-#include "include/gpu/GrContext.h"
+#include "include/gpu/GrDirectContext.h"
#include "samplecode/Sample.h"
#include "tools/timer/TimeUtils.h"
@@ -17,9 +17,9 @@
* This sample exercises heavy texture updates and uploads.
*/
class TextureUploadSample : public Sample {
- static constexpr int kMinTileSize = 128;
- static constexpr int kMaxTileSize = 2048;
- static constexpr float kGridScale = 0.25f;
+ inline static constexpr int kMinTileSize = 128;
+ inline static constexpr int kMaxTileSize = 2048;
+ inline static constexpr float kGridScale = 0.25f;
bool fDrawTexturesToScreen = true;
int fTileSize = 256;
@@ -31,11 +31,11 @@
class RenderTargetTexture : public SkRefCnt {
public:
- RenderTargetTexture(GrContext* context, int size) {
- SkSurfaceProps surfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
+ RenderTargetTexture(GrDirectContext* direct, int size) {
+ SkSurfaceProps surfaceProps(0, kRGB_H_SkPixelGeometry);
SkImageInfo imageInfo = SkImageInfo::Make(size, size, kRGBA_8888_SkColorType,
kPremul_SkAlphaType);
- fSurface = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, imageInfo, 0,
+ fSurface = SkSurface::MakeRenderTarget(direct, SkBudgeted::kNo, imageInfo, 0,
&surfaceProps);
}
@@ -55,7 +55,7 @@
};
SkTArray<sk_sp<RenderTargetTexture>> fTextures;
- GrContext* fCachedContext = nullptr;
+ GrDirectContext* fCachedContext = nullptr;
SkScalar fActiveTileIndex = 0;
SkString name() override {
@@ -67,12 +67,12 @@
fDrawTexturesToScreen = !fDrawTexturesToScreen;
return true;
} else if ('>' == uni) {
- fTileSize = SkTMin(kMaxTileSize, 2*fTileSize);
+ fTileSize = std::min(kMaxTileSize, 2*fTileSize);
fTileRows = kMaxTileSize/fTileSize;
fTileCols = kMaxTileSize/fTileSize;
fCachedContext = nullptr;
} else if ('<' == uni) {
- fTileSize = SkTMax(kMinTileSize, fTileSize/2);
+ fTileSize = std::max(kMinTileSize, fTileSize/2);
fTileRows = kMaxTileSize/fTileSize;
fTileCols = kMaxTileSize/fTileSize;
fCachedContext = nullptr;
@@ -92,11 +92,11 @@
this->setSize(1024, 1024);
}
- void initializeTextures(GrContext* context) {
+ void initializeTextures(GrDirectContext* direct) {
fTextures.reset();
int textureCount = fTileRows * fTileCols;
for (int i = 0; i < textureCount; i++) {
- fTextures.emplace_back(new RenderTargetTexture(context, fTileSize));
+ fTextures.emplace_back(new RenderTargetTexture(direct, fTileSize));
}
// Construct two simple rasters of differing colors to serve
@@ -107,14 +107,12 @@
void onDrawContent(SkCanvas* canvas) override {
#if SK_SUPPORT_GPU
- SkPaint paint;
-
- GrContext* context = canvas->getGrContext();
- if (context) {
+ auto direct = GrAsDirectContext(canvas->recordingContext());
+ if (direct) {
// One-time context-specific setup.
- if (context != fCachedContext) {
- fCachedContext = context;
- this->initializeTextures(context);
+ if (direct != fCachedContext) {
+ fCachedContext = direct;
+ this->initializeTextures(direct);
}
// Upload new texture data for all textures, simulating a full page of tiles
@@ -133,7 +131,7 @@
for (int x = 0; x < fTileCols; x++) {
int currentIndex = y * fTileCols + x;
canvas->drawImage(fTextures[currentIndex]->getImage(),
- x * fTileSize, y * fTileSize, &paint);
+ x * fTileSize, y * fTileSize);
}
}
}
@@ -150,8 +148,6 @@
}
};
-const int TextureUploadSample::kMinTileSize;
-const int TextureUploadSample::kMaxTileSize;
DEF_SAMPLE( return new TextureUploadSample(); )
diff --git a/third_party/skia/samplecode/SampleThinAA.cpp b/third_party/skia/samplecode/SampleThinAA.cpp
index 92aa202..5989deb 100644
--- a/third_party/skia/samplecode/SampleThinAA.cpp
+++ b/third_party/skia/samplecode/SampleThinAA.cpp
@@ -18,10 +18,8 @@
class ShapeRenderer : public SkRefCntBase {
public:
- static constexpr SkScalar kTileWidth = 20.f;
- static constexpr SkScalar kTileHeight = 20.f;
-
- virtual ~ShapeRenderer() {}
+ inline static constexpr SkScalar kTileWidth = 20.f;
+ inline static constexpr SkScalar kTileHeight = 20.f;
// Draw the shape, limited to kTileWidth x kTileHeight. It must apply the local subpixel (tx,
// ty) translation and rotation by angle. Prior to these transform adjustments, the SkCanvas
@@ -66,7 +64,7 @@
private:
RectRenderer() {}
- typedef ShapeRenderer INHERITED;
+ using INHERITED = ShapeRenderer;
};
class PathRenderer : public ShapeRenderer {
@@ -133,7 +131,7 @@
// Adding round caps forces Ganesh to use the path renderer for lines instead of converting
// them to rectangles (which are already explicitly tested). However, when not curved, the
- // GrShape will still find a way to turn it into a rrect draw so it doesn't hit the
+ // GrStyledShape will still find a way to turn it into a rrect draw so it doesn't hit the
// path renderer in that condition.
paint->setStrokeCap(SkPaint::kRound_Cap);
paint->setStrokeJoin(SkPaint::kMiter_Join);
@@ -151,7 +149,7 @@
: fDepth(depth)
, fHairline(hairline) {}
- typedef ShapeRenderer INHERITED;
+ using INHERITED = ShapeRenderer;
};
class OffscreenShapeRenderer : public ShapeRenderer {
@@ -210,7 +208,6 @@
// Use medium quality filter to get mipmaps when drawing smaller, or use nearest filtering
// when upscaling
SkPaint blit;
- blit.setFilterQuality(scale > 1.f ? kNone_SkFilterQuality : kMedium_SkFilterQuality);
if (debugMode) {
// Makes anything that's > 1/255 alpha fully opaque and sets color to medium green.
static constexpr float kFilter[] = {
@@ -223,8 +220,15 @@
blit.setColorFilter(SkColorFilters::Matrix(kFilter));
}
+ auto sampling = scale > 1 ? SkSamplingOptions(SkFilterMode::kNearest)
+ : SkSamplingOptions(SkFilterMode::kLinear,
+ SkMipmapMode::kLinear);
+
canvas->scale(scale, scale);
- canvas->drawImageRect(fLastRendered, SkRect::MakeWH(kTileWidth, kTileHeight), &blit);
+ canvas->drawImageRect(fLastRendered.get(),
+ SkRect::MakeWH(kTileWidth, kTileHeight),
+ SkRect::MakeWH(kTileWidth, kTileHeight),
+ sampling, &blit, SkCanvas::kFast_SrcRectConstraint);
}
private:
@@ -239,7 +243,7 @@
, fRenderer(std::move(renderer))
, fSupersampleFactor(supersample) { }
- typedef ShapeRenderer INHERITED;
+ using INHERITED = ShapeRenderer;
};
class ThinAASample : public Sample {
@@ -403,8 +407,8 @@
case 'u': fAngle = 0.f; return true;
case 'y': fAngle = 90.f; return true;
case ' ': fAngle = SkScalarMod(fAngle + 15.f, 360.f); return true;
- case '-': fStrokeWidth = SkMaxScalar(0.1f, fStrokeWidth - 0.05f); return true;
- case '=': fStrokeWidth = SkMinScalar(1.f, fStrokeWidth + 0.05f); return true;
+ case '-': fStrokeWidth = std::max(0.1f, fStrokeWidth - 0.05f); return true;
+ case '=': fStrokeWidth = std::min(1.f, fStrokeWidth + 0.05f); return true;
}
return false;
}
@@ -480,8 +484,7 @@
SkFont font(nullptr, 12);
if (gridX == 0) {
- SkString name = shape->name();
- SkScalar centering = name.size() * 4.f; // ad-hoc
+ SkScalar centering = shape->name().size() * 4.f; // ad-hoc
canvas->save();
canvas->translate(-10.f, 4 * ShapeRenderer::kTileHeight + centering);
@@ -537,11 +540,11 @@
canvas->translate(0.f, 8.f * ShapeRenderer::kTileHeight + 20.f);
}
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
DEF_SAMPLE( return new ThinAASample; )
-}
+} // namespace skiagm
diff --git a/third_party/skia/samplecode/SampleTiming.cpp b/third_party/skia/samplecode/SampleTiming.cpp
new file mode 100644
index 0000000..d8e3216
--- /dev/null
+++ b/third_party/skia/samplecode/SampleTiming.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2020 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/SkFont.h"
+#include "include/core/SkSurface.h"
+#include "samplecode/Sample.h"
+#include <chrono>
+
+struct TimingSample : public Sample {
+ inline static constexpr int W = 24,
+ H = 16;
+ sk_sp<SkImage> fImg;
+
+ SkString name() override { return SkString("Timing"); }
+
+ void onOnceBeforeDraw() override {
+ sk_sp<SkSurface> surf = SkSurface::MakeRasterN32Premul(W,H);
+ surf->getCanvas()->drawString("abc", 2,H-4, SkFont{}, SkPaint{});
+ fImg = surf->makeImageSnapshot();
+ }
+
+ void onDrawContent(SkCanvas* canvas) override {
+ canvas->scale(8,8);
+
+ // Draw normally.
+ canvas->drawImage(fImg, 0,0);
+
+ canvas->translate(0,H);
+
+ // Draw one pixel at a time with drawImageRect(),
+ // timing how long each drawImageRect() call takes.
+ double cost[H][W];
+ double min = +INFINITY,
+ max = -INFINITY;
+ for (int y = 0; y < H; y++)
+ for (int x = 0; x < W; x++) {
+ auto start = std::chrono::steady_clock::now();
+ canvas->drawImageRect(fImg.get(),
+ SkRect::MakeXYWH(x,y,1,1), SkRect::MakeXYWH(x,y,1,1),
+ SkSamplingOptions(), /*paint=*/nullptr,
+ SkCanvas::kStrict_SrcRectConstraint);
+ auto elapsed = std::chrono::steady_clock::now() - start;
+
+ cost[y][x] = elapsed.count();
+ min = std::min(min, cost[y][x]);
+ max = std::max(max, cost[y][x]);
+ }
+
+ canvas->translate(0,H);
+
+ // Draw using those per-pixel timings,
+ // with the slowest pixel scaled to alpha=1, the fastest to alpha=0.
+ for (int y = 0; y < H; y++)
+ for (int x = 0; x < W; x++) {
+ SkPaint p;
+ p.setAlphaf( (cost[y][x] - min) / (max - min) );
+ canvas->drawRect(SkRect::MakeXYWH(x,y,1,1), p);
+ }
+
+ canvas->translate(0,H);
+
+ // Draw each pixel into offscreen, timing each draw.
+ SkImageInfo info = canvas->imageInfo().makeWH(1024,1024);
+ if (sk_sp<SkSurface> offscreen = canvas->makeSurface(info)) {
+ min = +INFINITY;
+ max = -INFINITY;
+ for (int y = 0; y < H; y++)
+ for (int x = 0; x < W; x++) {
+ auto start = std::chrono::steady_clock::now();
+ offscreen->getCanvas()->drawImageRect(fImg,
+ SkRect::MakeXYWH(x,y,1,1),
+ SkRect::MakeXYWH(0,0,1024,1024),
+ SkSamplingOptions(),
+ /*paint=*/nullptr,
+ SkCanvas::kStrict_SrcRectConstraint);
+ auto elapsed = std::chrono::steady_clock::now() - start;
+
+ cost[y][x] = elapsed.count();
+ min = std::min(min, cost[y][x]);
+ max = std::max(max, cost[y][x]);
+ }
+ for (int y = 0; y < H; y++)
+ for (int x = 0; x < W; x++) {
+ SkPaint p;
+ p.setAlphaf( (cost[y][x] - min) / (max - min) );
+ canvas->drawRect(SkRect::MakeXYWH(x,y,1,1), p);
+ }
+ }
+ }
+};
+DEF_SAMPLE( return new TimingSample; )
diff --git a/third_party/skia/samplecode/SampleUnpremul.cpp b/third_party/skia/samplecode/SampleUnpremul.cpp
deleted file mode 100644
index 9c606bd..0000000
--- a/third_party/skia/samplecode/SampleUnpremul.cpp
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * Copyright 2013 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/SkColorPriv.h"
-#include "include/core/SkStream.h"
-#include "include/core/SkString.h"
-#include "include/core/SkTypes.h"
-#include "samplecode/DecodeFile.h"
-#include "samplecode/Sample.h"
-#include "src/core/SkBlurMask.h"
-#include "src/core/SkOSFile.h"
-#include "src/utils/SkOSPath.h"
-#include "src/utils/SkUTF.h"
-#include "tools/Resources.h"
-#include "tools/ToolUtils.h"
-
-/**
- * Interprets c as an unpremultiplied color, and returns the
- * premultiplied equivalent.
- */
-static SkPMColor premultiply_unpmcolor(SkPMColor c) {
- U8CPU a = SkGetPackedA32(c);
- U8CPU r = SkGetPackedR32(c);
- U8CPU g = SkGetPackedG32(c);
- U8CPU b = SkGetPackedB32(c);
- return SkPreMultiplyARGB(a, r, g, b);
-}
-
-class UnpremulView : public Sample {
-public:
- UnpremulView(SkString res)
- : fResPath(res)
- , fPremul(true)
- , fDecodeSucceeded(false) {
- this->nextImage();
- }
-
-protected:
- SkString name() override { return SkString("unpremul"); }
-
- bool onChar(SkUnichar uni) override {
- char utf8[SkUTF::kMaxBytesInUTF8Sequence];
- size_t size = SkUTF::ToUTF8(uni, utf8);
- // Only consider events for single char keys
- if (1 == size) {
- switch (utf8[0]) {
- case fNextImageChar:
- this->nextImage();
- return true;
- case fTogglePremulChar:
- this->togglePremul();
- return true;
- default:
- break;
- }
- }
- return false;
- }
-
- void onDrawBackground(SkCanvas* canvas) override {
- ToolUtils::draw_checkerboard(canvas, 0xFFCCCCCC, 0xFFFFFFFF, 12);
- }
-
- void onDrawContent(SkCanvas* canvas) override {
- SkPaint paint;
- paint.setAntiAlias(true);
-
- SkFont font;
- font.setSize(24);
- SkScalar height = font.getMetrics(nullptr);
- if (!fDecodeSucceeded) {
- SkString failure;
- if (fResPath.size() == 0) {
- failure.printf("resource path is required!");
- } else {
- failure.printf("Failed to decode %s", fCurrFile.c_str());
- }
- canvas->drawString(failure, 0, height, font, paint);
- return;
- }
-
- // Name, size of the file, and whether or not it is premultiplied.
- SkString header(SkOSPath::Basename(fCurrFile.c_str()));
- header.appendf(" [%dx%d] %s", fBitmap.width(), fBitmap.height(),
- (fPremul ? "premultiplied" : "unpremultiplied"));
- canvas->drawString(header, 0, height, font, paint);
- canvas->translate(0, height);
-
- // Help messages
- header.printf("Press '%c' to move to the next image.'", fNextImageChar);
- canvas->drawString(header, 0, height, font, paint);
- canvas->translate(0, height);
-
- header.printf("Press '%c' to toggle premultiplied decode.", fTogglePremulChar);
- canvas->drawString(header, 0, height, font, paint);
-
- // Now draw the image itself.
- canvas->translate(height * 2, height * 2);
- if (!fPremul) {
- // A premultiplied bitmap cannot currently be drawn.
- // Copy it to a bitmap which can be drawn, converting
- // to premultiplied:
- SkBitmap bm;
- bm.allocN32Pixels(fBitmap.width(), fBitmap.height());
- for (int i = 0; i < fBitmap.width(); ++i) {
- for (int j = 0; j < fBitmap.height(); ++j) {
- *bm.getAddr32(i, j) = premultiply_unpmcolor(*fBitmap.getAddr32(i, j));
- }
- }
- canvas->drawBitmap(bm, 0, 0);
- } else {
- canvas->drawBitmap(fBitmap, 0, 0);
- }
- }
-
-private:
- const SkString fResPath;
- SkString fCurrFile;
- bool fPremul;
- bool fDecodeSucceeded;
- SkBitmap fBitmap;
- SkOSFile::Iter fFileIter;
-
- static const char fNextImageChar = 'j';
- static const char fTogglePremulChar = 'h';
-
- void nextImage() {
- if (fResPath.size() == 0) {
- return;
- }
- SkString basename;
- if (!fFileIter.next(&basename)) {
- fFileIter.reset(fResPath.c_str());
- if (!fFileIter.next(&basename)) {
- // Perhaps this should draw some error message?
- return;
- }
- }
- fCurrFile = SkOSPath::Join(fResPath.c_str(), basename.c_str());
- this->decodeCurrFile();
- }
-
- void decodeCurrFile() {
- if (fCurrFile.size() == 0) {
- fDecodeSucceeded = false;
- return;
- }
- fDecodeSucceeded = decode_file(fCurrFile.c_str(), &fBitmap, kN32_SkColorType, !fPremul);
- }
-
- void togglePremul() {
- fPremul = !fPremul;
- this->decodeCurrFile();
- }
-
- typedef Sample INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-DEF_SAMPLE( return new UnpremulView(GetResourcePath("images")); )
diff --git a/third_party/skia/samplecode/SampleVariableWidthStroker.cpp b/third_party/skia/samplecode/SampleVariableWidthStroker.cpp
new file mode 100644
index 0000000..65efa11
--- /dev/null
+++ b/third_party/skia/samplecode/SampleVariableWidthStroker.cpp
@@ -0,0 +1,1391 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "imgui.h"
+#include "include/core/SkBitmap.h"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkPathMeasure.h"
+#include "include/utils/SkParsePath.h"
+#include "samplecode/Sample.h"
+
+#include "src/core/SkGeometry.h"
+
+#include <stack>
+
+namespace {
+
+//////////////////////////////////////////////////////////////////////////////
+
+constexpr inline SkPoint rotate90(const SkPoint& p) { return {p.fY, -p.fX}; }
+inline SkPoint rotate180(const SkPoint& p) { return p * -1; }
+inline bool isClockwise(const SkPoint& a, const SkPoint& b) { return a.cross(b) > 0; }
+
+static SkPoint checkSetLength(SkPoint p, float len, const char* file, int line) {
+ if (!p.setLength(len)) {
+ SkDebugf("%s:%d: Failed to set point length\n", file, line);
+ }
+ return p;
+}
+
+/** Version of setLength that prints debug msg on failure to help catch edge cases */
+#define setLength(p, len) checkSetLength(p, len, __FILE__, __LINE__)
+
+constexpr uint64_t choose(uint64_t n, uint64_t k) {
+ SkASSERT(n >= k);
+ uint64_t result = 1;
+ for (uint64_t i = 1; i <= k; i++) {
+ result *= (n + 1 - i);
+ result /= i;
+ }
+ return result;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A scalar (float-valued weights) Bezier curve of arbitrary degree.
+ */
+class ScalarBezCurve {
+public:
+ inline static constexpr int kDegreeInvalid = -1;
+
+ /** Creates an empty curve with invalid degree. */
+ ScalarBezCurve() : fDegree(kDegreeInvalid) {}
+
+ /** Creates a curve of the specified degree with weights initialized to 0. */
+ explicit ScalarBezCurve(int degree) : fDegree(degree) {
+ SkASSERT(degree >= 0);
+ fWeights.resize(degree + 1, {0});
+ }
+
+ /** Creates a curve of specified degree with the given weights. */
+ ScalarBezCurve(int degree, const std::vector<float>& weights) : ScalarBezCurve(degree) {
+ SkASSERT(degree >= 0);
+ SkASSERT(weights.size() == (size_t)degree + 1);
+ fWeights.insert(fWeights.begin(), weights.begin(), weights.end());
+ }
+
+ /** Returns the extreme-valued weight */
+ float extremumWeight() const {
+ float f = 0;
+ int sign = 1;
+ for (float w : fWeights) {
+ if (std::abs(w) > f) {
+ f = std::abs(w);
+ sign = w >= 0 ? 1 : -1;
+ }
+ }
+ return sign * f;
+ }
+
+ /** Evaluates the curve at t */
+ float eval(float t) const { return Eval(*this, t); }
+
+ /** Evaluates the curve at t */
+ static float Eval(const ScalarBezCurve& curve, float t) {
+ // Set up starting point of recursion (k=0)
+ ScalarBezCurve result = curve;
+
+ for (int k = 1; k <= curve.fDegree; k++) {
+ // k is level of recursion, k-1 has previous level's values.
+ for (int i = curve.fDegree; i >= k; i--) {
+ result.fWeights[i] = result.fWeights[i - 1] * (1 - t) + result.fWeights[i] * t;
+ }
+ }
+
+ return result.fWeights[curve.fDegree];
+ }
+
+ /** Splits this curve at t into two halves (of the same degree) */
+ void split(float t, ScalarBezCurve* left, ScalarBezCurve* right) const {
+ Split(*this, t, left, right);
+ }
+
+ /** Splits this curve into the subinterval [tmin,tmax]. */
+ void split(float tmin, float tmax, ScalarBezCurve* result) const {
+ // TODO: I believe there's a more efficient algorithm for this
+ const float tRel = tmin / tmax;
+ ScalarBezCurve ll, rl, rr;
+ this->split(tmax, &rl, &rr);
+ rl.split(tRel, &ll, result);
+ }
+
+ /** Splits the curve at t into two halves (of the same degree) */
+ static void Split(const ScalarBezCurve& curve,
+ float t,
+ ScalarBezCurve* left,
+ ScalarBezCurve* right) {
+ // Set up starting point of recursion (k=0)
+ const int degree = curve.fDegree;
+ ScalarBezCurve result = curve;
+ *left = ScalarBezCurve(degree);
+ *right = ScalarBezCurve(degree);
+ left->fWeights[0] = curve.fWeights[0];
+ right->fWeights[degree] = curve.fWeights[degree];
+
+ for (int k = 1; k <= degree; k++) {
+ // k is level of recursion, k-1 has previous level's values.
+ for (int i = degree; i >= k; i--) {
+ result.fWeights[i] = result.fWeights[i - 1] * (1 - t) + result.fWeights[i] * t;
+ }
+
+ left->fWeights[k] = result.fWeights[k];
+ right->fWeights[degree - k] = result.fWeights[degree];
+ }
+ }
+
+ /**
+ * Increases the degree of the curve to the given degree. Has no effect if the
+ * degree is already equal to the given degree.
+ *
+ * This process is always exact (NB the reverse, degree reduction, is not exact).
+ */
+ void elevateDegree(int newDegree) {
+ if (newDegree == fDegree) {
+ return;
+ }
+
+ fWeights = ElevateDegree(*this, newDegree).fWeights;
+ fDegree = newDegree;
+ }
+
+ /**
+ * Increases the degree of the curve to the given degree. Has no effect if the
+ * degree is already equal to the given degree.
+ *
+ * This process is always exact (NB the reverse, degree reduction, is not exact).
+ */
+ static ScalarBezCurve ElevateDegree(const ScalarBezCurve& curve, int newDegree) {
+ SkASSERT(newDegree >= curve.degree());
+ if (newDegree == curve.degree()) {
+ return curve;
+ }
+
+ // From Farouki, Rajan, "Algorithms for polynomials in Bernstein form" 1988.
+ ScalarBezCurve elevated(newDegree);
+ const int r = newDegree - curve.fDegree;
+ const int n = curve.fDegree;
+
+ for (int i = 0; i <= n + r; i++) {
+ elevated.fWeights[i] = 0;
+ for (int j = std::max(0, i - r); j <= std::min(n, i); j++) {
+ const float f =
+ (choose(n, j) * choose(r, i - j)) / static_cast<float>(choose(n + r, i));
+ elevated.fWeights[i] += curve.fWeights[j] * f;
+ }
+ }
+
+ return elevated;
+ }
+
+ /**
+ * Returns the zero-set of this curve, which is a list of t values where the curve crosses 0.
+ */
+ std::vector<float> zeroSet() const { return ZeroSet(*this); }
+
+ /**
+ * Returns the zero-set of the curve, which is a list of t values where the curve crosses 0.
+ */
+ static std::vector<float> ZeroSet(const ScalarBezCurve& curve) {
+ constexpr float kTol = 0.001f;
+ std::vector<float> result;
+ ZeroSetRec(curve, 0, 1, kTol, &result);
+ return result;
+ }
+
+ /** Multiplies the curve's weights by a constant value */
+ static ScalarBezCurve Mul(const ScalarBezCurve& curve, float f) {
+ ScalarBezCurve result = curve;
+ for (int k = 0; k <= curve.fDegree; k++) {
+ result.fWeights[k] *= f;
+ }
+ return result;
+ }
+
+ /**
+ * Multiplies the two curves and returns the result.
+ *
+ * Degree of resulting curve is the sum of the degrees of the input curves.
+ */
+ static ScalarBezCurve Mul(const ScalarBezCurve& a, const ScalarBezCurve& b) {
+ // From G. Elber, "Free form surface analysis using a hybrid of symbolic and numeric
+ // computation". PhD thesis, 1992. p.11.
+ const int n = a.degree(), m = b.degree();
+ const int newDegree = n + m;
+ ScalarBezCurve result(newDegree);
+
+ for (int k = 0; k <= newDegree; k++) {
+ result.fWeights[k] = 0;
+ for (int i = std::max(0, k - n); i <= std::min(k, m); i++) {
+ const float f =
+ (choose(m, i) * choose(n, k - i)) / static_cast<float>(choose(m + n, k));
+ result.fWeights[k] += a.fWeights[i] * b.fWeights[k - i] * f;
+ }
+ }
+
+ return result;
+ }
+
+ /** Returns a^2 + b^2. This is a specialized method because the loops are easily fused. */
+ static ScalarBezCurve AddSquares(const ScalarBezCurve& a, const ScalarBezCurve& b) {
+ const int n = a.degree(), m = b.degree();
+ const int newDegree = n + m;
+ ScalarBezCurve result(newDegree);
+
+ for (int k = 0; k <= newDegree; k++) {
+ float aSq = 0, bSq = 0;
+ for (int i = std::max(0, k - n); i <= std::min(k, m); i++) {
+ const float f =
+ (choose(m, i) * choose(n, k - i)) / static_cast<float>(choose(m + n, k));
+ aSq += a.fWeights[i] * a.fWeights[k - i] * f;
+ bSq += b.fWeights[i] * b.fWeights[k - i] * f;
+ }
+ result.fWeights[k] = aSq + bSq;
+ }
+
+ return result;
+ }
+
+ /** Returns a - b. */
+ static ScalarBezCurve Sub(const ScalarBezCurve& a, const ScalarBezCurve& b) {
+ ScalarBezCurve result = a;
+ result.sub(b);
+ return result;
+ }
+
+ /** Subtracts the other curve from this curve */
+ void sub(const ScalarBezCurve& other) {
+ SkASSERT(other.fDegree == fDegree);
+ for (int k = 0; k <= fDegree; k++) {
+ fWeights[k] -= other.fWeights[k];
+ }
+ }
+
+ /** Subtracts a constant from this curve */
+ void sub(float f) {
+ for (int k = 0; k <= fDegree; k++) {
+ fWeights[k] -= f;
+ }
+ }
+
+ /** Returns the curve degree */
+ int degree() const { return fDegree; }
+
+ /** Returns the curve weights */
+ const std::vector<float>& weights() const { return fWeights; }
+
+ float operator[](size_t i) const { return fWeights[i]; }
+ float& operator[](size_t i) { return fWeights[i]; }
+
+private:
+ /** Recursive helper for ZeroSet */
+ static void ZeroSetRec(const ScalarBezCurve& curve,
+ float tmin,
+ float tmax,
+ float tol,
+ std::vector<float>* result) {
+ float lenP = 0;
+ bool allPos = curve.fWeights[0] >= 0, allNeg = curve.fWeights[0] < 0;
+ for (int i = 1; i <= curve.fDegree; i++) {
+ lenP += std::abs(curve.fWeights[i] - curve.fWeights[i - 1]);
+ allPos &= curve.fWeights[i] >= 0;
+ allNeg &= curve.fWeights[i] < 0;
+ }
+ if (lenP <= tol) {
+ result->push_back((tmin + tmax) * 0.5);
+ return;
+ } else if (allPos || allNeg) {
+ // No zero crossings possible if the coefficients don't change sign (convex hull
+ // property)
+ return;
+ } else if (SkScalarNearlyZero(tmax - tmin)) {
+ return;
+ } else {
+ ScalarBezCurve left(curve.fDegree), right(curve.fDegree);
+ Split(curve, 0.5f, &left, &right);
+
+ const float tmid = (tmin + tmax) * 0.5;
+ ZeroSetRec(left, tmin, tmid, tol, result);
+ ZeroSetRec(right, tmid, tmax, tol, result);
+ }
+ }
+
+ int fDegree;
+ std::vector<float> fWeights;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+/** Helper class that measures per-verb path lengths. */
+class PathVerbMeasure {
+public:
+ explicit PathVerbMeasure(const SkPath& path) : fPath(path), fIter(path, false) { nextVerb(); }
+
+ SkScalar totalLength() const;
+
+ SkScalar currentVerbLength() { return fMeas.getLength(); }
+
+ void nextVerb();
+
+private:
+ const SkPath& fPath;
+ SkPoint fFirstPointInContour;
+ SkPoint fPreviousPoint;
+ SkPath fCurrVerb;
+ SkPath::Iter fIter;
+ SkPathMeasure fMeas;
+};
+
+SkScalar PathVerbMeasure::totalLength() const {
+ SkPathMeasure meas(fPath, false);
+ return meas.getLength();
+}
+
+void PathVerbMeasure::nextVerb() {
+ SkPoint pts[4];
+ SkPath::Verb verb = fIter.next(pts);
+
+ while (verb == SkPath::kMove_Verb || verb == SkPath::kClose_Verb) {
+ if (verb == SkPath::kMove_Verb) {
+ fFirstPointInContour = pts[0];
+ fPreviousPoint = fFirstPointInContour;
+ }
+ verb = fIter.next(pts);
+ }
+
+ fCurrVerb.rewind();
+ fCurrVerb.moveTo(fPreviousPoint);
+ switch (verb) {
+ case SkPath::kLine_Verb:
+ fCurrVerb.lineTo(pts[1]);
+ break;
+ case SkPath::kQuad_Verb:
+ fCurrVerb.quadTo(pts[1], pts[2]);
+ break;
+ case SkPath::kCubic_Verb:
+ fCurrVerb.cubicTo(pts[1], pts[2], pts[3]);
+ break;
+ case SkPath::kConic_Verb:
+ fCurrVerb.conicTo(pts[1], pts[2], fIter.conicWeight());
+ break;
+ case SkPath::kDone_Verb:
+ break;
+ case SkPath::kClose_Verb:
+ case SkPath::kMove_Verb:
+ SkASSERT(false);
+ break;
+ }
+
+ fCurrVerb.getLastPt(&fPreviousPoint);
+ fMeas.setPath(&fCurrVerb, false);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+// Several debug-only visualization helpers
+namespace viz {
+std::unique_ptr<ScalarBezCurve> outerErr;
+SkPath outerFirstApprox;
+} // namespace viz
+
+/**
+ * Prototype variable-width path stroker.
+ *
+ * Takes as input a path to be stroked, and two distance functions (inside and outside).
+ * Produces a fill path with the stroked path geometry.
+ *
+ * The algorithms in use here are from:
+ *
+ * G. Elber, E. Cohen. "Error bounded variable distance offset operator for free form curves and
+ * surfaces." International Journal of Computational Geometry & Applications 1, no. 01 (1991)
+ *
+ * G. Elber. "Free form surface analysis using a hybrid of symbolic and numeric computation."
+ * PhD diss., Dept. of Computer Science, University of Utah, 1992.
+ */
+class SkVarWidthStroker {
+public:
+ /** Metric to use for interpolation of distance function across path segments. */
+ enum class LengthMetric {
+ /** Each path segment gets an equal interval of t in [0,1] */
+ kNumSegments,
+ /** Each path segment gets t interval equal to its percent of the total path length */
+ kPathLength,
+ };
+
+ /**
+ * Strokes the path with a fixed-width distance function. This produces a traditional stroked
+ * path.
+ */
+ SkPath getFillPath(const SkPath& path, const SkPaint& paint) {
+ return getFillPath(path, paint, identityVarWidth(paint.getStrokeWidth()),
+ identityVarWidth(paint.getStrokeWidth()));
+ }
+
+ /**
+ * Strokes the given path using the two given distance functions for inner and outer offsets.
+ */
+ SkPath getFillPath(const SkPath& path,
+ const SkPaint& paint,
+ const ScalarBezCurve& varWidth,
+ const ScalarBezCurve& varWidthInner,
+ LengthMetric lengthMetric = LengthMetric::kNumSegments);
+
+private:
+ /** Helper struct referring to a single segment of an SkPath */
+ struct PathSegment {
+ SkPath::Verb fVerb;
+ std::array<SkPoint, 4> fPoints;
+ };
+
+ struct OffsetSegments {
+ std::vector<PathSegment> fInner;
+ std::vector<PathSegment> fOuter;
+ };
+
+ /** Initialize stroker state */
+ void initForPath(const SkPath& path, const SkPaint& paint);
+
+ /** Strokes a path segment */
+ OffsetSegments strokeSegment(const PathSegment& segment,
+ const ScalarBezCurve& varWidth,
+ const ScalarBezCurve& varWidthInner,
+ bool needsMove);
+
+ /**
+ * Strokes the given segment using the given distance function.
+ *
+ * Returns a list of quad segments that approximate the offset curve.
+ * TODO: no reason this needs to return a vector of quads, can just append to the path
+ */
+ std::vector<PathSegment> strokeSegment(const PathSegment& seg,
+ const ScalarBezCurve& distanceFunc) const;
+
+ /** Adds an endcap to fOuter */
+ enum class CapLocation { Start, End };
+ void endcap(CapLocation loc);
+
+ /** Adds a join between the two segments */
+ void join(const SkPoint& common,
+ float innerRadius,
+ float outerRadius,
+ const OffsetSegments& prev,
+ const OffsetSegments& curr);
+
+ /** Appends path in reverse to result */
+ static void appendPathReversed(const SkPath& path, SkPath* result);
+
+ /** Returns the segment unit normal and unit tangent if not nullptr */
+ static SkPoint unitNormal(const PathSegment& seg, float t, SkPoint* tangentOut);
+
+ /** Returns the degree of a segment curve */
+ static int segmentDegree(const PathSegment& seg);
+
+ /** Splits a path segment at t */
+ static void splitSegment(const PathSegment& seg, float t, PathSegment* segA, PathSegment* segB);
+
+ /**
+ * Returns a quadratic segment that approximates the given segment using the given distance
+ * function.
+ */
+ static void approximateSegment(const PathSegment& seg,
+ const ScalarBezCurve& distFnc,
+ PathSegment* approxQuad);
+
+ /** Returns a constant (deg 0) distance function for the given stroke width */
+ static ScalarBezCurve identityVarWidth(float strokeWidth) {
+ return ScalarBezCurve(0, {strokeWidth / 2.0f});
+ }
+
+ float fRadius;
+ SkPaint::Cap fCap;
+ SkPaint::Join fJoin;
+ SkPath fInner, fOuter;
+ ScalarBezCurve fVarWidth, fVarWidthInner;
+ float fCurrT;
+};
+
+void SkVarWidthStroker::initForPath(const SkPath& path, const SkPaint& paint) {
+ fRadius = paint.getStrokeWidth() / 2;
+ fCap = paint.getStrokeCap();
+ fJoin = paint.getStrokeJoin();
+ fInner.rewind();
+ fOuter.rewind();
+ fCurrT = 0;
+}
+
+SkPath SkVarWidthStroker::getFillPath(const SkPath& path,
+ const SkPaint& paint,
+ const ScalarBezCurve& varWidth,
+ const ScalarBezCurve& varWidthInner,
+ LengthMetric lengthMetric) {
+ const auto appendStrokes = [this](const OffsetSegments& strokes, bool needsMove) {
+ if (needsMove) {
+ fOuter.moveTo(strokes.fOuter.front().fPoints[0]);
+ fInner.moveTo(strokes.fInner.front().fPoints[0]);
+ }
+
+ for (const PathSegment& seg : strokes.fOuter) {
+ fOuter.quadTo(seg.fPoints[1], seg.fPoints[2]);
+ }
+
+ for (const PathSegment& seg : strokes.fInner) {
+ fInner.quadTo(seg.fPoints[1], seg.fPoints[2]);
+ }
+ };
+
+ initForPath(path, paint);
+ fVarWidth = varWidth;
+ fVarWidthInner = varWidthInner;
+
+ // TODO: this assumes one contour:
+ PathVerbMeasure meas(path);
+ const float totalPathLength = lengthMetric == LengthMetric::kPathLength
+ ? meas.totalLength()
+ : (path.countVerbs() - 1);
+
+ // Trace the inner and outer paths simultaneously. Inner will therefore be
+ // recorded in reverse from how we trace the outline.
+ SkPath::Iter it(path, false);
+ PathSegment segment, prevSegment;
+ OffsetSegments offsetSegs, prevOffsetSegs;
+ bool firstSegment = true, prevWasFirst = false;
+
+ float lenTraveled = 0;
+ while ((segment.fVerb = it.next(&segment.fPoints[0])) != SkPath::kDone_Verb) {
+ const float verbLength = lengthMetric == LengthMetric::kPathLength
+ ? (meas.currentVerbLength() / totalPathLength)
+ : (1.0f / totalPathLength);
+ const float tmin = lenTraveled;
+ const float tmax = lenTraveled + verbLength;
+
+ // Subset the distance function for the current interval.
+ ScalarBezCurve partVarWidth, partVarWidthInner;
+ fVarWidth.split(tmin, tmax, &partVarWidth);
+ fVarWidthInner.split(tmin, tmax, &partVarWidthInner);
+ partVarWidthInner = ScalarBezCurve::Mul(partVarWidthInner, -1);
+
+ // Stroke the current segment
+ switch (segment.fVerb) {
+ case SkPath::kLine_Verb:
+ case SkPath::kQuad_Verb:
+ case SkPath::kCubic_Verb:
+ offsetSegs = strokeSegment(segment, partVarWidth, partVarWidthInner, firstSegment);
+ break;
+ case SkPath::kMove_Verb:
+ // Don't care about multiple contours currently
+ continue;
+ default:
+ SkDebugf("Unhandled path verb %d\n", segment.fVerb);
+ SkASSERT(false);
+ break;
+ }
+
+ // Join to the previous segment
+ if (!firstSegment) {
+ // Append prev inner and outer strokes
+ appendStrokes(prevOffsetSegs, prevWasFirst);
+
+ // Append the join
+ const float innerRadius = varWidthInner.eval(tmin);
+ const float outerRadius = varWidth.eval(tmin);
+ join(segment.fPoints[0], innerRadius, outerRadius, prevOffsetSegs, offsetSegs);
+ }
+
+ std::swap(segment, prevSegment);
+ std::swap(offsetSegs, prevOffsetSegs);
+ prevWasFirst = firstSegment;
+ firstSegment = false;
+ lenTraveled += verbLength;
+ meas.nextVerb();
+ }
+
+ // Finish appending final offset segments
+ appendStrokes(prevOffsetSegs, prevWasFirst);
+
+ // Open contour => endcap at the end
+ const bool isClosed = path.isLastContourClosed();
+ if (isClosed) {
+ SkDebugf("Unhandled closed contour\n");
+ SkASSERT(false);
+ } else {
+ endcap(CapLocation::End);
+ }
+
+ // Walk inner path in reverse, appending to result
+ appendPathReversed(fInner, &fOuter);
+ endcap(CapLocation::Start);
+
+ return fOuter;
+}
+
+SkVarWidthStroker::OffsetSegments SkVarWidthStroker::strokeSegment(
+ const PathSegment& segment,
+ const ScalarBezCurve& varWidth,
+ const ScalarBezCurve& varWidthInner,
+ bool needsMove) {
+ viz::outerErr.reset(nullptr);
+
+ std::vector<PathSegment> outer = strokeSegment(segment, varWidth);
+ std::vector<PathSegment> inner = strokeSegment(segment, varWidthInner);
+ return {inner, outer};
+}
+
+std::vector<SkVarWidthStroker::PathSegment> SkVarWidthStroker::strokeSegment(
+ const PathSegment& seg, const ScalarBezCurve& distanceFunc) const {
+ // Work item for the recursive splitting stack.
+ struct Item {
+ PathSegment fSeg;
+ ScalarBezCurve fDistFnc, fDistFncSqd;
+ ScalarBezCurve fSegX, fSegY;
+
+ Item(const PathSegment& seg,
+ const ScalarBezCurve& distFnc,
+ const ScalarBezCurve& distFncSqd)
+ : fSeg(seg), fDistFnc(distFnc), fDistFncSqd(distFncSqd) {
+ const int segDegree = segmentDegree(seg);
+ fSegX = ScalarBezCurve(segDegree);
+ fSegY = ScalarBezCurve(segDegree);
+ for (int i = 0; i <= segDegree; i++) {
+ fSegX[i] = seg.fPoints[i].fX;
+ fSegY[i] = seg.fPoints[i].fY;
+ }
+ }
+ };
+
+ // Push the initial segment and distance function
+ std::stack<Item> stack;
+ stack.push(Item(seg, distanceFunc, ScalarBezCurve::Mul(distanceFunc, distanceFunc)));
+
+ std::vector<PathSegment> result;
+ constexpr int kMaxIters = 5000; /** TODO: this is completely arbitrary */
+ int iter = 0;
+ while (!stack.empty()) {
+ if (iter++ >= kMaxIters) break;
+ const Item item = stack.top();
+ stack.pop();
+
+ const ScalarBezCurve& distFnc = item.fDistFnc;
+ ScalarBezCurve distFncSqd = item.fDistFncSqd;
+ const float kTol = std::abs(0.5f * distFnc.extremumWeight());
+
+ // Compute a quad that approximates stroke outline
+ PathSegment quadApprox;
+ approximateSegment(item.fSeg, distFnc, &quadApprox);
+ ScalarBezCurve quadApproxX(2), quadApproxY(2);
+ for (int i = 0; i < 3; i++) {
+ quadApproxX[i] = quadApprox.fPoints[i].fX;
+ quadApproxY[i] = quadApprox.fPoints[i].fY;
+ }
+
+ // Compute control polygon for the delta(t) curve. First must elevate to a common degree.
+ const int deltaDegree = std::max(quadApproxX.degree(), item.fSegX.degree());
+ ScalarBezCurve segX = item.fSegX, segY = item.fSegY;
+ segX.elevateDegree(deltaDegree);
+ segY.elevateDegree(deltaDegree);
+ quadApproxX.elevateDegree(deltaDegree);
+ quadApproxY.elevateDegree(deltaDegree);
+
+ ScalarBezCurve deltaX = ScalarBezCurve::Sub(quadApproxX, segX);
+ ScalarBezCurve deltaY = ScalarBezCurve::Sub(quadApproxY, segY);
+
+ // Compute psi(t) = delta_x(t)^2 + delta_y(t)^2.
+ ScalarBezCurve E = ScalarBezCurve::AddSquares(deltaX, deltaY);
+
+ // Promote E and d(t)^2 to a common degree.
+ const int commonDeg = std::max(distFncSqd.degree(), E.degree());
+ distFncSqd.elevateDegree(commonDeg);
+ E.elevateDegree(commonDeg);
+
+ // Subtract dist squared curve from E, resulting in:
+ // eps(t) = delta_x(t)^2 + delta_y(t)^2 - d(t)^2
+ E.sub(distFncSqd);
+
+ // Purely for debugging/testing, save the first approximation and error function:
+ if (viz::outerErr == nullptr) {
+ using namespace viz;
+ outerErr = std::make_unique<ScalarBezCurve>(E);
+ outerFirstApprox.rewind();
+ outerFirstApprox.moveTo(quadApprox.fPoints[0]);
+ outerFirstApprox.quadTo(quadApprox.fPoints[1], quadApprox.fPoints[2]);
+ }
+
+ // Compute maxErr, which is just the max coefficient of eps (using convex hull property
+ // of bez curves)
+ float maxAbsErr = std::abs(E.extremumWeight());
+
+ if (maxAbsErr > kTol) {
+ PathSegment left, right;
+ splitSegment(item.fSeg, 0.5f, &left, &right);
+
+ ScalarBezCurve distFncL, distFncR;
+ distFnc.split(0.5f, &distFncL, &distFncR);
+
+ ScalarBezCurve distFncSqdL, distFncSqdR;
+ distFncSqd.split(0.5f, &distFncSqdL, &distFncSqdR);
+
+ stack.push(Item(right, distFncR, distFncSqdR));
+ stack.push(Item(left, distFncL, distFncSqdL));
+ } else {
+ // Approximation is good enough.
+ quadApprox.fVerb = SkPath::kQuad_Verb;
+ result.push_back(quadApprox);
+ }
+ }
+ SkASSERT(!result.empty());
+ return result;
+}
+
+void SkVarWidthStroker::endcap(CapLocation loc) {
+ const auto buttCap = [this](CapLocation loc) {
+ if (loc == CapLocation::Start) {
+ // Back at the start of the path: just close the stroked outline
+ fOuter.close();
+ } else {
+ // Inner last pt == first pt when appending in reverse
+ SkPoint innerLastPt;
+ fInner.getLastPt(&innerLastPt);
+ fOuter.lineTo(innerLastPt);
+ }
+ };
+
+ switch (fCap) {
+ case SkPaint::kButt_Cap:
+ buttCap(loc);
+ break;
+ default:
+ SkDebugf("Unhandled endcap %d\n", fCap);
+ buttCap(loc);
+ break;
+ }
+}
+
+void SkVarWidthStroker::join(const SkPoint& common,
+ float innerRadius,
+ float outerRadius,
+ const OffsetSegments& prev,
+ const OffsetSegments& curr) {
+ const auto miterJoin = [this](const SkPoint& common,
+ float leftRadius,
+ float rightRadius,
+ const OffsetSegments& prev,
+ const OffsetSegments& curr) {
+ // With variable-width stroke you can actually have a situation where both sides
+ // need an "inner" or an "outer" join. So we call the two sides "left" and
+ // "right" and they can each independently get an inner or outer join.
+ const auto makeJoin = [this, &common, &prev, &curr](bool left, float radius) {
+ SkPath* path = left ? &fOuter : &fInner;
+ const auto& prevSegs = left ? prev.fOuter : prev.fInner;
+ const auto& currSegs = left ? curr.fOuter : curr.fInner;
+ SkASSERT(!prevSegs.empty());
+ SkASSERT(!currSegs.empty());
+ const SkPoint afterEndpt = currSegs.front().fPoints[0];
+ SkPoint before = unitNormal(prevSegs.back(), 1, nullptr);
+ SkPoint after = unitNormal(currSegs.front(), 0, nullptr);
+
+ // Don't create any join geometry if the normals are nearly identical.
+ const float cosTheta = before.dot(after);
+ if (!SkScalarNearlyZero(1 - cosTheta)) {
+ bool outerJoin;
+ if (left) {
+ outerJoin = isClockwise(before, after);
+ } else {
+ before = rotate180(before);
+ after = rotate180(after);
+ outerJoin = !isClockwise(before, after);
+ }
+
+ if (outerJoin) {
+ // Before and after have the same origin and magnitude, so before+after is the
+ // diagonal of their rhombus. Origin of this vector is the midpoint of the miter
+ // line.
+ SkPoint miterVec = before + after;
+
+ // Note the relationship (draw a right triangle with the miter line as its
+ // hypoteneuse):
+ // sin(theta/2) = strokeWidth / miterLength
+ // so miterLength = strokeWidth / sin(theta/2)
+ // where miterLength is the length of the miter from outer point to inner
+ // corner. miterVec's origin is the midpoint of the miter line, so we use
+ // strokeWidth/2. Sqrt is just an application of half-angle identities.
+ const float sinHalfTheta = sqrtf(0.5 * (1 + cosTheta));
+ const float halfMiterLength = radius / sinHalfTheta;
+ // TODO: miter length limit
+ miterVec = setLength(miterVec, halfMiterLength);
+
+ // Outer join: connect to the miter point, and then to t=0 of next segment.
+ path->lineTo(common + miterVec);
+ path->lineTo(afterEndpt);
+ } else {
+ // Connect to the miter midpoint (common path endpoint of the two segments),
+ // and then to t=0 of the next segment. This adds an interior "loop"
+ // of geometry that handles edge cases where segment lengths are shorter than
+ // the stroke width.
+ path->lineTo(common);
+ path->lineTo(afterEndpt);
+ }
+ }
+ };
+
+ makeJoin(true, leftRadius);
+ makeJoin(false, rightRadius);
+ };
+
+ switch (fJoin) {
+ case SkPaint::kMiter_Join:
+ miterJoin(common, innerRadius, outerRadius, prev, curr);
+ break;
+ default:
+ SkDebugf("Unhandled join %d\n", fJoin);
+ miterJoin(common, innerRadius, outerRadius, prev, curr);
+ break;
+ }
+}
+
+void SkVarWidthStroker::appendPathReversed(const SkPath& path, SkPath* result) {
+ const int numVerbs = path.countVerbs();
+ const int numPoints = path.countPoints();
+ std::vector<uint8_t> verbs;
+ std::vector<SkPoint> points;
+ verbs.resize(numVerbs);
+ points.resize(numPoints);
+ path.getVerbs(verbs.data(), numVerbs);
+ path.getPoints(points.data(), numPoints);
+
+ for (int i = numVerbs - 1, j = numPoints; i >= 0; i--) {
+ auto verb = static_cast<SkPath::Verb>(verbs[i]);
+ switch (verb) {
+ case SkPath::kLine_Verb: {
+ j -= 1;
+ SkASSERT(j >= 1);
+ result->lineTo(points[j - 1]);
+ break;
+ }
+ case SkPath::kQuad_Verb: {
+ j -= 1;
+ SkASSERT(j >= 2);
+ result->quadTo(points[j - 1], points[j - 2]);
+ j -= 1;
+ break;
+ }
+ case SkPath::kMove_Verb:
+ // Ignore
+ break;
+ default:
+ SkASSERT(false);
+ break;
+ }
+ }
+}
+
+int SkVarWidthStroker::segmentDegree(const PathSegment& seg) {
+ static constexpr int lut[] = {
+ -1, // move,
+ 1, // line
+ 2, // quad
+ -1, // conic
+ 3, // cubic
+ -1 // done
+ };
+ const int deg = lut[static_cast<uint8_t>(seg.fVerb)];
+ SkASSERT(deg > 0);
+ return deg;
+}
+
+void SkVarWidthStroker::splitSegment(const PathSegment& seg,
+ float t,
+ PathSegment* segA,
+ PathSegment* segB) {
+ // TODO: although general, this is a pretty slow way to do this
+ const int degree = segmentDegree(seg);
+ ScalarBezCurve x(degree), y(degree);
+ for (int i = 0; i <= degree; i++) {
+ x[i] = seg.fPoints[i].fX;
+ y[i] = seg.fPoints[i].fY;
+ }
+
+ ScalarBezCurve leftX(degree), rightX(degree), leftY(degree), rightY(degree);
+ x.split(t, &leftX, &rightX);
+ y.split(t, &leftY, &rightY);
+
+ segA->fVerb = segB->fVerb = seg.fVerb;
+ for (int i = 0; i <= degree; i++) {
+ segA->fPoints[i] = {leftX[i], leftY[i]};
+ segB->fPoints[i] = {rightX[i], rightY[i]};
+ }
+}
+
+void SkVarWidthStroker::approximateSegment(const PathSegment& seg,
+ const ScalarBezCurve& distFnc,
+ PathSegment* approxQuad) {
+ // This is a simple control polygon transformation.
+ // From F. Yzerman. "Precise offsetting of quadratic Bezier curves". 2019.
+ // TODO: detect and handle more degenerate cases (e.g. linear)
+ // TODO: Tiller-Hanson works better in many cases but does not generalize well
+ SkPoint tangentStart, tangentEnd;
+ SkPoint offsetStart = unitNormal(seg, 0, &tangentStart);
+ SkPoint offsetEnd = unitNormal(seg, 1, &tangentEnd);
+ SkPoint offsetMid = offsetStart + offsetEnd;
+
+ const float radiusStart = distFnc.eval(0);
+ const float radiusMid = distFnc.eval(0.5f);
+ const float radiusEnd = distFnc.eval(1);
+
+ offsetStart = radiusStart == 0 ? SkPoint::Make(0, 0) : setLength(offsetStart, radiusStart);
+ offsetMid = radiusMid == 0 ? SkPoint::Make(0, 0) : setLength(offsetMid, radiusMid);
+ offsetEnd = radiusEnd == 0 ? SkPoint::Make(0, 0) : setLength(offsetEnd, radiusEnd);
+
+ SkPoint start, mid, end;
+ switch (segmentDegree(seg)) {
+ case 1:
+ start = seg.fPoints[0];
+ end = seg.fPoints[1];
+ mid = (start + end) * 0.5f;
+ break;
+ case 2:
+ start = seg.fPoints[0];
+ mid = seg.fPoints[1];
+ end = seg.fPoints[2];
+ break;
+ case 3:
+ start = seg.fPoints[0];
+ mid = (seg.fPoints[1] + seg.fPoints[2]) * 0.5f;
+ end = seg.fPoints[3];
+ break;
+ default:
+ SkDebugf("Unhandled degree for segment approximation");
+ SkASSERT(false);
+ break;
+ }
+
+ approxQuad->fPoints[0] = start + offsetStart;
+ approxQuad->fPoints[1] = mid + offsetMid;
+ approxQuad->fPoints[2] = end + offsetEnd;
+}
+
+SkPoint SkVarWidthStroker::unitNormal(const PathSegment& seg, float t, SkPoint* tangentOut) {
+ switch (seg.fVerb) {
+ case SkPath::kLine_Verb: {
+ const SkPoint tangent = setLength(seg.fPoints[1] - seg.fPoints[0], 1);
+ const SkPoint normal = rotate90(tangent);
+ if (tangentOut) {
+ *tangentOut = tangent;
+ }
+ return normal;
+ }
+ case SkPath::kQuad_Verb: {
+ SkPoint tangent;
+ if (t == 0) {
+ tangent = seg.fPoints[1] - seg.fPoints[0];
+ } else if (t == 1) {
+ tangent = seg.fPoints[2] - seg.fPoints[1];
+ } else {
+ tangent = ((seg.fPoints[1] - seg.fPoints[0]) * (1 - t) +
+ (seg.fPoints[2] - seg.fPoints[1]) * t) *
+ 2;
+ }
+ if (!tangent.normalize()) {
+ SkDebugf("Failed to normalize quad tangent\n");
+ SkASSERT(false);
+ }
+ if (tangentOut) {
+ *tangentOut = tangent;
+ }
+ return rotate90(tangent);
+ }
+ case SkPath::kCubic_Verb: {
+ SkPoint tangent;
+ SkEvalCubicAt(seg.fPoints.data(), t, nullptr, &tangent, nullptr);
+ if (!tangent.normalize()) {
+ SkDebugf("Failed to normalize cubic tangent\n");
+ SkASSERT(false);
+ }
+ if (tangentOut) {
+ *tangentOut = tangent;
+ }
+ return rotate90(tangent);
+ }
+ default:
+ SkDebugf("Unhandled verb for unit normal %d\n", seg.fVerb);
+ SkASSERT(false);
+ return {};
+ }
+}
+
+} // namespace
+
+//////////////////////////////////////////////////////////////////////////////
+
+class VariableWidthStroker : public Sample {
+public:
+ VariableWidthStroker()
+ : fShowHidden(true)
+ , fShowSkeleton(true)
+ , fShowStrokePoints(false)
+ , fShowUI(false)
+ , fDifferentInnerFunc(false)
+ , fShowErrorCurve(false) {
+ resetToDefaults();
+
+ fPtsPaint.setAntiAlias(true);
+ fPtsPaint.setStrokeWidth(10);
+ fPtsPaint.setStrokeCap(SkPaint::kRound_Cap);
+
+ fStrokePointsPaint.setAntiAlias(true);
+ fStrokePointsPaint.setStrokeWidth(5);
+ fStrokePointsPaint.setStrokeCap(SkPaint::kRound_Cap);
+
+ fStrokePaint.setAntiAlias(true);
+ fStrokePaint.setStyle(SkPaint::kStroke_Style);
+ fStrokePaint.setColor(0x80FF0000);
+
+ fNewFillPaint.setAntiAlias(true);
+ fNewFillPaint.setColor(0x8000FF00);
+
+ fHiddenPaint.setAntiAlias(true);
+ fHiddenPaint.setStyle(SkPaint::kStroke_Style);
+ fHiddenPaint.setColor(0xFF0000FF);
+
+ fSkeletonPaint.setAntiAlias(true);
+ fSkeletonPaint.setStyle(SkPaint::kStroke_Style);
+ fSkeletonPaint.setColor(SK_ColorRED);
+ }
+
+private:
+ /** Selectable menu item for choosing distance functions */
+ struct DistFncMenuItem {
+ std::string fName;
+ int fDegree;
+ bool fSelected;
+ std::vector<float> fWeights;
+
+ DistFncMenuItem(const std::string& name, int degree, bool selected) {
+ fName = name;
+ fDegree = degree;
+ fSelected = selected;
+ fWeights.resize(degree + 1, 1.0f);
+ }
+ };
+
+ SkString name() override { return SkString("VariableWidthStroker"); }
+
+ void onSizeChange() override {
+ fWinSize = SkSize::Make(this->width(), this->height());
+ INHERITED::onSizeChange();
+ }
+
+ bool onChar(SkUnichar uni) override {
+ switch (uni) {
+ case '0':
+ this->toggle(fShowUI);
+ return true;
+ case '1':
+ this->toggle(fShowSkeleton);
+ return true;
+ case '2':
+ this->toggle(fShowHidden);
+ return true;
+ case '3':
+ this->toggle(fShowStrokePoints);
+ return true;
+ case '4':
+ this->toggle(fShowErrorCurve);
+ return true;
+ case '5':
+ this->toggle(fLengthMetric);
+ return true;
+ case 'x':
+ resetToDefaults();
+ return true;
+ case '-':
+ fWidth -= 5;
+ return true;
+ case '=':
+ fWidth += 5;
+ return true;
+ default:
+ break;
+ }
+ return false;
+ }
+
+ void toggle(bool& value) { value = !value; }
+ void toggle(SkVarWidthStroker::LengthMetric& value) {
+ value = value == SkVarWidthStroker::LengthMetric::kPathLength
+ ? SkVarWidthStroker::LengthMetric::kNumSegments
+ : SkVarWidthStroker::LengthMetric::kPathLength;
+ }
+
+ void resetToDefaults() {
+ fPathPts[0] = {300, 400};
+ fPathPts[1] = {500, 400};
+ fPathPts[2] = {700, 400};
+ fPathPts[3] = {900, 400};
+ fPathPts[4] = {1100, 400};
+
+ fWidth = 175;
+
+ fLengthMetric = SkVarWidthStroker::LengthMetric::kPathLength;
+ fDistFncs = fDefaultsDistFncs;
+ fDistFncsInner = fDefaultsDistFncs;
+ }
+
+ void makePath(SkPath* path) {
+ path->moveTo(fPathPts[0]);
+ path->quadTo(fPathPts[1], fPathPts[2]);
+ path->quadTo(fPathPts[3], fPathPts[4]);
+ }
+
+ static ScalarBezCurve makeDistFnc(const std::vector<DistFncMenuItem>& fncs, float strokeWidth) {
+ const float radius = strokeWidth / 2;
+ for (const auto& df : fncs) {
+ if (df.fSelected) {
+ return ScalarBezCurve::Mul(ScalarBezCurve(df.fDegree, df.fWeights), radius);
+ }
+ }
+ SkASSERT(false);
+ return ScalarBezCurve(0, {radius});
+ }
+
+ void onDrawContent(SkCanvas* canvas) override {
+ canvas->drawColor(0xFFEEEEEE);
+
+ SkPath path;
+ this->makePath(&path);
+
+ fStrokePaint.setStrokeWidth(fWidth);
+
+ // Elber-Cohen stroker result
+ ScalarBezCurve distFnc = makeDistFnc(fDistFncs, fWidth);
+ ScalarBezCurve distFncInner =
+ fDifferentInnerFunc ? makeDistFnc(fDistFncsInner, fWidth) : distFnc;
+ SkVarWidthStroker stroker;
+ SkPath fillPath =
+ stroker.getFillPath(path, fStrokePaint, distFnc, distFncInner, fLengthMetric);
+ fillPath.setFillType(SkPathFillType::kWinding);
+ canvas->drawPath(fillPath, fNewFillPaint);
+
+ if (fShowHidden) {
+ canvas->drawPath(fillPath, fHiddenPaint);
+ }
+
+ if (fShowSkeleton) {
+ canvas->drawPath(path, fSkeletonPaint);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, fPathPts.size(), fPathPts.data(),
+ fPtsPaint);
+ }
+
+ if (fShowStrokePoints) {
+ drawStrokePoints(canvas, fillPath);
+ }
+
+ if (fShowUI) {
+ drawUI();
+ }
+
+ if (fShowErrorCurve && viz::outerErr != nullptr) {
+ SkPaint firstApproxPaint;
+ firstApproxPaint.setStrokeWidth(4);
+ firstApproxPaint.setStyle(SkPaint::kStroke_Style);
+ firstApproxPaint.setColor(SK_ColorRED);
+ canvas->drawPath(viz::outerFirstApprox, firstApproxPaint);
+ drawErrorCurve(canvas, *viz::outerErr);
+ }
+ }
+
+ Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
+ const SkScalar tol = 4;
+ const SkRect r = SkRect::MakeXYWH(x - tol, y - tol, tol * 2, tol * 2);
+ for (size_t i = 0; i < fPathPts.size(); ++i) {
+ if (r.intersects(SkRect::MakeXYWH(fPathPts[i].fX, fPathPts[i].fY, 1, 1))) {
+ return new Click([this, i](Click* c) {
+ fPathPts[i] = c->fCurr;
+ return true;
+ });
+ }
+ }
+ return nullptr;
+ }
+
+ void drawStrokePoints(SkCanvas* canvas, const SkPath& fillPath) {
+ SkPath::Iter it(fillPath, false);
+ SkPoint points[4];
+ SkPath::Verb verb;
+ std::vector<SkPoint> pointsVec, ctrlPts;
+ while ((verb = it.next(&points[0])) != SkPath::kDone_Verb) {
+ switch (verb) {
+ case SkPath::kLine_Verb:
+ pointsVec.push_back(points[1]);
+ break;
+ case SkPath::kQuad_Verb:
+ ctrlPts.push_back(points[1]);
+ pointsVec.push_back(points[2]);
+ break;
+ case SkPath::kMove_Verb:
+ pointsVec.push_back(points[0]);
+ break;
+ case SkPath::kClose_Verb:
+ break;
+ default:
+ SkDebugf("Unhandled path verb %d for stroke points\n", verb);
+ SkASSERT(false);
+ break;
+ }
+ }
+
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, pointsVec.size(), pointsVec.data(),
+ fStrokePointsPaint);
+ fStrokePointsPaint.setColor(SK_ColorBLUE);
+ fStrokePointsPaint.setStrokeWidth(3);
+ canvas->drawPoints(SkCanvas::kPoints_PointMode, ctrlPts.size(), ctrlPts.data(),
+ fStrokePointsPaint);
+ fStrokePointsPaint.setColor(SK_ColorBLACK);
+ fStrokePointsPaint.setStrokeWidth(5);
+ }
+
+ void drawErrorCurve(SkCanvas* canvas, const ScalarBezCurve& E) {
+ const float winW = fWinSize.width() * 0.75f, winH = fWinSize.height() * 0.25f;
+ const float padding = 25;
+ const SkRect box = SkRect::MakeXYWH(padding, fWinSize.height() - winH - padding,
+ winW - 2 * padding, winH);
+ constexpr int nsegs = 100;
+ constexpr float dt = 1.0f / nsegs;
+ constexpr float dx = 10.0f;
+ const int deg = E.degree();
+ SkPath path;
+ for (int i = 0; i < nsegs; i++) {
+ const float tmin = i * dt, tmax = (i + 1) * dt;
+ ScalarBezCurve left(deg), right(deg);
+ E.split(tmax, &left, &right);
+ const float tRel = tmin / tmax;
+ ScalarBezCurve rl(deg), rr(deg);
+ left.split(tRel, &rl, &rr);
+
+ const float x = i * dx;
+ if (i == 0) {
+ path.moveTo(x, -rr[0]);
+ }
+ path.lineTo(x + dx, -rr[deg]);
+ }
+
+ SkPaint paint;
+ paint.setStyle(SkPaint::kStroke_Style);
+ paint.setAntiAlias(true);
+ paint.setStrokeWidth(0);
+ paint.setColor(SK_ColorRED);
+ const SkRect pathBounds = path.computeTightBounds();
+ constexpr float yAxisMax = 8000;
+ const float sx = box.width() / pathBounds.width();
+ const float sy = box.height() / (2 * yAxisMax);
+ canvas->save();
+ canvas->translate(box.left(), box.top() + box.height() / 2);
+ canvas->scale(sx, sy);
+ canvas->drawPath(path, paint);
+
+ SkPath axes;
+ axes.moveTo(0, 0);
+ axes.lineTo(pathBounds.width(), 0);
+ axes.moveTo(0, -yAxisMax);
+ axes.lineTo(0, yAxisMax);
+ paint.setColor(SK_ColorBLACK);
+ paint.setAntiAlias(false);
+ canvas->drawPath(axes, paint);
+
+ canvas->restore();
+ }
+
+ void drawUI() {
+ static constexpr auto kUIOpacity = 0.35f;
+ static constexpr float kUIWidth = 200.0f, kUIHeight = 400.0f;
+ ImGui::SetNextWindowBgAlpha(kUIOpacity);
+ if (ImGui::Begin("E-C Controls", nullptr,
+ ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoResize |
+ ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
+ ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav)) {
+ const SkRect uiArea = SkRect::MakeXYWH(10, 10, kUIWidth, kUIHeight);
+ ImGui::SetWindowPos(ImVec2(uiArea.x(), uiArea.y()));
+ ImGui::SetWindowSize(ImVec2(uiArea.width(), uiArea.height()));
+
+ const auto drawControls = [](std::vector<DistFncMenuItem>& distFncs,
+ const std::string& menuPfx,
+ const std::string& ptPfx) {
+ std::string degreeMenuLabel = menuPfx + ": ";
+ for (const auto& df : distFncs) {
+ if (df.fSelected) {
+ degreeMenuLabel += df.fName;
+ break;
+ }
+ }
+ if (ImGui::BeginMenu(degreeMenuLabel.c_str())) {
+ for (size_t i = 0; i < distFncs.size(); i++) {
+ if (ImGui::MenuItem(distFncs[i].fName.c_str(), nullptr,
+ distFncs[i].fSelected)) {
+ for (size_t j = 0; j < distFncs.size(); j++) {
+ distFncs[j].fSelected = j == i;
+ }
+ }
+ }
+ ImGui::EndMenu();
+ }
+
+ for (auto& df : distFncs) {
+ if (df.fSelected) {
+ for (int i = 0; i <= df.fDegree; i++) {
+ const std::string label = ptPfx + std::to_string(i);
+ ImGui::SliderFloat(label.c_str(), &(df.fWeights[i]), 0, 1);
+ }
+ }
+ }
+ };
+
+ const std::array<std::pair<std::string, SkVarWidthStroker::LengthMetric>, 2> metrics = {
+ std::make_pair("% path length", SkVarWidthStroker::LengthMetric::kPathLength),
+ std::make_pair("% segment count",
+ SkVarWidthStroker::LengthMetric::kNumSegments),
+ };
+ if (ImGui::BeginMenu("Interpolation metric:")) {
+ for (const auto& metric : metrics) {
+ if (ImGui::MenuItem(metric.first.c_str(), nullptr,
+ fLengthMetric == metric.second)) {
+ fLengthMetric = metric.second;
+ }
+ }
+ ImGui::EndMenu();
+ }
+
+ drawControls(fDistFncs, "Degree", "P");
+
+ if (ImGui::CollapsingHeader("Inner stroke", true)) {
+ fDifferentInnerFunc = true;
+ drawControls(fDistFncsInner, "Degree (inner)", "Q");
+ } else {
+ fDifferentInnerFunc = false;
+ }
+ }
+ ImGui::End();
+ }
+
+ bool fShowHidden, fShowSkeleton, fShowStrokePoints, fShowUI, fDifferentInnerFunc,
+ fShowErrorCurve;
+ float fWidth = 175;
+ SkPaint fPtsPaint, fStrokePaint, fNewFillPaint, fHiddenPaint, fSkeletonPaint,
+ fStrokePointsPaint;
+ inline static constexpr int kNPts = 5;
+ std::array<SkPoint, kNPts> fPathPts;
+ SkSize fWinSize;
+ SkVarWidthStroker::LengthMetric fLengthMetric;
+ const std::vector<DistFncMenuItem> fDefaultsDistFncs = {
+ DistFncMenuItem("Linear", 1, true), DistFncMenuItem("Quadratic", 2, false),
+ DistFncMenuItem("Cubic", 3, false), DistFncMenuItem("One Louder (11)", 11, false),
+ DistFncMenuItem("30?!", 30, false)};
+ std::vector<DistFncMenuItem> fDistFncs = fDefaultsDistFncs;
+ std::vector<DistFncMenuItem> fDistFncsInner = fDefaultsDistFncs;
+
+ using INHERITED = Sample;
+};
+
+DEF_SAMPLE(return new VariableWidthStroker;)
diff --git a/third_party/skia/samplecode/SampleVertices.cpp b/third_party/skia/samplecode/SampleVertices.cpp
index 25afd41..d2c7fea 100644
--- a/third_party/skia/samplecode/SampleVertices.cpp
+++ b/third_party/skia/samplecode/SampleVertices.cpp
@@ -34,7 +34,8 @@
pixels[0] = pixels[2] = color0;
pixels[1] = pixels[3] = color1;
- return bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat);
+ return bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat,
+ SkSamplingOptions(SkFilterMode::kLinear));
}
static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
@@ -73,7 +74,6 @@
void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
paint.setDither(true);
- paint.setFilterQuality(kLow_SkFilterQuality);
for (size_t i = 0; i < SK_ARRAY_COUNT(fRecs); i++) {
auto verts = SkVertices::MakeCopy(fRecs[i].fMode, fRecs[i].fCount,
@@ -204,7 +204,7 @@
Rec fRecs[3];
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleWritePixels.cpp b/third_party/skia/samplecode/SampleWritePixels.cpp
index f6d31e5..eeed376 100644
--- a/third_party/skia/samplecode/SampleWritePixels.cpp
+++ b/third_party/skia/samplecode/SampleWritePixels.cpp
@@ -32,9 +32,9 @@
WritePixelsView() {}
protected:
- virtual SkString name() { return SkString("WritePixels"); }
+ SkString name() override { return SkString("WritePixels"); }
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) override {
SkBitmap bitmap;
create_bitmap(&bitmap);
int x = bitmap.width() / 2;
@@ -50,7 +50,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/third_party/skia/samplecode/SampleXfer.cpp b/third_party/skia/samplecode/SampleXfer.cpp
index ba0a939..68b179e 100644
--- a/third_party/skia/samplecode/SampleXfer.cpp
+++ b/third_party/skia/samplecode/SampleXfer.cpp
@@ -193,9 +193,114 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
+DEF_SAMPLE( return new XferDemo; )
//////////////////////////////////////////////////////////////////////////////
-DEF_SAMPLE( return new XferDemo; )
+#include "tools/Resources.h"
+
+class CubicResamplerDemo : public Sample {
+ struct Rec {
+ sk_sp<SkImage> fImage;
+ SkRect fBounds;
+
+ void draw(SkCanvas* canvas, SkCubicResampler cubic) const {
+ SkRect r = fBounds;
+ SkPaint paint;
+
+ SkMatrix lm = SkMatrix::Translate(r.x(), r.y())
+ * SkMatrix::Scale(10, 10);
+ paint.setShader(fImage->makeShader(SkSamplingOptions(), lm));
+ canvas->drawRect(r, paint);
+
+ r.offset(r.width() + 10, 0);
+ lm.postTranslate(r.width() + 10, 0);
+
+ paint.setShader(fImage->makeShader(SkSamplingOptions(SkFilterMode::kLinear), lm));
+ canvas->drawRect(r, paint);
+
+ r.offset(r.width() + 10, 0);
+ lm.postTranslate(r.width() + 10, 0);
+
+ paint.setShader(fImage->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
+ SkSamplingOptions(cubic), &lm));
+ canvas->drawRect(r, paint);
+ }
+ };
+ std::vector<Rec> fRecs;
+
+public:
+ CubicResamplerDemo() {
+ const char* names[] = {
+ "images/mandrill_128.png",
+ "images/rle.bmp",
+ "images/example_4.png",
+ };
+ SkRect r = {10, 10, 200, 200};
+ for (auto name : names) {
+ fRecs.push_back({GetResourceAsImage(name), r});
+ r.offset(0, r.height() + 10);
+ }
+
+ fDomain.setXYWH(r.fLeft + 3*r.width() + 40, 50, 200, 200);
+ fCubic = {.3f, .5f};
+ }
+
+protected:
+ SkString name() override { return SkString("CubicResampler"); }
+
+ void onDrawContent(SkCanvas* canvas) override {
+ for (const auto& rec : fRecs) {
+ rec.draw(canvas, fCubic);
+ }
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+ paint.setStroke(true);
+ canvas->drawRect(fDomain, paint);
+
+ paint.setColor(SK_ColorRED);
+ paint.setStroke(false);
+ SkPoint loc = SkMatrix::RectToRect({0,0,1,1}, fDomain).mapXY(fCubic.B, fCubic.C);
+ canvas->drawCircle(loc.fX, loc.fY, 8, paint);
+
+ SkString str;
+ str.printf("B=%4.2f C=%4.2f", fCubic.B, fCubic.C);
+ SkFont font;
+ font.setSize(25);
+ font.setEdging(SkFont::Edging::kAntiAlias);
+ paint.setColor(SK_ColorBLACK);
+ canvas->drawSimpleText(str.c_str(), str.size(), SkTextEncoding::kUTF8,
+ fDomain.fLeft + 10, fDomain.fBottom + 40, font, paint);
+ }
+
+ static float pin_unitize(float min, float max, float value) {
+ return (std::min(std::max(value, min), max) - min) / (max - min);
+ }
+ static SkPoint pin_unitize(const SkRect& r, SkPoint p) {
+ return {
+ pin_unitize(r.fLeft, r.fRight, p.fX),
+ pin_unitize(r.fTop, r.fBottom, p.fY),
+ };
+ }
+
+ Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override {
+ if (fDomain.contains(x, y)) {
+ return new Click([this](Click* click) {
+ auto [B, C] = pin_unitize(fDomain, click->fCurr);
+ fCubic = {B, C};
+ return true;
+ });
+ }
+ return nullptr;
+ }
+
+private:
+ SkRect fDomain;
+ SkImage::CubicResampler fCubic;
+
+ using INHERITED = Sample;
+};
+DEF_SAMPLE( return new CubicResamplerDemo; )
diff --git a/third_party/skia/samplecode/SampleXfermodesBlur.cpp b/third_party/skia/samplecode/SampleXfermodesBlur.cpp
index 9ec35dc..bd603d5 100644
--- a/third_party/skia/samplecode/SampleXfermodesBlur.cpp
+++ b/third_party/skia/samplecode/SampleXfermodesBlur.cpp
@@ -25,8 +25,8 @@
#include "src/utils/SkUTF.h"
#include "include/core/SkColorPriv.h"
+#include "include/core/SkMaskFilter.h"
#include "include/core/SkStream.h"
-#include "include/effects/SkBlurMaskFilter.h"
static void setNamedTypeface(SkFont* font, const char name[]) {
font->setTypeface(SkTypeface::MakeFromName(name, SkFontStyle()));
@@ -73,9 +73,9 @@
}
protected:
- virtual SkString name() { return SkString("XfermodesBlur"); }
+ SkString name() override { return SkString("XfermodesBlur"); }
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) override {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
const SkBlendMode gModes[] = {
@@ -98,13 +98,13 @@
const SkScalar h = SkIntToScalar(H);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
- auto s = fBG.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, &m);
+ auto s = fBG.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, SkSamplingOptions(), m);
SkFont font;
font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
setNamedTypeface(&font, "Menlo Regular");
- const int W = 5;
+ const int kWrap = 5;
SkScalar x0 = 0;
for (int twice = 0; twice < 2; twice++) {
@@ -131,7 +131,7 @@
SkTextUtils::DrawString(canvas, label, x + w/2, y - font.getSize()/2, font, SkPaint(),
SkTextUtils::kCenter_Align);
x += w + SkIntToScalar(10);
- if ((i % W) == W - 1) {
+ if ((i % kWrap) == kWrap - 1) {
x = x0;
y += h + SkIntToScalar(30);
}
@@ -141,7 +141,7 @@
}
private:
- typedef Sample INHERITED;
+ using INHERITED = Sample;
};
//////////////////////////////////////////////////////////////////////////////
