AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove asTextureRef from SkSpecialImage & update effects accordingly (take 2)

Browse Source 
This CL also renames SkSpecialImage::asTextureProxy to asTextureProxyRef

This is a reland of: https://skia-review.googlesource.com/c/7995/ (Remove asTextureRef from SkSpecialImage & update effects accordingly)

It should be good to land since https://skia-review.googlesource.com/c/8701/ (Replace SkSpecialImage::makeTightSubset with asImage (take 2)) fixes the Chrome-side issue

Change-Id: I3d88b2b3d23fd69f3fb914a69dacca96cbc038a4
Reviewed-on: https://skia-review.googlesource.com/8450
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
This commit is contained in:
Robert Phillips 2017-02-19 12:27:01 -05:00 committed by Skia Commit-Bot
parent a3091099fa
commit 8e1c4e6725
17 changed files with 371 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/effects/SkMagnifierImageFilter.h
View File

@ -14,7 +14,7 @@
class SK_API SkMagnifierImageFilter : public SkImageFilter {
public:
static sk_sp<SkImageFilter> Make(const SkRect& src, SkScalar inset,
static sk_sp<SkImageFilter> Make(const SkRect& srcRect, SkScalar inset,
sk_sp<SkImageFilter> input,
const CropRect* cropRect = nullptr);
@ -32,8 +32,9 @@ protected:
SkIPoint* offset) const override;
private:
SkRect fSrcRect;
SkRect fSrcRect;
SkScalar fInset;
typedef SkImageFilter INHERITED;
};

2
src/core/SkBlurImageFilter.cpp
View File

@ -141,7 +141,7 @@ sk_sp<SkSpecialImage> SkBlurImageFilterImpl::onFilterImage(SkSpecialImage* sourc
// xform during the filter itself.
input = ImageToColorSpace(input.get(), ctx.outputProperties());
sk_sp<GrTextureProxy> inputTexture(input->asTextureProxy(context));
sk_sp<GrTextureProxy> inputTexture(input->asTextureProxyRef(context));
if (!inputTexture) {
return nullptr;
}

29
src/core/SkSpecialImage.cpp
View File

@ -51,8 +51,7 @@ public:
virtual SkColorSpace* onGetColorSpace() const = 0;
#if SK_SUPPORT_GPU
virtual sk_sp<GrTexture> onAsTextureRef(GrContext* context) const = 0;
virtual sk_sp<GrTextureProxy> onAsTextureProxy(GrContext* context) const = 0;
virtual sk_sp<GrTextureProxy> onAsTextureProxyRef(GrContext* context) const = 0;
#endif
virtual sk_sp<SkSpecialImage> onMakeSubset(const SkIRect& subset) const = 0;
@ -148,12 +147,8 @@ SkColorSpace* SkSpecialImage::getColorSpace() const {
}
#if SK_SUPPORT_GPU
sk_sp<GrTexture> SkSpecialImage::asTextureRef(GrContext* context) const {
return as_SIB(this)->onAsTextureRef(context);
}
sk_sp<GrTextureProxy> SkSpecialImage::asTextureProxy(GrContext* context) const {
return as_SIB(this)->onAsTextureProxy(context);
sk_sp<GrTextureProxy> SkSpecialImage::asTextureProxyRef(GrContext* context) const {
return as_SIB(this)->onAsTextureProxyRef(context);
}
#endif
@ -252,16 +247,7 @@ public:
}
#if SK_SUPPORT_GPU
sk_sp<GrTexture> onAsTextureRef(GrContext* context) const override {
if (context) {
return sk_ref_sp(GrRefCachedBitmapTexture(context, fBitmap,
GrSamplerParams::ClampNoFilter(), nullptr));
}
return nullptr;
}
sk_sp<GrTextureProxy> onAsTextureProxy(GrContext* context) const override {
sk_sp<GrTextureProxy> onAsTextureProxyRef(GrContext* context) const override {
if (context) {
return GrMakeCachedBitmapProxy(context, fBitmap);
}
@ -437,12 +423,7 @@ public:
GrContext* onGetContext() const override { return fContext; }
// This entry point should go away in favor of asTextureProxy
sk_sp<GrTexture> onAsTextureRef(GrContext* context) const override {
return sk_ref_sp(fTextureProxy->instantiate(context->textureProvider()));
}
sk_sp<GrTextureProxy> onAsTextureProxy(GrContext*) const override {
sk_sp<GrTextureProxy> onAsTextureProxyRef(GrContext*) const override {
return fTextureProxy;
}

9
src/core/SkSpecialImage.h
View File

@ -139,15 +139,10 @@ public:
#if SK_SUPPORT_GPU
/**
* Regardless of the underlying backing store, return the contents as a GrTexture.
* Regardless of the underlying backing store, return the contents as a GrTextureProxy.
* The active portion of the texture can be retrieved via 'subset'.
*/
sk_sp<GrTexture> asTextureRef(GrContext*) const;
/**
* The same as above but return the contents as a GrTextureProxy.
*/
sk_sp<GrTextureProxy> asTextureProxy(GrContext*) const;
sk_sp<GrTextureProxy> asTextureProxyRef(GrContext*) const;
#endif
// TODO: hide this whe the imagefilter all have a consistent draw path (see skbug.com/5063)

42
src/effects/GrAlphaThresholdFragmentProcessor.cpp
View File

@ -9,6 +9,7 @@
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "SkRefCnt.h"
#include "glsl/GrGLSLColorSpaceXformHelper.h"
#include "glsl/GrGLSLFragmentProcessor.h"
@ -16,20 +17,6 @@
#include "glsl/GrGLSLUniformHandler.h"
#include "../private/GrGLSL.h"
sk_sp<GrFragmentProcessor> GrAlphaThresholdFragmentProcessor::Make(
GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
GrTexture* maskTexture,
float innerThreshold,
float outerThreshold,
const SkIRect& bounds) {
return sk_sp<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(
texture, std::move(colorSpaceXform),
maskTexture,
innerThreshold, outerThreshold,
bounds));
}
inline GrFragmentProcessor::OptimizationFlags GrAlphaThresholdFragmentProcessor::OptFlags(float outerThreshold) {
if (outerThreshold >= 1.f) {
return kPreservesOpaqueInput_OptimizationFlag |
@ -64,6 +51,33 @@ GrAlphaThresholdFragmentProcessor::GrAlphaThresholdFragmentProcessor(
this->addTextureSampler(&fMaskTextureSampler);
}
GrAlphaThresholdFragmentProcessor::GrAlphaThresholdFragmentProcessor(
GrContext* context,
sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform,
GrTexture* maskTexture,
float innerThreshold,
float outerThreshold,
const SkIRect& bounds)
: INHERITED(OptFlags(outerThreshold))
, fInnerThreshold(innerThreshold)
, fOuterThreshold(outerThreshold)
, fImageCoordTransform(context, SkMatrix::I(), proxy.get(),
GrSamplerParams::kNone_FilterMode)
, fImageTextureSampler(context->textureProvider(), std::move(proxy))
, fColorSpaceXform(std::move(colorSpaceXform))
, fMaskCoordTransform(
SkMatrix::MakeTrans(SkIntToScalar(-bounds.x()), SkIntToScalar(-bounds.y())),
maskTexture,
GrSamplerParams::kNone_FilterMode)
, fMaskTextureSampler(maskTexture) {
this->initClassID<GrAlphaThresholdFragmentProcessor>();
this->addCoordTransform(&fImageCoordTransform);
this->addTextureSampler(&fImageTextureSampler);
this->addCoordTransform(&fMaskCoordTransform);
this->addTextureSampler(&fMaskTextureSampler);
}
bool GrAlphaThresholdFragmentProcessor::onIsEqual(const GrFragmentProcessor& sBase) const {
const GrAlphaThresholdFragmentProcessor& s = sBase.cast<GrAlphaThresholdFragmentProcessor>();
return (this->fInnerThreshold == s.fInnerThreshold &&

33
src/effects/GrAlphaThresholdFragmentProcessor.h
View File

@ -25,7 +25,30 @@ public:
GrTexture* maskTexture,
float innerThreshold,
float outerThreshold,
const SkIRect& bounds);
const SkIRect& bounds) {
return sk_sp<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(
texture,
std::move(colorSpaceXform),
maskTexture,
innerThreshold, outerThreshold,
bounds));
}
static sk_sp<GrFragmentProcessor> Make(GrContext* context,
sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform,
GrTexture* maskTexture,
float innerThreshold,
float outerThreshold,
const SkIRect& bounds) {
return sk_sp<GrFragmentProcessor>(new GrAlphaThresholdFragmentProcessor(
context,
std::move(proxy),
std::move(colorSpaceXform),
maskTexture,
innerThreshold, outerThreshold,
bounds));
}
const char* name() const override { return "Alpha Threshold"; }
@ -44,6 +67,14 @@ private:
float outerThreshold,
const SkIRect& bounds);
GrAlphaThresholdFragmentProcessor(GrContext*,
sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform,
GrTexture* maskTexture,
float innerThreshold,
float outerThreshold,
const SkIRect& bounds);
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;

7
src/effects/SkAlphaThresholdFilter.cpp
View File

@ -150,8 +150,8 @@ sk_sp<SkSpecialImage> SkAlphaThresholdFilterImpl::onFilterImage(SkSpecialImage*
if (source->isTextureBacked()) {
GrContext* context = source->getContext();
sk_sp<GrTexture> inputTexture(input->asTextureRef(context));
SkASSERT(inputTexture);
sk_sp<GrTextureProxy> inputProxy(input->asTextureProxyRef(context));
SkASSERT(inputProxy);
offset->fX = bounds.left();
offset->fY = bounds.top();
@ -175,7 +175,8 @@ sk_sp<SkSpecialImage> SkAlphaThresholdFilterImpl::onFilterImage(SkSpecialImage*
return nullptr;
}
sk_sp<GrFragmentProcessor> fp(GrAlphaThresholdFragmentProcessor::Make(
inputTexture.get(),
context,
std::move(inputProxy),
std::move(colorSpaceXform),
maskTex,
fInnerThreshold,

14
src/effects/SkArithmeticImageFilter.cpp
View File

@ -337,26 +337,26 @@ sk_sp<SkSpecialImage> ArithmeticImageFilterImpl::filterImageGPU(
GrContext* context = source->getContext();
sk_sp<GrTexture> backgroundTex, foregroundTex;
sk_sp<GrTextureProxy> backgroundProxy, foregroundProxy;
if (background) {
backgroundTex = background->asTextureRef(context);
backgroundProxy = background->asTextureProxyRef(context);
}
if (foreground) {
foregroundTex = foreground->asTextureRef(context);
foregroundProxy = foreground->asTextureProxyRef(context);
}
GrPaint paint;
sk_sp<GrFragmentProcessor> bgFP;
if (backgroundTex) {
if (backgroundProxy) {
SkMatrix backgroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
-SkIntToScalar(backgroundOffset.fY));
sk_sp<GrColorSpaceXform> bgXform =
GrColorSpaceXform::Make(background->getColorSpace(), outputProperties.colorSpace());
bgFP = GrTextureDomainEffect::Make(
backgroundTex.get(), std::move(bgXform), backgroundMatrix,
context, std::move(backgroundProxy), std::move(bgXform), backgroundMatrix,
GrTextureDomain::MakeTexelDomain(background->subset()),
GrTextureDomain::kDecal_Mode, GrSamplerParams::kNone_FilterMode);
} else {
@ -364,7 +364,7 @@ sk_sp<SkSpecialImage> ArithmeticImageFilterImpl::filterImageGPU(
GrConstColorProcessor::kIgnore_InputMode);
}
if (foregroundTex) {
if (foregroundProxy) {
SkMatrix foregroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(foregroundOffset.fX),
-SkIntToScalar(foregroundOffset.fY));
sk_sp<GrColorSpaceXform> fgXform =
@ -372,7 +372,7 @@ sk_sp<SkSpecialImage> ArithmeticImageFilterImpl::filterImageGPU(
sk_sp<GrFragmentProcessor> foregroundFP;
foregroundFP = GrTextureDomainEffect::Make(
foregroundTex.get(), std::move(fgXform), foregroundMatrix,
context, std::move(foregroundProxy), std::move(fgXform), foregroundMatrix,
GrTextureDomain::MakeTexelDomain(foreground->subset()),
GrTextureDomain::kDecal_Mode, GrSamplerParams::kNone_FilterMode);

64
src/effects/SkDisplacementMapEffect.cpp
View File

@ -225,6 +225,19 @@ public:
colorDimensions));
}
static sk_sp<GrFragmentProcessor> Make(GrContext* context,
SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector, SkVector scale,
sk_sp<GrTextureProxy> displacement, const SkMatrix& offsetMatrix,
sk_sp<GrTextureProxy> color,
sk_sp<GrColorSpaceXform> colorSpaceXform, const SkISize& colorDimensions) {
return sk_sp<GrFragmentProcessor>(
new GrDisplacementMapEffect(context, xChannelSelector, yChannelSelector, scale,
std::move(displacement),
offsetMatrix, std::move(color), std::move(colorSpaceXform),
colorDimensions));
}
virtual ~GrDisplacementMapEffect();
SkDisplacementMapEffect::ChannelSelectorType xChannelSelector() const {
@ -253,6 +266,14 @@ private:
GrTexture* color, sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkISize& colorDimensions);
GrDisplacementMapEffect(GrContext*,
SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
const SkVector& scale,
sk_sp<GrTextureProxy> displacement, const SkMatrix& offsetMatrix,
sk_sp<GrTextureProxy> color, sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkISize& colorDimensions);
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
GrCoordTransform fDisplacementTransform;
@ -324,9 +345,9 @@ sk_sp<SkSpecialImage> SkDisplacementMapEffect::onFilterImage(SkSpecialImage* sou
if (source->isTextureBacked()) {
GrContext* context = source->getContext();
sk_sp<GrTexture> colorTexture(color->asTextureRef(context));
sk_sp<GrTexture> displTexture(displ->asTextureRef(context));
if (!colorTexture || !displTexture) {
sk_sp<GrTextureProxy> colorProxy(color->asTextureProxyRef(context));
sk_sp<GrTextureProxy> displProxy(displ->asTextureProxyRef(context));
if (!colorProxy || !displProxy) {
return nullptr;
}
@ -337,12 +358,13 @@ sk_sp<SkSpecialImage> SkDisplacementMapEffect::onFilterImage(SkSpecialImage* sou
colorSpace);
GrPaint paint;
paint.addColorFragmentProcessor(
GrDisplacementMapEffect::Make(fXChannelSelector,
GrDisplacementMapEffect::Make(context,
fXChannelSelector,
fYChannelSelector,
scale,
displTexture.get(),
std::move(displProxy),
offsetMatrix,
colorTexture.get(),
std::move(colorProxy),
std::move(colorSpaceXform),
SkISize::Make(color->width(), color->height())));
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
@ -508,6 +530,36 @@ GrDisplacementMapEffect::GrDisplacementMapEffect(
this->addTextureSampler(&fColorSampler);
}
GrDisplacementMapEffect::GrDisplacementMapEffect(
GrContext* context,
SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
const SkVector& scale,
sk_sp<GrTextureProxy> displacement,
const SkMatrix& offsetMatrix,
sk_sp<GrTextureProxy> color,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkISize& colorDimensions)
: INHERITED(GrPixelConfigIsOpaque(color->config()) ? kPreservesOpaqueInput_OptimizationFlag
: kNone_OptimizationFlags)
, fDisplacementTransform(context, offsetMatrix, displacement.get(),
GrSamplerParams::kNone_FilterMode)
, fDisplacementSampler(context->textureProvider(), displacement)
, fColorTransform(context, color.get(), GrSamplerParams::kNone_FilterMode)
, fDomain(color.get(), GrTextureDomain::MakeTexelDomain(SkIRect::MakeSize(colorDimensions)),
GrTextureDomain::kDecal_Mode)
, fColorSampler(context->textureProvider(), color)
, fColorSpaceXform(std::move(colorSpaceXform))
, fXChannelSelector(xChannelSelector)
, fYChannelSelector(yChannelSelector)
, fScale(scale) {
this->initClassID<GrDisplacementMapEffect>();
this->addCoordTransform(&fDisplacementTransform);
this->addTextureSampler(&fDisplacementSampler);
this->addCoordTransform(&fColorTransform);
this->addTextureSampler(&fColorSampler);
}
GrDisplacementMapEffect::~GrDisplacementMapEffect() {
}

1
src/effects/SkImageSource.cpp
View File

@ -93,6 +93,7 @@ sk_sp<SkSpecialImage> SkImageSource::onFilterImage(SkSpecialImage* source, const
// The dest is just an un-scaled integer translation of the entire image; return it
offset->fX = iLeft;
offset->fY = iTop;
return SkSpecialImage::MakeFromImage(SkIRect::MakeWH(fImage->width(), fImage->height()),
fImage, ctx.outputProperties().colorSpace(),
&source->props());

139
src/effects/SkLightingImageFilter.cpp
View File

@ -361,15 +361,15 @@ protected:
const SkIRect& bounds,
const SkMatrix& matrix,
const OutputProperties& outputProperties) const;
virtual sk_sp<GrFragmentProcessor> makeFragmentProcessor(GrTexture*,
virtual sk_sp<GrFragmentProcessor> makeFragmentProcessor(GrContext*, sk_sp<GrTextureProxy>,
const SkMatrix&,
const SkIRect* srcBounds,
BoundaryMode boundaryMode) const = 0;
#endif
private:
#if SK_SUPPORT_GPU
void drawRect(GrRenderTargetContext* renderTargetContext,
GrTexture* src,
void drawRect(GrContext*, GrRenderTargetContext*,
sk_sp<GrTextureProxy> srcProxy,
const SkMatrix& matrix,
const GrClip& clip,
const SkRect& dstRect,
@ -381,8 +381,9 @@ private:
};
#if SK_SUPPORT_GPU
void SkLightingImageFilterInternal::drawRect(GrRenderTargetContext* renderTargetContext,
GrTexture* src,
void SkLightingImageFilterInternal::drawRect(GrContext* context,
GrRenderTargetContext* renderTargetContext,
sk_sp<GrTextureProxy> srcProxy,
const SkMatrix& matrix,
const GrClip& clip,
const SkRect& dstRect,
@ -392,7 +393,8 @@ void SkLightingImageFilterInternal::drawRect(GrRenderTargetContext* renderTarget
SkRect srcRect = dstRect.makeOffset(SkIntToScalar(bounds.x()), SkIntToScalar(bounds.y()));
GrPaint paint;
paint.setGammaCorrect(renderTargetContext->isGammaCorrect());
sk_sp<GrFragmentProcessor> fp(this->makeFragmentProcessor(src, matrix, srcBounds,
sk_sp<GrFragmentProcessor> fp(this->makeFragmentProcessor(context, std::move(srcProxy),
matrix, srcBounds,
boundaryMode));
paint.addColorFragmentProcessor(std::move(fp));
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
@ -410,8 +412,8 @@ sk_sp<SkSpecialImage> SkLightingImageFilterInternal::filterImageGPU(
GrContext* context = source->getContext();
sk_sp<GrTexture> inputTexture(input->asTextureRef(context));
SkASSERT(inputTexture);
sk_sp<GrTextureProxy> inputProxy(input->asTextureProxyRef(context));
SkASSERT(inputProxy);
sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
SkBackingFit::kApprox, offsetBounds.width(), offsetBounds.height(),
@ -439,23 +441,23 @@ sk_sp<SkSpecialImage> SkLightingImageFilterInternal::filterImageGPU(
SkRect bottomRight = SkRect::MakeXYWH(dstRect.width() - 1, dstRect.height() - 1, 1, 1);
const SkIRect* pSrcBounds = inputBounds.contains(offsetBounds) ? nullptr : &inputBounds;
this->drawRect(renderTargetContext.get(), inputTexture.get(), matrix, clip, topLeft,
this->drawRect(context, renderTargetContext.get(), inputProxy, matrix, clip, topLeft,
kTopLeft_BoundaryMode, pSrcBounds, offsetBounds);
this->drawRect(renderTargetContext.get(), inputTexture.get(), matrix, clip, top,
this->drawRect(context, renderTargetContext.get(), inputProxy, matrix, clip, top,
kTop_BoundaryMode, pSrcBounds, offsetBounds);
this->drawRect(renderTargetContext.get(), inputTexture.get(), matrix, clip, topRight,
this->drawRect(context, renderTargetContext.get(), inputProxy, matrix, clip, topRight,
kTopRight_BoundaryMode, pSrcBounds, offsetBounds);
this->drawRect(renderTargetContext.get(), inputTexture.get(), matrix, clip, left,
this->drawRect(context, renderTargetContext.get(), inputProxy, matrix, clip, left,
kLeft_BoundaryMode, pSrcBounds, offsetBounds);
this->drawRect(renderTargetContext.get(), inputTexture.get(), matrix, clip, interior,
this->drawRect(context, renderTargetContext.get(), inputProxy, matrix, clip, interior,
kInterior_BoundaryMode, pSrcBounds, offsetBounds);
this->drawRect(renderTargetContext.get(), inputTexture.get(), matrix, clip, right,
this->drawRect(context, renderTargetContext.get(), inputProxy, matrix, clip, right,
kRight_BoundaryMode, pSrcBounds, offsetBounds);
this->drawRect(renderTargetContext.get(), inputTexture.get(), matrix, clip, bottomLeft,
this->drawRect(context, renderTargetContext.get(), inputProxy, matrix, clip, bottomLeft,
kBottomLeft_BoundaryMode, pSrcBounds, offsetBounds);
this->drawRect(renderTargetContext.get(), inputTexture.get(), matrix, clip, bottom,
this->drawRect(context, renderTargetContext.get(), inputProxy, matrix, clip, bottom,
kBottom_BoundaryMode, pSrcBounds, offsetBounds);
this->drawRect(renderTargetContext.get(), inputTexture.get(), matrix, clip, bottomRight,
this->drawRect(context, renderTargetContext.get(), inputProxy, matrix, clip, bottomRight,
kBottomRight_BoundaryMode, pSrcBounds, offsetBounds);
return SkSpecialImage::MakeDeferredFromGpu(
@ -489,8 +491,8 @@ protected:
SkIPoint* offset) const override;
#if SK_SUPPORT_GPU
sk_sp<GrFragmentProcessor> makeFragmentProcessor(GrTexture*, const SkMatrix&,
const SkIRect* bounds,
sk_sp<GrFragmentProcessor> makeFragmentProcessor(GrContext*, sk_sp<GrTextureProxy>,
const SkMatrix&, const SkIRect* bounds,
BoundaryMode) const override;
#endif
@ -525,8 +527,8 @@ protected:
SkIPoint* offset) const override;
#if SK_SUPPORT_GPU
sk_sp<GrFragmentProcessor> makeFragmentProcessor(GrTexture*, const SkMatrix&,
const SkIRect* bounds,
sk_sp<GrFragmentProcessor> makeFragmentProcessor(GrContext*, sk_sp<GrTextureProxy>,
const SkMatrix&, const SkIRect* bounds,
BoundaryMode) const override;
#endif
@ -541,7 +543,8 @@ private:
class GrLightingEffect : public GrSingleTextureEffect {
public:
GrLightingEffect(GrTexture* texture, const SkImageFilterLight* light, SkScalar surfaceScale,
GrLightingEffect(GrContext*, sk_sp<GrTextureProxy>,
const SkImageFilterLight* light, SkScalar surfaceScale,
const SkMatrix& matrix, BoundaryMode boundaryMode, const SkIRect* srcBounds);
~GrLightingEffect() override;
@ -567,7 +570,8 @@ private:
class GrDiffuseLightingEffect : public GrLightingEffect {
public:
static sk_sp<GrFragmentProcessor> Make(GrTexture* texture,
static sk_sp<GrFragmentProcessor> Make(GrContext* context,
sk_sp<GrTextureProxy> proxy,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
@ -575,8 +579,8 @@ public:
BoundaryMode boundaryMode,
const SkIRect* srcBounds) {
return sk_sp<GrFragmentProcessor>(
new GrDiffuseLightingEffect(texture, light, surfaceScale, matrix, kd, boundaryMode,
srcBounds));
new GrDiffuseLightingEffect(context, std::move(proxy), light,
surfaceScale, matrix, kd, boundaryMode, srcBounds));
}
const char* name() const override { return "DiffuseLighting"; }
@ -590,7 +594,7 @@ private:
bool onIsEqual(const GrFragmentProcessor&) const override;
GrDiffuseLightingEffect(GrTexture* texture,
GrDiffuseLightingEffect(GrContext*, sk_sp<GrTextureProxy>,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
@ -599,13 +603,15 @@ private:
const SkIRect* srcBounds);
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrLightingEffect INHERITED;
SkScalar fKD;
typedef GrLightingEffect INHERITED;
};
class GrSpecularLightingEffect : public GrLightingEffect {
public:
static sk_sp<GrFragmentProcessor> Make(GrTexture* texture,
static sk_sp<GrFragmentProcessor> Make(GrContext* context,
sk_sp<GrTextureProxy> proxy,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
@ -614,7 +620,8 @@ public:
BoundaryMode boundaryMode,
const SkIRect* srcBounds) {
return sk_sp<GrFragmentProcessor>(
new GrSpecularLightingEffect(texture, light, surfaceScale, matrix, ks, shininess,
new GrSpecularLightingEffect(context, std::move(proxy),
light, surfaceScale, matrix, ks, shininess,
boundaryMode, srcBounds));
}
@ -630,7 +637,7 @@ private:
bool onIsEqual(const GrFragmentProcessor&) const override;
GrSpecularLightingEffect(GrTexture* texture,
GrSpecularLightingEffect(GrContext*, sk_sp<GrTextureProxy>,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
@ -640,9 +647,10 @@ private:
const SkIRect* srcBounds);
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrLightingEffect INHERITED;
SkScalar fKS;
SkScalar fShininess;
typedef GrLightingEffect INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
@ -1332,12 +1340,14 @@ void SkDiffuseLightingImageFilter::toString(SkString* str) const {
#if SK_SUPPORT_GPU
sk_sp<GrFragmentProcessor> SkDiffuseLightingImageFilter::makeFragmentProcessor(
GrTexture* texture,
GrContext* context,
sk_sp<GrTextureProxy> proxy,
const SkMatrix& matrix,
const SkIRect* srcBounds,
BoundaryMode boundaryMode) const {
SkScalar scale = this->surfaceScale() * 255;
return GrDiffuseLightingEffect::Make(texture, this->light(), scale, matrix, this->kd(),
return GrDiffuseLightingEffect::Make(context, std::move(proxy),
this->light(), scale, matrix, this->kd(),
boundaryMode, srcBounds);
}
#endif
@ -1497,12 +1507,14 @@ void SkSpecularLightingImageFilter::toString(SkString* str) const {
#if SK_SUPPORT_GPU
sk_sp<GrFragmentProcessor> SkSpecularLightingImageFilter::makeFragmentProcessor(
GrTexture* texture,
GrContext* context,
sk_sp<GrTextureProxy> proxy,
const SkMatrix& matrix,
const SkIRect* srcBounds,
BoundaryMode boundaryMode) const {
SkScalar scale = this->surfaceScale() * 255;
return GrSpecularLightingEffect::Make(texture, this->light(), scale, matrix, this->ks(),
return GrSpecularLightingEffect::Make(context, std::move(proxy), this->light(),
scale, matrix, this->ks(),
this->shininess(), boundaryMode, srcBounds);
}
#endif
@ -1675,29 +1687,30 @@ private:
///////////////////////////////////////////////////////////////////////////////
static GrTextureDomain create_domain(GrTexture* texture, const SkIRect* srcBounds,
static GrTextureDomain create_domain(GrTextureProxy* proxy, const SkIRect* srcBounds,
GrTextureDomain::Mode mode) {
if (srcBounds) {
SkRect texelDomain = GrTextureDomain::MakeTexelDomainForMode(*srcBounds, mode);
return GrTextureDomain(texture, texelDomain, mode);
return GrTextureDomain(proxy, texelDomain, mode);
} else {
return GrTextureDomain::IgnoredDomain();
}
}
GrLightingEffect::GrLightingEffect(GrTexture* texture,
GrLightingEffect::GrLightingEffect(GrContext* context,
sk_sp<GrTextureProxy> proxy,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
BoundaryMode boundaryMode,
const SkIRect* srcBounds)
// Perhaps this could advertise the opaque or coverage-as-alpha optimizations?
: INHERITED(texture, nullptr, SkMatrix::I(), kNone_OptimizationFlags)
: INHERITED(context, kNone_OptimizationFlags, proxy, nullptr, SkMatrix::I())
, fLight(light)
, fSurfaceScale(surfaceScale)
, fFilterMatrix(matrix)
, fBoundaryMode(boundaryMode)
, fDomain(create_domain(texture, srcBounds, GrTextureDomain::kDecal_Mode)) {
, fDomain(create_domain(proxy.get(), srcBounds, GrTextureDomain::kDecal_Mode)) {
fLight->ref();
}
@ -1714,14 +1727,16 @@ bool GrLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
///////////////////////////////////////////////////////////////////////////////
GrDiffuseLightingEffect::GrDiffuseLightingEffect(GrTexture* texture,
GrDiffuseLightingEffect::GrDiffuseLightingEffect(GrContext* context,
sk_sp<GrTextureProxy> proxy,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
SkScalar kd,
BoundaryMode boundaryMode,
const SkIRect* srcBounds)
: INHERITED(texture, light, surfaceScale, matrix, boundaryMode, srcBounds), fKD(kd) {
: INHERITED(context, std::move(proxy), light, surfaceScale, matrix,
boundaryMode, srcBounds), fKD(kd) {
this->initClassID<GrDiffuseLightingEffect>();
}
@ -1743,9 +1758,9 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect);
#if GR_TEST_UTILS
sk_sp<GrFragmentProcessor> GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
GrTexture* tex = d->fTextures[texIdx];
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
SkScalar surfaceScale = d->fRandom->nextSScalar1();
SkScalar kd = d->fRandom->nextUScalar1();
sk_sp<SkImageFilterLight> light(create_random_light(d->fRandom));
@ -1753,13 +1768,14 @@ sk_sp<GrFragmentProcessor> GrDiffuseLightingEffect::TestCreate(GrProcessorTestDa
for (int i = 0; i < 9; i++) {
matrix[i] = d->fRandom->nextUScalar1();
}
SkIRect srcBounds = SkIRect::MakeXYWH(d->fRandom->nextRangeU(0, tex->width()),
d->fRandom->nextRangeU(0, tex->height()),
d->fRandom->nextRangeU(0, tex->width()),
d->fRandom->nextRangeU(0, tex->height()));
SkIRect srcBounds = SkIRect::MakeXYWH(d->fRandom->nextRangeU(0, proxy->width()),
d->fRandom->nextRangeU(0, proxy->height()),
d->fRandom->nextRangeU(0, proxy->width()),
d->fRandom->nextRangeU(0, proxy->height()));
BoundaryMode mode = static_cast<BoundaryMode>(d->fRandom->nextU() % kBoundaryModeCount);
return GrDiffuseLightingEffect::Make(tex, light.get(), surfaceScale, matrix, kd, mode,
&srcBounds);
return GrDiffuseLightingEffect::Make(d->context(),
std::move(proxy), light.get(), surfaceScale,
matrix, kd, mode, &srcBounds);
}
#endif
@ -1929,7 +1945,8 @@ void GrGLDiffuseLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman,
///////////////////////////////////////////////////////////////////////////////
GrSpecularLightingEffect::GrSpecularLightingEffect(GrTexture* texture,
GrSpecularLightingEffect::GrSpecularLightingEffect(GrContext* context,
sk_sp<GrTextureProxy> proxy,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
@ -1937,7 +1954,7 @@ GrSpecularLightingEffect::GrSpecularLightingEffect(GrTexture* texture,
SkScalar shininess,
BoundaryMode boundaryMode,
const SkIRect* srcBounds)
: INHERITED(texture, light, surfaceScale, matrix, boundaryMode, srcBounds)
: INHERITED(context, std::move(proxy), light, surfaceScale, matrix, boundaryMode, srcBounds)
, fKS(ks)
, fShininess(shininess) {
this->initClassID<GrSpecularLightingEffect>();
@ -1963,9 +1980,9 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect);
#if GR_TEST_UTILS
sk_sp<GrFragmentProcessor> GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
GrTexture* tex = d->fTextures[texIdx];
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);
SkScalar surfaceScale = d->fRandom->nextSScalar1();
SkScalar ks = d->fRandom->nextUScalar1();
SkScalar shininess = d->fRandom->nextUScalar1();
@ -1975,11 +1992,11 @@ sk_sp<GrFragmentProcessor> GrSpecularLightingEffect::TestCreate(GrProcessorTestD
matrix[i] = d->fRandom->nextUScalar1();
}
BoundaryMode mode = static_cast<BoundaryMode>(d->fRandom->nextU() % kBoundaryModeCount);
SkIRect srcBounds = SkIRect::MakeXYWH(d->fRandom->nextRangeU(0, tex->width()),
d->fRandom->nextRangeU(0, tex->height()),
d->fRandom->nextRangeU(0, tex->width()),
d->fRandom->nextRangeU(0, tex->height()));
return GrSpecularLightingEffect::Make(d->fTextures[GrProcessorUnitTest::kAlphaTextureIdx],
SkIRect srcBounds = SkIRect::MakeXYWH(d->fRandom->nextRangeU(0, proxy->width()),
d->fRandom->nextRangeU(0, proxy->height()),
d->fRandom->nextRangeU(0, proxy->width()),
d->fRandom->nextRangeU(0, proxy->height()));
return GrSpecularLightingEffect::Make(d->context(), std::move(proxy),
light.get(), surfaceScale, matrix, ks, shininess, mode,
&srcBounds);
}

195
src/effects/SkMagnifierImageFilter.cpp
View File

@ -17,6 +17,7 @@
////////////////////////////////////////////////////////////////////////////////
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "effects/GrProxyMove.h"
#include "effects/GrSingleTextureEffect.h"
#include "glsl/GrGLSLColorSpaceXformHelper.h"
#include "glsl/GrGLSLFragmentProcessor.h"
@ -24,20 +25,55 @@
#include "glsl/GrGLSLProgramDataManager.h"
#include "glsl/GrGLSLUniformHandler.h"
#include "../private/GrGLSL.h"
#endif
sk_sp<SkImageFilter> SkMagnifierImageFilter::Make(const SkRect& srcRect, SkScalar inset,
sk_sp<SkImageFilter> input,
const CropRect* cropRect) {
if (!SkScalarIsFinite(inset) || !SkIsValidRect(srcRect)) {
return nullptr;
}
if (inset < 0) {
return nullptr;
}
// Negative numbers in src rect are not supported
if (srcRect.fLeft < 0 || srcRect.fTop < 0) {
return nullptr;
}
return sk_sp<SkImageFilter>(new SkMagnifierImageFilter(srcRect, inset,
std::move(input),
cropRect));
}
#if SK_SUPPORT_GPU
class GrMagnifierEffect : public GrSingleTextureEffect {
public:
static sk_sp<GrFragmentProcessor> Make(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkRect& bounds,
float xOffset,
float yOffset,
const SkIRect& bounds,
const SkRect& srcRect,
float xInvZoom,
float yInvZoom,
float xInvInset,
float yInvInset) {
return sk_sp<GrFragmentProcessor>(new GrMagnifierEffect(texture, std::move(colorSpaceXform),
bounds, xOffset, yOffset,
bounds, srcRect,
xInvZoom, yInvZoom,
xInvInset, yInvInset));
}
static sk_sp<GrFragmentProcessor> Make(GrContext* context,
sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkIRect& bounds,
const SkRect& srcRect,
float xInvZoom,
float yInvZoom,
float xInvInset,
float yInvInset) {
return sk_sp<GrFragmentProcessor>(new GrMagnifierEffect(context,
std::move(proxy),
std::move(colorSpaceXform),
bounds, srcRect,
xInvZoom, yInvZoom,
xInvInset, yInvInset));
}
@ -46,10 +82,8 @@ public:
const char* name() const override { return "Magnifier"; }
const SkRect& bounds() const { return fBounds; } // Bounds of source image.
// Offset to apply to zoomed pixels, (srcRect position / texture size).
float xOffset() const { return fXOffset; }
float yOffset() const { return fYOffset; }
const SkIRect& bounds() const { return fBounds; } // Bounds of source image.
const SkRect& srcRect() const { return fSrcRect; }
// Scale to apply to zoomed pixels (srcRect size / bounds size).
float xInvZoom() const { return fXInvZoom; }
@ -62,9 +96,8 @@ public:
private:
GrMagnifierEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkRect& bounds,
float xOffset,
float yOffset,
const SkIRect& bounds,
const SkRect& srcRect,
float xInvZoom,
float yInvZoom,
float xInvInset,
@ -72,8 +105,30 @@ private:
: INHERITED(texture, std::move(colorSpaceXform), SkMatrix::I(),
ModulationFlags(texture->config()))
, fBounds(bounds)
, fXOffset(xOffset)
, fYOffset(yOffset)
, fSrcRect(srcRect)
, fXInvZoom(xInvZoom)
, fYInvZoom(yInvZoom)
, fXInvInset(xInvInset)
, fYInvInset(yInvInset) {
this->initClassID<GrMagnifierEffect>();
}
GrMagnifierEffect(GrContext* context,
sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkIRect& bounds,
const SkRect& srcRect,
float xInvZoom,
float yInvZoom,
float xInvInset,
float yInvInset)
: INHERITED{context,
ModulationFlags(proxy->config()),
GR_PROXY_MOVE(proxy),
std::move(colorSpaceXform),
SkMatrix::I()} // TODO: no GrSamplerParams::kBilerp_FilterMode?
, fBounds(bounds)
, fSrcRect(srcRect)
, fXInvZoom(xInvZoom)
, fYInvZoom(yInvZoom)
, fXInvInset(xInvInset)
@ -89,9 +144,8 @@ private:
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
SkRect fBounds;
float fXOffset;
float fYOffset;
SkIRect fBounds;
SkRect fSrcRect;
float fXInvZoom;
float fYInvZoom;
float fXInvInset;
@ -184,11 +238,38 @@ void GrGLMagnifierEffect::emitCode(EmitArgs& args) {
void GrGLMagnifierEffect::onSetData(const GrGLSLProgramDataManager& pdman,
const GrProcessor& effect) {
const GrMagnifierEffect& zoom = effect.cast<GrMagnifierEffect>();
pdman.set2f(fOffsetVar, zoom.xOffset(), zoom.yOffset());
GrTexture* tex = zoom.textureSampler(0).texture();
SkASSERT(tex);
SkScalar invW = 1.0f / tex->width();
SkScalar invH = 1.0f / tex->height();
{
SkScalar y = zoom.srcRect().y() * invH;
if (tex->origin() != kTopLeft_GrSurfaceOrigin) {
y = 1.0f - (zoom.srcRect().height() / zoom.bounds().height()) - y;
}
pdman.set2f(fOffsetVar, zoom.srcRect().x() * invW, y);
}
pdman.set2f(fInvZoomVar, zoom.xInvZoom(), zoom.yInvZoom());
pdman.set2f(fInvInsetVar, zoom.xInvInset(), zoom.yInvInset());
pdman.set4f(fBoundsVar, zoom.bounds().x(), zoom.bounds().y(),
zoom.bounds().width(), zoom.bounds().height());
{
SkScalar y = zoom.bounds().y() * invH;
if (tex->origin() != kTopLeft_GrSurfaceOrigin) {
y = 1.0f - zoom.bounds().height() * invH;
}
pdman.set4f(fBoundsVar,
zoom.bounds().x() * invW,
y,
SkIntToScalar(tex->width()) / zoom.bounds().width(),
SkIntToScalar(tex->height()) / zoom.bounds().height());
}
if (SkToBool(zoom.colorSpaceXform())) {
pdman.setSkMatrix44(fColorSpaceXformVar, zoom.colorSpaceXform()->srcToDst());
}
@ -209,27 +290,28 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMagnifierEffect);
#if GR_TEST_UTILS
sk_sp<GrFragmentProcessor> GrMagnifierEffect::TestCreate(GrProcessorTestData* d) {
GrTexture* texture = d->fTextures[0];
sk_sp<GrTextureProxy> proxy = d->textureProxy(0);
const int kMaxWidth = 200;
const int kMaxHeight = 200;
const int kMaxInset = 20;
const SkScalar kMaxInset = 20.0f;
uint32_t width = d->fRandom->nextULessThan(kMaxWidth);
uint32_t height = d->fRandom->nextULessThan(kMaxHeight);
uint32_t x = d->fRandom->nextULessThan(kMaxWidth - width);
uint32_t y = d->fRandom->nextULessThan(kMaxHeight - height);
uint32_t inset = d->fRandom->nextULessThan(kMaxInset);
auto colorSpaceXform = GrTest::TestColorXform(d->fRandom);
SkScalar inset = d->fRandom->nextRangeScalar(1.0f, kMaxInset);
sk_sp<GrColorSpaceXform> colorSpaceXform = GrTest::TestColorXform(d->fRandom);
SkIRect bounds = SkIRect::MakeWH(SkIntToScalar(kMaxWidth), SkIntToScalar(kMaxHeight));
SkRect srcRect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
sk_sp<GrFragmentProcessor> effect(GrMagnifierEffect::Make(
texture,
d->context(),
std::move(proxy),
std::move(colorSpaceXform),
SkRect::MakeWH(SkIntToScalar(kMaxWidth), SkIntToScalar(kMaxHeight)),
(float) width / texture->width(),
(float) height / texture->height(),
texture->width() / (float) x,
texture->height() / (float) y,
(float) inset / texture->width(),
(float) inset / texture->height()));
bounds,
srcRect,
srcRect.width() / bounds.width(),
srcRect.height() / bounds.height(),
bounds.width() / inset,
bounds.height() / inset));
SkASSERT(effect);
return effect;
}
@ -240,8 +322,7 @@ sk_sp<GrFragmentProcessor> GrMagnifierEffect::TestCreate(GrProcessorTestData* d)
bool GrMagnifierEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
const GrMagnifierEffect& s = sBase.cast<GrMagnifierEffect>();
return (this->fBounds == s.fBounds &&
this->fXOffset == s.fXOffset &&
this->fYOffset == s.fYOffset &&
this->fSrcRect == s.fSrcRect &&
this->fXInvZoom == s.fXInvZoom &&
this->fYInvZoom == s.fYInvZoom &&
this->fXInvInset == s.fXInvInset &&
@ -252,23 +333,6 @@ bool GrMagnifierEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
////////////////////////////////////////////////////////////////////////////////
sk_sp<SkImageFilter> SkMagnifierImageFilter::Make(const SkRect& srcRect, SkScalar inset,
sk_sp<SkImageFilter> input,
const CropRect* cropRect) {
if (!SkScalarIsFinite(inset) || !SkIsValidRect(srcRect)) {
return nullptr;
}
// Negative numbers in src rect are not supported
if (srcRect.fLeft < 0 || srcRect.fTop < 0) {
return nullptr;
}
return sk_sp<SkImageFilter>(new SkMagnifierImageFilter(srcRect, inset,
std::move(input),
cropRect));
}
SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect,
SkScalar inset,
sk_sp<SkImageFilter> input,
@ -276,7 +340,7 @@ SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect,
: INHERITED(&input, 1, cropRect)
, fSrcRect(srcRect)
, fInset(inset) {
SkASSERT(srcRect.x() >= 0 && srcRect.y() >= 0 && inset >= 0);
SkASSERT(srcRect.left() >= 0 && srcRect.top() >= 0 && inset >= 0);
}
sk_sp<SkFlattenable> SkMagnifierImageFilter::CreateProc(SkReadBuffer& buffer) {
@ -319,35 +383,22 @@ sk_sp<SkSpecialImage> SkMagnifierImageFilter::onFilterImage(SkSpecialImage* sour
if (source->isTextureBacked()) {
GrContext* context = source->getContext();
sk_sp<GrTexture> inputTexture(input->asTextureRef(context));
SkASSERT(inputTexture);
sk_sp<GrTextureProxy> inputProxy(input->asTextureProxyRef(context));
SkASSERT(inputProxy);
offset->fX = bounds.left();
offset->fY = bounds.top();
bounds.offset(-inputOffset);
SkScalar yOffset = inputTexture->origin() == kTopLeft_GrSurfaceOrigin
? fSrcRect.y()
: inputTexture->height() -
fSrcRect.height() * inputTexture->height() / bounds.height() - fSrcRect.y();
int boundsY = inputTexture->origin() == kTopLeft_GrSurfaceOrigin
? bounds.y()
: inputTexture->height() - bounds.height();
SkRect effectBounds = SkRect::MakeXYWH(
SkIntToScalar(bounds.x()) / inputTexture->width(),
SkIntToScalar(boundsY) / inputTexture->height(),
SkIntToScalar(inputTexture->width()) / bounds.width(),
SkIntToScalar(inputTexture->height()) / bounds.height());
SkColorSpace* dstColorSpace = ctx.outputProperties().colorSpace();
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(input->getColorSpace(),
dstColorSpace);
sk_sp<GrFragmentProcessor> fp(GrMagnifierEffect::Make(
inputTexture.get(),
context,
std::move(inputProxy),
std::move(colorSpaceXform),
effectBounds,
fSrcRect.x() / inputTexture->width(),
yOffset / inputTexture->height(),
bounds,
fSrcRect,
invXZoom,
invYZoom,
bounds.width() * invInset,

7
src/effects/SkMatrixConvolutionImageFilter.cpp
View File

@ -311,14 +311,15 @@ sk_sp<SkSpecialImage> SkMatrixConvolutionImageFilter::onFilterImage(SkSpecialIma
// fall-back, which saves us from having to do the xform during the filter itself.
input = ImageToColorSpace(input.get(), ctx.outputProperties());
sk_sp<GrTexture> inputTexture(input->asTextureRef(context));
SkASSERT(inputTexture);
sk_sp<GrTextureProxy> inputProxy(input->asTextureProxyRef(context));
SkASSERT(inputProxy);
offset->fX = bounds.left();
offset->fY = bounds.top();
bounds.offset(-inputOffset);
sk_sp<GrFragmentProcessor> fp(GrMatrixConvolutionEffect::Make(inputTexture.get(),
sk_sp<GrFragmentProcessor> fp(GrMatrixConvolutionEffect::Make(context,
std::move(inputProxy),
bounds,
fKernelSize,
fKernel,

2
src/effects/SkMorphologyImageFilter.cpp
View File

@ -477,7 +477,7 @@ static sk_sp<SkSpecialImage> apply_morphology(
GrMorphologyEffect::MorphologyType morphType,
SkISize radius,
const SkImageFilter::OutputProperties& outputProperties) {
sk_sp<GrTextureProxy> srcTexture(input->asTextureProxy(context));
sk_sp<GrTextureProxy> srcTexture(input->asTextureProxyRef(context));
SkASSERT(srcTexture);
sk_sp<SkColorSpace> colorSpace = sk_ref_sp(outputProperties.colorSpace());
GrPixelConfig config = GrRenderableConfigForColorSpace(colorSpace.get());

24
src/effects/SkXfermodeImageFilter.cpp
View File

@ -235,26 +235,26 @@ sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::filterImageGPU(
GrContext* context = source->getContext();
sk_sp<GrTexture> backgroundTex, foregroundTex;
sk_sp<GrTextureProxy> backgroundProxy, foregroundProxy;
if (background) {
backgroundTex = background->asTextureRef(context);
backgroundProxy = background->asTextureProxyRef(context);
}
if (foreground) {
foregroundTex = foreground->asTextureRef(context);
foregroundProxy = foreground->asTextureProxyRef(context);
}
GrPaint paint;
sk_sp<GrFragmentProcessor> bgFP;
if (backgroundTex) {
SkMatrix backgroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
-SkIntToScalar(backgroundOffset.fY));
if (backgroundProxy) {
SkMatrix bgMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
-SkIntToScalar(backgroundOffset.fY));
sk_sp<GrColorSpaceXform> bgXform = GrColorSpaceXform::Make(background->getColorSpace(),
outputProperties.colorSpace());
bgFP = GrTextureDomainEffect::Make(
backgroundTex.get(), std::move(bgXform), backgroundMatrix,
context, std::move(backgroundProxy), std::move(bgXform), bgMatrix,
GrTextureDomain::MakeTexelDomain(background->subset()),
GrTextureDomain::kDecal_Mode,
GrSamplerParams::kNone_FilterMode);
@ -263,15 +263,15 @@ sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::filterImageGPU(
GrConstColorProcessor::kIgnore_InputMode);
}
if (foregroundTex) {
SkMatrix foregroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(foregroundOffset.fX),
-SkIntToScalar(foregroundOffset.fY));
if (foregroundProxy) {
SkMatrix fgMatrix = SkMatrix::MakeTrans(-SkIntToScalar(foregroundOffset.fX),
-SkIntToScalar(foregroundOffset.fY));
sk_sp<GrColorSpaceXform> fgXform = GrColorSpaceXform::Make(foreground->getColorSpace(),
outputProperties.colorSpace());
sk_sp<GrFragmentProcessor> foregroundFP;
foregroundFP = GrTextureDomainEffect::Make(
foregroundTex.get(), std::move(fgXform), foregroundMatrix,
context, std::move(foregroundProxy), std::move(fgXform), fgMatrix,
GrTextureDomain::MakeTexelDomain(foreground->subset()),
GrTextureDomain::kDecal_Mode,
GrSamplerParams::kNone_FilterMode);

14
src/gpu/SkGpuDevice.cpp
View File

@ -1163,25 +1163,29 @@ void SkGpuDevice::drawSpecial(const SkDraw& draw,
}
SkASSERT(result->isTextureBacked());
sk_sp<GrTexture> texture = result->asTextureRef(fContext.get());
if (!texture) {
sk_sp<GrTextureProxy> proxy = result->asTextureProxyRef(fContext.get());
if (!proxy) {
return;
}
const GrPixelConfig config = proxy->config();
SkPaint tmpUnfiltered(paint);
tmpUnfiltered.setImageFilter(nullptr);
sk_sp<GrColorSpaceXform> colorSpaceXform =
GrColorSpaceXform::Make(result->getColorSpace(), fRenderTargetContext->getColorSpace());
GrPaint grPaint;
sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(texture.get(),
sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(fContext.get(),
std::move(proxy),
std::move(colorSpaceXform),
SkMatrix::I()));
if (GrPixelConfigIsAlphaOnly(texture->config())) {
if (GrPixelConfigIsAlphaOnly(config)) {
fp = GrFragmentProcessor::MakeInputPremulAndMulByOutput(std::move(fp));
} else {
fp = GrFragmentProcessor::MulOutputByInputAlpha(std::move(fp));
}
GrPaint grPaint;
if (!SkPaintToGrPaintReplaceShader(this->context(), fRenderTargetContext.get(), tmpUnfiltered,
std::move(fp), &grPaint)) {
return;

6
tests/SpecialImageTest.cpp
View File

@ -65,10 +65,10 @@ static void test_image(const sk_sp<SkSpecialImage>& img, skiatest::Reporter* rep
#if SK_SUPPORT_GPU
//--------------
// Test getTextureAsRef - as long as there is a context this should succeed
// Test asTextureProxyRef - as long as there is a context this should succeed
if (context) {
sk_sp<GrTexture> texture(img->asTextureRef(context));
REPORTER_ASSERT(reporter, texture);
sk_sp<GrTextureProxy> proxy(img->asTextureProxyRef(context));
REPORTER_ASSERT(reporter, proxy);
}
#endif