26#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
28 float angleStep = 360.0f / n, angle = 0.0f;
30 angle = angleStep/2.0f;
34 angleStep = -angleStep;
37 for (
int i = 0; i < n; ++i) {
116 { -47.55f, -15.45f },
117 { -40.45f, -29.39f },
118 { -29.39f, -40.45f },
119 { -15.45f, -47.55f },
133 { -72.55f, -15.45f },
134 { -65.45f, -29.39f },
135 { -54.39f, -40.45f },
136 { -40.45f, -47.55f },
158 { 19.6157f, 25.f + 3.9018f },
159 { 18.4776f, 25.f + 7.6537f },
160 { 16.6294f, 25.f + 11.1114f },
161 { 14.1421f, 25.f + 14.1421f },
162 { 11.1114f, 25.f + 16.6294f },
163 { 7.6537f, 25.f + 18.4776f },
164 { 3.9018f, 25.f + 19.6157f },
166 { -3.9018f, 25.f + 19.6157f },
167 { -7.6537f, 25.f + 18.4776f },
168 { -11.1114f, 25.f + 16.6294f },
169 { -14.1421f, 25.f + 14.1421f },
170 { -16.6294f, 25.f + 11.1114f },
171 { -18.4776f, 25.f + 7.6537f },
172 { -19.6157f, 25.f + 3.9018f },
200 { 19.6157f,
kBottom - 3.9018f },
201 { 18.4776f,
kBottom - 7.6537f },
202 { 16.6294f,
kBottom - 11.1114f },
203 { 14.1421f,
kBottom - 14.1421f },
204 { 11.1114f,
kBottom - 16.6294f },
205 { 7.6537f,
kBottom - 18.4776f },
206 { 3.9018f,
kBottom - 19.6157f },
208 { -3.9018f,
kBottom - 19.6157f },
209 { -7.6537f,
kBottom - 18.4776f },
210 { -11.1114f,
kBottom - 16.6294f },
211 { -14.1421f,
kBottom - 14.1421f },
212 { -16.6294f,
kBottom - 11.1114f },
213 { -18.4776f,
kBottom - 7.6537f },
214 { -19.6157f,
kBottom - 3.9018f },
288 { -15 + 6.5f, -11.5f },
289 { -15 + 10.6f, -14 },
290 { -15 + 14, -15.2f },
291 { -15 + 17, -15.5f },
292 { -15 + 20, -15.2f },
293 { -15 + 23.4f, -14 },
294 { -15 + 27.5f, -11.5f },
300 { -15 + 27.5f, 11.5f },
306 { -15 + 6.5f, 11.5f },
427 : fConvexOnly(convexOnly) {
434 return SkString(
"convex-polygon-inset");
436 return SkString(
"simple-polygon-offset");
443 std::unique_ptr<
SkPoint[]>* data,
int* numPts) {
447 *data = std::make_unique<SkPoint[]>(*numPts);
449 for (
int i = 0; i < *numPts; ++i) {
453 for (
int i = 0; i < *numPts; ++i) {
461 int numPtsArray[] = { 3, 4, 5, 5, 6, 8, 8, 20, 100 };
464 SkASSERT(arrayIndex < std::size(numPtsArray));
465 *numPts = numPtsArray[arrayIndex];
466 if (arrayIndex == 3 || arrayIndex == 6) {
468 width = kMaxPathHeight / 5;
471 *data = std::make_unique<SkPoint[]>(*numPts);
478 std::unique_ptr<
SkPoint[]>* data,
int* numPts) {
482 *data = std::make_unique<SkPoint[]>(*numPts);
484 for (
int i = 0; i < *numPts; ++i) {
488 for (
int i = 0; i < *numPts; ++i) {
496 int numPtsArray[] = { 5, 7, 8, 20, 100 };
499 arrayIndex = std::min(arrayIndex, std::size(numPtsArray) - 1);
500 SkASSERT(arrayIndex < std::size(numPtsArray));
501 *numPts = numPtsArray[arrayIndex];
503 width = kMaxPathHeight / 5;
505 *data = std::make_unique<SkPoint[]>(*numPts);
515 std::unique_ptr<SkPoint[]> data(
nullptr);
523 bounds.setBounds(data.get(), numPts);
525 bounds.outset(kMaxOutset, kMaxOutset);
527 if (position->
fX + bounds.width() > kGMWidth) {
529 position->
fY += kMaxPathHeight;
532 position->
fX += bounds.width();
536 const float insets[] = { 5, 10, 15, 20, 25, 30, 35, 40 };
537 const float offsets[] = { 2, 5, 9, 14, 20, 27, 35, 44, -2, -5, -9 };
538 const SkColor colors[] = { 0xFF901313, 0xFF8D6214, 0xFF698B14, 0xFF1C8914,
539 0xFF148755, 0xFF146C84, 0xFF142482, 0xFF4A1480,
540 0xFF901313, 0xFF8D6214, 0xFF698B14 };
543 paint.setAntiAlias(
true);
545 paint.setStrokeWidth(1);
547 std::unique_ptr<SkPoint[]> data(
nullptr);
557 path.moveTo(data.get()[0]);
558 for (
int i = 1; i < numPts; ++i) {
559 path.lineTo(data.get()[i]);
569 size_t count = fConvexOnly ? std::size(insets) : std::size(offsets);
570 for (
size_t i = 0; i <
count; ++i) {
579 bounds.setBoundsCheck(data.get(), numPts);
584 path.moveTo(offsetPoly[0]);
585 for (
int j = 1; j < offsetPoly.
size(); ++j) {
586 path.lineTo(offsetPoly[j]);
606 for (
int i = 0; i < kNumPaths; ++i) {
612 inline static constexpr int kNumPaths = 20;
613 inline static constexpr int kMaxPathHeight = 100;
614 inline static constexpr int kMaxOutset = 16;
615 inline static constexpr int kGMWidth = 512;
616 inline static constexpr int kGMHeight = 512;
620 using INHERITED =
GM;
625DEF_GM(
return new PolygonOffsetGM(
true);)
626DEF_GM(
return new PolygonOffsetGM(
false);)
bool SkOffsetSimplePolygon(const SkPoint *inputPolygonVerts, int inputPolygonSize, const SkRect &bounds, SkScalar offset, SkTDArray< SkPoint > *offsetPolygon, SkTDArray< int > *polygonIndices)
bool SkInsetConvexPolygon(const SkPoint *inputPolygonVerts, int inputPolygonSize, SkScalar inset, SkTDArray< SkPoint > *insetPolygon)
#define SkDegreesToRadians(degrees)
#define SkScalarSin(radians)
#define SkScalarCos(radians)
static SkScalar center(float pos0, float pos1)
Type::kYUV Type::kRGBA() int(0.7 *637)
void translate(SkScalar dx, SkScalar dy)
void drawPath(const SkPath &path, const SkPaint &paint)
@ kStroke_Style
set to stroke geometry
void onDraw(SkCanvas *canvas) override
static void GetConvexPolygon(int index, SkPathDirection dir, std::unique_ptr< SkPoint[]> *data, int *numPts)
SkString getName() const override
SkISize getISize() override
void drawPolygon(SkCanvas *canvas, int index, SkPoint *position)
bool runAsBench() const override
static void GetSimplePolygon(int index, SkPathDirection dir, std::unique_ptr< SkPoint[]> *data, int *numPts)
PolygonOffsetGM(bool convexOnly)
static void create_ngon(int n, SkPoint *pts, SkScalar width, SkScalar height)
const size_t gConvexSizes[]
const SkPoint gPoints14[]
const SkPoint gPoints12[]
const SkPoint gPoints16[]
const SkPoint gPoints10[]
const SkPoint * gSimplePoints[]
const SkPoint gPoints13[]
const SkPoint gPoints15[]
const size_t gSimpleSizes[]
const SkPoint * gConvexPoints[]
const SkPoint gPoints18[]
const SkPoint gPoints17[]
const SkPoint gPoints11[]
static void create_ngon(int n, SkPoint *pts, SkScalar w, SkScalar h, SkPathDirection dir)
static constexpr SkISize Make(int32_t w, int32_t h)