vertices.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/SkColorFilter.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRefCnt.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/SkTypes.h"
#include "include/core/SkVertices.h"
#include "include/effects/SkGradientShader.h"
#include "include/effects/SkRuntimeEffect.h"
#include "include/private/base/SkTDArray.h"
#include "src/base/SkRandom.h"
#include "src/core/SkVerticesPriv.h"
#include "src/shaders/SkLocalMatrixShader.h"
#include "src/utils/SkPatchUtils.h"
#include "tools/DecodeUtils.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"
#include <initializer_list>
#include <utility>

Go to the source code of this file.

Classes
class	VerticesGM

Functions
static sk_sp< SkShader >	make_shader1 (SkScalar shaderScale)
static sk_sp< SkShader >	make_shader2 ()
static sk_sp< SkColorFilter >	make_color_filter ()
static void	fill_mesh (SkPoint pts[kMeshVertexCnt], SkPoint texs[kMeshVertexCnt], SkColor colors[kMeshVertexCnt], SkScalar shaderScale)
static void	draw_batching (SkCanvas *canvas)
	DEF_SIMPLE_GM (vertices_batching, canvas, 100, 500)
	DEF_SIMPLE_GM (vertices_perspective, canvas, 256, 256)
	DEF_SIMPLE_GM (skbug_13047, canvas, 200, 200)
	DEF_SIMPLE_GM_BG (vertices_collapsed, canvas, 50, 50, SK_ColorWHITE)

Variables
static constexpr SkScalar	kShaderSize = 40
static constexpr SkScalar	kMeshSize = 30
static constexpr uint16_t	kMeshFan []
static const int	kMeshIndexCnt = (int)std::size(kMeshFan)
static const int	kMeshVertexCnt = 9

Function Documentation

DEF_SIMPLE_GM() [1/3]

DEF_SIMPLE_GM	(	skbug_13047	,
		canvas	,
		200	,
		200
	)

Definition at line 310 of file vertices.cpp.

                                             {
    auto image = ToolUtils::GetResourceAsImage("images/mandrill_128.png");
 
    const float w = image->width();
    const float h = image->height();
 
    SkPoint verts[] = {{0, 0}, {200, 0}, {200, 200}, {0, 200}};
    SkPoint texs[] = {{0, 0}, {w, 0}, {w, h}, {0, h}};
    uint16_t indices[] = {0, 1, 2, 2, 3, 0};
 
    auto v = SkVertices::MakeCopy(
            SkVertices::kTriangles_VertexMode, 4, verts, texs, nullptr, 6, indices);
 
    auto m = SkMatrix::Scale(2, 2);  // ignored in CPU ???
    auto s = image->makeShader(SkSamplingOptions(SkFilterMode::kLinear), &m);
 
    SkPaint p;
    p.setShader(s);
 
    canvas->drawVertices(v, SkBlendMode::kModulate, p);
}

DEF_SIMPLE_GM() [2/3]

DEF_SIMPLE_GM	(	vertices_batching	,
		canvas	,
		100	,
		500
	)

Definition at line 265 of file vertices.cpp.

                                                   {
    draw_batching(canvas);
    canvas->translate(50, 0);
    draw_batching(canvas);
}

DEF_SIMPLE_GM() [3/3]

DEF_SIMPLE_GM	(	vertices_perspective	,
		canvas	,
		256	,
		256
	)

Definition at line 273 of file vertices.cpp.

                                                      {
    SkPaint paint;
    paint.setShader(ToolUtils::create_checkerboard_shader(SK_ColorBLACK, SK_ColorWHITE, 32));
 
    SkRect r = SkRect::MakeWH(128, 128);
 
    SkPoint pos[4];
    r.toQuad(pos);
    auto verts = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, 4, pos, pos, nullptr);
 
    SkMatrix persp;
    persp.setPerspY(SK_Scalar1 / 100);
 
    canvas->save();
    canvas->concat(persp);
    canvas->drawRect(r, paint);
    canvas->restore();
 
    canvas->save();
    canvas->translate(r.width(), 0);
    canvas->concat(persp);
    canvas->drawRect(r, paint);
    canvas->restore();
 
    canvas->save();
    canvas->translate(0, r.height());
    canvas->concat(persp);
    canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
    canvas->restore();
 
    canvas->save();
    canvas->translate(r.width(), r.height());
    canvas->concat(persp);
    canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
    canvas->restore();
}

DEF_SIMPLE_GM_BG()

DEF_SIMPLE_GM_BG	(	vertices_collapsed	,
		canvas	,
		50	,
		50	,
		SK_ColorWHITE
	)

Definition at line 334 of file vertices.cpp.

                                                                    {
    SkPoint verts[] = {{5, 5}, {45, 5}, {45, 45}, {5, 45}};
    SkPoint texs[] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
    uint16_t indices[] = {0, 1, 2, 2, 3, 0};
 
    sk_sp<SkVertices> v = SkVertices::MakeCopy(
            SkVertices::kTriangles_VertexMode, 4, verts, texs, nullptr, 6, indices);
 
    sk_sp<SkSurface> surf = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(1, 1));
    surf->getCanvas()->clear(SK_ColorGREEN);
    sk_sp<SkShader> shader = surf->makeImageSnapshot()->makeShader(SkSamplingOptions{});
    SkPaint paint;
    paint.setShader(shader);
 
    canvas->drawVertices(v, SkBlendMode::kDst, paint);
}

draw_batching()

static void draw_batching ( SkCanvas *  canvas )

static

Definition at line 211 of file vertices.cpp.

                                            {
    // Triangle fans can't batch so we convert to regular triangles,
    static constexpr int kNumTris = kMeshIndexCnt - 2;
    SkVertices::Builder builder(SkVertices::kTriangles_VertexMode, kMeshVertexCnt, 3 * kNumTris,
                                SkVertices::kHasColors_BuilderFlag |
                                SkVertices::kHasTexCoords_BuilderFlag);
 
    SkPoint* pts = builder.positions();
    SkPoint* texs = builder.texCoords();
    SkColor* colors = builder.colors();
    fill_mesh(pts, texs, colors, 1);
 
    SkTDArray<SkMatrix> matrices;
    matrices.append()->reset();
    matrices.append()->setTranslate(0, 40);
    matrices.append()
            ->setRotate(45, kMeshSize / 2, kMeshSize / 2)
            .postScale(1.2f, .8f, kMeshSize / 2, kMeshSize / 2)
            .postTranslate(0, 80);
 
    auto shader = make_shader1(1);
 
    uint16_t* indices = builder.indices();
    for (size_t i = 0; i < kNumTris; ++i) {
        indices[3 * i] = kMeshFan[0];
        indices[3 * i + 1] = kMeshFan[i + 1];
        indices[3 * i + 2] = kMeshFan[i + 2];
 
    }
 
    canvas->save();
    canvas->translate(10, 10);
    for (bool useShader : {false, true}) {
        for (bool useTex : {false, true}) {
            for (const auto& m : matrices) {
                canvas->save();
                canvas->concat(m);
                SkPaint paint;
                paint.setShader(useShader ? shader : nullptr);
                paint.setColor(SK_ColorWHITE);
 
                const SkPoint* t = useTex ? texs : nullptr;
                auto v = SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode, kMeshVertexCnt,
                                              pts, t, colors, kNumTris * 3, indices);
                canvas->drawVertices(v, SkBlendMode::kModulate, paint);
                canvas->restore();
            }
            canvas->translate(0, 120);
        }
    }
    canvas->restore();
}

fill_mesh()

static void fill_mesh ( SkPoint  pts[kMeshVertexCnt], SkPoint  texs[kMeshVertexCnt], SkColor  colors[kMeshVertexCnt], SkScalar  shaderScale  )

static

Definition at line 76 of file vertices.cpp.

                                                                            {
    pts[0].set(0, 0);
    pts[1].set(kMeshSize / 2, 3);
    pts[2].set(kMeshSize, 0);
    pts[3].set(3, kMeshSize / 2);
    pts[4].set(kMeshSize / 2, kMeshSize / 2);
    pts[5].set(kMeshSize - 3, kMeshSize / 2);
    pts[6].set(0, kMeshSize);
    pts[7].set(kMeshSize / 2, kMeshSize - 3);
    pts[8].set(kMeshSize, kMeshSize);
 
    const auto shaderSize = kShaderSize * shaderScale;
    texs[0].set(0, 0);
    texs[1].set(shaderSize / 2, 0);
    texs[2].set(shaderSize, 0);
    texs[3].set(0, shaderSize / 2);
    texs[4].set(shaderSize / 2, shaderSize / 2);
    texs[5].set(shaderSize, shaderSize / 2);
    texs[6].set(0, shaderSize);
    texs[7].set(shaderSize / 2, shaderSize);
    texs[8].set(shaderSize, shaderSize);
 
    SkRandom rand;
    for (size_t i = 0; i < kMeshVertexCnt; ++i) {
        colors[i] = rand.nextU() | 0xFF000000;
    }
}

make_color_filter()

static sk_sp< SkColorFilter > make_color_filter ( )

static

Definition at line 61 of file vertices.cpp.

                                                {
    return SkColorFilters::Blend(0xFFAABBCC, SkBlendMode::kDarken);
}

make_shader1()

static sk_sp< SkShader > make_shader1 ( SkScalar  shaderScale )

static

Definition at line 39 of file vertices.cpp.

                                                          {
    const SkColor colors[] = {
        SK_ColorRED, SK_ColorCYAN, SK_ColorGREEN, SK_ColorWHITE,
        SK_ColorMAGENTA, SK_ColorBLUE, SK_ColorYELLOW,
    };
    const SkPoint pts[] = {{kShaderSize / 4, 0}, {3 * kShaderSize / 4, kShaderSize}};
    const SkMatrix localMatrix = SkMatrix::Scale(shaderScale, shaderScale);
 
    sk_sp<SkShader> grad = SkGradientShader::MakeLinear(pts, colors, nullptr,
                                                        std::size(colors),
                                                        SkTileMode::kMirror, 0,
                                                        &localMatrix);
    // Throw in a couple of local matrix wrappers for good measure.
    return shaderScale == 1 ? grad
                            : grad->makeWithLocalMatrix(SkMatrix::Translate(-10, 0))
                                       ->makeWithLocalMatrix(SkMatrix::Translate(10, 0));
}

make_shader2()

static sk_sp< SkShader > make_shader2 ( )

static

Definition at line 57 of file vertices.cpp.

                                      {
    return SkShaders::Color(SK_ColorBLUE);
}

Variable Documentation

kMeshFan

constexpr uint16_t kMeshFan[]

staticconstexpr

Initial value:

= {
        4,
        0, 1, 2, 5, 8, 7, 6, 3, 0
}

Definition at line 68 of file vertices.cpp.

kMeshIndexCnt

const int kMeshIndexCnt = (int)std::size(kMeshFan)

static

Definition at line 73 of file vertices.cpp.

kMeshSize

constexpr SkScalar kMeshSize = 30

staticconstexpr

Definition at line 65 of file vertices.cpp.

kMeshVertexCnt

const int kMeshVertexCnt = 9

static

Definition at line 74 of file vertices.cpp.

kShaderSize

constexpr SkScalar kShaderSize = 40

staticconstexpr

Definition at line 38 of file vertices.cpp.