drawquadset.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkFont.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkGradientShader.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/core/SkCanvasPriv.h"
#include "src/gpu/ganesh/GrCanvas.h"
#include "src/gpu/ganesh/GrPaint.h"
#include "src/gpu/ganesh/SkGr.h"
#include "src/gpu/ganesh/SurfaceDrawContext.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include <utility>

Go to the source code of this file.

Classes
class	skiagm::DrawQuadSetGM

Namespaces
namespace	skiagm

Typedefs
typedef void(*	TileRenderer) (SkCanvas *)

Functions
static void	draw_text (SkCanvas *canvas, const char *text)
static void	draw_gradient_tiles (SkCanvas *canvas, bool alignGradients)
static void	draw_color_tiles (SkCanvas *canvas, bool multicolor)
static void	draw_tile_boundaries (SkCanvas *canvas, const SkMatrix &local)

Variables
static constexpr SkScalar	kTileWidth = 40
static constexpr SkScalar	kTileHeight = 30
static constexpr int	kRowCount = 4
static constexpr int	kColCount = 3
static TileRenderer	kTileSets []
static const char *	kTileSetNames [] = { "Local", "Aligned", "Green", "Multicolor" }

Typedef Documentation

TileRenderer

typedef void(* TileRenderer) (SkCanvas *)

Definition at line 169 of file drawquadset.cpp.

Function Documentation

draw_color_tiles()

static void draw_color_tiles ( SkCanvas *  canvas, bool  multicolor  )

static

Definition at line 111 of file drawquadset.cpp.

                                                                {
    for (int i = 0; i < kRowCount; ++i) {
        for (int j = 0; j < kColCount; ++j) {
            SkRect tile = SkRect::MakeXYWH(j * kTileWidth, i * kTileHeight, kTileWidth, kTileHeight);
 
            SkColor4f color;
            if (multicolor) {
                color = {(i + 1.f) / kRowCount, (j + 1.f) / kColCount, .4f, 1.f};
            } else {
                color = {.2f, .8f, .3f, 1.f};
            }
 
            unsigned aa = SkCanvas::kNone_QuadAAFlags;
            if (i == 0) {
                aa |= SkCanvas::kTop_QuadAAFlag;
            }
            if (i == kRowCount - 1) {
                aa |= SkCanvas::kBottom_QuadAAFlag;
            }
            if (j == 0) {
                aa |= SkCanvas::kLeft_QuadAAFlag;
            }
            if (j == kColCount - 1) {
                aa |= SkCanvas::kRight_QuadAAFlag;
            }
 
            canvas->experimental_DrawEdgeAAQuad(
                    tile, nullptr, static_cast<SkCanvas::QuadAAFlags>(aa), color.toSkColor(),
                    SkBlendMode::kSrcOver);
        }
    }
}

draw_gradient_tiles()

static void draw_gradient_tiles ( SkCanvas *  canvas, bool  alignGradients  )

static

Definition at line 48 of file drawquadset.cpp.

                                                                       {
    // Always draw the same gradient
    static constexpr SkPoint pts[] = { {0.f, 0.f}, {0.25f * kTileWidth, 0.25f * kTileHeight} };
    static constexpr SkColor colors[] = { SK_ColorBLUE, SK_ColorWHITE };
 
    auto sdc = skgpu::ganesh::TopDeviceSurfaceDrawContext(canvas);
 
    auto rContext = canvas->recordingContext();
 
    auto gradient = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kMirror);
    SkPaint paint;
    paint.setShader(gradient);
 
    for (int i = 0; i < kRowCount; ++i) {
        for (int j = 0; j < kColCount; ++j) {
            SkRect tile = SkRect::MakeWH(kTileWidth, kTileHeight);
            if (alignGradients) {
                tile.offset(j * kTileWidth, i * kTileHeight);
            } else {
                canvas->save();
                canvas->translate(j * kTileWidth, i * kTileHeight);
            }
 
            unsigned aa = SkCanvas::kNone_QuadAAFlags;
            if (i == 0) {
                aa |= SkCanvas::kTop_QuadAAFlag;
            }
            if (i == kRowCount - 1) {
                aa |= SkCanvas::kBottom_QuadAAFlag;
            }
            if (j == 0) {
                aa |= SkCanvas::kLeft_QuadAAFlag;
            }
            if (j == kColCount - 1) {
                aa |= SkCanvas::kRight_QuadAAFlag;
            }
 
            if (sdc) {
                // Use non-public API to leverage general GrPaint capabilities
                const SkMatrix& view = canvas->getTotalMatrix();
                SkSurfaceProps props;
                GrPaint grPaint;
                SkPaintToGrPaint(rContext, sdc->colorInfo(), paint, view, props, &grPaint);
                sdc->fillRectWithEdgeAA(nullptr, std::move(grPaint),
                                        static_cast<GrQuadAAFlags>(aa), view, tile);
            } else {
                // Fallback to solid color on raster backend since the public API only has color
                SkColor color = alignGradients ? SK_ColorBLUE
                                               : (i * kColCount + j) % 2 == 0 ? SK_ColorBLUE
                                                                              : SK_ColorWHITE;
                canvas->experimental_DrawEdgeAAQuad(
                        tile, nullptr, static_cast<SkCanvas::QuadAAFlags>(aa), color,
                        SkBlendMode::kSrcOver);
            }
 
            if (!alignGradients) {
                // Pop off the matrix translation when drawing unaligned
                canvas->restore();
            }
        }
    }
}

draw_text()

static void draw_text ( SkCanvas *  canvas, const char *  text  )

static

Definition at line 43 of file drawquadset.cpp.

                                                          {
    SkFont font(ToolUtils::DefaultPortableTypeface(), 12);
    canvas->drawString(text, 0, 0, font, SkPaint());
}

draw_tile_boundaries()

static void draw_tile_boundaries ( SkCanvas *  canvas, const SkMatrix &  local  )

static

Definition at line 144 of file drawquadset.cpp.

                                                                          {
    // Draw grid of red lines at interior tile boundaries.
    static constexpr SkScalar kLineOutset = 10.f;
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setColor(SK_ColorRED);
    paint.setStyle(SkPaint::kStroke_Style);
    paint.setStrokeWidth(0.f);
    for (int x = 1; x < kColCount; ++x) {
        SkPoint pts[] = {{x * kTileWidth, 0}, {x * kTileWidth, kRowCount * kTileHeight}};
        local.mapPoints(pts, 2);
        SkVector v = pts[1] - pts[0];
        v.setLength(v.length() + kLineOutset);
        canvas->drawLine(pts[1] - v, pts[0] + v, paint);
    }
    for (int y = 1; y < kRowCount; ++y) {
        SkPoint pts[] = {{0, y * kTileHeight}, {kTileWidth * kColCount, y * kTileHeight}};
        local.mapPoints(pts, 2);
        SkVector v = pts[1] - pts[0];
        v.setLength(v.length() + kLineOutset);
        canvas->drawLine(pts[1] - v, pts[0] + v, paint);
    }
}

Variable Documentation

kColCount

constexpr int kColCount = 3

staticconstexpr

Definition at line 41 of file drawquadset.cpp.

kRowCount

constexpr int kRowCount = 4

staticconstexpr

Definition at line 40 of file drawquadset.cpp.

kTileHeight

constexpr SkScalar kTileHeight = 30

staticconstexpr

Definition at line 38 of file drawquadset.cpp.

kTileSetNames

const char* kTileSetNames[] = { "Local", "Aligned", "Green", "Multicolor" }

static

Definition at line 176 of file drawquadset.cpp.

{ "Local", "Aligned", "Green", "Multicolor" };

kTileSets

TileRenderer kTileSets[]

static

Initial value:

= {
    [](SkCanvas* canvas) { draw_gradient_tiles(canvas,  false); },
    [](SkCanvas* canvas) { draw_gradient_tiles(canvas,  true); },
    [](SkCanvas* canvas) { draw_color_tiles(canvas,  false); },
    [](SkCanvas* canvas) { draw_color_tiles(canvas, true); },
}

Definition at line 170 of file drawquadset.cpp.

                                  {
    [](SkCanvas* canvas) { draw_gradient_tiles(canvas, /* aligned */ false); },
    [](SkCanvas* canvas) { draw_gradient_tiles(canvas, /* aligned */ true); },
    [](SkCanvas* canvas) { draw_color_tiles(canvas, /* multicolor */ false); },
    [](SkCanvas* canvas) { draw_color_tiles(canvas, /* multicolor */true); },
};

kTileWidth

constexpr SkScalar kTileWidth = 40

staticconstexpr

Definition at line 37 of file drawquadset.cpp.