GrDirectContext.cpp File Reference

#include "include/gpu/GrDirectContext.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkSize.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTextureCompressionType.h"
#include "include/core/SkTraceMemoryDump.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrBackendSemaphore.h"
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrContextThreadSafeProxy.h"
#include "include/private/base/SingleOwner.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/base/SkAutoMalloc.h"
#include "src/core/SkCompressedDataUtils.h"
#include "src/core/SkMipmap.h"
#include "src/core/SkTaskGroup.h"
#include "src/core/SkTraceEvent.h"
#include "src/gpu/DataUtils.h"
#include "src/gpu/GpuTypesPriv.h"
#include "src/gpu/RefCntedCallback.h"
#include "src/gpu/Swizzle.h"
#include "src/gpu/ganesh/Device.h"
#include "src/gpu/ganesh/GrBackendUtils.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrClientMappedBufferManager.h"
#include "src/gpu/ganesh/GrColorInfo.h"
#include "src/gpu/ganesh/GrContextThreadSafeProxyPriv.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrDrawOpAtlas.h"
#include "src/gpu/ganesh/GrDrawingManager.h"
#include "src/gpu/ganesh/GrGpu.h"
#include "src/gpu/ganesh/GrPixmap.h"
#include "src/gpu/ganesh/GrProxyProvider.h"
#include "src/gpu/ganesh/GrRenderTargetProxy.h"
#include "src/gpu/ganesh/GrResourceCache.h"
#include "src/gpu/ganesh/GrResourceProvider.h"
#include "src/gpu/ganesh/GrSemaphore.h"
#include "src/gpu/ganesh/GrShaderCaps.h"
#include "src/gpu/ganesh/GrSurfaceProxy.h"
#include "src/gpu/ganesh/GrSurfaceProxyView.h"
#include "src/gpu/ganesh/GrThreadSafePipelineBuilder.h"
#include "src/gpu/ganesh/SurfaceContext.h"
#include "src/gpu/ganesh/image/SkImage_GaneshBase.h"
#include "src/gpu/ganesh/mock/GrMockGpu.h"
#include "src/gpu/ganesh/ops/SmallPathAtlasMgr.h"
#include "src/gpu/ganesh/surface/SkSurface_Ganesh.h"
#include "src/gpu/ganesh/text/GrAtlasManager.h"
#include "src/image/SkImage_Base.h"
#include "src/image/SkSurface_Base.h"
#include "src/text/gpu/StrikeCache.h"
#include "src/text/gpu/TextBlobRedrawCoordinator.h"
#include <array>
#include <atomic>
#include <forward_list>
#include <memory>
#include <utility>

Go to the source code of this file.

Macros
#define	ASSERT_SINGLE_OWNER   SKGPU_ASSERT_SINGLE_OWNER(this->singleOwner())

Typedefs
using	StrikeCache = sktext::gpu::StrikeCache

Functions
static GrBackendTexture	create_and_clear_backend_texture (GrDirectContext *dContext, SkISize dimensions, const GrBackendFormat &backendFormat, skgpu::Mipmapped mipmapped, GrRenderable renderable, GrProtected isProtected, sk_sp< skgpu::RefCntedCallback > finishedCallback, std::array< float, 4 > color, std::string_view label)
static bool	update_texture_with_pixmaps (GrDirectContext *context, const SkPixmap src[], int numLevels, const GrBackendTexture &backendTexture, GrSurfaceOrigin textureOrigin, sk_sp< skgpu::RefCntedCallback > finishedCallback)
static GrBackendTexture	create_and_update_compressed_backend_texture (GrDirectContext *dContext, SkISize dimensions, const GrBackendFormat &backendFormat, skgpu::Mipmapped mipmapped, GrProtected isProtected, sk_sp< skgpu::RefCntedCallback > finishedCallback, const void *data, size_t size)

Macro Definition Documentation

ASSERT_SINGLE_OWNER

#define ASSERT_SINGLE_OWNER   SKGPU_ASSERT_SINGLE_OWNER(this->singleOwner())

Definition at line 75 of file GrDirectContext.cpp.

Typedef Documentation

StrikeCache

using StrikeCache = sktext::gpu::StrikeCache

Definition at line 77 of file GrDirectContext.cpp.

Function Documentation

create_and_clear_backend_texture()

static GrBackendTexture create_and_clear_backend_texture ( GrDirectContext *  dContext, SkISize  dimensions, const GrBackendFormat &  backendFormat, skgpu::Mipmapped  mipmapped, GrRenderable  renderable, GrProtected  isProtected, sk_sp< skgpu::RefCntedCallback >  finishedCallback, std::array< float, 4 >  color, std::string_view  label  )

static

Definition at line 643 of file GrDirectContext.cpp.

                              {
    GrGpu* gpu = dContext->priv().getGpu();
    GrBackendTexture beTex = gpu->createBackendTexture(dimensions, backendFormat, renderable,
                                                       mipmapped, isProtected, label);
    if (!beTex.isValid()) {
        return {};
    }
 
    if (!dContext->priv().getGpu()->clearBackendTexture(beTex,
                                                        std::move(finishedCallback),
                                                        color)) {
        dContext->deleteBackendTexture(beTex);
        return {};
    }
    return beTex;
}

create_and_update_compressed_backend_texture()

static GrBackendTexture create_and_update_compressed_backend_texture ( GrDirectContext *  dContext, SkISize  dimensions, const GrBackendFormat &  backendFormat, skgpu::Mipmapped  mipmapped, GrProtected  isProtected, sk_sp< skgpu::RefCntedCallback >  finishedCallback, const void *  data, size_t  size  )

static

Definition at line 910 of file GrDirectContext.cpp.

                     {
    GrGpu* gpu = dContext->priv().getGpu();
 
    GrBackendTexture beTex = gpu->createCompressedBackendTexture(dimensions, backendFormat,
                                                                 mipmapped, isProtected);
    if (!beTex.isValid()) {
        return {};
    }
 
    if (!dContext->priv().getGpu()->updateCompressedBackendTexture(
                beTex, std::move(finishedCallback), data, size)) {
        dContext->deleteBackendTexture(beTex);
        return {};
    }
    return beTex;
}

update_texture_with_pixmaps()

static bool update_texture_with_pixmaps ( GrDirectContext *  context, const SkPixmap  src[], int  numLevels, const GrBackendTexture &  backendTexture, GrSurfaceOrigin  textureOrigin, sk_sp< skgpu::RefCntedCallback >  finishedCallback  )

static

Definition at line 669 of file GrDirectContext.cpp.

                                                                                       {
    GrColorType ct = SkColorTypeToGrColorType(src[0].colorType());
    const GrBackendFormat& format = backendTexture.getBackendFormat();
 
    if (!context->priv().caps()->areColorTypeAndFormatCompatible(ct, format)) {
        return false;
    }
 
    auto proxy = context->priv().proxyProvider()->wrapBackendTexture(backendTexture,
                                                                     kBorrow_GrWrapOwnership,
                                                                     GrWrapCacheable::kNo,
                                                                     kRW_GrIOType,
                                                                     std::move(finishedCallback));
    if (!proxy) {
        return false;
    }
 
    skgpu::Swizzle swizzle = context->priv().caps()->getReadSwizzle(format, ct);
    GrSurfaceProxyView view(std::move(proxy), textureOrigin, swizzle);
    skgpu::ganesh::SurfaceContext surfaceContext(
            context, std::move(view), src[0].info().colorInfo());
    AutoSTArray<15, GrCPixmap> tmpSrc(numLevels);
    for (int i = 0; i < numLevels; ++i) {
        tmpSrc[i] = src[i];
    }
    if (!surfaceContext.writePixels(context, tmpSrc.get(), numLevels)) {
        return false;
    }
 
    GrSurfaceProxy* p = surfaceContext.asSurfaceProxy();
    GrFlushInfo info;
    context->priv().drawingManager()->flushSurfaces(
            {&p, 1}, SkSurfaces::BackendSurfaceAccess::kNoAccess, info, nullptr);
    return true;
}