sk_gpu_test Namespace Reference

Namespaces
namespace	test_ops

Classes
class	ContextInfo
class	FenceSync
class	FlushFinishTracker
class	GLTestContext
class	GpuTimer
class	GrContextFactory
class	LazyYUVImage
class	MemoryCache
class	TestContext
class	VkTestMemoryAllocator

Typedefs
using	Mipmapped = skgpu::Mipmapped
using	Protected = skgpu::Protected
using	Renderable = skgpu::Renderable
using	PlatformFence = uint64_t
using	PlatformTimerQuery = uint64_t

Enumerations
enum class	ANGLEBackend { kD3D9 , kD3D11 , kOpenGL , kMetal }
enum class	ANGLEContextVersion { kES2 , kES3 }

Functions
GLTestContext *	CreatePlatformGLTestContext (GrGLStandard forcedGpuAPI, GLTestContext *shareContext)
sk_sp< SkSurface >	MakeBackendTextureSurface (GrDirectContext *dContext, const SkImageInfo &ii, GrSurfaceOrigin origin, int sampleCnt, skgpu::Mipmapped mipmapped, GrProtected isProtected, const SkSurfaceProps *props)
sk_sp< SkSurface >	MakeBackendTextureSurface (GrDirectContext *dContext, SkISize dimensions, GrSurfaceOrigin origin, int sampleCnt, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, skgpu::Mipmapped mipmapped, GrProtected isProtected, const SkSurfaceProps *props)
sk_sp< SkSurface >	MakeBackendRenderTargetSurface (GrDirectContext *dContext, const SkImageInfo &ii, GrSurfaceOrigin origin, int sampleCnt, GrProtected isProtected, const SkSurfaceProps *props)
sk_sp< SkSurface >	MakeBackendRenderTargetSurface (GrDirectContext *dContext, SkISize dimensions, GrSurfaceOrigin origin, int sampleCnt, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, GrProtected isProtected, const SkSurfaceProps *props)
GrTextureProxy *	GetTextureImageProxy (SkImage *image, GrRecordingContext *rContext)
GrSurfaceProxyView	MakeTextureProxyViewFromData (GrDirectContext *dContext, GrRenderable renderable, GrSurfaceOrigin origin, GrCPixmap pixmap)

Variables
static constexpr PlatformFence	kInvalidFence = 0
static constexpr PlatformTimerQuery	kInvalidTimerQuery = 0

Typedef Documentation

Mipmapped

using sk_gpu_test::Mipmapped = typedef skgpu::Mipmapped

Definition at line 32 of file BackendTextureImageFactory.h.

PlatformFence

using sk_gpu_test::PlatformFence = typedef uint64_t

Definition at line 15 of file FenceSync.h.

PlatformTimerQuery

using sk_gpu_test::PlatformTimerQuery = typedef uint64_t

Definition at line 17 of file GpuTimer.h.

Protected

using sk_gpu_test::Protected = typedef skgpu::Protected

Definition at line 33 of file BackendTextureImageFactory.h.

Renderable

using sk_gpu_test::Renderable = typedef skgpu::Renderable

Definition at line 34 of file BackendTextureImageFactory.h.

Enumeration Type Documentation

ANGLEBackend

enum class sk_gpu_test::ANGLEBackend

strong

Enumerator
kD3D9
kD3D11
kOpenGL
kMetal

Definition at line 21 of file GLTestContext_angle.h.

                        {
    kD3D9,
    kD3D11,
    kOpenGL,
    kMetal
};

ANGLEContextVersion

enum class sk_gpu_test::ANGLEContextVersion

strong

Enumerator
kES2
kES3

Definition at line 28 of file GLTestContext_angle.h.

                               {
    kES2,
    kES3
};

Function Documentation

CreatePlatformGLTestContext()

GLTestContext * sk_gpu_test::CreatePlatformGLTestContext	(	GrGLStandard	forcedGpuAPI,
		GLTestContext *	shareContext = nullptr
	)

Creates platform-dependent GL context object. The shareContext parameter is in an optional context with which to share display lists. This should be a pointer to an GLTestContext created with SkCreatePlatformGLTestContext. NULL indicates that no sharing is to take place. Returns a valid gl context object or NULL if such can not be created.

Definition at line 340 of file gm_bindings.cpp.

                                                                        {
    return new WasmWebGlTestContext();
}

GetTextureImageProxy()

GrTextureProxy * sk_gpu_test::GetTextureImageProxy	(	SkImage *	,
		GrRecordingContext *
	)

Returns the proxy backing an image if it is texture backed, otherwise nullptr.

Definition at line 32 of file ProxyUtils.cpp.

                                                                                   {
    if (!as_IB(image)->isGaneshBacked() || as_IB(image)->isYUVA()) {
        return nullptr;
    }
    if (!rContext) {
        // If the image is backed by a recording context we'll use that.
        GrImageContext* iContext = as_IB(image)->context();
        SkASSERT(iContext);
        rContext = iContext->priv().asRecordingContext();
        if (!rContext) {
            return nullptr;
        }
    }
    auto [view, ct] = skgpu::ganesh::AsView(rContext, image, skgpu::Mipmapped::kNo);
    if (!view) {
        // With the above checks we expect this to succeed unless there is a context mismatch.
        SkASSERT(!image->isValid(rContext));
        return nullptr;
    }
    GrSurfaceProxy* proxy = view.proxy();
    SkASSERT(proxy->asTextureProxy());
    return proxy->asTextureProxy();
}

MakeBackendRenderTargetSurface() [1/2]

sk_sp< SkSurface > sk_gpu_test::MakeBackendRenderTargetSurface	(	GrDirectContext *	,
		const SkImageInfo &	,
		GrSurfaceOrigin	,
		int	sampleCnt,
		GrProtected	= GrProtected::kNo,
		const SkSurfaceProps *	= nullptr
	)

Creates an SkSurface backed by a non-textureable render target.

Definition at line 70 of file BackendSurfaceFactory.cpp.

                                                                             {
    if (ii.alphaType() == kUnpremul_SkAlphaType || ii.alphaType() == kUnknown_SkAlphaType) {
        return nullptr;
    }
    auto ct = SkColorTypeToGrColorType(ii.colorType());
 
    struct ReleaseContext {
        sk_sp<GrDirectContext> fContext;
        GrBackendRenderTarget fRenderTarget;
    };
 
    auto bert = dContext->priv().getGpu()->createTestingOnlyBackendRenderTarget(
            ii.dimensions(), ct, sampleCnt, isProtected);
    auto rc = new ReleaseContext{sk_ref_sp(dContext), bert};
    SkASSERT(!bert.isValid() || bert.sampleCnt() >= sampleCnt);
 
    auto proc = [](void* c) {
        const auto* rc = static_cast<ReleaseContext*>(c);
        if (auto gpu = rc->fContext->priv().getGpu(); gpu && rc->fRenderTarget.isValid()) {
            gpu->deleteTestingOnlyBackendRenderTarget(rc->fRenderTarget);
        }
        delete rc;
    };
 
    return SkSurfaces::WrapBackendRenderTarget(
            dContext, bert, origin, ii.colorType(), ii.refColorSpace(), props, proc, rc);
}

MakeBackendRenderTargetSurface() [2/2]

sk_sp< SkSurface > sk_gpu_test::MakeBackendRenderTargetSurface	(	GrDirectContext *	dContext,
		SkISize	dimensions,
		GrSurfaceOrigin	origin,
		int	sampleCnt,
		SkColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		GrProtected	isProtected,
		const SkSurfaceProps *	props
	)

Definition at line 103 of file BackendSurfaceFactory.cpp.

                                                                             {
    auto ii = SkImageInfo::Make(dimensions, colorType, kPremul_SkAlphaType, std::move(colorSpace));
    return MakeBackendRenderTargetSurface(dContext, ii, origin, sampleCnt, isProtected, props);
}

MakeBackendTextureSurface() [1/2]

sk_sp< SkSurface > sk_gpu_test::MakeBackendTextureSurface	(	GrDirectContext *	dContext,
		const SkImageInfo &	ii,
		GrSurfaceOrigin	origin,
		int	sampleCnt,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		const SkSurfaceProps *	props
	)

Definition at line 26 of file BackendSurfaceFactory.cpp.

                                                                        {
    if (ii.alphaType() == kUnpremul_SkAlphaType) {
        return nullptr;
    }
    auto mbet = ManagedBackendTexture::MakeWithoutData(dContext,
                                                       ii.width(),
                                                       ii.height(),
                                                       ii.colorType(),
                                                       mipmapped,
                                                       GrRenderable::kYes,
                                                       isProtected);
    if (!mbet) {
        return nullptr;
    }
    return SkSurfaces::WrapBackendTexture(dContext,
                                          mbet->texture(),
                                          origin,
                                          sampleCnt,
                                          ii.colorType(),
                                          ii.refColorSpace(),
                                          props,
                                          ManagedBackendTexture::ReleaseProc,
                                          mbet->releaseContext());
}

MakeBackendTextureSurface() [2/2]

sk_sp< SkSurface > sk_gpu_test::MakeBackendTextureSurface	(	GrDirectContext *	dContext,
		SkISize	dimensions,
		GrSurfaceOrigin	origin,
		int	sampleCnt,
		SkColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		const SkSurfaceProps *	props
	)

Definition at line 57 of file BackendSurfaceFactory.cpp.

                                                                        {
    auto ii = SkImageInfo::Make(dimensions, colorType, kPremul_SkAlphaType, std::move(colorSpace));
    return MakeBackendTextureSurface(
            dContext, ii, origin, sampleCnt, mipmapped, isProtected, props);
}

MakeTextureProxyViewFromData()

GrSurfaceProxyView sk_gpu_test::MakeTextureProxyViewFromData	(	GrDirectContext *	,
		GrRenderable	,
		GrSurfaceOrigin	,
		GrCPixmap	pixmap
	)

Makes a texture proxy containing the passed in color data.

Definition at line 56 of file ProxyUtils.cpp.

                                                                  {
    if (dContext->abandoned()) {
        return {};
    }
 
    const GrCaps* caps = dContext->priv().caps();
 
    const GrBackendFormat format = caps->getDefaultBackendFormat(pixmap.colorType(), renderable);
    if (!format.isValid()) {
        return {};
    }
    skgpu::Swizzle swizzle = caps->getReadSwizzle(format, pixmap.colorType());
 
    sk_sp<GrTextureProxy> proxy;
    proxy = dContext->priv().proxyProvider()->createProxy(format,
                                                          pixmap.dimensions(),
                                                          renderable,
                                                          /*sample count*/ 1,
                                                          skgpu::Mipmapped::kNo,
                                                          SkBackingFit::kExact,
                                                          skgpu::Budgeted::kYes,
                                                          GrProtected::kNo,
                                                          /*label=*/"TextureProxyViewFromData");
    if (!proxy) {
        return {};
    }
    GrSurfaceProxyView view(proxy, origin, swizzle);
    auto sContext = dContext->priv().makeSC(std::move(view), pixmap.colorInfo());
    if (!sContext) {
        return {};
    }
    if (!sContext->writePixels(dContext, pixmap, {0, 0})) {
        return {};
    }
    return sContext->readSurfaceView();
}

Variable Documentation

kInvalidFence

constexpr PlatformFence sk_gpu_test::kInvalidFence = 0

staticconstexpr

Definition at line 16 of file FenceSync.h.

kInvalidTimerQuery

constexpr PlatformTimerQuery sk_gpu_test::kInvalidTimerQuery = 0

staticconstexpr

Definition at line 18 of file GpuTimer.h.