#include <SkPictureRecord.h>

Inheritance diagram for SkPictureRecord:

Public Member Functions
	SkPictureRecord (const SkISize &dimensions, uint32_t recordFlags)

	SkPictureRecord (const SkIRect &dimensions, uint32_t recordFlags)

const skia_private::TArray< sk_sp< const SkPicture > > &	getPictures () const

const skia_private::TArray< sk_sp< SkDrawable > > &	getDrawables () const

const skia_private::TArray< sk_sp< const SkTextBlob > > &	getTextBlobs () const

const skia_private::TArray< sk_sp< const sktext::gpu::Slug > > &	getSlugs () const

const skia_private::TArray< sk_sp< const SkVertices > > &	getVertices () const

const skia_private::TArray< sk_sp< const SkImage > > &	getImages () const

sk_sp< SkData >	opData () const

void	setFlags (uint32_t recordFlags)

const SkWriter32 &	writeStream () const

void	beginRecording ()

void	endRecording ()

Public Member Functions inherited from SkCanvas
	SkCanvas ()

	SkCanvas (int width, int height, const SkSurfaceProps *props=nullptr)

	SkCanvas (sk_sp< SkDevice > device)

	SkCanvas (const SkBitmap &bitmap)

	SkCanvas (const SkBitmap &bitmap, const SkSurfaceProps &props)

virtual	~SkCanvas ()

SkImageInfo	imageInfo () const

bool	getProps (SkSurfaceProps *props) const

SkSurfaceProps	getBaseProps () const

SkSurfaceProps	getTopProps () const

virtual SkISize	getBaseLayerSize () const

sk_sp< SkSurface >	makeSurface (const SkImageInfo &info, const SkSurfaceProps *props=nullptr)

virtual GrRecordingContext *	recordingContext () const

virtual skgpu::graphite::Recorder *	recorder () const

SkSurface *	getSurface () const

void *	accessTopLayerPixels (SkImageInfo info, size_t rowBytes, SkIPoint *origin=nullptr)

SkRasterHandleAllocator::Handle	accessTopRasterHandle () const

bool	peekPixels (SkPixmap *pixmap)

bool	readPixels (const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY)

bool	readPixels (const SkPixmap &pixmap, int srcX, int srcY)

bool	readPixels (const SkBitmap &bitmap, int srcX, int srcY)

bool	writePixels (const SkImageInfo &info, const void *pixels, size_t rowBytes, int x, int y)

bool	writePixels (const SkBitmap &bitmap, int x, int y)

int	save ()

int	saveLayer (const SkRect bounds, const SkPaint paint)

int	saveLayer (const SkRect &bounds, const SkPaint *paint)

int	saveLayerAlphaf (const SkRect *bounds, float alpha)

int	saveLayerAlpha (const SkRect *bounds, U8CPU alpha)

int	saveLayer (const SaveLayerRec &layerRec)

void	restore ()

int	getSaveCount () const

void	restoreToCount (int saveCount)

void	translate (SkScalar dx, SkScalar dy)

void	scale (SkScalar sx, SkScalar sy)

void	rotate (SkScalar degrees)

void	rotate (SkScalar degrees, SkScalar px, SkScalar py)

void	skew (SkScalar sx, SkScalar sy)

void	concat (const SkMatrix &matrix)

void	concat (const SkM44 &)

void	setMatrix (const SkM44 &matrix)

void	setMatrix (const SkMatrix &matrix)

void	resetMatrix ()

void	clipRect (const SkRect &rect, SkClipOp op, bool doAntiAlias)

void	clipRect (const SkRect &rect, SkClipOp op)

void	clipRect (const SkRect &rect, bool doAntiAlias=false)

void	clipIRect (const SkIRect &irect, SkClipOp op=SkClipOp::kIntersect)

void	androidFramework_setDeviceClipRestriction (const SkIRect &rect)

void	clipRRect (const SkRRect &rrect, SkClipOp op, bool doAntiAlias)

void	clipRRect (const SkRRect &rrect, SkClipOp op)

void	clipRRect (const SkRRect &rrect, bool doAntiAlias=false)

void	clipPath (const SkPath &path, SkClipOp op, bool doAntiAlias)

void	clipPath (const SkPath &path, SkClipOp op)

void	clipPath (const SkPath &path, bool doAntiAlias=false)

void	clipShader (sk_sp< SkShader >, SkClipOp=SkClipOp::kIntersect)

void	clipRegion (const SkRegion &deviceRgn, SkClipOp op=SkClipOp::kIntersect)

bool	quickReject (const SkRect &rect) const

bool	quickReject (const SkPath &path) const

SkRect	getLocalClipBounds () const

bool	getLocalClipBounds (SkRect *bounds) const

SkIRect	getDeviceClipBounds () const

bool	getDeviceClipBounds (SkIRect *bounds) const

void	drawColor (SkColor color, SkBlendMode mode=SkBlendMode::kSrcOver)

void	drawColor (const SkColor4f &color, SkBlendMode mode=SkBlendMode::kSrcOver)

void	clear (SkColor color)

void	clear (const SkColor4f &color)

void	discard ()

void	drawPaint (const SkPaint &paint)

void	drawPoints (PointMode mode, size_t count, const SkPoint pts[], const SkPaint &paint)

void	drawPoint (SkScalar x, SkScalar y, const SkPaint &paint)

void	drawPoint (SkPoint p, const SkPaint &paint)

void	drawLine (SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint &paint)

void	drawLine (SkPoint p0, SkPoint p1, const SkPaint &paint)

void	drawRect (const SkRect &rect, const SkPaint &paint)

void	drawIRect (const SkIRect &rect, const SkPaint &paint)

void	drawRegion (const SkRegion &region, const SkPaint &paint)

void	drawOval (const SkRect &oval, const SkPaint &paint)

void	drawRRect (const SkRRect &rrect, const SkPaint &paint)

void	drawDRRect (const SkRRect &outer, const SkRRect &inner, const SkPaint &paint)

void	drawCircle (SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint &paint)

void	drawCircle (SkPoint center, SkScalar radius, const SkPaint &paint)

void	drawArc (const SkRect &oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint &paint)

void	drawArc (const SkArc &arc, const SkPaint &paint)

void	drawRoundRect (const SkRect &rect, SkScalar rx, SkScalar ry, const SkPaint &paint)

void	drawPath (const SkPath &path, const SkPaint &paint)

void	drawImage (const SkImage *image, SkScalar left, SkScalar top)

void	drawImage (const sk_sp< SkImage > &image, SkScalar left, SkScalar top)

void	drawImage (const SkImage , SkScalar x, SkScalar y, const SkSamplingOptions &, const SkPaint =nullptr)

void	drawImage (const sk_sp< SkImage > &image, SkScalar x, SkScalar y, const SkSamplingOptions &sampling, const SkPaint *paint=nullptr)

void	drawImageRect (const SkImage , const SkRect &src, const SkRect &dst, const SkSamplingOptions &, const SkPaint , SrcRectConstraint)

void	drawImageRect (const SkImage , const SkRect &dst, const SkSamplingOptions &, const SkPaint =nullptr)

void	drawImageRect (const sk_sp< SkImage > &image, const SkRect &src, const SkRect &dst, const SkSamplingOptions &sampling, const SkPaint *paint, SrcRectConstraint constraint)

void	drawImageRect (const sk_sp< SkImage > &image, const SkRect &dst, const SkSamplingOptions &sampling, const SkPaint *paint=nullptr)

void	drawImageNine (const SkImage image, const SkIRect &center, const SkRect &dst, SkFilterMode filter, const SkPaint paint=nullptr)

void	drawImageLattice (const SkImage image, const Lattice &lattice, const SkRect &dst, SkFilterMode filter, const SkPaint paint=nullptr)

void	drawImageLattice (const SkImage *image, const Lattice &lattice, const SkRect &dst)

void	experimental_DrawEdgeAAQuad (const SkRect &rect, const SkPoint clip[4], QuadAAFlags aaFlags, const SkColor4f &color, SkBlendMode mode)

void	experimental_DrawEdgeAAQuad (const SkRect &rect, const SkPoint clip[4], QuadAAFlags aaFlags, SkColor color, SkBlendMode mode)

void	experimental_DrawEdgeAAImageSet (const ImageSetEntry imageSet[], int cnt, const SkPoint dstClips[], const SkMatrix preViewMatrices[], const SkSamplingOptions &, const SkPaint *paint=nullptr, SrcRectConstraint constraint=kStrict_SrcRectConstraint)

void	drawSimpleText (const void *text, size_t byteLength, SkTextEncoding encoding, SkScalar x, SkScalar y, const SkFont &font, const SkPaint &paint)

void	drawString (const char str[], SkScalar x, SkScalar y, const SkFont &font, const SkPaint &paint)

void	drawString (const SkString &str, SkScalar x, SkScalar y, const SkFont &font, const SkPaint &paint)

void	drawGlyphs (int count, const SkGlyphID glyphs[], const SkPoint positions[], const uint32_t clusters[], int textByteCount, const char utf8text[], SkPoint origin, const SkFont &font, const SkPaint &paint)

void	drawGlyphs (int count, const SkGlyphID glyphs[], const SkPoint positions[], SkPoint origin, const SkFont &font, const SkPaint &paint)

void	drawGlyphs (int count, const SkGlyphID glyphs[], const SkRSXform xforms[], SkPoint origin, const SkFont &font, const SkPaint &paint)

void	drawTextBlob (const SkTextBlob *blob, SkScalar x, SkScalar y, const SkPaint &paint)

void	drawTextBlob (const sk_sp< SkTextBlob > &blob, SkScalar x, SkScalar y, const SkPaint &paint)

void	drawPicture (const SkPicture *picture)

void	drawPicture (const sk_sp< SkPicture > &picture)

void	drawPicture (const SkPicture picture, const SkMatrix matrix, const SkPaint *paint)

void	drawPicture (const sk_sp< SkPicture > &picture, const SkMatrix matrix, const SkPaint paint)

void	drawVertices (const SkVertices *vertices, SkBlendMode mode, const SkPaint &paint)

void	drawVertices (const sk_sp< SkVertices > &vertices, SkBlendMode mode, const SkPaint &paint)

void	drawMesh (const SkMesh &mesh, sk_sp< SkBlender > blender, const SkPaint &paint)

void	drawPatch (const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode mode, const SkPaint &paint)

void	drawAtlas (const SkImage atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkSamplingOptions &sampling, const SkRect cullRect, const SkPaint *paint)

void	drawDrawable (SkDrawable drawable, const SkMatrix matrix=nullptr)

void	drawDrawable (SkDrawable *drawable, SkScalar x, SkScalar y)

void	drawAnnotation (const SkRect &rect, const char key[], SkData *value)

void	drawAnnotation (const SkRect &rect, const char key[], const sk_sp< SkData > &value)

virtual bool	isClipEmpty () const

virtual bool	isClipRect () const

SkM44	getLocalToDevice () const

SkMatrix	getLocalToDeviceAs3x3 () const

SkMatrix	getTotalMatrix () const

void	temporary_internal_getRgnClip (SkRegion *region)

void	private_draw_shadow_rec (const SkPath &, const SkDrawShadowRec &)

Protected Member Functions
void	addNoOp ()

void	validate (size_t initialOffset, size_t size) const

sk_sp< SkSurface >	onNewSurface (const SkImageInfo &, const SkSurfaceProps &) override

bool	onPeekPixels (SkPixmap *) override

void	willSave () override

SaveLayerStrategy	getSaveLayerStrategy (const SaveLayerRec &) override

bool	onDoSaveBehind (const SkRect *) override

void	willRestore () override

void	didConcat44 (const SkM44 &) override

void	didSetM44 (const SkM44 &) override

void	didScale (SkScalar, SkScalar) override

void	didTranslate (SkScalar, SkScalar) override

void	onDrawDRRect (const SkRRect &, const SkRRect &, const SkPaint &) override

void	onDrawTextBlob (const SkTextBlob *blob, SkScalar x, SkScalar y, const SkPaint &paint) override

void	onDrawSlug (const sktext::gpu::Slug *slug, const SkPaint &paint) override

void	onDrawPatch (const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode, const SkPaint &paint) override

void	onDrawPaint (const SkPaint &) override

void	onDrawBehind (const SkPaint &) override

void	onDrawPoints (PointMode, size_t count, const SkPoint pts[], const SkPaint &) override

void	onDrawRect (const SkRect &, const SkPaint &) override

void	onDrawRegion (const SkRegion &, const SkPaint &) override

void	onDrawOval (const SkRect &, const SkPaint &) override

void	onDrawArc (const SkRect &, SkScalar, SkScalar, bool, const SkPaint &) override

void	onDrawRRect (const SkRRect &, const SkPaint &) override

void	onDrawPath (const SkPath &, const SkPaint &) override

void	onDrawImage2 (const SkImage , SkScalar, SkScalar, const SkSamplingOptions &, const SkPaint ) override

void	onDrawImageRect2 (const SkImage , const SkRect &, const SkRect &, const SkSamplingOptions &, const SkPaint , SrcRectConstraint) override

void	onDrawImageLattice2 (const SkImage , const Lattice &, const SkRect &, SkFilterMode, const SkPaint ) override

void	onDrawAtlas2 (const SkImage , const SkRSXform[], const SkRect[], const SkColor[], int, SkBlendMode, const SkSamplingOptions &, const SkRect , const SkPaint *) override

void	onDrawShadowRec (const SkPath &, const SkDrawShadowRec &) override

void	onDrawVerticesObject (const SkVertices *, SkBlendMode, const SkPaint &) override

void	onClipRect (const SkRect &, SkClipOp, ClipEdgeStyle) override

void	onClipRRect (const SkRRect &, SkClipOp, ClipEdgeStyle) override

void	onClipPath (const SkPath &, SkClipOp, ClipEdgeStyle) override

void	onClipShader (sk_sp< SkShader >, SkClipOp) override

void	onClipRegion (const SkRegion &, SkClipOp) override

void	onResetClip () override

void	onDrawPicture (const SkPicture , const SkMatrix , const SkPaint *) override

void	onDrawDrawable (SkDrawable , const SkMatrix ) override

void	onDrawAnnotation (const SkRect &, const char[], SkData *) override

void	onDrawEdgeAAQuad (const SkRect &, const SkPoint[4], QuadAAFlags, const SkColor4f &, SkBlendMode) override

void	onDrawEdgeAAImageSet2 (const ImageSetEntry[], int count, const SkPoint[], const SkMatrix[], const SkSamplingOptions &, const SkPaint *, SrcRectConstraint) override

int	addPathToHeap (const SkPath &path)

void	recordConcat (const SkMatrix &matrix)

void	recordTranslate (const SkMatrix &matrix)

void	recordScale (const SkMatrix &matrix)

size_t	recordClipRect (const SkRect &rect, SkClipOp op, bool doAA)

size_t	recordClipRRect (const SkRRect &rrect, SkClipOp op, bool doAA)

size_t	recordClipPath (int pathID, SkClipOp op, bool doAA)

size_t	recordClipRegion (const SkRegion &region, SkClipOp op)

void	recordSave ()

void	recordSaveLayer (const SaveLayerRec &)

void	recordRestore (bool fillInSkips=true)

Protected Member Functions inherited from SkCanvasVirtualEnforcer< SkCanvas >
void	onDrawPaint (const SkPaint &paint) override=0

void	onDrawBehind (const SkPaint &) override

void	onDrawRect (const SkRect &rect, const SkPaint &paint) override=0

void	onDrawRRect (const SkRRect &rrect, const SkPaint &paint) override=0

void	onDrawDRRect (const SkRRect &outer, const SkRRect &inner, const SkPaint &paint) override=0

void	onDrawOval (const SkRect &rect, const SkPaint &paint) override=0

void	onDrawArc (const SkRect &rect, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint &paint) override=0

void	onDrawPath (const SkPath &path, const SkPaint &paint) override=0

void	onDrawRegion (const SkRegion &region, const SkPaint &paint) override=0

void	onDrawTextBlob (const SkTextBlob *blob, SkScalar x, SkScalar y, const SkPaint &paint) override=0

void	onDrawPatch (const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode mode, const SkPaint &paint) override=0

void	onDrawPoints (SkCanvas::PointMode mode, size_t count, const SkPoint pts[], const SkPaint &paint) override=0

void	onDrawEdgeAAQuad (const SkRect &rect, const SkPoint clip[4], SkCanvas::QuadAAFlags aaFlags, const SkColor4f &color, SkBlendMode mode) override=0

void	onDrawAnnotation (const SkRect &rect, const char key[], SkData *value) override=0

void	onDrawShadowRec (const SkPath &, const SkDrawShadowRec &) override=0

void	onDrawDrawable (SkDrawable drawable, const SkMatrix matrix) override=0

void	onDrawPicture (const SkPicture picture, const SkMatrix matrix, const SkPaint *paint) override=0

Protected Member Functions inherited from SkCanvas
virtual sk_sp< SkSurface >	onNewSurface (const SkImageInfo &info, const SkSurfaceProps &props)

virtual bool	onPeekPixels (SkPixmap *pixmap)

virtual bool	onAccessTopLayerPixels (SkPixmap *pixmap)

virtual SkImageInfo	onImageInfo () const

virtual bool	onGetProps (SkSurfaceProps *props, bool top) const

virtual void	willSave ()

virtual SaveLayerStrategy	getSaveLayerStrategy (const SaveLayerRec &)

virtual bool	onDoSaveBehind (const SkRect *)

virtual void	willRestore ()

virtual void	didRestore ()

virtual void	didConcat44 (const SkM44 &)

virtual void	didSetM44 (const SkM44 &)

virtual void	didTranslate (SkScalar, SkScalar)

virtual void	didScale (SkScalar, SkScalar)

virtual void	onDrawPaint (const SkPaint &paint)

virtual void	onDrawBehind (const SkPaint &paint)

virtual void	onDrawRect (const SkRect &rect, const SkPaint &paint)

virtual void	onDrawRRect (const SkRRect &rrect, const SkPaint &paint)

virtual void	onDrawDRRect (const SkRRect &outer, const SkRRect &inner, const SkPaint &paint)

virtual void	onDrawOval (const SkRect &rect, const SkPaint &paint)

virtual void	onDrawArc (const SkRect &rect, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint &paint)

virtual void	onDrawPath (const SkPath &path, const SkPaint &paint)

virtual void	onDrawRegion (const SkRegion &region, const SkPaint &paint)

virtual void	onDrawTextBlob (const SkTextBlob *blob, SkScalar x, SkScalar y, const SkPaint &paint)

virtual void	onDrawGlyphRunList (const sktext::GlyphRunList &glyphRunList, const SkPaint &paint)

virtual void	onDrawPatch (const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode mode, const SkPaint &paint)

virtual void	onDrawPoints (PointMode mode, size_t count, const SkPoint pts[], const SkPaint &paint)

virtual void	onDrawImage2 (const SkImage , SkScalar dx, SkScalar dy, const SkSamplingOptions &, const SkPaint )

virtual void	onDrawImageRect2 (const SkImage , const SkRect &src, const SkRect &dst, const SkSamplingOptions &, const SkPaint , SrcRectConstraint)

virtual void	onDrawImageLattice2 (const SkImage , const Lattice &, const SkRect &dst, SkFilterMode, const SkPaint )

virtual void	onDrawAtlas2 (const SkImage , const SkRSXform[], const SkRect src[], const SkColor[], int count, SkBlendMode, const SkSamplingOptions &, const SkRect cull, const SkPaint *)

virtual void	onDrawEdgeAAImageSet2 (const ImageSetEntry imageSet[], int count, const SkPoint dstClips[], const SkMatrix preViewMatrices[], const SkSamplingOptions &, const SkPaint *, SrcRectConstraint)

virtual void	onDrawVerticesObject (const SkVertices *vertices, SkBlendMode mode, const SkPaint &paint)

virtual void	onDrawMesh (const SkMesh &, sk_sp< SkBlender >, const SkPaint &)

virtual void	onDrawAnnotation (const SkRect &rect, const char key[], SkData *value)

virtual void	onDrawShadowRec (const SkPath &, const SkDrawShadowRec &)

virtual void	onDrawDrawable (SkDrawable drawable, const SkMatrix matrix)

virtual void	onDrawPicture (const SkPicture picture, const SkMatrix matrix, const SkPaint *paint)

virtual void	onDrawEdgeAAQuad (const SkRect &rect, const SkPoint clip[4], QuadAAFlags aaFlags, const SkColor4f &color, SkBlendMode mode)

virtual void	onClipRect (const SkRect &rect, SkClipOp op, ClipEdgeStyle edgeStyle)

virtual void	onClipRRect (const SkRRect &rrect, SkClipOp op, ClipEdgeStyle edgeStyle)

virtual void	onClipPath (const SkPath &path, SkClipOp op, ClipEdgeStyle edgeStyle)

virtual void	onClipShader (sk_sp< SkShader >, SkClipOp)

virtual void	onClipRegion (const SkRegion &deviceRgn, SkClipOp op)

virtual void	onResetClip ()

virtual void	onDiscard ()

virtual sk_sp< sktext::gpu::Slug >	onConvertGlyphRunListToSlug (const sktext::GlyphRunList &glyphRunList, const SkPaint &paint)

virtual void	onDrawSlug (const sktext::gpu::Slug *slug, const SkPaint &paint)

	SkCanvas (const SkIRect &bounds)

Friends
class	SkPictureData

Additional Inherited Members
Public Types inherited from SkCanvas
enum	SaveLayerFlagsSet { kPreserveLCDText_SaveLayerFlag = 1 << 1 , kInitWithPrevious_SaveLayerFlag = 1 << 2 , kF16ColorType = 1 << 4 }

enum	PointMode { kPoints_PointMode , kLines_PointMode , kPolygon_PointMode }

enum	SrcRectConstraint { kStrict_SrcRectConstraint , kFast_SrcRectConstraint }

enum	QuadAAFlags : unsigned { kLeft_QuadAAFlag = 0b0001 , kTop_QuadAAFlag = 0b0010 , kRight_QuadAAFlag = 0b0100 , kBottom_QuadAAFlag = 0b1000 , kNone_QuadAAFlags = 0b0000 , kAll_QuadAAFlags = 0b1111 }

using	SaveLayerFlags = uint32_t

using	FilterSpan = SkSpan< sk_sp< SkImageFilter > >

Static Public Member Functions inherited from SkCanvas
static std::unique_ptr< SkCanvas >	MakeRasterDirect (const SkImageInfo &info, void pixels, size_t rowBytes, const SkSurfaceProps props=nullptr)

static std::unique_ptr< SkCanvas >	MakeRasterDirectN32 (int width, int height, SkPMColor *pixels, size_t rowBytes)

Static Public Attributes inherited from SkCanvas
static constexpr int	kMaxFiltersPerLayer = 16

Protected Types inherited from SkCanvas
enum	SaveLayerStrategy { kFullLayer_SaveLayerStrategy , kNoLayer_SaveLayerStrategy }

enum	ClipEdgeStyle { kHard_ClipEdgeStyle , kSoft_ClipEdgeStyle }

Detailed Description

Definition at line 67 of file SkPictureRecord.h.

Constructor & Destructor Documentation

◆ SkPictureRecord() [1/2]

SkPictureRecord::SkPictureRecord	(	const SkISize &	dimensions,
		uint32_t	recordFlags
	)

Definition at line 55 of file SkPictureRecord.cpp.

56 : SkPictureRecord(SkIRect::MakeSize(dimensions), flags) {}

SkCanvas::SkPictureRecord

friend class SkPictureRecord

Definition: SkCanvas.h:2493

flags

FlutterSemanticsFlag flags

Definition: fl_accessible_node.cc:106

SkIRect::MakeSize

static constexpr SkIRect MakeSize(const SkISize &size)

Definition: SkRect.h:66

◆ SkPictureRecord() [2/2]

SkPictureRecord::SkPictureRecord	(	const SkIRect &	dimensions,
		uint32_t	recordFlags
	)

Definition at line 49 of file SkPictureRecord.cpp.

    : SkCanvasVirtualEnforcer<SkCanvas>(dimensions)
    , fRecordFlags(flags)
    , fInitialSaveCount(kNoInitialSave) {
}

Member Function Documentation

◆ addNoOp()

void SkPictureRecord::addNoOp ( )

protected

Definition at line 910 of file SkPictureRecord.cpp.

                              {
    size_t size = kUInt32Size; // op
    this->addDraw(NOOP, &size);
}

◆ addPathToHeap()

int SkPictureRecord::addPathToHeap ( const SkPath & path )

protected

Definition at line 875 of file SkPictureRecord.cpp.

                                                     {
    if (int* n = fPaths.find(path)) {
        return *n;
    }
    int n = fPaths.count() + 1;  // 0 is reserved for null / error.
    fPaths.set(path, n);
    return n;
}

◆ beginRecording()

void SkPictureRecord::beginRecording ( )

Definition at line 296 of file SkPictureRecord.cpp.

                                     {
    // we have to call this *after* our constructor, to ensure that it gets
    // recorded. This is balanced by restoreToCount() call from endRecording,
    // which in-turn calls our overridden restore(), so those get recorded too.
    fInitialSaveCount = this->save();
}

◆ didConcat44()

void SkPictureRecord::didConcat44 ( const SkM44 & m )

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 239 of file SkPictureRecord.cpp.

                                                {
    this->validate(fWriter.bytesWritten(), 0);
    // op + matrix
    size_t size = kUInt32Size + 16 * sizeof(SkScalar);
    size_t initialOffset = this->addDraw(CONCAT44, &size);
    fWriter.write(SkMatrixPriv::M44ColMajor(m), 16 * sizeof(SkScalar));
    this->validate(initialOffset, size);
 
    this->SkCanvasVirtualEnforcer<SkCanvas>::didConcat44(m);
}

◆ didScale()

void SkPictureRecord::didScale	(	SkScalar	x,
		SkScalar	y
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 260 of file SkPictureRecord.cpp.

                                                     {
    this->didConcat44(SkM44::Scale(x, y));
}

◆ didSetM44()

void SkPictureRecord::didSetM44 ( const SkM44 & m )

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 250 of file SkPictureRecord.cpp.

                                              {
    this->validate(fWriter.bytesWritten(), 0);
    // op + matrix
    size_t size = kUInt32Size + 16 * sizeof(SkScalar);
    size_t initialOffset = this->addDraw(SET_M44, &size);
    fWriter.write(SkMatrixPriv::M44ColMajor(m), 16 * sizeof(SkScalar));
    this->validate(initialOffset, size);
    this->SkCanvasVirtualEnforcer<SkCanvas>::didSetM44(m);
}

◆ didTranslate()

void SkPictureRecord::didTranslate	(	SkScalar	x,
		SkScalar	y
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 264 of file SkPictureRecord.cpp.

                                                         {
    this->didConcat44(SkM44::Translate(x, y));
}

◆ endRecording()

void SkPictureRecord::endRecording ( )

Definition at line 303 of file SkPictureRecord.cpp.

                                   {
    SkASSERT(kNoInitialSave != fInitialSaveCount);
    this->restoreToCount(fInitialSaveCount);
}

◆ getDrawables()

const skia_private::TArray< sk_sp< SkDrawable > > & SkPictureRecord::getDrawables ( ) const

inline

Definition at line 77 of file SkPictureRecord.h.

                                                                      {
        return fDrawables;
    }

◆ getImages()

const skia_private::TArray< sk_sp< const SkImage > > & SkPictureRecord::getImages ( ) const

inline

Definition at line 93 of file SkPictureRecord.h.

                                                                      {
        return fImages;
    }

◆ getPictures()

const skia_private::TArray< sk_sp< const SkPicture > > & SkPictureRecord::getPictures ( ) const

inline

Definition at line 73 of file SkPictureRecord.h.

                                                                          {
        return fPictures;
    }

◆ getSaveLayerStrategy()

SkCanvas::SaveLayerStrategy SkPictureRecord::getSaveLayerStrategy ( const SaveLayerRec & rec )

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 75 of file SkPictureRecord.cpp.

                                                                                       {
    // record the offset to us, making it non-positive to distinguish a save
    // from a clip entry.
    fRestoreOffsetStack.push_back(-(int32_t)fWriter.bytesWritten());
    this->recordSaveLayer(rec);
 
    (void)this->SkCanvasVirtualEnforcer<SkCanvas>::getSaveLayerStrategy(rec);
    /*  No need for a (potentially very big) layer which we don't actually need
        at this time (and may not be able to afford since during record our
        clip starts out the size of the picture, which is often much larger
        than the size of the actual device we'll use during playback).
     */
    return kNoLayer_SaveLayerStrategy;
}

◆ getSlugs()

const skia_private::TArray< sk_sp< const sktext::gpu::Slug > > & SkPictureRecord::getSlugs ( ) const

inline

Definition at line 85 of file SkPictureRecord.h.

                                                                           {
        return fSlugs;
    }

◆ getTextBlobs()

const skia_private::TArray< sk_sp< const SkTextBlob > > & SkPictureRecord::getTextBlobs ( ) const

inline

Definition at line 81 of file SkPictureRecord.h.

                                                                            {
        return fTextBlobs;
    }

◆ getVertices()

const skia_private::TArray< sk_sp< const SkVertices > > & SkPictureRecord::getVertices ( ) const

inline

Definition at line 89 of file SkPictureRecord.h.

                                                                           {
        return fVertices;
    }

◆ onClipPath()

void SkPictureRecord::onClipPath	(	const SkPath &	path,
		SkClipOp	op,
		ClipEdgeStyle	edgeStyle
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 369 of file SkPictureRecord.cpp.

                                                                                         {
    int pathID = this->addPathToHeap(path);
    this->recordClipPath(pathID, op, kSoft_ClipEdgeStyle == edgeStyle);
    this->SkCanvasVirtualEnforcer<SkCanvas>::onClipPath(path, op, edgeStyle);
}

◆ onClipRect()

void SkPictureRecord::onClipRect	(	const SkRect &	rect,
		SkClipOp	op,
		ClipEdgeStyle	edgeStyle
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 326 of file SkPictureRecord.cpp.

                                                                                         {
    this->recordClipRect(rect, op, kSoft_ClipEdgeStyle == edgeStyle);
    this->SkCanvasVirtualEnforcer<SkCanvas>::onClipRect(rect, op, edgeStyle);
}

◆ onClipRegion()

void SkPictureRecord::onClipRegion	(	const SkRegion &	region,
		SkClipOp	op
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 407 of file SkPictureRecord.cpp.

                                                                      {
    this->recordClipRegion(region, op);
    this->SkCanvasVirtualEnforcer<SkCanvas>::onClipRegion(region, op);
}

◆ onClipRRect()

void SkPictureRecord::onClipRRect	(	const SkRRect &	rrect,
		SkClipOp	op,
		ClipEdgeStyle	edgeStyle
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 348 of file SkPictureRecord.cpp.

                                                                                            {
    this->recordClipRRect(rrect, op, kSoft_ClipEdgeStyle == edgeStyle);
    this->SkCanvasVirtualEnforcer<SkCanvas>::onClipRRect(rrect, op, edgeStyle);
}

◆ onClipShader()

void SkPictureRecord::onClipShader	(	sk_sp< SkShader >	cs,
		SkClipOp	op
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 391 of file SkPictureRecord.cpp.

                                                                  {
    // Overkill to store a whole paint, but we don't have an existing structure to just store
    // shaders. If size becomes an issue in the future, we can optimize this.
    SkPaint paint;
    paint.setShader(cs);
 
    // op + paint index + clipop
    size_t size = 3 * kUInt32Size;
    size_t initialOffset = this->addDraw(CLIP_SHADER_IN_PAINT, &size);
    this->addPaint(paint);
    this->addInt((int)op);
    this->validate(initialOffset, size);
 
    this->SkCanvasVirtualEnforcer<SkCanvas>::onClipShader(std::move(cs), op);
}

◆ onDoSaveBehind()

bool SkPictureRecord::onDoSaveBehind ( const SkRect * subset )

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 90 of file SkPictureRecord.cpp.

                                                         {
    fRestoreOffsetStack.push_back(-(int32_t)fWriter.bytesWritten());
 
    size_t size = sizeof(kUInt32Size) + sizeof(uint32_t); // op + flags
    uint32_t flags = 0;
    if (subset) {
        flags |= SAVEBEHIND_HAS_SUBSET;
        size += sizeof(*subset);
    }
 
    size_t initialOffset = this->addDraw(SAVE_BEHIND, &size);
    this->addInt(flags);
    if (subset) {
        this->addRect(*subset);
    }
 
    this->validate(initialOffset, size);
    return false;
}

◆ onDrawAnnotation()

void SkPictureRecord::onDrawAnnotation	(	const SkRect &	rect,
		const char	key[],
		SkData *	value
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 757 of file SkPictureRecord.cpp.

                                                                                          {
    size_t keyLen = SkWriter32::WriteStringSize(key);
    size_t valueLen = SkWriter32::WriteDataSize(value);
    size_t size = 4 + sizeof(SkRect) + keyLen + valueLen;
 
    size_t initialOffset = this->addDraw(DRAW_ANNOTATION, &size);
    this->addRect(rect);
    fWriter.writeString(key);
    fWriter.writeData(value);
    this->validate(initialOffset, size);
}

◆ onDrawArc()

void SkPictureRecord::onDrawArc	(	const SkRect &	oval,
		SkScalar	startAngle,
		SkScalar	sweepAngle,
		bool	useCenter,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 481 of file SkPictureRecord.cpp.

                                                                      {
    // op + paint index + rect + start + sweep + bool (as int)
    size_t size = 2 * kUInt32Size + sizeof(oval) + sizeof(startAngle) + sizeof(sweepAngle) +
                  sizeof(int);
    size_t initialOffset = this->addDraw(DRAW_ARC, &size);
    this->addPaint(paint);
    this->addRect(oval);
    this->addScalar(startAngle);
    this->addScalar(sweepAngle);
    this->addInt(useCenter);
    this->validate(initialOffset, size);
}

◆ onDrawAtlas2()

void SkPictureRecord::onDrawAtlas2	(	const SkImage *	atlas,
		const SkRSXform	xform[],
		const SkRect	tex[],
		const SkColor	colors[],
		int	count,
		SkBlendMode	mode,
		const SkSamplingOptions &	sampling,
		const SkRect *	cull,
		const SkPaint *	paint
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 701 of file SkPictureRecord.cpp.

                                                         {
    // [op + paint-index + atlas-index + flags + count] + [xform] + [tex] + [*colors + mode] + cull
    size_t size = 5 * kUInt32Size + count * sizeof(SkRSXform) + count * sizeof(SkRect);
    size += SkSamplingPriv::FlatSize(sampling);
    uint32_t flags = 0;
    if (colors) {
        flags |= DRAW_ATLAS_HAS_COLORS;
        size += count * sizeof(SkColor);
        size += sizeof(uint32_t);   // xfermode::mode
    }
    if (cull) {
        flags |= DRAW_ATLAS_HAS_CULL;
        size += sizeof(SkRect);
    }
    flags |= DRAW_ATLAS_HAS_SAMPLING;
 
    size_t initialOffset = this->addDraw(DRAW_ATLAS, &size);
    this->addPaintPtr(paint);
    this->addImage(atlas);
    this->addInt(flags);
    this->addInt(count);
    fWriter.write(xform, count * sizeof(SkRSXform));
    fWriter.write(tex, count * sizeof(SkRect));
 
    // write optional parameters
    if (colors) {
        fWriter.write(colors, count * sizeof(SkColor));
        this->addInt((int)mode);
    }
    if (cull) {
        fWriter.write(cull, sizeof(SkRect));
    }
    this->addSampling(sampling);
    this->validate(initialOffset, size);
}

◆ onDrawBehind()

void SkPictureRecord::onDrawBehind ( const SkPaint & paint )

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 450 of file SkPictureRecord.cpp.

                                                       {
    // logically the same as drawPaint, but with a diff enum
    // op + paint index
    size_t size = 2 * kUInt32Size;
    size_t initialOffset = this->addDraw(DRAW_BEHIND_PAINT, &size);
    this->addPaint(paint);
    this->validate(initialOffset, size);
}

◆ onDrawDrawable()

void SkPictureRecord::onDrawDrawable	(	SkDrawable *	drawable,
		const SkMatrix *	matrix
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 633 of file SkPictureRecord.cpp.

                                                                                 {
    // op + drawable index
    size_t size = 2 * kUInt32Size;
    size_t initialOffset;
 
    if (nullptr == matrix) {
        initialOffset = this->addDraw(DRAW_DRAWABLE, &size);
        this->addDrawable(drawable);
    } else {
        size += SkMatrixPriv::WriteToMemory(*matrix, nullptr);    // matrix
        initialOffset = this->addDraw(DRAW_DRAWABLE_MATRIX, &size);
        this->addMatrix(*matrix);
        this->addDrawable(drawable);
    }
    this->validate(initialOffset, size);
}

◆ onDrawDRRect()

void SkPictureRecord::onDrawDRRect	(	const SkRRect &	outer,
		const SkRRect &	inner,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 523 of file SkPictureRecord.cpp.

                                                         {
    // op + paint index + rrects
    size_t size = 2 * kUInt32Size + SkRRect::kSizeInMemory * 2;
    size_t initialOffset = this->addDraw(DRAW_DRRECT, &size);
    this->addPaint(paint);
    this->addRRect(outer);
    this->addRRect(inner);
    this->validate(initialOffset, size);
}

◆ onDrawEdgeAAImageSet2()

void SkPictureRecord::onDrawEdgeAAImageSet2	(	const	ImageSetEntry[],
		int	count,
		const SkPoint	dstClips[],
		const SkMatrix	preViewMatrices[],
		const SkSamplingOptions &	sampling,
		const SkPaint *	paint,
		SkCanvas::SrcRectConstraint	constraint
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 788 of file SkPictureRecord.cpp.

                                                                                  {
    static constexpr size_t kMatrixSize = 9 * sizeof(SkScalar); // *not* sizeof(SkMatrix)
    // op + count + paint + constraint + (image index, src rect, dst rect, alpha, aa flags,
    // hasClip(int), matrixIndex) * cnt + totalClipCount + dstClips + totalMatrixCount + matrices
    int totalDstClipCount, totalMatrixCount;
    SkCanvasPriv::GetDstClipAndMatrixCounts(set, count, &totalDstClipCount, &totalMatrixCount);
 
    size_t size = 6 * kUInt32Size + sizeof(SkPoint) * totalDstClipCount +
                  kMatrixSize * totalMatrixCount +
                  (4 * kUInt32Size + 2 * sizeof(SkRect) + sizeof(SkScalar)) * count +
                  SkSamplingPriv::FlatSize(sampling);
    size_t initialOffset = this->addDraw(DRAW_EDGEAA_IMAGE_SET2, &size);
    this->addInt(count);
    this->addPaintPtr(paint);
    this->addSampling(sampling);
    this->addInt((int) constraint);
    for (int i = 0; i < count; ++i) {
        this->addImage(set[i].fImage.get());
        this->addRect(set[i].fSrcRect);
        this->addRect(set[i].fDstRect);
        this->addInt(set[i].fMatrixIndex);
        this->addScalar(set[i].fAlpha);
        this->addInt((int)set[i].fAAFlags);
        this->addInt(set[i].fHasClip);
    }
    this->addInt(totalDstClipCount);
    this->addPoints(dstClips, totalDstClipCount);
    this->addInt(totalMatrixCount);
    for (int i = 0; i < totalMatrixCount; ++i) {
        this->addMatrix(preViewMatrices[i]);
    }
    this->validate(initialOffset, size);
}

◆ onDrawEdgeAAQuad()

void SkPictureRecord::onDrawEdgeAAQuad	(	const SkRect &	rect,
		const SkPoint	clip[4],
		SkCanvas::QuadAAFlags	aa,
		const SkColor4f &	color,
		SkBlendMode	mode
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 769 of file SkPictureRecord.cpp.

                                                         {
 
    // op + rect + aa flags + color + mode + hasClip(as int) + clipCount*points
    size_t size = 4 * kUInt32Size + sizeof(SkColor4f) + sizeof(rect) +
            (clip ? 4 : 0) * sizeof(SkPoint);
    size_t initialOffset = this->addDraw(DRAW_EDGEAA_QUAD, &size);
    this->addRect(rect);
    this->addInt((int) aa);
    fWriter.write(&color, sizeof(SkColor4f));
    this->addInt((int) mode);
    this->addInt(clip != nullptr);
    if (clip) {
        this->addPoints(clip, 4);
    }
    this->validate(initialOffset, size);
}

◆ onDrawImage2()

void SkPictureRecord::onDrawImage2	(	const SkImage *	image,
		SkScalar	x,
		SkScalar	y,
		const SkSamplingOptions &	sampling,
		const SkPaint *	paint
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 543 of file SkPictureRecord.cpp.

                                                                                            {
    // op + paint_index + image_index + x + y
    size_t size = 3 * kUInt32Size + 2 * sizeof(SkScalar) + SkSamplingPriv::FlatSize(sampling);
    size_t initialOffset = this->addDraw(DRAW_IMAGE2, &size);
    this->addPaintPtr(paint);
    this->addImage(image);
    this->addScalar(x);
    this->addScalar(y);
    this->addSampling(sampling);
    this->validate(initialOffset, size);
}

◆ onDrawImageLattice2()

void SkPictureRecord::onDrawImageLattice2	(	const SkImage *	image,
		const Lattice &	lattice,
		const SkRect &	dst,
		SkFilterMode	filter,
		const SkPaint *	paint
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 573 of file SkPictureRecord.cpp.

                                                                {
    size_t latticeSize = SkCanvasPriv::WriteLattice(nullptr, lattice);
    // op + paint index + image index + lattice + dst rect
    size_t size = 3 * kUInt32Size + latticeSize + sizeof(dst) + sizeof(uint32_t); // filter
    size_t initialOffset = this->addDraw(DRAW_IMAGE_LATTICE2, &size);
    this->addPaintPtr(paint);
    this->addImage(image);
    (void)SkCanvasPriv::WriteLattice(fWriter.reservePad(latticeSize), lattice);
    this->addRect(dst);
    this->addInt(static_cast<uint32_t>(filter));
    this->validate(initialOffset, size);
}

◆ onDrawImageRect2()

void SkPictureRecord::onDrawImageRect2	(	const SkImage *	image,
		const SkRect &	src,
		const SkRect &	dst,
		const SkSamplingOptions &	sampling,
		const SkPaint *	paint,
		SrcRectConstraint	constraint
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 556 of file SkPictureRecord.cpp.

                                                                     {
    // id + paint_index + image_index + constraint
    size_t size = 3 * kUInt32Size + 2 * sizeof(dst) + SkSamplingPriv::FlatSize(sampling) +
                  kUInt32Size;
 
    size_t initialOffset = this->addDraw(DRAW_IMAGE_RECT2, &size);
    this->addPaintPtr(paint);
    this->addImage(image);
    this->addRect(src);
    this->addRect(dst);
    this->addSampling(sampling);
    this->addInt(constraint);
    this->validate(initialOffset, size);
}

◆ onDrawOval()

void SkPictureRecord::onDrawOval	(	const SkRect &	oval,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 472 of file SkPictureRecord.cpp.

                                                                         {
    // op + paint index + rect
    size_t size = 2 * kUInt32Size + sizeof(oval);
    size_t initialOffset = this->addDraw(DRAW_OVAL, &size);
    this->addPaint(paint);
    this->addRect(oval);
    this->validate(initialOffset, size);
}

◆ onDrawPaint()

void SkPictureRecord::onDrawPaint ( const SkPaint & paint )

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 442 of file SkPictureRecord.cpp.

                                                      {
    // op + paint index
    size_t size = 2 * kUInt32Size;
    size_t initialOffset = this->addDraw(DRAW_PAINT, &size);
    this->addPaint(paint);
    this->validate(initialOffset, size);
}

◆ onDrawPatch()

void SkPictureRecord::onDrawPatch	(	const SkPoint	cubics[12],
		const SkColor	colors[4],
		const SkPoint	texCoords[4],
		SkBlendMode	bmode,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 664 of file SkPictureRecord.cpp.

                                                        {
    // op + paint index + patch 12 control points + flag + patch 4 colors + 4 texture coordinates
    size_t size = 2 * kUInt32Size + SkPatchUtils::kNumCtrlPts * sizeof(SkPoint) + kUInt32Size;
    uint32_t flag = 0;
    if (colors) {
        flag |= DRAW_VERTICES_HAS_COLORS;
        size += SkPatchUtils::kNumCorners * sizeof(SkColor);
    }
    if (texCoords) {
        flag |= DRAW_VERTICES_HAS_TEXS;
        size += SkPatchUtils::kNumCorners * sizeof(SkPoint);
    }
    if (SkBlendMode::kModulate != bmode) {
        flag |= DRAW_VERTICES_HAS_XFER;
        size += kUInt32Size;
    }
 
    size_t initialOffset = this->addDraw(DRAW_PATCH, &size);
    this->addPaint(paint);
    this->addPatch(cubics);
    this->addInt(flag);
 
    // write optional parameters
    if (colors) {
        fWriter.write(colors, SkPatchUtils::kNumCorners * sizeof(SkColor));
    }
    if (texCoords) {
        fWriter.write(texCoords, SkPatchUtils::kNumCorners * sizeof(SkPoint));
    }
    if (flag & DRAW_VERTICES_HAS_XFER) {
        this->addInt((int)bmode);
    }
    this->validate(initialOffset, size);
}

◆ onDrawPath()

void SkPictureRecord::onDrawPath	(	const SkPath &	path,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 534 of file SkPictureRecord.cpp.

                                                                         {
    // op + paint index + path index
    size_t size = 3 * kUInt32Size;
    size_t initialOffset = this->addDraw(DRAW_PATH, &size);
    this->addPaint(paint);
    this->addPath(path);
    this->validate(initialOffset, size);
}

◆ onDrawPicture()

void SkPictureRecord::onDrawPicture	(	const SkPicture *	picture,
		const SkMatrix *	matrix,
		const SkPaint *	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 613 of file SkPictureRecord.cpp.

                                                          {
    // op + picture index
    size_t size = 2 * kUInt32Size;
    size_t initialOffset;
 
    if (nullptr == matrix && nullptr == paint) {
        initialOffset = this->addDraw(DRAW_PICTURE, &size);
        this->addPicture(picture);
    } else {
        const SkMatrix& m = matrix ? *matrix : SkMatrix::I();
        size += SkMatrixPriv::WriteToMemory(m, nullptr) + kUInt32Size;    // matrix + paint
        initialOffset = this->addDraw(DRAW_PICTURE_MATRIX_PAINT, &size);
        this->addPaintPtr(paint);
        this->addMatrix(m);
        this->addPicture(picture);
    }
    this->validate(initialOffset, size);
}

◆ onDrawPoints()

void SkPictureRecord::onDrawPoints	(	PointMode	mode,
		size_t	count,
		const SkPoint	pts[],
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 459 of file SkPictureRecord.cpp.

                                                         {
    // op + paint index + mode + count + point data
    size_t size = 4 * kUInt32Size + count * sizeof(SkPoint);
    size_t initialOffset = this->addDraw(DRAW_POINTS, &size);
    this->addPaint(paint);
 
    this->addInt(mode);
    this->addInt(SkToInt(count));
    fWriter.writeMul4(pts, count * sizeof(SkPoint));
    this->validate(initialOffset, size);
}

◆ onDrawRect()

void SkPictureRecord::onDrawRect	(	const SkRect &	rect,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 495 of file SkPictureRecord.cpp.

                                                                         {
    // op + paint index + rect
    size_t size = 2 * kUInt32Size + sizeof(rect);
    size_t initialOffset = this->addDraw(DRAW_RECT, &size);
    this->addPaint(paint);
    this->addRect(rect);
    this->validate(initialOffset, size);
}

◆ onDrawRegion()

void SkPictureRecord::onDrawRegion	(	const SkRegion &	region,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 504 of file SkPictureRecord.cpp.

                                                                               {
    // op + paint index + region
    size_t regionBytes = region.writeToMemory(nullptr);
    size_t size = 2 * kUInt32Size + regionBytes;
    size_t initialOffset = this->addDraw(DRAW_REGION, &size);
    this->addPaint(paint);
    fWriter.writeRegion(region);
    this->validate(initialOffset, size);
}

◆ onDrawRRect()

void SkPictureRecord::onDrawRRect	(	const SkRRect &	rrect,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 514 of file SkPictureRecord.cpp.

                                                                            {
    // op + paint index + rrect
    size_t size = 2 * kUInt32Size + SkRRect::kSizeInMemory;
    size_t initialOffset = this->addDraw(DRAW_RRECT, &size);
    this->addPaint(paint);
    this->addRRect(rrect);
    this->validate(initialOffset, size);
}

◆ onDrawShadowRec()

void SkPictureRecord::onDrawShadowRec	(	const SkPath &	path,
		const SkDrawShadowRec &	rec
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 740 of file SkPictureRecord.cpp.

                                                                                    {
    // op + path index + zParams + lightPos + lightRadius + spot/ambient alphas + color + flags
    size_t size = 2 * kUInt32Size + 2 * sizeof(SkPoint3) + 1 * sizeof(SkScalar) + 3 * kUInt32Size;
    size_t initialOffset = this->addDraw(DRAW_SHADOW_REC, &size);
 
    this->addPath(path);
 
    fWriter.writePoint3(rec.fZPlaneParams);
    fWriter.writePoint3(rec.fLightPos);
    fWriter.writeScalar(rec.fLightRadius);
    fWriter.write32(rec.fAmbientColor);
    fWriter.write32(rec.fSpotColor);
    fWriter.write32(rec.fFlags);
 
    this->validate(initialOffset, size);
}

◆ onDrawSlug()

void SkPictureRecord::onDrawSlug	(	const sktext::gpu::Slug *	slug,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 603 of file SkPictureRecord.cpp.

                                                                                {
    // op + paint index + slug id
    size_t size = 3 * kUInt32Size;
    size_t initialOffset = this->addDraw(DRAW_SLUG, &size);
 
    this->addPaint(paint);
    this->addSlug(slug);
    this->validate(initialOffset, size);
}

◆ onDrawTextBlob()

void SkPictureRecord::onDrawTextBlob	(	const SkTextBlob *	blob,
		SkScalar	x,
		SkScalar	y,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Implements SkCanvasVirtualEnforcer< SkCanvas >.

Definition at line 588 of file SkPictureRecord.cpp.

                                                           {
 
    // op + paint index + blob index + x/y
    size_t size = 3 * kUInt32Size + 2 * sizeof(SkScalar);
    size_t initialOffset = this->addDraw(DRAW_TEXT_BLOB, &size);
 
    this->addPaint(paint);
    this->addTextBlob(blob);
    this->addScalar(x);
    this->addScalar(y);
 
    this->validate(initialOffset, size);
}

◆ onDrawVerticesObject()

void SkPictureRecord::onDrawVerticesObject	(	const SkVertices *	vertices,
		SkBlendMode	mode,
		const SkPaint &	paint
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 650 of file SkPictureRecord.cpp.

                                                                                   {
    // op + paint index + vertices index + zero_bones + mode
    size_t size = 5 * kUInt32Size;
    size_t initialOffset = this->addDraw(DRAW_VERTICES_OBJECT, &size);
 
    this->addPaint(paint);
    this->addVertices(vertices);
    this->addInt(0);    // legacy bone count
    this->addInt(static_cast<uint32_t>(mode));
 
    this->validate(initialOffset, size);
}

◆ onNewSurface()

sk_sp< SkSurface > SkPictureRecord::onNewSurface	(	const SkImageInfo &	info,
		const SkSurfaceProps &
	)

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 853 of file SkPictureRecord.cpp.

                                                                                             {
    return nullptr;
}

◆ onPeekPixels()

bool SkPictureRecord::onPeekPixels ( SkPixmap * )

inlineoverrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 197 of file SkPictureRecord.h.

197{ return false; }

◆ onResetClip()

void SkPictureRecord::onResetClip ( )

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 429 of file SkPictureRecord.cpp.

                                  {
    if (!fRestoreOffsetStack.empty()) {
        // Run back through any previous clip ops, and mark their offset to
        // be 0, disabling their ability to trigger a jump-to-restore, otherwise
        // they could hide this expansion of the clip.
        this->fillRestoreOffsetPlaceholdersForCurrentStackLevel(0);
    }
    size_t size = sizeof(kUInt32Size);
    size_t initialOffset = this->addDraw(RESET_CLIP, &size);
    this->validate(initialOffset, size);
    this->SkCanvasVirtualEnforcer<SkCanvas>::onResetClip();
}

◆ opData()

sk_sp< SkData > SkPictureRecord::opData ( ) const

inline

Definition at line 97 of file SkPictureRecord.h.

                                 {
        this->validate(fWriter.bytesWritten(), 0);
 
        if (fWriter.bytesWritten() == 0) {
            return SkData::MakeEmpty();
        }
        return fWriter.snapshotAsData();
    }

◆ recordClipPath()

size_t SkPictureRecord::recordClipPath	(	int	pathID,
		SkClipOp	op,
		bool	doAA
	)

protected

Definition at line 375 of file SkPictureRecord.cpp.

                                                                         {
    // op + path index + clip params
    size_t size = 3 * kUInt32Size;
    // recordRestoreOffsetPlaceholder doesn't always write an offset
    if (!fRestoreOffsetStack.empty()) {
        // + restore offset
        size += kUInt32Size;
    }
    size_t initialOffset = this->addDraw(CLIP_PATH, &size);
    this->addInt(pathID);
    this->addInt(ClipParams_pack(op, doAA));
    size_t offset = recordRestoreOffsetPlaceholder();
    this->validate(initialOffset, size);
    return offset;
}

◆ recordClipRect()

size_t SkPictureRecord::recordClipRect	(	const SkRect &	rect,
		SkClipOp	op,
		bool	doAA
	)

protected

Definition at line 331 of file SkPictureRecord.cpp.

                                                                                 {
    // id + rect + clip params
    size_t size = 1 * kUInt32Size + sizeof(rect) + 1 * kUInt32Size;
    // recordRestoreOffsetPlaceholder doesn't always write an offset
    if (!fRestoreOffsetStack.empty()) {
        // + restore offset
        size += kUInt32Size;
    }
    size_t initialOffset = this->addDraw(CLIP_RECT, &size);
    this->addRect(rect);
    this->addInt(ClipParams_pack(op, doAA));
    size_t offset = this->recordRestoreOffsetPlaceholder();
 
    this->validate(initialOffset, size);
    return offset;
}

◆ recordClipRegion()

size_t SkPictureRecord::recordClipRegion	(	const SkRegion &	region,
		SkClipOp	op
	)

protected

Definition at line 412 of file SkPictureRecord.cpp.

                                                                            {
    // op + clip params + region
    size_t size = 2 * kUInt32Size + region.writeToMemory(nullptr);
    // recordRestoreOffsetPlaceholder doesn't always write an offset
    if (!fRestoreOffsetStack.empty()) {
        // + restore offset
        size += kUInt32Size;
    }
    size_t initialOffset = this->addDraw(CLIP_REGION, &size);
    this->addRegion(region);
    this->addInt(ClipParams_pack(op, false));
    size_t offset = this->recordRestoreOffsetPlaceholder();
 
    this->validate(initialOffset, size);
    return offset;
}

◆ recordClipRRect()

size_t SkPictureRecord::recordClipRRect	(	const SkRRect &	rrect,
		SkClipOp	op,
		bool	doAA
	)

protected

Definition at line 353 of file SkPictureRecord.cpp.

                                                                                    {
    // op + rrect + clip params
    size_t size = 1 * kUInt32Size + SkRRect::kSizeInMemory + 1 * kUInt32Size;
    // recordRestoreOffsetPlaceholder doesn't always write an offset
    if (!fRestoreOffsetStack.empty()) {
        // + restore offset
        size += kUInt32Size;
    }
    size_t initialOffset = this->addDraw(CLIP_RRECT, &size);
    this->addRRect(rrect);
    this->addInt(ClipParams_pack(op, doAA));
    size_t offset = recordRestoreOffsetPlaceholder();
    this->validate(initialOffset, size);
    return offset;
}

◆ recordConcat()

void SkPictureRecord::recordConcat ( const SkMatrix & matrix )

protected

Definition at line 268 of file SkPictureRecord.cpp.

                                                         {
    this->validate(fWriter.bytesWritten(), 0);
    // op + matrix
    size_t size = kUInt32Size + SkMatrixPriv::WriteToMemory(matrix, nullptr);
    size_t initialOffset = this->addDraw(CONCAT, &size);
    this->addMatrix(matrix);
    this->validate(initialOffset, size);
}

◆ recordRestore()

void SkPictureRecord::recordRestore ( bool fillInSkips = true )

protected

Definition at line 208 of file SkPictureRecord.cpp.

                                                    {
    if (fillInSkips) {
        this->fillRestoreOffsetPlaceholdersForCurrentStackLevel((uint32_t)fWriter.bytesWritten());
    }
    size_t size = 1 * kUInt32Size; // RESTORE consists solely of 1 op code
    size_t initialOffset = this->addDraw(RESTORE, &size);
    this->validate(initialOffset, size);
}

◆ recordSave()

void SkPictureRecord::recordSave ( )

protected

Definition at line 67 of file SkPictureRecord.cpp.

                                 {
    // op only
    size_t size = sizeof(kUInt32Size);
    size_t initialOffset = this->addDraw(SAVE, &size);
 
    this->validate(initialOffset, size);
}

◆ recordSaveLayer()

void SkPictureRecord::recordSaveLayer ( const SaveLayerRec & rec )

protected

Definition at line 110 of file SkPictureRecord.cpp.

                                                             {
    // op + flatflags
    size_t size = 2 * kUInt32Size;
    uint32_t flatFlags = 0;
    uint32_t filterCount = SkToU32(rec.fFilters.size());
 
    if (rec.fBounds) {
        flatFlags |= SAVELAYERREC_HAS_BOUNDS;
        size += sizeof(*rec.fBounds);
    }
    if (rec.fPaint) {
        flatFlags |= SAVELAYERREC_HAS_PAINT;
        size += sizeof(uint32_t); // index
    }
    if (rec.fBackdrop) {
        flatFlags |= SAVELAYERREC_HAS_BACKDROP;
        size += sizeof(uint32_t); // (paint) index
    }
    if (rec.fSaveLayerFlags) {
        flatFlags |= SAVELAYERREC_HAS_FLAGS;
        size += sizeof(uint32_t);
    }
    if (SkCanvasPriv::GetBackdropScaleFactor(rec) != 1.f) {
        flatFlags |= SAVELAYERREC_HAS_BACKDROP_SCALE;
        size += sizeof(SkScalar);
    }
    if (filterCount) {
        flatFlags |= SAVELAYERREC_HAS_MULTIPLE_FILTERS;
        size += sizeof(uint32_t);  // count
        size += sizeof(uint32_t) * filterCount;  // N (paint) indices
    }
 
    const size_t initialOffset = this->addDraw(SAVE_LAYER_SAVELAYERREC, &size);
    this->addInt(flatFlags);
    if (flatFlags & SAVELAYERREC_HAS_BOUNDS) {
        this->addRect(*rec.fBounds);
    }
    if (flatFlags & SAVELAYERREC_HAS_PAINT) {
        this->addPaintPtr(rec.fPaint);
    }
    if (flatFlags & SAVELAYERREC_HAS_BACKDROP) {
        // overkill, but we didn't already track single flattenables, so using a paint for that
        SkPaint paint;
        paint.setImageFilter(sk_ref_sp(const_cast<SkImageFilter*>(rec.fBackdrop)));
        this->addPaint(paint);
    }
    if (flatFlags & SAVELAYERREC_HAS_FLAGS) {
        this->addInt(rec.fSaveLayerFlags);
    }
    if (flatFlags & SAVELAYERREC_HAS_BACKDROP_SCALE) {
        this->addScalar(SkCanvasPriv::GetBackdropScaleFactor(rec));
    }
    if (flatFlags & SAVELAYERREC_HAS_MULTIPLE_FILTERS) {
        this->addInt(filterCount);
        for (uint32_t i = 0; i < filterCount; ++i) {
            // overkill to store a paint, oh well.
            SkPaint paint;
            paint.setImageFilter(rec.fFilters[i]);
            this->addPaint(paint);
        }
    }
    this->validate(initialOffset, size);
}

◆ recordScale()

void SkPictureRecord::recordScale ( const SkMatrix & matrix )

protected

Definition at line 228 of file SkPictureRecord.cpp.

                                                   {
    SkASSERT(SkMatrix::kScale_Mask == m.getType());
 
    // op + sx + sy
    size_t size = 1 * kUInt32Size + 2 * sizeof(SkScalar);
    size_t initialOffset = this->addDraw(SCALE, &size);
    this->addScalar(m.getScaleX());
    this->addScalar(m.getScaleY());
    this->validate(initialOffset, size);
}

◆ recordTranslate()

void SkPictureRecord::recordTranslate ( const SkMatrix & matrix )

protected

Definition at line 217 of file SkPictureRecord.cpp.

                                                       {
    SkASSERT(SkMatrix::kTranslate_Mask == m.getType());
 
    // op + dx + dy
    size_t size = 1 * kUInt32Size + 2 * sizeof(SkScalar);
    size_t initialOffset = this->addDraw(TRANSLATE, &size);
    this->addScalar(m.getTranslateX());
    this->addScalar(m.getTranslateY());
    this->validate(initialOffset, size);
}

◆ setFlags()

void SkPictureRecord::setFlags ( uint32_t recordFlags )

inline

Definition at line 106 of file SkPictureRecord.h.

                                        {
        fRecordFlags = recordFlags;
    }

◆ validate()

void SkPictureRecord::validate	(	size_t	initialOffset,
		size_t	size
	)		const

inlineprotected

Definition at line 192 of file SkPictureRecord.h.

                                                           {
        SkASSERT(fWriter.bytesWritten() == initialOffset + size);
    }

◆ willRestore()

void SkPictureRecord::willRestore ( )

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 191 of file SkPictureRecord.cpp.

                                  {
#if 0
    SkASSERT(fRestoreOffsetStack.count() > 1);
#endif
 
    // check for underflow
    if (fRestoreOffsetStack.empty()) {
        return;
    }
 
    this->recordRestore();
 
    fRestoreOffsetStack.pop_back();
 
    this->SkCanvasVirtualEnforcer<SkCanvas>::willRestore();
}

◆ willSave()

void SkPictureRecord::willSave ( )

overrideprotectedvirtual

Reimplemented from SkCanvas.

Definition at line 58 of file SkPictureRecord.cpp.

                               {
    // record the offset to us, making it non-positive to distinguish a save
    // from a clip entry.
    fRestoreOffsetStack.push_back(-(int32_t)fWriter.bytesWritten());
    this->recordSave();
 
    this->SkCanvasVirtualEnforcer<SkCanvas>::willSave();
}

◆ writeStream()

const SkWriter32 & SkPictureRecord::writeStream ( ) const

inline

Definition at line 110 of file SkPictureRecord.h.

                                          {
        return fWriter;
    }

Friends And Related Function Documentation

◆ SkPictureData

friend class SkPictureData

friend

Definition at line 292 of file SkPictureRecord.h.

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

third_party/skia/src/core/SkPictureRecord.h
third_party/skia/src/core/SkPictureRecord.cpp

Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SkPictureRecord() [1/2]

◆ SkPictureRecord() [2/2]

Member Function Documentation

◆ addNoOp()

◆ addPathToHeap()

◆ beginRecording()

◆ didConcat44()

◆ didScale()

◆ didSetM44()

◆ didTranslate()

◆ endRecording()

◆ getDrawables()

◆ getImages()

◆ getPictures()

◆ getSaveLayerStrategy()

◆ getSlugs()

◆ getTextBlobs()

◆ getVertices()

◆ onClipPath()

◆ onClipRect()

◆ onClipRegion()

◆ onClipRRect()

◆ onClipShader()

◆ onDoSaveBehind()

◆ onDrawAnnotation()

◆ onDrawArc()

◆ onDrawAtlas2()

◆ onDrawBehind()

◆ onDrawDrawable()

◆ onDrawDRRect()

◆ onDrawEdgeAAImageSet2()

◆ onDrawEdgeAAQuad()

◆ onDrawImage2()

◆ onDrawImageLattice2()

◆ onDrawImageRect2()

◆ onDrawOval()

◆ onDrawPaint()

◆ onDrawPatch()

◆ onDrawPath()

◆ onDrawPicture()

◆ onDrawPoints()

◆ onDrawRect()

◆ onDrawRegion()

◆ onDrawRRect()

◆ onDrawShadowRec()

◆ onDrawSlug()

◆ onDrawTextBlob()

◆ onDrawVerticesObject()

◆ onNewSurface()

◆ onPeekPixels()

◆ onResetClip()

◆ opData()

◆ recordClipPath()

◆ recordClipRect()

◆ recordClipRegion()

◆ recordClipRRect()

◆ recordConcat()

◆ recordRestore()

◆ recordSave()

◆ recordSaveLayer()

◆ recordScale()

◆ recordTranslate()

◆ setFlags()

◆ validate()

◆ willRestore()

◆ willSave()

◆ writeStream()

Friends And Related Function Documentation

◆ SkPictureData