#include "src/gpu/ganesh/Device.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkClipOp.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkDrawable.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkM44.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkMesh.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRRect.h"
#include "include/core/SkRSXform.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkRegion.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkSpan.h"
#include "include/core/SkStrokeRec.h"
#include "include/core/SkSurface.h"
#include "include/core/SkSurfaceProps.h"
#include "include/core/SkVertices.h"
#include "include/effects/SkRuntimeEffect.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/ganesh/GrBackendSurface.h"
#include "include/gpu/ganesh/GrContextOptions.h"
#include "include/gpu/ganesh/GrDirectContext.h"
#include "include/gpu/ganesh/GrRecordingContext.h"
#include "include/gpu/ganesh/GrTypes.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "include/private/SkColorData.h"
#include "include/private/base/SingleOwner.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTo.h"
#include "include/private/chromium/Slug.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/base/SkTLazy.h"
#include "src/core/SkDevice.h"
#include "src/core/SkDrawBase.h"
#include "src/core/SkImageFilterTypes.h"
#include "src/core/SkImageInfoPriv.h"
#include "src/core/SkLatticeIter.h"
#include "src/core/SkMeshPriv.h"
#include "src/core/SkRasterClip.h"
#include "src/core/SkSpecialImage.h"
#include "src/core/SkStrikeCache.h"
#include "src/core/SkTraceEvent.h"
#include "src/core/SkVerticesPriv.h"
#include "src/gpu/SkBackingFit.h"
#include "src/gpu/Swizzle.h"
#include "src/gpu/TiledTextureUtils.h"
#include "src/gpu/ganesh/ClipStack.h"
#include "src/gpu/ganesh/GrAuditTrail.h"
#include "src/gpu/ganesh/GrBlurUtils.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrColorInfo.h"
#include "src/gpu/ganesh/GrColorSpaceXform.h"
#include "src/gpu/ganesh/GrFPArgs.h"
#include "src/gpu/ganesh/GrFragmentProcessor.h"
#include "src/gpu/ganesh/GrFragmentProcessors.h"
#include "src/gpu/ganesh/GrImageInfo.h"
#include "src/gpu/ganesh/GrPaint.h"
#include "src/gpu/ganesh/GrProxyProvider.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/GrRenderTargetProxy.h"
#include "src/gpu/ganesh/GrStyle.h"
#include "src/gpu/ganesh/GrSurfaceProxy.h"
#include "src/gpu/ganesh/GrSurfaceProxyPriv.h"
#include "src/gpu/ganesh/GrSurfaceProxyView.h"
#include "src/gpu/ganesh/GrTextureProxy.h"
#include "src/gpu/ganesh/GrTracing.h"
#include "src/gpu/ganesh/GrUserStencilSettings.h"
#include "src/gpu/ganesh/GrXferProcessor.h"
#include "src/gpu/ganesh/SkGr.h"
#include "src/gpu/ganesh/SurfaceContext.h"
#include "src/gpu/ganesh/SurfaceDrawContext.h"
#include "src/gpu/ganesh/SurfaceFillContext.h"
#include "src/gpu/ganesh/effects/GrDisableColorXP.h"
#include "src/gpu/ganesh/effects/GrRRectEffect.h"
#include "src/gpu/ganesh/geometry/GrShape.h"
#include "src/gpu/ganesh/geometry/GrStyledShape.h"
#include "src/gpu/ganesh/image/GrImageUtils.h"
#include "src/gpu/ganesh/image/SkSpecialImage_Ganesh.h"
#include "src/text/GlyphRun.h"
#include "src/text/gpu/SlugImpl.h"
#include "src/text/gpu/SubRunContainer.h"
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <tuple>
#include <utility>
class GrBackendSemaphore;
struct GrShaderCaps;
struct SkDrawShadowRec;
usingnamespaceskia_private;
#define ASSERT_SINGLE_OWNER …
#if defined(GPU_TEST_UTILS)
int gOverrideMaxTextureSizeGanesh = 0;
std::atomic<int> gNumTilesDrawnGanesh{0};
#endif
namespace {
bool force_aa_clip(const skgpu::ganesh::SurfaceDrawContext* sdc) { … }
inline GrPrimitiveType point_mode_to_primitive_type(SkCanvas::PointMode mode) { … }
std::unique_ptr<GrFragmentProcessor> make_inverse_rrect_fp(const SkMatrix& viewMatrix,
const SkRRect& rrect, GrAA aa,
const GrShaderCaps& shaderCaps) { … }
bool init_vertices_paint(GrRecordingContext* rContext,
const GrColorInfo& colorInfo,
const SkPaint& skPaint,
const SkMatrix& ctm,
SkBlender* blender,
bool hasColors,
const SkSurfaceProps& props,
GrPaint* grPaint) { … }
bool init_mesh_child_effects(GrRecordingContext* rContext,
const GrColorInfo& colorInfo,
const SkSurfaceProps& surfaceProps,
const SkMesh& mesh,
TArray<std::unique_ptr<GrFragmentProcessor>>* meshChildFPs) { … }
}
namespace skgpu::ganesh {
sk_sp<Device> Device::Make(GrRecordingContext* rContext,
GrColorType colorType,
sk_sp<GrSurfaceProxy> proxy,
sk_sp<SkColorSpace> colorSpace,
GrSurfaceOrigin origin,
const SkSurfaceProps& surfaceProps,
InitContents init) { … }
SkImageInfo Device::MakeInfo(SurfaceContext* sc, DeviceFlags flags) { … }
bool Device::CheckAlphaTypeAndGetFlags(SkAlphaType alphaType,
InitContents init,
DeviceFlags* flags) { … }
sk_sp<Device> Device::Make(std::unique_ptr<SurfaceDrawContext> sdc,
SkAlphaType alphaType,
InitContents init) { … }
sk_sp<Device> Device::Make(GrRecordingContext* rContext,
skgpu::Budgeted budgeted,
const SkImageInfo& ii,
SkBackingFit fit,
int sampleCount,
skgpu::Mipmapped mipmapped,
GrProtected isProtected,
GrSurfaceOrigin origin,
const SkSurfaceProps& props,
InitContents init) { … }
Device::Device(std::unique_ptr<SurfaceDrawContext> sdc, DeviceFlags flags)
: … { … }
Device::~Device() = default;
bool Device::onReadPixels(const SkPixmap& pm, int x, int y) { … }
bool Device::onWritePixels(const SkPixmap& pm, int x, int y) { … }
bool Device::onAccessPixels(SkPixmap* pmap) { … }
SurfaceDrawContext* Device::surfaceDrawContext() { … }
const SurfaceDrawContext* Device::surfaceDrawContext() const { … }
SurfaceFillContext* Device::surfaceFillContext() { … }
void Device::clearAll() { … }
void Device::clipPath(const SkPath& path, SkClipOp op, bool aa) { … }
void Device::clipRegion(const SkRegion& globalRgn, SkClipOp op) { … }
void Device::android_utils_clipAsRgn(SkRegion* region) const { … }
bool Device::isClipAntiAliased() const { … }
void Device::drawPaint(const SkPaint& paint) { … }
void Device::drawPoints(SkCanvas::PointMode mode,
size_t count,
const SkPoint pts[],
const SkPaint& paint) { … }
void Device::drawRect(const SkRect& rect, const SkPaint& paint) { … }
void Device::drawEdgeAAQuad(const SkRect& rect,
const SkPoint clip[4],
SkCanvas::QuadAAFlags aaFlags,
const SkColor4f& color,
SkBlendMode mode) { … }
void Device::drawRRect(const SkRRect& rrect, const SkPaint& paint) { … }
void Device::drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) { … }
void Device::drawRegion(const SkRegion& region, const SkPaint& paint) { … }
void Device::drawOval(const SkRect& oval, const SkPaint& paint) { … }
void Device::drawArc(const SkArc& arc, const SkPaint& paint) { … }
void Device::drawPath(const SkPath& origSrcPath, const SkPaint& paint, bool pathIsMutable) { … }
sk_sp<skif::Backend> Device::createImageFilteringBackend(const SkSurfaceProps& surfaceProps,
SkColorType colorType) const { … }
sk_sp<SkSpecialImage> Device::makeSpecial(const SkBitmap& bitmap) { … }
sk_sp<SkSpecialImage> Device::makeSpecial(const SkImage* image) { … }
sk_sp<SkSpecialImage> Device::snapSpecial(const SkIRect& subset, bool forceCopy) { … }
sk_sp<SkSpecialImage> Device::snapSpecialScaled(const SkIRect& subset, const SkISize& dstDims) { … }
void Device::drawDevice(SkDevice* device,
const SkSamplingOptions& sampling,
const SkPaint& paint) { … }
void Device::drawImageRect(const SkImage* image,
const SkRect* src,
const SkRect& dst,
const SkSamplingOptions& sampling,
const SkPaint& paint,
SkCanvas::SrcRectConstraint constraint) { … }
bool Device::drawAsTiledImageRect(SkCanvas* canvas,
const SkImage* image,
const SkRect* src,
const SkRect& dst,
const SkSamplingOptions& sampling,
const SkPaint& paint,
SkCanvas::SrcRectConstraint constraint) { … }
void Device::drawViewLattice(GrSurfaceProxyView view,
const GrColorInfo& info,
std::unique_ptr<SkLatticeIter> iter,
const SkRect& dst,
SkFilterMode filter,
const SkPaint& origPaint) { … }
void Device::drawImageLattice(const SkImage* image,
const SkCanvas::Lattice& lattice,
const SkRect& dst,
SkFilterMode filter,
const SkPaint& paint) { … }
void Device::drawVertices(const SkVertices* vertices,
sk_sp<SkBlender> blender,
const SkPaint& paint,
bool skipColorXform) { … }
void Device::drawMesh(const SkMesh& mesh, sk_sp<SkBlender> blender, const SkPaint& paint) { … }
#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
void Device::drawShadow(const SkPath& path, const SkDrawShadowRec& rec) { … }
#endif
void Device::drawAtlas(const SkRSXform xform[],
const SkRect texRect[],
const SkColor colors[],
int count,
sk_sp<SkBlender> blender,
const SkPaint& paint) { … }
void Device::onDrawGlyphRunList(SkCanvas* canvas,
const sktext::GlyphRunList& glyphRunList,
const SkPaint& paint) { … }
void Device::drawDrawable(SkCanvas* canvas, SkDrawable* drawable, const SkMatrix* matrix) { … }
GrSurfaceProxyView Device::readSurfaceView() { … }
GrRenderTargetProxy* Device::targetProxy() { … }
bool Device::wait(int numSemaphores,
const GrBackendSemaphore* waitSemaphores,
bool deleteSemaphoresAfterWait) { … }
void Device::discard() { … }
void Device::resolveMSAA() { … }
bool Device::replaceBackingProxy(SkSurface::ContentChangeMode mode,
sk_sp<GrRenderTargetProxy> newRTP,
GrColorType grColorType,
sk_sp<SkColorSpace> colorSpace,
GrSurfaceOrigin origin,
const SkSurfaceProps& props) { … }
bool Device::replaceBackingProxy(SkSurface::ContentChangeMode mode) { … }
void Device::asyncRescaleAndReadPixels(const SkImageInfo& info,
const SkIRect& srcRect,
RescaleGamma rescaleGamma,
RescaleMode rescaleMode,
ReadPixelsCallback callback,
ReadPixelsContext context) { … }
void Device::asyncRescaleAndReadPixelsYUV420(SkYUVColorSpace yuvColorSpace,
bool readAlpha,
sk_sp<SkColorSpace> dstColorSpace,
const SkIRect& srcRect,
SkISize dstSize,
RescaleGamma rescaleGamma,
RescaleMode rescaleMode,
ReadPixelsCallback callback,
ReadPixelsContext context) { … }
sk_sp<SkDevice> Device::createDevice(const CreateInfo& cinfo, const SkPaint*) { … }
sk_sp<SkSurface> Device::makeSurface(const SkImageInfo& info, const SkSurfaceProps& props) { … }
bool Device::android_utils_clipWithStencil() { … }
SkStrikeDeviceInfo Device::strikeDeviceInfo() const { … }
sk_sp<sktext::gpu::Slug> Device::convertGlyphRunListToSlug(const sktext::GlyphRunList& glyphRunList,
const SkPaint& paint) { … }
#if defined(SK_DEBUG)
static bool valid_slug_matrices(const SkMatrix& creationMatrix, const SkMatrix& positionMatrix) { … }
#endif
void Device::drawSlug(SkCanvas* canvas, const sktext::gpu::Slug* slug, const SkPaint& paint) { … }
}