SkDevice.cpp | Explore in Territory

/*
 * Copyright 2011 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "src/core/SkDevice.h"

#include "include/core/SkAlphaType.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkDrawable.h"
#include "include/core/SkImage.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkRRect.h"
#include "include/core/SkRSXform.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSpan.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
#include "include/core/SkVertices.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/chromium/Slug.h"  // IWYU pragma: keep
#include "src/core/SkEnumerate.h"
#include "src/core/SkImageFilterTypes.h"
#include "src/core/SkImageFilter_Base.h"
#include "src/core/SkLatticeIter.h"
#include "src/core/SkMatrixPriv.h"
#include "src/core/SkMemset.h"
#include "src/core/SkPathPriv.h"
#include "src/core/SkRectPriv.h"
#include "src/core/SkScalerContext.h"
#include "src/core/SkSpecialImage.h"
#include "src/text/GlyphRun.h"
#include "src/utils/SkPatchUtils.h"

#include <cstdint>

SkDevice::SkDevice(const SkImageInfo& info, const SkSurfaceProps& surfaceProps)
        : … { … }

void SkDevice::setDeviceCoordinateSystem(const SkM44& deviceToGlobal,
                                         const SkM44& globalToDevice,
                                         const SkM44& localToDevice,
                                         int bufferOriginX,
                                         int bufferOriginY) { … }

void SkDevice::setGlobalCTM(const SkM44& ctm) { … }

bool SkDevice::isPixelAlignedToGlobal() const { … }

SkIPoint SkDevice::getOrigin() const { … }

SkMatrix SkDevice::getRelativeTransform(const SkDevice& dstDevice) const { … }

static inline bool is_int(float x) { … }

void SkDevice::drawRegion(const SkRegion& region, const SkPaint& paint) { … }

void SkDevice::drawArc(const SkArc& arc, const SkPaint& paint) { … }

void SkDevice::drawDRRect(const SkRRect& outer,
                          const SkRRect& inner, const SkPaint& paint) { … }

void SkDevice::drawPatch(const SkPoint cubics[12], const SkColor colors[4],
                         const SkPoint texCoords[4], sk_sp<SkBlender> blender,
                         const SkPaint& paint) { … }

void SkDevice::drawImageLattice(const SkImage* image, const SkCanvas::Lattice& lattice,
                                const SkRect& dst, SkFilterMode filter, const SkPaint& paint) { … }

static SkPoint* quad_to_tris(SkPoint tris[6], const SkPoint quad[4]) { … }

void SkDevice::drawAtlas(const SkRSXform xform[],
                         const SkRect tex[],
                         const SkColor colors[],
                         int quadCount,
                         sk_sp<SkBlender> blender,
                         const SkPaint& paint) { … }

void SkDevice::drawEdgeAAQuad(const SkRect& r, const SkPoint clip[4], SkCanvas::QuadAAFlags aa,
                              const SkColor4f& color, SkBlendMode mode) { … }

void SkDevice::drawEdgeAAImageSet(const SkCanvas::ImageSetEntry images[], int count,
                                  const SkPoint dstClips[], const SkMatrix preViewMatrices[],
                                  const SkSamplingOptions& sampling, const SkPaint& paint,
                                  SkCanvas::SrcRectConstraint constraint) { … }

///////////////////////////////////////////////////////////////////////////////////////////////////

void SkDevice::drawDrawable(SkCanvas* canvas, SkDrawable* drawable, const SkMatrix* matrix) { … }

///////////////////////////////////////////////////////////////////////////////////////////////////

void SkDevice::drawSpecial(SkSpecialImage*, const SkMatrix&, const SkSamplingOptions&,
                           const SkPaint&, SkCanvas::SrcRectConstraint) { … }
void SkDevice::drawCoverageMask(const SkSpecialImage*, const SkMatrix& maskToDevice,
                                const SkSamplingOptions&, const SkPaint&) { … }

sk_sp<SkSpecialImage> SkDevice::makeSpecial(const SkBitmap&) { … }
sk_sp<SkSpecialImage> SkDevice::makeSpecial(const SkImage*) { … }
sk_sp<SkSpecialImage> SkDevice::snapSpecial(const SkIRect&, bool forceCopy) { … }
sk_sp<SkSpecialImage> SkDevice::snapSpecialScaled(const SkIRect& subset,
                                                  const SkISize& dstDims) { … }
sk_sp<SkSpecialImage> SkDevice::snapSpecial() { … }

sk_sp<skif::Backend> SkDevice::createImageFilteringBackend(const SkSurfaceProps& surfaceProps,
                                                           SkColorType colorType) const { … }

void SkDevice::drawDevice(SkDevice* device,
                          const SkSamplingOptions& sampling,
                          const SkPaint& paint) { … }

void SkDevice::drawFilteredImage(const skif::Mapping& mapping,
                                 SkSpecialImage* src,
                                 SkColorType colorType,
                                 const SkImageFilter* filter,
                                 const SkSamplingOptions& sampling,
                                 const SkPaint& paint) { … }

///////////////////////////////////////////////////////////////////////////////////////////////////

bool SkDevice::accessPixels(SkPixmap* pmap) { … }

bool SkDevice::peekPixels(SkPixmap* pmap) { … }

//////////////////////////////////////////////////////////////////////////////////////////

static sk_sp<SkShader> make_post_inverse_lm(const SkShader* shader, const SkMatrix& lm) { … }

void SkDevice::drawGlyphRunList(SkCanvas* canvas,
                                const sktext::GlyphRunList& glyphRunList,
                                const SkPaint& paint) { … }

void SkDevice::simplifyGlyphRunRSXFormAndRedraw(SkCanvas* canvas,
                                                const sktext::GlyphRunList& glyphRunList,
                                                const SkPaint& paint) { … }

sk_sp<sktext::gpu::Slug> SkDevice::convertGlyphRunListToSlug(
        const sktext::GlyphRunList& glyphRunList, const SkPaint& paint) { … }

void SkDevice::drawSlug(SkCanvas*, const sktext::gpu::Slug*, const SkPaint&) { … }

//////////////////////////////////////////////////////////////////////////////////////////

sk_sp<SkSurface> SkDevice::makeSurface(SkImageInfo const&, SkSurfaceProps const&) { … }

SkScalerContextFlags SkDevice::scalerContextFlags() const { … }

//////////////////////////////////////////////////////////////////////////////////////////

SkNoPixelsDevice::SkNoPixelsDevice(const SkIRect& bounds, const SkSurfaceProps& props)
    : … { … }

SkNoPixelsDevice::SkNoPixelsDevice(const SkIRect& bounds, const SkSurfaceProps& props,
                                   sk_sp<SkColorSpace> colorSpace)
    : … { … }

bool SkNoPixelsDevice::resetForNextPicture(const SkIRect& bounds) { … }

void SkNoPixelsDevice::pushClipStack() { … }

void SkNoPixelsDevice::popClipStack() { … }

SkNoPixelsDevice::ClipState& SkNoPixelsDevice::writableClip() { … }

void SkNoPixelsDevice::clipRect(const SkRect& rect, SkClipOp op, bool aa) { … }

void SkNoPixelsDevice::clipRRect(const SkRRect& rrect, SkClipOp op, bool aa) { … }

void SkNoPixelsDevice::clipPath(const SkPath& path, SkClipOp op, bool aa) { … }

void SkNoPixelsDevice::clipRegion(const SkRegion& globalRgn, SkClipOp op) { … }

void SkNoPixelsDevice::onClipShader(sk_sp<SkShader> shader) { … }

void SkNoPixelsDevice::replaceClip(const SkIRect& rect) { … }

void SkNoPixelsDevice::ClipState::op(SkClipOp op, const SkM44& transform, const SkRect& bounds,
                                     bool isAA, bool fillsBounds) { … }
chromium/third_party/skia/src/core/SkDevice.cpp
