/* * 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 "gm.h" #include "SkCanvas.h" #include "SkPath.h" static void test_quadstroke(SkCanvas* canvas) { SkPath path; path.moveTo(6, 0); path.quadTo(150, 150, 0, 6); SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); canvas->translate(20, 20); #if 1 canvas->drawPath(path, paint); canvas->translate(100, 0); #endif paint.setStrokeWidth(1.01f); canvas->drawPath(path, paint); } static void draw_conic(SkCanvas* canvas, SkScalar weight, const SkPaint& paint) { SkPath path; path.moveTo(100, 100); path.conicTo(300, 100, 300, 300, weight); canvas->drawPath(path, paint); } static void test_conic(SkCanvas* canvas) { SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); static const struct { SkScalar fWeight; SkColor fColor; } gRec[] = { { 2 , SK_ColorRED }, { 1 , SK_ColorGREEN }, { 0.5f, SK_ColorBLUE }, }; for (SkScalar width = 0; width <= 20; width += 20) { canvas->save(); paint.setStrokeWidth(width); for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) { paint.setColor(gRec[i].fColor); draw_conic(canvas, gRec[i].fWeight, paint); canvas->translate(-30, 30); } canvas->restore(); canvas->translate(300, 0); } } #include "SkGradientShader.h" static void test_shallow_gradient(SkCanvas* canvas, SkScalar width, SkScalar height) { SkColor colors[] = { 0xFF7F7F7F, 0xFF7F7F7F, 0xFF000000 }; SkScalar pos[] = { 0, 0.35f, SK_Scalar1 }; SkPoint pts[] = { { 0, 0 }, { width, height } }; SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode); SkPaint paint; paint.setShader(s)->unref(); canvas->drawPaint(paint); } #include "SkDashPathEffect.h" static void test_giant_dash(SkCanvas* canvas) { SkPaint paint; const SkScalar intervals[] = { SK_Scalar1, SK_Scalar1 }; paint.setStrokeWidth(2); paint.setPathEffect(new SkDashPathEffect(intervals, 2, 0))->unref(); SkScalar big = 500 * 1000; canvas->drawLine(10, 10, big, 10, paint); canvas->drawLine(-big, 20, 500, 20, paint); canvas->drawLine(-big, 30, big, 30, paint); const SkScalar intervals2[] = { 20, 5, 10, 5 }; paint.setPathEffect(new SkDashPathEffect(intervals2, 4, 17))->unref(); canvas->translate(0, 40); SkScalar x = -500; SkScalar width = 3173; for (int i = 0; i < 40; ++i) { if (i > 10) canvas->drawLine(x, 0, x + width, 0, paint); x += 1; canvas->translate(0, 4); } } // Reproduces bug found here: http://jsfiddle.net/R8Cu5/1/ // #include "SkGradientShader.h" static void test_grad(SkCanvas* canvas) { SkPoint pts[] = { { 478.544067f, -84.2041016f }, { 602.455933f, 625.204102f }, }; SkColor colors[] = { SK_ColorBLACK, SK_ColorBLACK, SK_ColorRED, SK_ColorRED }; SkScalar pos[] = { 0, 0.3f, 0.3f, 1.0f }; SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode); SkPaint p; p.setShader(s)->unref(); canvas->drawPaint(p); } static SkCanvas* MakeCanvas(const SkIRect& bounds) { SkBitmap bm; bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height()); bm.allocPixels(); bm.eraseColor(SK_ColorTRANSPARENT); SkCanvas* canvas = new SkCanvas(bm); canvas->translate(-SkIntToScalar(bounds.fLeft), -SkIntToScalar(bounds.fTop)); return canvas; } #ifdef SK_DEBUG static void GetBitmap(const SkCanvas* canvas, SkBitmap* bm) { *bm = canvas->getDevice()->accessBitmap(false); } #endif static void compare_canvas(const SkCanvas* a, const SkCanvas* b) { #ifdef SK_DEBUG SkBitmap bma, bmb; GetBitmap(a, &bma); GetBitmap(b, &bmb); SkASSERT(bma.width() == bmb.width()); SkASSERT(bma.height() == bmb.height()); bma.lockPixels(); bmb.lockPixels(); for (int y = 0; y < bma.height(); ++y) { const SkPMColor* rowa = bma.getAddr32(0, y); const SkPMColor* rowb = bmb.getAddr32(0, y); SkASSERT(!memcmp(rowa, rowb, bma.width() << 2)); for (int x = 1; x < bma.width() - 1; ++x) { SkASSERT(0xFF000000 == rowa[x]); SkASSERT(0xFF000000 == rowb[x]); } } #endif } static void drawRectAsPath(SkCanvas* canvas, const SkRect& r, const SkPaint& p) { SkPath path; path.addRect(r); canvas->drawPath(path, p); } static void test_maskFromPath(const SkPath& path) { SkIRect bounds; path.getBounds().roundOut(&bounds); SkPaint paint; paint.setAntiAlias(true); SkAutoTUnref path_canvas(MakeCanvas(bounds)); path_canvas->drawPath(path, paint); SkAutoTUnref rect_canvas(MakeCanvas(bounds)); drawRectAsPath(rect_canvas, path.getBounds(), paint); compare_canvas(path_canvas, rect_canvas); } static void test_mask() { for (int i = 1; i <= 20; ++i) { const SkScalar dx = SK_Scalar1 / i; const SkRect constr = SkRect::MakeWH(dx, SkIntToScalar(2)); for (int n = 2; n < 20; ++n) { SkPath path; path.setFillType(SkPath::kEvenOdd_FillType); SkRect r = constr; while (r.fRight < SkIntToScalar(4)) { path.addRect(r); r.offset(dx, 0); } test_maskFromPath(path); } } } /** Draw a 2px border around the target, then red behind the target; set the clip to match the target, then draw >> the target in blue. */ static void draw (SkCanvas* canvas, SkRect& target, int x, int y) { SkPaint borderPaint; borderPaint.setColor(SkColorSetRGB(0x0, 0xDD, 0x0)); borderPaint.setAntiAlias(true); SkPaint backgroundPaint; backgroundPaint.setColor(SkColorSetRGB(0xDD, 0x0, 0x0)); backgroundPaint.setAntiAlias(true); SkPaint foregroundPaint; foregroundPaint.setColor(SkColorSetRGB(0x0, 0x0, 0xDD)); foregroundPaint.setAntiAlias(true); canvas->save(); canvas->translate(SkIntToScalar(x), SkIntToScalar(y)); target.inset(SkIntToScalar(-2), SkIntToScalar(-2)); canvas->drawRect(target, borderPaint); target.inset(SkIntToScalar(2), SkIntToScalar(2)); canvas->drawRect(target, backgroundPaint); canvas->clipRect(target, SkRegion::kIntersect_Op, true); target.inset(SkIntToScalar(-4), SkIntToScalar(-4)); canvas->drawRect(target, foregroundPaint); canvas->restore(); } static void draw_square (SkCanvas* canvas, int x, int y) { SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 10 * SK_Scalar1)); draw(canvas, target, x, y); } static void draw_column (SkCanvas* canvas, int x, int y) { SkRect target (SkRect::MakeWH(1 * SK_Scalar1, 10 * SK_Scalar1)); draw(canvas, target, x, y); } static void draw_bar (SkCanvas* canvas, int x, int y) { SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 1 * SK_Scalar1)); draw(canvas, target, x, y); } static void draw_rect_tests (SkCanvas* canvas) { draw_square(canvas, 10, 10); draw_column(canvas, 30, 10); draw_bar(canvas, 10, 30); } /** Test a set of clipping problems discovered while writing blitAntiRect, and test all the code paths through the clipping blitters. Each region should show as a blue center surrounded by a 2px green border, with no red. */ class AAClipGM : public skiagm::GM { public: AAClipGM() { } protected: virtual SkString onShortName() SK_OVERRIDE { return SkString("aaclip"); } virtual SkISize onISize() SK_OVERRIDE { return SkISize::Make(640, 480); } virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { if (false) { test_quadstroke(canvas); return; } if (false) { test_conic(canvas); return; } if (false) { SkRect bounds; canvas->getClipBounds(&bounds); test_shallow_gradient(canvas, bounds.width(), bounds.height()); return; } if (false) { test_giant_dash(canvas); return; } if (false) { test_grad(canvas); return; } if (false) { // avoid bit rot, suppress warning test_mask(); } // Initial pixel-boundary-aligned draw draw_rect_tests(canvas); // Repeat 4x with .2, .4, .6, .8 px offsets canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); canvas->translate(SkIntToScalar(50), 0); draw_rect_tests(canvas); canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); canvas->translate(SkIntToScalar(50), 0); draw_rect_tests(canvas); canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); canvas->translate(SkIntToScalar(50), 0); draw_rect_tests(canvas); canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); canvas->translate(SkIntToScalar(50), 0); draw_rect_tests(canvas); } virtual uint32_t onGetFlags() const { return kSkipPipe_Flag; } private: typedef skiagm::GM INHERITED; }; DEF_GM( return SkNEW(AAClipGM); )