skgpu::ganesh Namespace Reference

Namespaces
namespace	DashOp
namespace	DrawAtlasOp
namespace	DrawMeshOp
namespace	FillRRectOp
namespace	LatticeOp
namespace	QuadPerEdgeAA
namespace	RegionOp
namespace	ShadowRRectOp
namespace	StrokeRectOp

Classes
class	AAConvexPathRenderer
class	AAHairLinePathRenderer
class	AALinearizingConvexPathRenderer
class	AtlasInstancedHelper
class	AtlasPathRenderer
class	AtlasRenderTask
class	AtlasTextOp
class	AtlasTextOpTools
class	AutoCheckFlush
class	ClearOp
class	ClipStack
class	DashLinePathRenderer
class	DefaultPathRenderer
class	Device
class	DrawableOp
class	DrawAtlasPathOp
class	FillRectOp
class	OpsTask
class	PathCurveTessellator
class	PathInnerTriangulateOp
class	PathRenderer
class	PathRendererChain
class	PathStencilCoverOp
class	PathTessellateBenchmark
class	PathTessellateOp
class	PathTessellator
class	PathWedgeTessellator
class	SmallPathAtlasMgr
class	SmallPathRenderer
class	SmallPathShapeData
class	SmallPathShapeDataKey
class	SoftwarePathRenderer
class	StencilClip
class	StencilMaskHelper
class	StrokeTessellateOp
class	StrokeTessellator
class	SurfaceContext
class	SurfaceDrawContext
class	SurfaceFillContext
class	TessellationPathRenderer
class	TessPrepareBench
class	TextureOp
class	TriangulatingPathRenderer
class	VertexChunkPatchAllocator

Typedefs
using	PathStrokeList = StrokeTessellator::PathStrokeList
using	MakePathStrokesFn = std::vector< PathStrokeList >(*)()
using	PatchAttribs = tess::PatchAttribs
using	DataType = SkYUVAPixmapInfo::DataType
using	DoSimplify = GrStyledShape::DoSimplify

Enumerations
enum class	FillPathFlags { kNone = 0 , kStencilOnly = (1 << 0) , kWireframe = (1 << 1) }

Functions
static sk_sp< GrDirectContext >	make_mock_context ()
static SkPath	make_cubic_path (int maxPow2)
static SkPath	make_conic_path ()
static SkPath	make_quad_path (int maxPow2)
static SkPath	make_line_path (int maxPow2)
	DEF_PATH_TESS_BENCH (GrPathCurveTessellator, make_cubic_path(8), SkMatrix::I())
	DEF_PATH_TESS_BENCH (GrPathWedgeTessellator, make_cubic_path(8), SkMatrix::I())
static void	benchmark_wangs_formula_cubic_log2 (const SkMatrix &matrix, const SkPath &path)
	DEF_PATH_TESS_BENCH (wangs_formula_cubic_log2, make_cubic_path(18), SkMatrix::I())
	DEF_PATH_TESS_BENCH (wangs_formula_cubic_log2_scale, make_cubic_path(18), SkMatrix::Scale(1.1f, 0.9f))
	DEF_PATH_TESS_BENCH (wangs_formula_cubic_log2_affine, make_cubic_path(18), SkMatrix::MakeAll(.9f, 0.9f, 0, 1.1f, 1.1f, 0, 0, 0, 1))
static void	benchmark_wangs_formula_conic (const SkMatrix &matrix, const SkPath &path)
static void	benchmark_wangs_formula_conic_log2 (const SkMatrix &matrix, const SkPath &path)
	DEF_PATH_TESS_BENCH (wangs_formula_conic, make_conic_path(), SkMatrix::I())
	DEF_PATH_TESS_BENCH (wangs_formula_conic_log2, make_conic_path(), SkMatrix::I())
	DEF_PATH_TESS_BENCH (middle_out_triangulation, ToolUtils::make_star(SkRect::MakeWH(500, 500), kNumCubicsInChalkboard), SkMatrix::I())
static std::vector< PathStrokeList >	make_simple_cubic_path ()
static std::vector< PathStrokeList >	make_motionmark_paths ()
	DEF_BENCH (return new TessPrepareBench(make_simple_cubic_path, PatchAttribs::kNone, 1, "GrStrokeFixedCountTessellator");) DEF_BENCH(return new TessPrepareBench(make_simple_cubic_path
SkIRect	TopLayerBounds (const SkCanvas *)
GrBackendRenderTarget	TopLayerBackendRenderTarget (const SkCanvas *)
bool	PinAsTexture (GrRecordingContext *, SkImage *)
void	UnpinTexture (GrRecordingContext *, SkImage *)
SK_API GrSemaphoresSubmitted	Flush (sk_sp< SkSurface >)
SK_API GrSemaphoresSubmitted	Flush (SkSurface *)
SK_API void	FlushAndSubmit (sk_sp< SkSurface >)
SK_API void	FlushAndSubmit (SkSurface *)
SK_API bool	DrawDDL (SkSurface *, sk_sp< const GrDeferredDisplayList > ddl)
SK_API bool	DrawDDL (sk_sp< SkSurface >, sk_sp< const GrDeferredDisplayList > ddl)
SurfaceDrawContext *	TopDeviceSurfaceDrawContext (const SkCanvas *canvas)
SurfaceFillContext *	TopDeviceSurfaceFillContext (const SkCanvas *canvas)
GrRenderTargetProxy *	TopDeviceTargetProxy (const SkCanvas *canvas)
GrSurfaceProxyView	CopyView (GrRecordingContext *context, GrSurfaceProxyView src, skgpu::Mipmapped mipmapped, GrImageTexGenPolicy policy, std::string_view label)
std::tuple< GrSurfaceProxyView, GrColorType >	RasterAsView (GrRecordingContext *rContext, const SkImage_Raster *raster, skgpu::Mipmapped mipmapped, GrImageTexGenPolicy policy)
GrColorType	ColorTypeOfLockTextureProxy (const GrCaps *caps, SkColorType sct)
static GrSurfaceOrigin	get_origin (const SkImage_Lazy *img)
static GrSurfaceProxyView	texture_proxy_view_from_planes (GrRecordingContext *ctx, const SkImage_Lazy *img, skgpu::Budgeted budgeted)
static GrSurfaceProxyView	generate_picture_texture (GrRecordingContext *ctx, const SkImage_Picture *img, skgpu::Mipmapped mipmapped, GrImageTexGenPolicy texGenPolicy)
GrSurfaceProxyView	LockTextureProxyView (GrRecordingContext *rContext, const SkImage_Lazy *img, GrImageTexGenPolicy texGenPolicy, skgpu::Mipmapped mipmapped)
static std::tuple< GrSurfaceProxyView, GrColorType >	lazy_as_view (GrRecordingContext *context, const SkImage_Lazy *img, skgpu::Mipmapped mipmapped, GrImageTexGenPolicy policy)
std::tuple< GrSurfaceProxyView, GrColorType >	AsView (GrRecordingContext *rContext, const SkImage *img, skgpu::Mipmapped mipmapped, GrImageTexGenPolicy policy)
static std::unique_ptr< GrFragmentProcessor >	make_fp_from_view (GrRecordingContext *rContext, GrSurfaceProxyView view, SkAlphaType at, SkSamplingOptions sampling, const SkTileMode tileModes[2], const SkMatrix &m, const SkRect *subset, const SkRect *domain)
std::unique_ptr< GrFragmentProcessor >	raster_as_fp (GrRecordingContext *rContext, const SkImage_Raster *img, SkSamplingOptions sampling, const SkTileMode tileModes[2], const SkMatrix &m, const SkRect *subset, const SkRect *domain)
std::unique_ptr< GrFragmentProcessor >	AsFragmentProcessor (GrRecordingContext *rContext, const SkImage *img, SkSamplingOptions sampling, const SkTileMode tileModes[2], const SkMatrix &m, const SkRect *subset, const SkRect *domain)
std::unique_ptr< GrFragmentProcessor >	MakeFragmentProcessorFromView (GrRecordingContext *rContext, GrSurfaceProxyView view, SkAlphaType at, SkSamplingOptions sampling, const SkTileMode tileModes[2], const SkMatrix &m, const SkRect *subset, const SkRect *domain)
GrSurfaceProxyView	FindOrMakeCachedMipmappedView (GrRecordingContext *rContext, GrSurfaceProxyView view, uint32_t imageUniqueID)
SkYUVAPixmapInfo::SupportedDataTypes	SupportedTextureFormats (const GrImageContext &context)
std::tuple< GrSurfaceProxyView, GrColorType >	AsView (GrRecordingContext *ctx, const sk_sp< const SkImage > &img, skgpu::Mipmapped mm, GrImageTexGenPolicy policy=GrImageTexGenPolicy::kDraw)
std::unique_ptr< GrFragmentProcessor >	AsFragmentProcessor (GrRecordingContext *ctx, const sk_sp< const SkImage > &img, SkSamplingOptions opt, const SkTileMode tm[2], const SkMatrix &m, const SkRect *subset=nullptr, const SkRect *domain=nullptr)
	SKGPU_DECLARE_STATIC_UNIQUE_KEY (gHullVertexBufferKey)
static constexpr GrUserStencilSettings	kMarkStencil (GrUserStencilSettings::StaticInit< 0x0001, GrUserStencilTest::kLessIfInClip, 0x0000, GrUserStencilOp::kZero, GrUserStencilOp::kReplace, 0xffff >())
static constexpr GrUserStencilSettings	kTestAndResetStencil (GrUserStencilSettings::StaticInit< 0x0000, GrUserStencilTest::kLessIfInClip, 0x0001, GrUserStencilOp::kZero, GrUserStencilOp::kReplace, 0xffff >())
std::tuple< bool, bool >	FilterAndMipmapHaveNoEffect (const GrQuad &srcQuad, const GrQuad &dstQuad)
static bool	alpha_types_compatible (SkAlphaType srcAlphaType, SkAlphaType dstAlphaType)
static SkIRect	get_clip_bounds (const SurfaceDrawContext *sdc, const GrClip *clip)
	SKGPU_DECLARE_STATIC_UNIQUE_KEY (gFixedCountCurveVertexBufferKey)
	SKGPU_DECLARE_STATIC_UNIQUE_KEY (gFixedCountCurveIndexBufferKey)
	SKGPU_DECLARE_STATIC_UNIQUE_KEY (gFixedCountWedgesVertexBufferKey)
	SKGPU_DECLARE_STATIC_UNIQUE_KEY (gFixedCountWedgesIndexBufferKey)
	SKGPU_DECLARE_STATIC_UNIQUE_KEY (gVertexIDFallbackBufferKey)
GrBackendApi	ContextTypeBackend (skgpu::ContextType type)

Variables
static constexpr int	kNumCubicsInChalkboard = 47182
static const SkMatrix	gAlmostIdentity
	GrStrokeFixedCountTessellator_one_chop
static constexpr int	kElementStackIncrement = 8
static constexpr int	kSaveStackIncrement = 8
static constexpr int	kMaskStackIncrement = 4
static constexpr int	kMaxAnalyticFPs = 4
static constexpr int	kNumStackMasks = 4
static constexpr auto	kAtlasAlpha8Type = GrColorType::kAlpha_8
static constexpr int	kAtlasInitialSize = 512
static constexpr auto	kAtlasAlgorithm = GrDynamicAtlas::RectanizerAlgorithm::kPow2
static constexpr int	kAtlasMaxPathHeight = 256
static constexpr int	kAtlasMaxPathHeightWithMSAAFallback = 128
static constexpr int	kAtlasMaxPathWidth = 1024
static constexpr int	kVerticesPerGlyph = 4
static constexpr int	kIndicesPerGlyph = 6
static thread_local void *	gCache = nullptr

Typedef Documentation

DataType

using skgpu::ganesh::DataType = typedef SkYUVAPixmapInfo::DataType

Definition at line 701 of file GrImageUtils.cpp.

DoSimplify

using skgpu::ganesh::DoSimplify = typedef GrStyledShape::DoSimplify

Definition at line 118 of file SurfaceDrawContext.cpp.

MakePathStrokesFn

using skgpu::ganesh::MakePathStrokesFn = typedef std::vector<PathStrokeList>(*)()

Definition at line 244 of file TessellateBench.cpp.

PatchAttribs

using skgpu::ganesh::PatchAttribs = typedef tess::PatchAttribs

Definition at line 311 of file TessellateBench.cpp.

PathStrokeList

using skgpu::ganesh::PathStrokeList = typedef StrokeTessellator::PathStrokeList

Definition at line 243 of file TessellateBench.cpp.

Enumeration Type Documentation

FillPathFlags

enum class skgpu::ganesh::FillPathFlags

strong

Enumerator
kNone
kStencilOnly
kWireframe

Definition at line 16 of file FillPathFlags.h.

                         {
    kNone        = 0,
    kStencilOnly = (1 << 0),
    kWireframe   = (1 << 1)
};

Function Documentation

alpha_types_compatible()

static bool skgpu::ganesh::alpha_types_compatible ( SkAlphaType  srcAlphaType, SkAlphaType  dstAlphaType  )

static

Definition at line 64 of file SurfaceContext.cpp.

                                                                                       {
    // If both alpha types are kUnknown things make sense. If not, it's too underspecified.
    return (srcAlphaType == kUnknown_SkAlphaType) == (dstAlphaType == kUnknown_SkAlphaType);
}

AsFragmentProcessor() [1/2]

std::unique_ptr< GrFragmentProcessor > skgpu::ganesh::AsFragmentProcessor ( GrRecordingContext *  ctx, const sk_sp< const SkImage > &  img, SkSamplingOptions  opt, const SkTileMode  tm[2], const SkMatrix &  m, const SkRect *  subset = nullptr, const SkRect *  domain = nullptr  )

inline

Definition at line 100 of file GrImageUtils.h.

                                                                                                {
    return AsFragmentProcessor(ctx, img.get(), opt, tm, m, subset, domain);
}

AsFragmentProcessor() [2/2]

std::unique_ptr< GrFragmentProcessor > skgpu::ganesh::AsFragmentProcessor	(	GrRecordingContext *	,
		const SkImage *	,
		SkSamplingOptions	,
		const SkTileMode	[2],
		const SkMatrix &	,
		const SkRect *	subset = nullptr,
		const SkRect *	domain = nullptr
	)

Returns a GrFragmentProcessor that can be used with the passed GrRecordingContext to draw the image. SkSamplingOptions indicates the filter and SkTileMode[] indicates the x and y tile modes. The passed matrix is applied to the coordinates before sampling the image. Optional 'subset' indicates whether the tile modes should be applied to a subset of the image Optional 'domain' is a bound on the coordinates of the image that will be required and can be used to optimize the shader if 'subset' is also specified.

Definition at line 535 of file GrImageUtils.cpp.

                                                                               {
    if (!rContext) {
        return {};
    }
    if (sampling.useCubic && !GrValidCubicResampler(sampling.cubic)) {
        return {};
    }
    if (sampling.mipmap != SkMipmapMode::kNone &&
        (!rContext->priv().caps()->mipmapSupport() || img->dimensions().area() <= 1)) {
        sampling = SkSamplingOptions(sampling.filter);
    }
 
    auto ib = static_cast<const SkImage_Base*>(img);
    if (ib->isRasterBacked()) {
        return raster_as_fp(rContext,
                            static_cast<const SkImage_Raster*>(ib),
                            sampling,
                            tileModes,
                            m,
                            subset,
                            domain);
    } else if (ib->isGaneshBacked()) {
        auto gb = static_cast<const SkImage_GaneshBase*>(img);
        return gb->asFragmentProcessor(rContext, sampling, tileModes, m, subset, domain);
    } else if (ib->isLazyGenerated()) {
        // TODO: If the CPU data is extracted as planes return a FP that reconstructs the image from
        // the planes.
        auto mm = sampling.mipmap == SkMipmapMode::kNone ? skgpu::Mipmapped::kNo : skgpu::Mipmapped::kYes;
        return MakeFragmentProcessorFromView(rContext,
                                             std::get<0>(AsView(rContext, img, mm)),
                                             img->alphaType(),
                                             sampling,
                                             tileModes,
                                             m,
                                             subset,
                                             domain);
    }
 
    SkDEBUGFAIL("Unsupported image type to make a FragmentProcessor");
    return {};
}

AsView() [1/2]

std::tuple< GrSurfaceProxyView, GrColorType > skgpu::ganesh::AsView ( GrRecordingContext *  ctx, const sk_sp< const SkImage > &  img, skgpu::Mipmapped  mm, GrImageTexGenPolicy  policy = GrImageTexGenPolicy::kDraw  )

inline

Definition at line 50 of file GrImageUtils.h.

                                                               {
    return AsView(ctx, img.get(), mm, policy);
}

AsView() [2/2]

std::tuple< GrSurfaceProxyView, GrColorType > skgpu::ganesh::AsView	(	GrRecordingContext *	rContext,
		const SkImage *	img,
		skgpu::Mipmapped	mipmapped,
		GrImageTexGenPolicy	policy
	)

Definition at line 414 of file GrImageUtils.cpp.

                                                                               {
    SkASSERT(img);
    if (!rContext) {
        return {};
    }
    if (!rContext->priv().caps()->mipmapSupport() || img->dimensions().area() <= 1) {
        mipmapped = skgpu::Mipmapped::kNo;
    }
 
    auto ib = static_cast<const SkImage_Base*>(img);
    if (ib->type() == SkImage_Base::Type::kRaster) {
        return skgpu::ganesh::RasterAsView(
                    rContext, static_cast<const SkImage_Raster*>(ib), mipmapped, policy);
    } else if (ib->type() == SkImage_Base::Type::kRasterPinnable) {
        auto rp = static_cast<const SkImage_RasterPinnable*>(img);
        return rp->asView(rContext, mipmapped, policy);
    } else if (ib->isGaneshBacked()) {
        auto gb = static_cast<const SkImage_GaneshBase*>(img);
        return gb->asView(rContext, mipmapped, policy);
    } else if (ib->isLazyGenerated()) {
        return lazy_as_view(rContext, static_cast<const SkImage_Lazy*>(ib), mipmapped, policy);
    }
 
    SkDEBUGFAIL("Unsupported image type to make a View");
    return {};
}

benchmark_wangs_formula_conic()

static void skgpu::ganesh::benchmark_wangs_formula_conic ( const SkMatrix &  matrix, const SkPath &  path  )

static

Definition at line 189 of file TessellateBench.cpp.

                                                                                      {
    int sum = 0;
    wangs_formula::VectorXform xform(matrix);
    for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
        if (verb == SkPathVerb::kConic) {
            sum += wangs_formula::conic(4, pts, *w, xform);
        }
    }
    // Don't let the compiler optimize away wangs_formula::conic.
    if (sum <= 0) {
        SK_ABORT("sum should be > 0.");
    }
}

benchmark_wangs_formula_conic_log2()

static void skgpu::ganesh::benchmark_wangs_formula_conic_log2 ( const SkMatrix &  matrix, const SkPath &  path  )

static

Definition at line 203 of file TessellateBench.cpp.

                                                                                           {
    int sum = 0;
    wangs_formula::VectorXform xform(matrix);
    for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
        if (verb == SkPathVerb::kConic) {
            sum += wangs_formula::conic_log2(4, pts, *w, xform);
        }
    }
    // Don't let the compiler optimize away wangs_formula::conic.
    if (sum <= 0) {
        SK_ABORT("sum should be > 0.");
    }
}

benchmark_wangs_formula_cubic_log2()

static void skgpu::ganesh::benchmark_wangs_formula_cubic_log2 ( const SkMatrix &  matrix, const SkPath &  path  )

static

Definition at line 161 of file TessellateBench.cpp.

                                                                                           {
    int sum = 0;
    wangs_formula::VectorXform xform(matrix);
    for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
        if (verb == SkPathVerb::kCubic) {
            sum += wangs_formula::cubic_log2(4, pts, xform);
        }
    }
    // Don't let the compiler optimize away wangs_formula::cubic_log2.
    if (sum <= 0) {
        SK_ABORT("sum should be > 0.");
    }
}

ColorTypeOfLockTextureProxy()

GrColorType skgpu::ganesh::ColorTypeOfLockTextureProxy	(	const GrCaps *	caps,
		SkColorType	sct
	)

Definition at line 128 of file GrImageUtils.cpp.

                                                                             {
    GrColorType ct = SkColorTypeToGrColorType(sct);
    GrBackendFormat format = caps->getDefaultBackendFormat(ct, GrRenderable::kNo);
    if (!format.isValid()) {
        ct = GrColorType::kRGBA_8888;
    }
    return ct;
}

ContextTypeBackend()

GrBackendApi skgpu::ganesh::ContextTypeBackend

(

skgpu::ContextType

type

)

Definition at line 92 of file ContextType.cpp.

                                                                  {
    switch (type) {
        case skgpu::ContextType::kGL:
        case skgpu::ContextType::kGLES:
        case skgpu::ContextType::kANGLE_D3D9_ES2:
        case skgpu::ContextType::kANGLE_D3D11_ES2:
        case skgpu::ContextType::kANGLE_D3D11_ES3:
        case skgpu::ContextType::kANGLE_GL_ES2:
        case skgpu::ContextType::kANGLE_GL_ES3:
        case skgpu::ContextType::kANGLE_Metal_ES2:
        case skgpu::ContextType::kANGLE_Metal_ES3:
            return GrBackendApi::kOpenGL;
 
        case ContextType::kVulkan:
            return GrBackendApi::kVulkan;
 
        case ContextType::kMetal:
            return GrBackendApi::kMetal;
 
        case ContextType::kDirect3D:
            return GrBackendApi::kDirect3D;
 
        case ContextType::kDawn_D3D11:
        case ContextType::kDawn_D3D12:
        case ContextType::kDawn_Metal:
        case ContextType::kDawn_Vulkan:
        case ContextType::kDawn_OpenGL:
        case ContextType::kDawn_OpenGLES:
            return GrBackendApi::kUnsupported;
 
        case ContextType::kMock:
            return GrBackendApi::kMock;
    }
    SkUNREACHABLE;
}

CopyView()

GrSurfaceProxyView skgpu::ganesh::CopyView	(	GrRecordingContext *	context,
		GrSurfaceProxyView	src,
		skgpu::Mipmapped	mipmapped,
		GrImageTexGenPolicy	policy,
		std::string_view	label
	)

Definition at line 84 of file GrImageUtils.cpp.

                                                  {
    skgpu::Budgeted budgeted = policy == GrImageTexGenPolicy::kNew_Uncached_Budgeted
                                       ? skgpu::Budgeted::kYes
                                       : skgpu::Budgeted::kNo;
    return GrSurfaceProxyView::Copy(context,
                                    std::move(src),
                                    mipmapped,
                                    SkBackingFit::kExact,
                                    budgeted,
                                    /*label=*/label);
}

DEF_BENCH()

skgpu::ganesh::DEF_BENCH ( return new TessPrepareBench(make_simple_cubic_path, PatchAttribs::kNone, 1, "GrStrokeFixedCountTessellator");   )

new

DEF_PATH_TESS_BENCH() [1/8]

skgpu::ganesh::DEF_PATH_TESS_BENCH	(	GrPathCurveTessellator	,
		make_cubic_path(8)	,
		SkMatrix::I()
	)

Definition at line 137 of file TessellateBench.cpp.

                                                                             {
    SkArenaAlloc arena(1024);
    GrPipeline noVaryingsPipeline(GrScissorTest::kDisabled, SkBlendMode::kSrcOver,
                                  skgpu::Swizzle::RGBA());
    auto tess = PathCurveTessellator::Make(&arena,
                                           fTarget->caps().shaderCaps()->fInfinitySupport);
    tess->prepare(fTarget.get(),
                  fMatrix,
                  {gAlmostIdentity, fPath, SK_PMColor4fTRANSPARENT},
                  fPath.countVerbs());
}

DEF_PATH_TESS_BENCH() [2/8]

skgpu::ganesh::DEF_PATH_TESS_BENCH	(	GrPathWedgeTessellator	,
		make_cubic_path(8)	,
		SkMatrix::I()
	)

Definition at line 149 of file TessellateBench.cpp.

                                                                             {
    SkArenaAlloc arena(1024);
    GrPipeline noVaryingsPipeline(GrScissorTest::kDisabled, SkBlendMode::kSrcOver,
                                  skgpu::Swizzle::RGBA());
    auto tess = PathWedgeTessellator::Make(&arena,
                                           fTarget->caps().shaderCaps()->fInfinitySupport);
    tess->prepare(fTarget.get(),
                  fMatrix,
                  {gAlmostIdentity, fPath, SK_PMColor4fTRANSPARENT},
                  fPath.countVerbs());
}

DEF_PATH_TESS_BENCH() [3/8]

skgpu::ganesh::DEF_PATH_TESS_BENCH	(	middle_out_triangulation	,
		ToolUtils::make_star(SkRect::MakeWH(500, 500), kNumCubicsInChalkboard)	,
		SkMatrix::I()
	)

Definition at line 225 of file TessellateBench.cpp.

                                 {
    // Conservative estimate of triangulation (see PathStencilCoverOp)
    const int maxVerts = 3 * (kNumCubicsInChalkboard - 2);
 
    sk_sp<const GrBuffer> buffer;
    int baseVertex;
    VertexWriter vertexWriter = fTarget->makeVertexWriter(
            sizeof(SkPoint), maxVerts, &buffer, &baseVertex);
    tess::AffineMatrix m(gAlmostIdentity);
    for (tess::PathMiddleOutFanIter it(fPath); !it.done();) {
        for (auto [p0, p1, p2] : it.nextStack()) {
            vertexWriter << m.map2Points(p0, p1) << m.mapPoint(p2);
        }
    }
}

DEF_PATH_TESS_BENCH() [4/8]

skgpu::ganesh::DEF_PATH_TESS_BENCH	(	wangs_formula_conic	,
		make_conic_path()	,
		SkMatrix::I()
	)

Definition at line 217 of file TessellateBench.cpp.

                                                                         {
    benchmark_wangs_formula_conic(fMatrix, fPath);
}

DEF_PATH_TESS_BENCH() [5/8]

skgpu::ganesh::DEF_PATH_TESS_BENCH	(	wangs_formula_conic_log2	,
		make_conic_path()	,
		SkMatrix::I()
	)

Definition at line 221 of file TessellateBench.cpp.

                                                                              {
    benchmark_wangs_formula_conic_log2(fMatrix, fPath);
}

DEF_PATH_TESS_BENCH() [6/8]

skgpu::ganesh::DEF_PATH_TESS_BENCH	(	wangs_formula_cubic_log2	,
		make_cubic_path(18)	,
		SkMatrix::I()
	)

Definition at line 175 of file TessellateBench.cpp.

                                                                                {
    benchmark_wangs_formula_cubic_log2(fMatrix, fPath);
}

DEF_PATH_TESS_BENCH() [7/8]

skgpu::ganesh::DEF_PATH_TESS_BENCH	(	wangs_formula_cubic_log2_affine	,
		make_cubic_path(18)	,
		SkMatrix::MakeAll(.9f, 0.9f, 0, 1.1f, 1.1f, 0, 0, 0, 1)
	)

Definition at line 184 of file TessellateBench.cpp.

                                                                      {
    benchmark_wangs_formula_cubic_log2(fMatrix, fPath);
}

DEF_PATH_TESS_BENCH() [8/8]

skgpu::ganesh::DEF_PATH_TESS_BENCH	(	wangs_formula_cubic_log2_scale	,
		make_cubic_path(18)	,
		SkMatrix::Scale(1.1f, 0.9f)
	)

Definition at line 179 of file TessellateBench.cpp.

                                               {
    benchmark_wangs_formula_cubic_log2(fMatrix, fPath);
}

DrawDDL() [1/2]

bool skgpu::ganesh::DrawDDL	(	sk_sp< SkSurface >	surface,
		sk_sp< const GrDeferredDisplayList >	ddl
	)

Definition at line 76 of file GrDeferredDisplayList.cpp.

                                                                               {
    return DrawDDL(surface.get(), ddl);
}

DrawDDL() [2/2]

bool skgpu::ganesh::DrawDDL	(	SkSurface *	surface,
		sk_sp< const GrDeferredDisplayList >	ddl
	)

Draws the deferred display list created via a GrDeferredDisplayListRecorder. If the deferred display list is not compatible with the surface, the draw is skipped and false is return.

The xOffset and yOffset parameters are experimental and, if not both zero, will cause the draw to be ignored. When implemented, if xOffset or yOffset are non-zero, the DDL will be drawn offset by that amount into the surface.

Parameters

SkSurface	The surface to apply the commands to, cannot be nullptr.
ddl	drawing commands, cannot be nullptr.

Returns

false if ddl is not compatible

example: https://fiddle.skia.org/c/@Surface_draw_2

Definition at line 64 of file GrDeferredDisplayList.cpp.

                                                                         {
    if (!surface || !ddl) {
        return false;
    }
    auto sb = asSB(surface);
    if (!sb->isGaneshBacked()) {
        return false;
    }
    auto gs = static_cast<SkSurface_Ganesh*>(surface);
    return gs->draw(ddl);
}

FilterAndMipmapHaveNoEffect()

std::tuple< bool, bool > skgpu::ganesh::FilterAndMipmapHaveNoEffect	(	const GrQuad &	srcQuad,
		const GrQuad &	dstQuad
	)

Tests if filtering will have any effect in the drawing of the 'srcQuad' to the 'dstquad'. We return false when filtering has no impact drawing operations as they are effectively blits.

Definition at line 1114 of file TextureOp.cpp.

                                                      {
    // If not axis-aligned in src or dst, then always say it has an effect
    if (srcQuad.quadType() != GrQuad::Type::kAxisAligned ||
        dstQuad.quadType() != GrQuad::Type::kAxisAligned) {
        return {true, true};
    }
 
    SkRect srcRect;
    SkRect dstRect;
    if (srcQuad.asRect(&srcRect) && dstQuad.asRect(&dstRect)) {
        // Disable filtering when there is no scaling (width and height are the same), and the
        // top-left corners have the same fraction (so src and dst snap to the pixel grid
        // identically).
        SkASSERT(srcRect.isSorted());
        bool filter = srcRect.width() != dstRect.width() || srcRect.height() != dstRect.height() ||
                      SkScalarFraction(srcRect.fLeft) != SkScalarFraction(dstRect.fLeft) ||
                      SkScalarFraction(srcRect.fTop) != SkScalarFraction(dstRect.fTop);
        bool mm = srcRect.width() > dstRect.width() || srcRect.height() > dstRect.height();
        return {filter, mm};
    }
    // Extract edge lengths
    SkSize srcSize = axis_aligned_quad_size(srcQuad);
    SkSize dstSize = axis_aligned_quad_size(dstQuad);
    // Although the quads are axis-aligned, the local coordinate system is transformed such
    // that fractionally-aligned sample centers will not align with the device coordinate system
    // So disable filtering when edges are the same length and both srcQuad and dstQuad
    // 0th vertex is integer aligned.
    bool filter = srcSize != dstSize || !SkScalarIsInt(srcQuad.x(0)) ||
                  !SkScalarIsInt(srcQuad.y(0)) || !SkScalarIsInt(dstQuad.x(0)) ||
                  !SkScalarIsInt(dstQuad.y(0));
    bool mm = srcSize.fWidth > dstSize.fWidth || srcSize.fHeight > dstSize.fHeight;
    return {filter, mm};
}

FindOrMakeCachedMipmappedView()

GrSurfaceProxyView skgpu::ganesh::FindOrMakeCachedMipmappedView	(	GrRecordingContext *	,
		GrSurfaceProxyView	,
		uint32_t	imageUniqueID
	)

Returns input view if it is already mipmapped. Otherwise, attempts to make a mipmapped view with the same contents. If the mipmapped copy is successfully created it will be cached using the image unique ID. A subsequent call with the same unique ID will return the cached view if it has not been purged. The view is cached with a key domain specific to this function.

Definition at line 666 of file GrImageUtils.cpp.

                                                                         {
    SkASSERT(rContext);
    SkASSERT(imageUniqueID != SK_InvalidUniqueID);
 
    if (!view || view.proxy()->asTextureProxy()->mipmapped() == skgpu::Mipmapped::kYes) {
        return view;
    }
    GrProxyProvider* proxyProvider = rContext->priv().proxyProvider();
 
    skgpu::UniqueKey baseKey;
    GrMakeKeyFromImageID(&baseKey, imageUniqueID, SkIRect::MakeSize(view.dimensions()));
    SkASSERT(baseKey.isValid());
    skgpu::UniqueKey mipmappedKey;
    static const skgpu::UniqueKey::Domain kMipmappedDomain = skgpu::UniqueKey::GenerateDomain();
    {  // No extra values beyond the domain are required. Must name the var to please
       // clang-tidy.
        skgpu::UniqueKey::Builder b(&mipmappedKey, baseKey, kMipmappedDomain, 0);
    }
    SkASSERT(mipmappedKey.isValid());
    if (sk_sp<GrTextureProxy> cachedMippedView =
                proxyProvider->findOrCreateProxyByUniqueKey(mipmappedKey)) {
        return {std::move(cachedMippedView), view.origin(), view.swizzle()};
    }
 
    auto copy = GrCopyBaseMipMapToView(rContext, view);
    if (!copy) {
        return view;
    }
    // TODO: If we move listeners up from SkImage_Lazy to SkImage_Base then add one here.
    proxyProvider->assignUniqueKeyToProxy(mipmappedKey, copy.asTextureProxy());
    return copy;
}

Flush() [1/2]

GrSemaphoresSubmitted skgpu::ganesh::Flush

(

sk_sp< SkSurface >

surface

)

Definition at line 787 of file SkSurface_Ganesh.cpp.

                                                      {
    if (!surface) {
        return GrSemaphoresSubmitted::kNo;
    }
    if (auto rContext = surface->recordingContext(); rContext != nullptr) {
        return rContext->asDirectContext()->flush(surface.get(), {});
    }
    return GrSemaphoresSubmitted::kNo;
}

Flush() [2/2]

GrSemaphoresSubmitted skgpu::ganesh::Flush

(

SkSurface *

surface

)

Definition at line 777 of file SkSurface_Ganesh.cpp.

                                                {
    if (!surface) {
        return GrSemaphoresSubmitted::kNo;
    }
    if (auto rContext = surface->recordingContext(); rContext != nullptr) {
        return rContext->asDirectContext()->flush(surface, {});
    }
    return GrSemaphoresSubmitted::kNo;
}

FlushAndSubmit() [1/2]

void skgpu::ganesh::FlushAndSubmit

(

sk_sp< SkSurface >

surface

)

Definition at line 806 of file SkSurface_Ganesh.cpp.

                                              {
    if (!surface) {
        return;
    }
    if (auto rContext = surface->recordingContext(); rContext != nullptr) {
        rContext->asDirectContext()->flushAndSubmit(surface.get(), GrSyncCpu::kNo);
    }
}

FlushAndSubmit() [2/2]

void skgpu::ganesh::FlushAndSubmit

(

SkSurface *

surface

)

Definition at line 797 of file SkSurface_Ganesh.cpp.

                                        {
    if (!surface) {
        return;
    }
    if (auto rContext = surface->recordingContext(); rContext != nullptr) {
        rContext->asDirectContext()->flushAndSubmit(surface, GrSyncCpu::kNo);
    }
}

generate_picture_texture()

static GrSurfaceProxyView skgpu::ganesh::generate_picture_texture ( GrRecordingContext *  ctx, const SkImage_Picture *  img, skgpu::Mipmapped  mipmapped, GrImageTexGenPolicy  texGenPolicy  )

static

Definition at line 237 of file GrImageUtils.cpp.

                                                                                     {
    SkASSERT(ctx);
    SkASSERT(img);
 
    skgpu::Budgeted budgeted = texGenPolicy == GrImageTexGenPolicy::kNew_Uncached_Unbudgeted
                                       ? skgpu::Budgeted::kNo
                                       : skgpu::Budgeted::kYes;
    auto surface = SkSurfaces::RenderTarget(ctx,
                                            budgeted,
                                            img->imageInfo(),
                                            0,
                                            kTopLeft_GrSurfaceOrigin,
                                            img->props(),
                                            mipmapped == skgpu::Mipmapped::kYes);
    if (!surface) {
        return {};
    }
 
    img->replay(surface->getCanvas());
 
    sk_sp<SkImage> image(surface->makeImageSnapshot());
    if (!image) {
        return {};
    }
 
    auto [view, ct] = AsView(ctx, image, mipmapped);
    SkASSERT(view);
    SkASSERT(mipmapped == skgpu::Mipmapped::kNo ||
             view.asTextureProxy()->mipmapped() == skgpu::Mipmapped::kYes);
    return view;
}

get_clip_bounds()

static SkIRect skgpu::ganesh::get_clip_bounds ( const SurfaceDrawContext *  sdc, const GrClip *  clip  )

static

Definition at line 1585 of file SurfaceDrawContext.cpp.

                                                                                  {
    return clip ? clip->getConservativeBounds() : SkIRect::MakeWH(sdc->width(), sdc->height());
}

get_origin()

static GrSurfaceOrigin skgpu::ganesh::get_origin ( const SkImage_Lazy *  img )

static

Definition at line 137 of file GrImageUtils.cpp.

                                                           {
    SkASSERT(img->generator());
    if (!img->generator()->isTextureGenerator()) {
        return kTopLeft_GrSurfaceOrigin;
    }
    // origin should be thread safe
    return static_cast<const GrTextureGenerator*>(img->generator()->fGenerator.get())->origin();
}

kMarkStencil()

static constexpr GrUserStencilSettings skgpu::ganesh::kMarkStencil ( GrUserStencilSettings::StaticInit< 0x0001, GrUserStencilTest::kLessIfInClip, 0x0000, GrUserStencilOp::kZero, GrUserStencilOp::kReplace, 0xffff >  () )

staticconstexpr

kTestAndResetStencil()

static constexpr GrUserStencilSettings skgpu::ganesh::kTestAndResetStencil ( GrUserStencilSettings::StaticInit< 0x0000, GrUserStencilTest::kLessIfInClip, 0x0001, GrUserStencilOp::kZero, GrUserStencilOp::kReplace, 0xffff >  () )

staticconstexpr

lazy_as_view()

static std::tuple< GrSurfaceProxyView, GrColorType > skgpu::ganesh::lazy_as_view ( GrRecordingContext *  context, const SkImage_Lazy *  img, skgpu::Mipmapped  mipmapped, GrImageTexGenPolicy  policy  )

static

Definition at line 406 of file GrImageUtils.cpp.

                                                                                            {
    GrColorType ct = ColorTypeOfLockTextureProxy(context->priv().caps(), img->colorType());
    return {LockTextureProxyView(context, img, policy, mipmapped), ct};
}

LockTextureProxyView()

GrSurfaceProxyView skgpu::ganesh::LockTextureProxyView	(	GrRecordingContext *	rContext,
		const SkImage_Lazy *	img,
		GrImageTexGenPolicy	texGenPolicy,
		skgpu::Mipmapped	mipmapped
	)

Definition at line 279 of file GrImageUtils.cpp.

                                                                  {
    // Values representing the various texture lock paths we can take. Used for logging the path
    // taken to a histogram.
    enum LockTexturePath {
        kFailure_LockTexturePath,
        kPreExisting_LockTexturePath,
        kNative_LockTexturePath,
        kCompressed_LockTexturePath, // Deprecated
        kYUV_LockTexturePath,
        kRGBA_LockTexturePath,
    };
 
    enum { kLockTexturePathCount = kRGBA_LockTexturePath + 1 };
 
    skgpu::UniqueKey key;
    if (texGenPolicy == GrImageTexGenPolicy::kDraw) {
        GrMakeKeyFromImageID(&key, img->uniqueID(), SkIRect::MakeSize(img->dimensions()));
    }
 
    const GrCaps* caps = rContext->priv().caps();
    GrProxyProvider* proxyProvider = rContext->priv().proxyProvider();
 
    auto installKey = [&](const GrSurfaceProxyView& view) {
        SkASSERT(view && view.asTextureProxy());
        if (key.isValid()) {
            auto listener = GrMakeUniqueKeyInvalidationListener(&key, rContext->priv().contextID());
            img->addUniqueIDListener(std::move(listener));
            proxyProvider->assignUniqueKeyToProxy(key, view.asTextureProxy());
        }
    };
 
    auto ct = ColorTypeOfLockTextureProxy(caps, img->colorType());
 
    // 1. Check the cache for a pre-existing one.
    if (key.isValid()) {
        auto proxy = proxyProvider->findOrCreateProxyByUniqueKey(key);
        if (proxy) {
            skgpu::Swizzle swizzle = caps->getReadSwizzle(proxy->backendFormat(), ct);
            GrSurfaceOrigin origin = get_origin(img);
            GrSurfaceProxyView view(std::move(proxy), origin, swizzle);
            if (mipmapped == skgpu::Mipmapped::kNo ||
                view.asTextureProxy()->mipmapped() == skgpu::Mipmapped::kYes) {
                return view;
            } else {
                // We need a mipped proxy, but we found a cached proxy that wasn't mipped. Thus we
                // generate a new mipped surface and copy the original proxy into the base layer. We
                // will then let the gpu generate the rest of the mips.
                auto mippedView = GrCopyBaseMipMapToView(rContext, view);
                if (!mippedView) {
                    // We failed to make a mipped proxy with the base copied into it. This could
                    // have been from failure to make the proxy or failure to do the copy. Thus we
                    // will fall back to just using the non mipped proxy; See skbug.com/7094.
                    return view;
                }
                proxyProvider->removeUniqueKeyFromProxy(view.asTextureProxy());
                installKey(mippedView);
                return mippedView;
            }
        }
    }
 
    // 2. Ask the generator to natively create one (if it knows how)
    {
        if (img->type() == SkImage_Base::Type::kLazyPicture) {
            if (auto view = generate_picture_texture(rContext,
                                                     static_cast<const SkImage_Picture*>(img),
                                                     mipmapped,
                                                     texGenPolicy)) {
                installKey(view);
                return view;
            }
        } else if (img->generator()->isTextureGenerator()) {
            auto sharedGenerator = img->generator();
            SkAutoMutexExclusive mutex(sharedGenerator->fMutex);
            auto textureGen = static_cast<GrTextureGenerator*>(sharedGenerator->fGenerator.get());
            if (auto view = textureGen->generateTexture(rContext,
                                                        img->imageInfo(),
                                                        mipmapped,
                                                        texGenPolicy)) {
                installKey(view);
                return view;
            }
        }
    }
 
    // 3. Ask the generator to return YUV planes, which the GPU can convert. If we will be mipping
    //    the texture we skip this step so the CPU generate non-planar MIP maps for us.
    if (mipmapped == skgpu::Mipmapped::kNo &&
        !rContext->priv().options().fDisableGpuYUVConversion) {
        // TODO: Update to create the mipped surface in the textureProxyViewFromPlanes generator and
        //  draw the base layer directly into the mipped surface.
        skgpu::Budgeted budgeted = texGenPolicy == GrImageTexGenPolicy::kNew_Uncached_Unbudgeted
                                           ? skgpu::Budgeted::kNo
                                           : skgpu::Budgeted::kYes;
        auto view = texture_proxy_view_from_planes(rContext, img, budgeted);
        if (view) {
            installKey(view);
            return view;
        }
    }
 
    // 4. Ask the generator to return a bitmap, which the GPU can convert.
    auto hint = texGenPolicy == GrImageTexGenPolicy::kDraw ? SkImage::CachingHint::kAllow_CachingHint
                                                           : SkImage::CachingHint::kDisallow_CachingHint;
    if (SkBitmap bitmap; img->getROPixels(nullptr, &bitmap, hint)) {
        // We always make an uncached bitmap here because we will cache it based on passed in policy
        // with *our* key, not a key derived from bitmap. We're just making the proxy here.
        auto budgeted = texGenPolicy == GrImageTexGenPolicy::kNew_Uncached_Unbudgeted
                                ? skgpu::Budgeted::kNo
                                : skgpu::Budgeted::kYes;
        auto view = std::get<0>(GrMakeUncachedBitmapProxyView(rContext,
                                                              bitmap,
                                                              mipmapped,
                                                              SkBackingFit::kExact,
                                                              budgeted));
        if (view) {
            installKey(view);
            return view;
        }
    }
 
    return {};
}

make_conic_path()

static SkPath skgpu::ganesh::make_conic_path ( )

static

Definition at line 55 of file TessellateBench.cpp.

                                {
    SkRandom rand;
    SkPath path;
    for (int i = 0; i < kNumCubicsInChalkboard / 40; ++i) {
        for (int j = -10; j <= 10; j++) {
            const float x = std::ldexp(rand.nextF(), (i % 18)) / 1e3f;
            const float w = std::ldexp(1 + rand.nextF(), j);
            path.conicTo(111.625f * x, 308.188f * x, 764.62f * x, -435.688f * x, w);
        }
    }
    return path;
}

make_cubic_path()

static SkPath skgpu::ganesh::make_cubic_path ( int  maxPow2 )

static

Definition at line 44 of file TessellateBench.cpp.

                                           {
    SkRandom rand;
    SkPath path;
    for (int i = 0; i < kNumCubicsInChalkboard/2; ++i) {
        float x = std::ldexp(rand.nextF(), (i % maxPow2)) / 1e3f;
        path.cubicTo(111.625f*x, 308.188f*x, 764.62f*x, -435.688f*x, 742.63f*x, 85.187f*x);
        path.cubicTo(764.62f*x, -435.688f*x, 111.625f*x, 308.188f*x, 0, 0);
    }
    return path;
}

make_fp_from_view()

static std::unique_ptr< GrFragmentProcessor > skgpu::ganesh::make_fp_from_view ( GrRecordingContext *  rContext, GrSurfaceProxyView  view, SkAlphaType  at, SkSamplingOptions  sampling, const SkTileMode  tileModes[2], const SkMatrix &  m, const SkRect *  subset, const SkRect *  domain  )

static

Definition at line 444 of file GrImageUtils.cpp.

                                                                                    {
    if (!view) {
        return nullptr;
    }
    const GrCaps& caps = *rContext->priv().caps();
    auto wmx = SkTileModeToWrapMode(tileModes[0]);
    auto wmy = SkTileModeToWrapMode(tileModes[1]);
    if (sampling.useCubic) {
        if (subset) {
            if (domain) {
                return GrBicubicEffect::MakeSubset(std::move(view),
                                                   at,
                                                   m,
                                                   wmx,
                                                   wmy,
                                                   *subset,
                                                   *domain,
                                                   sampling.cubic,
                                                   GrBicubicEffect::Direction::kXY,
                                                   *rContext->priv().caps());
            }
            return GrBicubicEffect::MakeSubset(std::move(view),
                                               at,
                                               m,
                                               wmx,
                                               wmy,
                                               *subset,
                                               sampling.cubic,
                                               GrBicubicEffect::Direction::kXY,
                                               *rContext->priv().caps());
        }
        return GrBicubicEffect::Make(std::move(view),
                                     at,
                                     m,
                                     wmx,
                                     wmy,
                                     sampling.cubic,
                                     GrBicubicEffect::Direction::kXY,
                                     *rContext->priv().caps());
    }
    if (sampling.isAniso()) {
        if (!rContext->priv().caps()->anisoSupport()) {
            // Fallback to linear
            sampling = SkSamplingPriv::AnisoFallback(view.mipmapped() == skgpu::Mipmapped::kYes);
        }
    } else if (view.mipmapped() == skgpu::Mipmapped::kNo) {
        sampling = SkSamplingOptions(sampling.filter);
    }
    GrSamplerState sampler;
    if (sampling.isAniso()) {
        sampler = GrSamplerState::Aniso(wmx, wmy, sampling.maxAniso, view.mipmapped());
    } else {
        sampler = GrSamplerState(wmx, wmy, sampling.filter, sampling.mipmap);
    }
    if (subset) {
        if (domain) {
            return GrTextureEffect::MakeSubset(
                    std::move(view), at, m, sampler, *subset, *domain, caps);
        }
        return GrTextureEffect::MakeSubset(std::move(view), at, m, sampler, *subset, caps);
    } else {
        return GrTextureEffect::Make(std::move(view), at, m, sampler, caps);
    }
}

make_line_path()

static SkPath skgpu::ganesh::make_line_path ( int  maxPow2 )

static

Definition at line 78 of file TessellateBench.cpp.

                                                           {
    SkRandom rand;
    SkPath path;
    for (int i = 0; i < kNumCubicsInChalkboard; ++i) {
        float x = std::ldexp(rand.nextF(), (i % maxPow2)) / 1e3f;
        path.lineTo(764.62f * x, -435.688f * x);
    }
    return path;
}

make_mock_context()

static sk_sp< GrDirectContext > skgpu::ganesh::make_mock_context ( )

static

Definition at line 29 of file TessellateBench.cpp.

                                                  {
    GrMockOptions mockOptions;
    mockOptions.fDrawInstancedSupport = true;
    mockOptions.fMapBufferFlags = GrCaps::kCanMap_MapFlag;
    mockOptions.fConfigOptions[(int)GrColorType::kAlpha_8].fRenderability =
            GrMockOptions::ConfigOptions::Renderability::kMSAA;
    mockOptions.fConfigOptions[(int)GrColorType::kAlpha_8].fTexturable = true;
    mockOptions.fIntegerSupport = true;
 
    GrContextOptions ctxOptions;
    ctxOptions.fGpuPathRenderers = GpuPathRenderers::kTessellation;
 
    return GrDirectContext::MakeMock(&mockOptions, ctxOptions);
}

make_motionmark_paths()

static std::vector< PathStrokeList > skgpu::ganesh::make_motionmark_paths ( )

static

Definition at line 259 of file TessellateBench.cpp.

                                                         {
    std::vector<PathStrokeList> pathStrokes;
    SkRandom rand;
    for (int i = 0; i < 8702; ++i) {
        // The number of paths with a given number of verbs in the MotionMark bench gets cut in half
        // every time the number of verbs increases by 1.
        int numVerbs = 28 - SkNextLog2(rand.nextRangeU(0, (1 << 27) - 1));
        SkPath path;
        for (int j = 0; j < numVerbs; ++j) {
            switch (rand.nextU() & 3) {
                case 0:
                case 1:
                    path.lineTo(rand.nextRangeF(0, 150), rand.nextRangeF(0, 150));
                    break;
                case 2:
                    if (rand.nextULessThan(10) == 0) {
                        // Cusp.
                        auto [x, y] = (path.isEmpty())
                                ? SkPoint{0,0}
                                : SkPathPriv::PointData(path)[path.countPoints() - 1];
                        path.quadTo(x + rand.nextRangeF(0, 150), y, x - rand.nextRangeF(0, 150), y);
                    } else {
                        path.quadTo(rand.nextRangeF(0, 150), rand.nextRangeF(0, 150),
                                    rand.nextRangeF(0, 150), rand.nextRangeF(0, 150));
                    }
                    break;
                case 3:
                    if (rand.nextULessThan(10) == 0) {
                        // Cusp.
                        float y = (path.isEmpty())
                                ? 0 : SkPathPriv::PointData(path)[path.countPoints() - 1].fY;
                        path.cubicTo(rand.nextRangeF(0, 150), y, rand.nextRangeF(0, 150), y,
                                     rand.nextRangeF(0, 150), y);
                    } else {
                        path.cubicTo(rand.nextRangeF(0, 150), rand.nextRangeF(0, 150),
                                     rand.nextRangeF(0, 150), rand.nextRangeF(0, 150),
                                     rand.nextRangeF(0, 150), rand.nextRangeF(0, 150));
                    }
                    break;
            }
        }
        SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
        // The number of paths with a given stroke width in the MotionMark bench gets cut in half
        // every time the stroke width increases by 1.
        float strokeWidth = 21 - log2f(rand.nextRangeF(0, 1 << 20));
        stroke.setStrokeStyle(strokeWidth);
        stroke.setStrokeParams(SkPaint::kButt_Cap, SkPaint::kBevel_Join, 0);
        pathStrokes.emplace_back(path, stroke, SK_PMColor4fWHITE);
    }
    return pathStrokes;
}

make_quad_path()

static SkPath skgpu::ganesh::make_quad_path ( int  maxPow2 )

static

Definition at line 68 of file TessellateBench.cpp.

                                                           {
    SkRandom rand;
    SkPath path;
    for (int i = 0; i < kNumCubicsInChalkboard; ++i) {
        float x = std::ldexp(rand.nextF(), (i % maxPow2)) / 1e3f;
        path.quadTo(111.625f * x, 308.188f * x, 764.62f * x, -435.688f * x);
    }
    return path;
}

make_simple_cubic_path()

static std::vector< PathStrokeList > skgpu::ganesh::make_simple_cubic_path ( )

static

Definition at line 246 of file TessellateBench.cpp.

                                                          {
    auto path = SkPath().moveTo(0, 0);
    for (int i = 0; i < kNumCubicsInChalkboard/2; ++i) {
        path.cubicTo(100, 0, 50, 100, 100, 100);
        path.cubicTo(0, -100, 200, 100, 0, 0);
    }
    SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
    stroke.setStrokeStyle(8);
    stroke.setStrokeParams(SkPaint::kButt_Cap, SkPaint::kMiter_Join, 4);
    return {{path, stroke, SK_PMColor4fWHITE}};
}

MakeFragmentProcessorFromView()

std::unique_ptr< GrFragmentProcessor > skgpu::ganesh::MakeFragmentProcessorFromView	(	GrRecordingContext *	rContext,
		GrSurfaceProxyView	view,
		SkAlphaType	at,
		SkSamplingOptions	sampling,
		const SkTileMode	tileModes[2],
		const SkMatrix &	m,
		const SkRect *	subset,
		const SkRect *	domain
	)

Definition at line 583 of file GrImageUtils.cpp.

                              {
    if (!view) {
        return nullptr;
    }
    const GrCaps& caps = *rContext->priv().caps();
    auto wmx = SkTileModeToWrapMode(tileModes[0]);
    auto wmy = SkTileModeToWrapMode(tileModes[1]);
    if (sampling.useCubic) {
        if (subset) {
            if (domain) {
                return GrBicubicEffect::MakeSubset(std::move(view),
                                                   at,
                                                   m,
                                                   wmx,
                                                   wmy,
                                                   *subset,
                                                   *domain,
                                                   sampling.cubic,
                                                   GrBicubicEffect::Direction::kXY,
                                                   *rContext->priv().caps());
            }
            return GrBicubicEffect::MakeSubset(std::move(view),
                                               at,
                                               m,
                                               wmx,
                                               wmy,
                                               *subset,
                                               sampling.cubic,
                                               GrBicubicEffect::Direction::kXY,
                                               *rContext->priv().caps());
        }
        return GrBicubicEffect::Make(std::move(view),
                                     at,
                                     m,
                                     wmx,
                                     wmy,
                                     sampling.cubic,
                                     GrBicubicEffect::Direction::kXY,
                                     *rContext->priv().caps());
    }
    if (sampling.isAniso()) {
        if (!rContext->priv().caps()->anisoSupport()) {
            // Fallback to linear
            sampling = SkSamplingPriv::AnisoFallback(view.mipmapped() == skgpu::Mipmapped::kYes);
        }
    } else if (view.mipmapped() == skgpu::Mipmapped::kNo) {
        sampling = SkSamplingOptions(sampling.filter);
    }
    GrSamplerState sampler;
    if (sampling.isAniso()) {
        sampler = GrSamplerState::Aniso(wmx, wmy, sampling.maxAniso, view.mipmapped());
    } else {
        sampler = GrSamplerState(wmx, wmy, sampling.filter, sampling.mipmap);
    }
    if (subset) {
        if (domain) {
            return GrTextureEffect::MakeSubset(std::move(view),
                                               at,
                                               m,
                                               sampler,
                                               *subset,
                                               *domain,
                                               caps);
        }
        return GrTextureEffect::MakeSubset(std::move(view),
                                           at,
                                           m,
                                           sampler,
                                           *subset,
                                           caps);
    } else {
        return GrTextureEffect::Make(std::move(view), at, m, sampler, caps);
    }
}

PinAsTexture()

bool skgpu::ganesh::PinAsTexture	(	GrRecordingContext *	rContext,
		SkImage *	img
	)

Will attempt to upload and lock the contents of the image as a texture, so that subsequent draws to a gpu-target will come from that texture (and not by looking at the original image src). In particular this is intended to use the texture even if the image's original content changes subsequent to this call (i.e. the src is mutable!).

Only compatible with SkImages created from SkImages::PinnableRasterFromBitmap.

All successful calls must be balanced by an equal number of calls to UnpinTexture().

Once in this "pinned" state, the image has all of the same thread restrictions that exist for a natively created gpu image (e.g. SkImage::MakeFromTexture)

• all drawing, pinning, unpinning must happen in the same thread as the GrContext.

Returns

true if the image was successfully uploaded and locked into a texture

Definition at line 66 of file SkImage_RasterPinnable.cpp.

                                                              {
    auto ib = as_IB(img);
    if (ib->type() != SkImage_Base::Type::kRasterPinnable) {
        // Cannot pin images which are not of subclass SkImage_RasterPinnable
        return false;
    }
    auto raster = static_cast<SkImage_RasterPinnable*>(ib);
    if (!raster->fPinnedData) {
        auto data = std::make_unique<PinnedData>();
        std::tie(data->fPinnedView, data->fPinnedColorType) =
                GrMakeCachedBitmapProxyView(rContext,
                                            raster->bitmap(),
                                            /*label=*/"ganesh_PinAsTexture",
                                            skgpu::Mipmapped::kNo);
        if (!data->fPinnedView) {
            return false;
        }
        data->fPinnedUniqueID = raster->bitmap().getGenerationID();
        data->fPinnedContextID = rContext->priv().contextID();
        raster->fPinnedData.swap(data);
    } else {
        SkASSERT(raster->fPinnedData->fPinnedCount > 0);
        SkASSERT(raster->fPinnedData->fPinnedUniqueID != 0);
        if (rContext->priv().contextID() != raster->fPinnedData->fPinnedContextID) {
            return false;
        }
    }
    // Note: we only increment if the texture was successfully pinned
    raster->fPinnedData->fPinnedCount++;
    return true;
}

raster_as_fp()

std::unique_ptr< GrFragmentProcessor > skgpu::ganesh::raster_as_fp	(	GrRecordingContext *	rContext,
		const SkImage_Raster *	img,
		SkSamplingOptions	sampling,
		const SkTileMode	tileModes[2],
		const SkMatrix &	m,
		const SkRect *	subset,
		const SkRect *	domain
	)

Definition at line 516 of file GrImageUtils.cpp.

                                                                        {
    auto mm =
            sampling.mipmap == SkMipmapMode::kNone ? skgpu::Mipmapped::kNo : skgpu::Mipmapped::kYes;
    return make_fp_from_view(rContext,
                             std::get<0>(AsView(rContext, img, mm)),
                             img->alphaType(),
                             sampling,
                             tileModes,
                             m,
                             subset,
                             domain);
}

RasterAsView()

std::tuple< GrSurfaceProxyView, GrColorType > skgpu::ganesh::RasterAsView	(	GrRecordingContext *	rContext,
		const SkImage_Raster *	raster,
		skgpu::Mipmapped	mipmapped,
		GrImageTexGenPolicy	policy
	)

Definition at line 100 of file GrImageUtils.cpp.

                                                                                     {
    if (policy == GrImageTexGenPolicy::kDraw) {
        // If the draw doesn't require mipmaps but this SkImage has them go ahead and make a
        // mipmapped texture. There are three reasons for this:
        // 1) Avoiding another texture creation if a later draw requires mipmaps.
        // 2) Ensuring we upload the bitmap's levels instead of generating on the GPU from the base.
        if (raster->hasMipmaps()) {
            mipmapped = skgpu::Mipmapped::kYes;
        }
        return GrMakeCachedBitmapProxyView(rContext,
                                           raster->bitmap(),
                                           /*label=*/"TextureForImageRasterWithPolicyEqualKDraw",
                                           mipmapped);
    }
    auto budgeted = (policy == GrImageTexGenPolicy::kNew_Uncached_Unbudgeted)
                            ? skgpu::Budgeted::kNo
                            : skgpu::Budgeted::kYes;
    return GrMakeUncachedBitmapProxyView(
            rContext, raster->bitmap(), mipmapped, SkBackingFit::kExact, budgeted);
}

SKGPU_DECLARE_STATIC_UNIQUE_KEY() [1/6]

skgpu::ganesh::SKGPU_DECLARE_STATIC_UNIQUE_KEY

(

gFixedCountCurveIndexBufferKey

)

SKGPU_DECLARE_STATIC_UNIQUE_KEY() [2/6]

skgpu::ganesh::SKGPU_DECLARE_STATIC_UNIQUE_KEY

(

gFixedCountCurveVertexBufferKey

)

SKGPU_DECLARE_STATIC_UNIQUE_KEY() [3/6]

skgpu::ganesh::SKGPU_DECLARE_STATIC_UNIQUE_KEY

(

gFixedCountWedgesIndexBufferKey

)

SKGPU_DECLARE_STATIC_UNIQUE_KEY() [4/6]

skgpu::ganesh::SKGPU_DECLARE_STATIC_UNIQUE_KEY

(

gFixedCountWedgesVertexBufferKey

)

SKGPU_DECLARE_STATIC_UNIQUE_KEY() [5/6]

skgpu::ganesh::SKGPU_DECLARE_STATIC_UNIQUE_KEY

(

gHullVertexBufferKey

)

SKGPU_DECLARE_STATIC_UNIQUE_KEY() [6/6]

skgpu::ganesh::SKGPU_DECLARE_STATIC_UNIQUE_KEY

(

gVertexIDFallbackBufferKey

)

SupportedTextureFormats()

SkYUVAPixmapInfo::SupportedDataTypes skgpu::ganesh::SupportedTextureFormats

(

const GrImageContext &

)

Init based on texture formats supported by the context.

Definition at line 703 of file GrImageUtils.cpp.

                                                                                          {
    SkYUVAPixmapInfo::SupportedDataTypes dataTypes;
    const auto isValid = [&context](DataType dt, int n) {
        return context.defaultBackendFormat(SkYUVAPixmapInfo::DefaultColorTypeForDataType(dt, n),
                                            GrRenderable::kNo).isValid();
    };
     for (int n = 1; n <= 4; ++n) {
        if (isValid(DataType::kUnorm8, n)) {
            dataTypes.enableDataType(DataType::kUnorm8, n);
        }
        if (isValid(DataType::kUnorm16, n)) {
            dataTypes.enableDataType(DataType::kUnorm16, n);
        }
        if (isValid(DataType::kFloat16, n)) {
            dataTypes.enableDataType(DataType::kFloat16, n);
        }
        if (isValid(DataType::kUnorm10_Unorm2, n)) {
            dataTypes.enableDataType(DataType::kUnorm10_Unorm2, n);
        }
    }
     return dataTypes;
}

texture_proxy_view_from_planes()

static GrSurfaceProxyView skgpu::ganesh::texture_proxy_view_from_planes ( GrRecordingContext *  ctx, const SkImage_Lazy *  img, skgpu::Budgeted  budgeted  )

static

Definition at line 147 of file GrImageUtils.cpp.

                                                                                 {
    auto supportedDataTypes = SupportedTextureFormats(*ctx);
    SkYUVAPixmaps yuvaPixmaps;
    sk_sp<SkCachedData> dataStorage = img->getPlanes(supportedDataTypes, &yuvaPixmaps);
    if (!dataStorage) {
        return {};
    }
 
    GrSurfaceProxyView views[SkYUVAInfo::kMaxPlanes];
    GrColorType pixmapColorTypes[SkYUVAInfo::kMaxPlanes];
    for (int i = 0; i < yuvaPixmaps.numPlanes(); ++i) {
        // If the sizes of the components are not all the same we choose to create exact-match
        // textures for the smaller ones rather than add a texture domain to the draw.
        // TODO: revisit this decision to improve texture reuse?
        SkBackingFit fit = yuvaPixmaps.plane(i).dimensions() == img->dimensions()
                                   ? SkBackingFit::kApprox
                                   : SkBackingFit::kExact;
 
        // We grab a ref to cached yuv data. When the SkBitmap we create below goes away it will
        // call releaseProc which will release this ref.
        // DDL TODO: Currently we end up creating a lazy proxy that will hold onto a ref to the
        // SkImage in its lambda. This means that we'll keep the ref on the YUV data around for the
        // life time of the proxy and not just upload. For non-DDL draws we should look into
        // releasing this SkImage after uploads (by deleting the lambda after instantiation).
        auto releaseProc = [](void*, void* data) {
            auto cachedData = static_cast<SkCachedData*>(data);
            SkASSERT(cachedData);
            cachedData->unref();
        };
        SkBitmap bitmap;
        bitmap.installPixels(yuvaPixmaps.plane(i).info(),
                             yuvaPixmaps.plane(i).writable_addr(),
                             yuvaPixmaps.plane(i).rowBytes(),
                             releaseProc,
                             SkRef(dataStorage.get()));
        bitmap.setImmutable();
 
        std::tie(views[i], std::ignore) =
                GrMakeUncachedBitmapProxyView(ctx, bitmap, skgpu::Mipmapped::kNo, fit);
        if (!views[i]) {
            return {};
        }
        pixmapColorTypes[i] = SkColorTypeToGrColorType(bitmap.colorType());
    }
 
    // TODO: investigate preallocating mip maps here
    GrImageInfo info(SkColorTypeToGrColorType(img->colorType()),
                     kPremul_SkAlphaType,
                     /*color space*/ nullptr,
                     img->dimensions());
 
    auto sfc = ctx->priv().makeSFC(info,
                                   "ImageLazy_TextureProxyViewFromPlanes",
                                   SkBackingFit::kExact,
                                   1,
                                   skgpu::Mipmapped::kNo,
                                   GrProtected::kNo,
                                   kTopLeft_GrSurfaceOrigin,
                                   budgeted);
    if (!sfc) {
        return {};
    }
 
    GrYUVATextureProxies yuvaProxies(yuvaPixmaps.yuvaInfo(), views, pixmapColorTypes);
    SkAssertResult(yuvaProxies.isValid());
 
    std::unique_ptr<GrFragmentProcessor> fp = GrYUVtoRGBEffect::Make(
            yuvaProxies,
            GrSamplerState::Filter::kNearest,
            *ctx->priv().caps());
 
    // The pixels after yuv->rgb will be in the generator's color space.
    // If onMakeColorTypeAndColorSpace has been called then this will not match this image's
    // color space. To correct this, apply a color space conversion from the generator's color
    // space to this image's color space.
    SkColorSpace* srcColorSpace = img->generator()->getInfo().colorSpace();
    SkColorSpace* dstColorSpace = img->colorSpace();
 
    // If the caller expects the pixels in a different color space than the one from the image,
    // apply a color conversion to do this.
    fp = GrColorSpaceXformEffect::Make(std::move(fp),
                                       srcColorSpace, kOpaque_SkAlphaType,
                                       dstColorSpace, kOpaque_SkAlphaType);
    sfc->fillWithFP(std::move(fp));
 
    return sfc->readSurfaceView();
}

TopDeviceSurfaceDrawContext()

SurfaceDrawContext * skgpu::ganesh::TopDeviceSurfaceDrawContext

(

const SkCanvas *

canvas

)

Definition at line 20 of file GrCanvas.cpp.

                                                                        {
    if (auto gpuDevice = SkCanvasPriv::TopDevice(canvas)->asGaneshDevice()) {
        return gpuDevice->surfaceDrawContext();
    }
    return nullptr;
}

TopDeviceSurfaceFillContext()

SurfaceFillContext * skgpu::ganesh::TopDeviceSurfaceFillContext

(

const SkCanvas *

canvas

)

Definition at line 27 of file GrCanvas.cpp.

                                                                        {
    if (auto gpuDevice = SkCanvasPriv::TopDevice(canvas)->asGaneshDevice()) {
        return gpuDevice->surfaceFillContext();
    }
    return nullptr;
}

TopDeviceTargetProxy()

GrRenderTargetProxy * skgpu::ganesh::TopDeviceTargetProxy

(

const SkCanvas *

canvas

)

Definition at line 34 of file GrCanvas.cpp.

                                                                  {
    if (auto gpuDevice = SkCanvasPriv::TopDevice(canvas)->asGaneshDevice()) {
        return gpuDevice->targetProxy();
    }
    return nullptr;
}

TopLayerBackendRenderTarget()

GrBackendRenderTarget skgpu::ganesh::TopLayerBackendRenderTarget

(

const SkCanvas *

canvas

)

Definition at line 45 of file GrCanvas.cpp.

                                                                          {
    auto proxy = TopDeviceTargetProxy(canvas);
    if (!proxy) {
        return {};
    }
    const GrRenderTarget* renderTarget = proxy->peekRenderTarget();
    return renderTarget ? renderTarget->getBackendRenderTarget() : GrBackendRenderTarget();
}

TopLayerBounds()

SkIRect skgpu::ganesh::TopLayerBounds

(

const SkCanvas *

canvas

)

Definition at line 41 of file GrCanvas.cpp.

                                               {
    return SkCanvasPriv::TopDevice(canvas)->getGlobalBounds();
}

UnpinTexture()

void skgpu::ganesh::UnpinTexture	(	GrRecordingContext *	,
		SkImage *	img
	)

The balancing call to a successful invocation of PinAsTexture. When a balanced number of calls have been made, then the "pinned" texture is free to be purged, etc. This also means that a subsequent "pin" call will look at the original content again, and if its uniqueID/generationID has changed, then a newer texture will be uploaded/pinned.

Only compatible with SkImages created from SkImages::PinnableRasterFromBitmap.

The context passed to unpin must match the one passed to pin.

Definition at line 98 of file SkImage_RasterPinnable.cpp.

                                                     {
    auto ib = as_IB(img);
    if (ib->type() != SkImage_Base::Type::kRasterPinnable) {
        // Cannot pin images which are not of subclass SkImage_RasterPinnable
        return;
    }
    auto raster = static_cast<SkImage_RasterPinnable*>(ib);
    if (!raster->fPinnedData) {
        SkASSERT(false);
        return;
    }
 
    SkASSERT(raster->fPinnedData->fPinnedCount > 0);
    SkASSERT(raster->fPinnedData->fPinnedUniqueID != 0);
    // It would be good to check rContext->priv().contextID() != fPinnedContextID
    // but Android used to (maybe still does) call Unpin with a freed context ptr
 
    raster->fPinnedData->fPinnedCount--;
    if (raster->fPinnedData->fPinnedCount <= 0) {
        raster->fPinnedData.reset(nullptr);
    }
}

Variable Documentation

gAlmostIdentity

const SkMatrix skgpu::ganesh::gAlmostIdentity

static

Initial value:

= SkMatrix::MakeAll(
        1.0001f, 0.0001f, 0.0001f,
        -.0001f, 0.9999f, -.0001f,
              0,       0,       1)

Definition at line 132 of file TessellateBench.cpp.

gCache

thread_local void* skgpu::ganesh::gCache = nullptr

static

Definition at line 59 of file AtlasTextOp.cpp.

GrStrokeFixedCountTessellator_one_chop

skgpu::ganesh::GrStrokeFixedCountTessellator_one_chop

Definition at line 375 of file TessellateBench.cpp.

kAtlasAlgorithm

constexpr auto skgpu::ganesh::kAtlasAlgorithm = GrDynamicAtlas::RectanizerAlgorithm::kPow2

staticconstexpr

Definition at line 93 of file AtlasPathRenderer.cpp.

kAtlasAlpha8Type

constexpr auto skgpu::ganesh::kAtlasAlpha8Type = GrColorType::kAlpha_8

staticconstexpr

Definition at line 87 of file AtlasPathRenderer.cpp.

kAtlasInitialSize

constexpr int skgpu::ganesh::kAtlasInitialSize = 512

staticconstexpr

Definition at line 88 of file AtlasPathRenderer.cpp.

kAtlasMaxPathHeight

constexpr int skgpu::ganesh::kAtlasMaxPathHeight = 256

staticconstexpr

Definition at line 96 of file AtlasPathRenderer.cpp.

kAtlasMaxPathHeightWithMSAAFallback

constexpr int skgpu::ganesh::kAtlasMaxPathHeightWithMSAAFallback = 128

staticconstexpr

Definition at line 100 of file AtlasPathRenderer.cpp.

kAtlasMaxPathWidth

constexpr int skgpu::ganesh::kAtlasMaxPathWidth = 1024

staticconstexpr

Definition at line 105 of file AtlasPathRenderer.cpp.

kElementStackIncrement

constexpr int skgpu::ganesh::kElementStackIncrement = 8

staticconstexpr

Definition at line 1134 of file ClipStack.cpp.

kIndicesPerGlyph

constexpr int skgpu::ganesh::kIndicesPerGlyph = 6

inlinestaticconstexpr

Definition at line 56 of file AtlasTextOp.cpp.

kMaskStackIncrement

constexpr int skgpu::ganesh::kMaskStackIncrement = 4

staticconstexpr

Definition at line 1136 of file ClipStack.cpp.

kMaxAnalyticFPs

constexpr int skgpu::ganesh::kMaxAnalyticFPs = 4

staticconstexpr

Definition at line 1141 of file ClipStack.cpp.

kNumCubicsInChalkboard

constexpr int skgpu::ganesh::kNumCubicsInChalkboard = 47182

staticconstexpr

Definition at line 27 of file TessellateBench.cpp.

kNumStackMasks

constexpr int skgpu::ganesh::kNumStackMasks = 4

staticconstexpr

Definition at line 1145 of file ClipStack.cpp.

kSaveStackIncrement

constexpr int skgpu::ganesh::kSaveStackIncrement = 8

staticconstexpr

Definition at line 1135 of file ClipStack.cpp.

kVerticesPerGlyph

constexpr int skgpu::ganesh::kVerticesPerGlyph = 4

inlinestaticconstexpr

Definition at line 55 of file AtlasTextOp.cpp.