SkImageShader.cpp File Reference

#include "src/shaders/SkImageShader.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkColorType.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkTileMode.h"
#include "include/private/base/SkMath.h"
#include "modules/skcms/skcms.h"
#include "src/base/SkArenaAlloc.h"
#include "src/core/SkBitmapProcState.h"
#include "src/core/SkColorSpaceXformSteps.h"
#include "src/core/SkEffectPriv.h"
#include "src/core/SkImageInfoPriv.h"
#include "src/core/SkImagePriv.h"
#include "src/core/SkMipmapAccessor.h"
#include "src/core/SkPicturePriv.h"
#include "src/core/SkRasterPipeline.h"
#include "src/core/SkRasterPipelineOpContexts.h"
#include "src/core/SkRasterPipelineOpList.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkSamplingPriv.h"
#include "src/core/SkWriteBuffer.h"
#include "src/image/SkImage_Base.h"
#include <optional>
#include <tuple>
#include <utility>

Go to the source code of this file.

Namespaces
namespace	SkShaders

Enumerations
enum class	LegacyFilterEnum {   kNone , kLow , kMedium , kHigh ,   kInheritFromPaint , kUseFilterOptions , kUseCubicResampler , kLast = kUseCubicResampler }

Functions
static SkTileMode	optimize (SkTileMode tm, int dimension)
sk_sp< SkShader >	SkMakeBitmapShaderForPaint (const SkPaint &paint, const SkBitmap &src, SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &sampling, const SkMatrix *localMatrix, SkCopyPixelsMode mode)
SkRect	SkModifyPaintAndDstForDrawImageRect (const SkImage *image, const SkSamplingOptions &sampling, SkRect src, SkRect dst, bool strictSrcSubset, SkPaint *paint)
static SkSamplingOptions	tweak_sampling (SkSamplingOptions sampling, const SkMatrix &matrix)
SK_API sk_sp< SkShader >	SkShaders::Image (sk_sp< SkImage > image, SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &options, const SkMatrix *localMatrix=nullptr)
SK_API sk_sp< SkShader >	SkShaders::RawImage (sk_sp< SkImage > image, SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &options, const SkMatrix *localMatrix=nullptr)

Enumeration Type Documentation

LegacyFilterEnum

enum class LegacyFilterEnum

strong

Enumerator
kNone
kLow
kMedium
kHigh
kInheritFromPaint
kUseFilterOptions
kUseCubicResampler
kLast

Definition at line 116 of file SkImageShader.cpp.

                            {
    kNone,
    kLow,
    kMedium,
    kHigh,
    // this is the special value for backward compatibility
    kInheritFromPaint,
    // this signals we should use the new SkFilterOptions
    kUseFilterOptions,
    // use cubic and ignore FilterOptions
    kUseCubicResampler,
 
    kLast = kUseCubicResampler,
};

Function Documentation

optimize()

static SkTileMode optimize ( SkTileMode  tm, int  dimension  )

static

We are faster in clamp, so always use that tiling when we can.

Definition at line 76 of file SkImageShader.cpp.

                                                         {
    SkASSERT(dimension > 0);
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
    // need to update frameworks/base/libs/hwui/tests/unit/SkiaBehaviorTests.cpp:55 to allow
    // for transforming to clamp.
    return tm;
#else
    // mirror and repeat on a 1px axis are the same as clamping, but decal will still transition to
    // transparent black.
    return (tm != SkTileMode::kDecal && dimension == 1) ? SkTileMode::kClamp : tm;
#endif
}

SkMakeBitmapShaderForPaint()

sk_sp< SkShader > SkMakeBitmapShaderForPaint	(	const SkPaint &	paint,
		const SkBitmap &	src,
		SkTileMode	tmx,
		SkTileMode	tmy,
		const SkSamplingOptions &	sampling,
		const SkMatrix *	localMatrix,
		SkCopyPixelsMode	mode
	)

Definition at line 358 of file SkImageShader.cpp.

                                                                                               {
    auto s = SkImageShader::Make(SkMakeImageFromRasterBitmap(src, mode),
                                 tmx, tmy, sampling, localMatrix);
    if (!s) {
        return nullptr;
    }
    if (SkColorTypeIsAlphaOnly(src.colorType()) && paint.getShader()) {
        // Compose the image shader with the paint's shader. Alpha images+shaders should output the
        // texture's alpha multiplied by the shader's color. DstIn (d*sa) will achieve this with
        // the source image and dst shader (MakeBlend takes dst first, src second).
        s = SkShaders::Blend(SkBlendMode::kDstIn, paint.refShader(), std::move(s));
    }
    return s;
}

SkModifyPaintAndDstForDrawImageRect()

SkRect SkModifyPaintAndDstForDrawImageRect	(	const SkImage *	image,
		const SkSamplingOptions &	sampling,
		SkRect	src,
		SkRect	dst,
		bool	strictSrcSubset,
		SkPaint *	paint
	)

Definition at line 376 of file SkImageShader.cpp.

                                                           {
    // The paint should have already been cleaned for a regular drawImageRect, e.g. no path
    // effect and is a fill.
    SkASSERT(paint);
    SkASSERT(paint->getStyle() == SkPaint::kFill_Style && !paint->getPathEffect());
 
    SkASSERT(image);
    SkRect imgBounds = SkRect::Make(image->bounds());
 
    SkASSERT(src.isFinite() && dst.isFinite() && dst.isSorted());
    SkMatrix localMatrix = SkMatrix::RectToRect(src, dst);
    if (!imgBounds.contains(src)) {
        if (!src.intersect(imgBounds)) {
            return SkRect::MakeEmpty(); // Nothing to draw for this entry
        }
        // Update dst to match smaller src
        dst = localMatrix.mapRect(src);
    }
 
    bool imageIsAlphaOnly = SkColorTypeIsAlphaOnly(image->colorType());
 
    sk_sp<SkShader> imgShader;
    if (strictSrcSubset) {
        imgShader = SkImageShader::MakeSubset(sk_ref_sp(image), src,
                                              SkTileMode::kClamp, SkTileMode::kClamp,
                                              sampling, &localMatrix);
    } else {
        imgShader = image->makeShader(SkTileMode::kClamp, SkTileMode::kClamp,
                                      sampling, &localMatrix);
    }
    if (!imgShader) {
        return SkRect::MakeEmpty();
    }
    if (imageIsAlphaOnly && paint->getShader()) {
        // Compose the image shader with the paint's shader. Alpha images+shaders should output the
        // texture's alpha multiplied by the shader's color. DstIn (d*sa) will achieve this with
        // the source image and dst shader (MakeBlend takes dst first, src second).
        imgShader = SkShaders::Blend(SkBlendMode::kDstIn, paint->refShader(), std::move(imgShader));
    }
 
    paint->setShader(std::move(imgShader));
    return dst;
}

tweak_sampling()

static SkSamplingOptions tweak_sampling ( SkSamplingOptions  sampling, const SkMatrix &  matrix  )

static

Definition at line 495 of file SkImageShader.cpp.

                                                                                            {
    SkFilterMode filter = sampling.filter;
 
    // When the matrix is just an integer translate, bilerp == nearest neighbor.
    if (filter == SkFilterMode::kLinear &&
            matrix.getType() <= SkMatrix::kTranslate_Mask &&
            matrix.getTranslateX() == (int)matrix.getTranslateX() &&
            matrix.getTranslateY() == (int)matrix.getTranslateY()) {
        filter = SkFilterMode::kNearest;
    }
 
    return SkSamplingOptions(filter, sampling.mipmap);
}