skiagm::MeshUpdateGM Class Reference

Inheritance diagram for skiagm::MeshUpdateGM:

Public Member Functions
	MeshUpdateGM ()=default
Public Member Functions inherited from skiagm::GM
	GM (SkColor backgroundColor=SK_ColorWHITE)
virtual	~GM ()
void	setMode (Mode mode)
Mode	getMode () const
DrawResult	gpuSetup (SkCanvas *, SkString *errorMsg, GraphiteTestContext *=nullptr)
void	gpuTeardown ()
void	onceBeforeDraw ()
DrawResult	draw (SkCanvas *canvas)
DrawResult	draw (SkCanvas *, SkString *errorMsg)
void	drawBackground (SkCanvas *)
DrawResult	drawContent (SkCanvas *canvas)
DrawResult	drawContent (SkCanvas *, SkString *errorMsg)
virtual SkISize	getISize ()=0
virtual SkString	getName () const =0
virtual bool	runAsBench () const
SkScalar	width ()
SkScalar	height ()
SkColor	getBGColor () const
void	setBGColor (SkColor)
void	drawSizeBounds (SkCanvas *, SkColor)
bool	animate (double)
virtual bool	onChar (SkUnichar)
bool	getControls (SkMetaData *controls)
void	setControls (const SkMetaData &controls)
virtual void	modifyGrContextOptions (GrContextOptions *)
virtual void	modifyGraphiteContextOptions (skgpu::graphite::ContextOptions *) const
virtual bool	isBazelOnly () const
virtual std::map< std::string, std::string >	getGoldKeys () const

Protected Types
using	Attribute = SkMeshSpecification::Attribute
using	Varying = SkMeshSpecification::Varying

Protected Member Functions
SkISize	getISize () override
void	onOnceBeforeDraw () override
SkString	getName () const override
DrawResult	onDraw (SkCanvas *canvas, SkString *error) override
Protected Member Functions inherited from skiagm::GM
virtual DrawResult	onGpuSetup (SkCanvas *, SkString *, GraphiteTestContext *)
virtual void	onGpuTeardown ()
virtual void	onOnceBeforeDraw ()
virtual DrawResult	onDraw (SkCanvas *, SkString *errorMsg)
virtual void	onDraw (SkCanvas *)
virtual bool	onAnimate (double)
virtual bool	onGetControls (SkMetaData *)
virtual void	onSetControls (const SkMetaData &)
GraphiteTestContext *	graphiteTestContext () const

Additional Inherited Members
Public Types inherited from skiagm::GM
enum	Mode { kGM_Mode , kSample_Mode , kBench_Mode }
using	DrawResult = skiagm::DrawResult
using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext
Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

Definition at line 678 of file mesh.cpp.

Member Typedef Documentation

Attribute

using skiagm::MeshUpdateGM::Attribute = SkMeshSpecification::Attribute

protected

Definition at line 683 of file mesh.cpp.

Varying

using skiagm::MeshUpdateGM::Varying = SkMeshSpecification::Varying

protected

Definition at line 684 of file mesh.cpp.

Constructor & Destructor Documentation

MeshUpdateGM()

skiagm::MeshUpdateGM::MeshUpdateGM ( )

default

Member Function Documentation

getISize()

SkISize skiagm::MeshUpdateGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 686 of file mesh.cpp.

{ return {270, 490}; }

getName()

SkString skiagm::MeshUpdateGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 727 of file mesh.cpp.

{ return SkString("mesh_updates"); }

onDraw()

DrawResult skiagm::MeshUpdateGM::onDraw ( SkCanvas *  canvas, SkString *  error  )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 729 of file mesh.cpp.

                                                                  {
        canvas->clear(SK_ColorBLACK);
 
        GrRecordingContext* rc = canvas->recordingContext();
        GrDirectContext* dc = GrAsDirectContext(rc);
        if (rc && !dc) {
            // On GPU this relies on using the DC to update the GPU backed vertex/index buffers.
            return DrawResult::kSkip;
        }
 
        if (dc && dc->abandoned()) {
            return DrawResult::kSkip;
        }
 
        SkPaint paint;
        paint.setShader(fShader);
 
        SkRect r = SkRect::MakeXYWH(10.f, 10.f, 50.f, 50.f);
 
        // We test updating CPU and GPU buffers.
        for (bool gpuBuffer : {false, true}) {
            auto ctx = gpuBuffer ? dc : nullptr;
 
            // How many rects worth of storage is in the vertex buffer?
            static constexpr int kVBRects = 2;
 
            // How many times do we update the vertex buffer? Wraps to start of buffer if
            // > kVBRects.
            static constexpr int kUpdatesRects = 3;
 
            auto vb = make_vertex_buffer(ctx, /*data=*/nullptr, kVBRects * 6 * sizeof(Vertex));
            SkASSERT(vb);
 
            SkRect bounds;
            for (int i = 0; i < kUpdatesRects; ++i) {
                auto p = r.makeOffset(100.f*i, 0.f);
                if (i) {
                    bounds.join(p);
                } else {
                    bounds = p;
                }
 
                SkPoint t[4];
                SkRect::MakeWH(2.f, 2.f).toQuad(t);
                SkMatrix::RotateDeg(90.f*i, {1.f, 1.f}).mapPoints(t, std::size(t));
 
                Vertex vertices[6];
                vertices[0] = {{p.left(), p.top()}, t[0]};
                vertices[1] = {{p.left(), p.bottom()}, t[3]};
                vertices[2] = {{p.right(), p.top()}, t[1]};
                vertices[3] = vertices[2];
                vertices[4] = vertices[1];
                vertices[5] = {{p.right(), p.bottom()}, t[2]};
 
                size_t offset = 6*(i % kVBRects)*sizeof(Vertex);
                SkAssertResult(vb->update(ctx, vertices, offset, 6*sizeof(Vertex)));
                // Make there aren't accidentally deferred reads of the client data.
                std::memset(vertices, 0, sizeof(vertices));
 
                int rectCount = std::min(i + 1, kVBRects);
                auto result = SkMesh::Make(fSpec,
                                           SkMesh::Mode::kTriangles,
                                           vb,
                                           /*vertexCount=*/6 * rectCount,
                                           /*vertexOffset=*/0,
                                           /*uniforms=*/nullptr,
                                           /*children=*/{},
                                           bounds);
 
                if (!result.mesh.isValid()) {
                    SkDebugf("Mesh creation failed: %s\n", result.error.c_str());
                    return DrawResult::kFail;
                }
 
                canvas->drawMesh(result.mesh, SkBlender::Mode(SkBlendMode::kDst), paint);
 
                canvas->translate(0, r.height() + 10);
            }
 
            // Now test updating an IB.
 
            // How many rects worth of storage is in the index buffer?
            static constexpr int kIBRects = 2;
 
            // How many times do we update the index buffer? Wraps to start of buffer if > kIBRects.
            static constexpr int kNumIBUpdates = 3;
 
            // Make the vertex buffer large enough to hold all the rects and populate.
            vb = make_vertex_buffer(ctx, /*data=*/nullptr, kNumIBUpdates * 4 * sizeof(Vertex));
            SkASSERT(vb);
            for (int i = 0; i < kNumIBUpdates; ++i) {
                SkPoint p[4];
                auto rect = r.makeOffset(100*i, 0);
                rect.toQuad(p);
                if (i) {
                    bounds.join(rect);
                } else {
                    bounds = rect;
                }
 
                SkPoint t[4];
                SkRect::MakeWH(2.f, 2.f).toQuad(t);
                SkMatrix::RotateDeg(90.f*i, {1.f, 1.f}).mapPoints(t, std::size(t));
                Vertex vertices[4]{{p[0], t[0]}, {p[1], t[1]}, {p[2], t[2]}, {p[3], t[3]}};
                SkAssertResult(
                        vb->update(ctx, vertices, i*4*sizeof(Vertex), 4*sizeof(Vertex)));
            }
 
            auto ib = make_index_buffer(
                    ctx, /*data=*/nullptr, kIBRects * 6 * sizeof(uint16_t));
            SkASSERT(ib);
            for (int i = 0; i < kNumIBUpdates; ++i) {
                uint16_t indices[6] = {SkToU16(0 + 4*i),
                                       SkToU16(3 + 4*i),
                                       SkToU16(1 + 4*i),
                                       SkToU16(1 + 4*i),
                                       SkToU16(3 + 4*i),
                                       SkToU16(2 + 4*i)};
                size_t offset = 6*(i % kIBRects)*sizeof(uint16_t);
                SkAssertResult(ib->update(ctx, indices, offset, 6*sizeof(uint16_t)));
                std::memset(indices, 0, 6*sizeof(uint16_t));
 
                auto result = SkMesh::MakeIndexed(fSpec,
                                                  SkMesh::Mode::kTriangles,
                                                  vb,
                                                  /*vertexCount=*/4 * kNumIBUpdates,
                                                  /*vertexOffset=*/0,
                                                  ib,
                                                  /*indexCount=*/6,
                                                  /*indexOffset=*/offset,
                                                  /*uniforms=*/nullptr,
                                                  /*children=*/{},
                                                  bounds);
 
                if (!result.mesh.isValid()) {
                    SkDebugf("Mesh creation failed: %s\n", result.error.c_str());
                    return DrawResult::kFail;
                }
 
                canvas->drawMesh(result.mesh, SkBlender::Mode(SkBlendMode::kDst), paint);
            }
            canvas->translate(0, r.height() + 10);
        }
 
        return DrawResult::kOk;
    }

onOnceBeforeDraw()

void skiagm::MeshUpdateGM::onOnceBeforeDraw ( )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 688 of file mesh.cpp.

                                     {
        static const Attribute kAttributes[]{
                {Attribute::Type::kFloat2, 0, SkString{"pos"}},
                {Attribute::Type::kFloat2, 8, SkString{"coords"}},
        };
        static const Varying kVaryings[]{
                {Varying::Type::kFloat2, SkString{"coords"}},
        };
        static constexpr char kVS[] = R"(
                Varyings main(const in Attributes attributes) {
                    Varyings varyings;
                    varyings.coords   = attributes.coords;
                    varyings.position = attributes.pos;
                    return varyings;
                }
        )";
        static constexpr char kFS[] = R"(
                float2 main(const Varyings varyings) { return varyings.coords; }
        )";
        auto [spec, error] = SkMeshSpecification::Make(kAttributes,
                                                       sizeof(Vertex),
                                                       kVaryings,
                                                       SkString(kVS),
                                                       SkString(kFS),
                                                       SkColorSpace::MakeSRGB(),
                                                       kPremul_SkAlphaType);
        if (!spec) {
            SkDebugf("%s\n", error.c_str());
        }
        fSpec = std::move(spec);
 
        uint32_t colors[] = {SK_ColorYELLOW, SK_ColorMAGENTA, SK_ColorCYAN, SK_ColorWHITE};
        SkPixmap pixmap(SkImageInfo::Make({2, 2}, kBGRA_8888_SkColorType, kPremul_SkAlphaType),
                        colors,
                        /*rowBytes=*/8);
        fShader = SkImages::RasterFromPixmapCopy(pixmap)->makeShader(
                SkTileMode::kClamp, SkTileMode::kClamp, SkFilterMode::kLinear);
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/gm/mesh.cpp