The idea here is that the GrCoordTransform will actually hold a GrTextureProxy (rather than a GrTexture) and then, in GrGLSLPrimitiveProcessor::GetTransformMatrix, use the instantiated width & height (when uploading the transform matrix)
Relanding of: https://skia-review.googlesource.com/c/6977/
Change-Id: Ibc9b9e354f7fc23b1a6e6e4fe7c9fe3cef771c02
Reviewed-on: https://skia-review.googlesource.com/7265
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
GrSamplerParams::FilterMode::kNone_FilterMode);
sk_sp<GrTexture> permutationsTexture(
GrRefCachedBitmapTexture(args.fContext, paintingData->getImprovedPermutationsBitmap(),
- textureParams));
+ textureParams, nullptr));
sk_sp<GrTexture> gradientTexture(
GrRefCachedBitmapTexture(args.fContext, paintingData->getGradientBitmap(),
- textureParams));
+ textureParams, nullptr));
return GrImprovedPerlinNoiseEffect::Make(fNumOctaves, fSeed, paintingData,
permutationsTexture.get(),
gradientTexture.get(), m);
sk_sp<GrTexture> permutationsTexture(
GrRefCachedBitmapTexture(args.fContext, paintingData->getPermutationsBitmap(),
- GrSamplerParams::ClampNoFilter()));
+ GrSamplerParams::ClampNoFilter(), nullptr));
sk_sp<GrTexture> noiseTexture(
GrRefCachedBitmapTexture(args.fContext, paintingData->getNoiseBitmap(),
- GrSamplerParams::ClampNoFilter()));
+ GrSamplerParams::ClampNoFilter(), nullptr));
if ((permutationsTexture) && (noiseTexture)) {
sk_sp<GrFragmentProcessor> inner(
sk_sp<SkColorSpace> texColorSpace;
sk_sp<GrTexture> texture(
cache->lockAsTexture(canvas->getGrContext(), GrSamplerParams::ClampBilerp(),
- canvas->imageInfo().colorSpace(), &texColorSpace, nullptr));
+ canvas->imageInfo().colorSpace(), &texColorSpace,
+ nullptr, nullptr));
if (!texture) {
// show placeholder if we have no texture
SkPaint paint;
} else {
vm.reset();
}
- SkMatrix tm;
- tm = vm;
- tm.postIDiv(2*S, 2*S);
- paint.addColorTextureProcessor(texture, nullptr, tm);
+ paint.addColorTextureProcessor(texture, nullptr, vm);
renderTargetContext->drawRect(clip, GrPaint(paint), GrAA::kNo, vm,
SkRect::MakeWH(2 * S, 2 * S));
}
sk_sp<GrTexture> texture(
- GrRefCachedBitmapTexture(context, fBmp, GrSamplerParams::ClampNoFilter()));
+ GrRefCachedBitmapTexture(context, fBmp, GrSamplerParams::ClampNoFilter(), nullptr));
if (!texture) {
return;
}
SkTArray<SkMatrix> textureMatrices;
- textureMatrices.push_back().setIDiv(texture->width(), texture->height());
- textureMatrices.push_back() = textureMatrices[0];
- textureMatrices.back().postScale(1.5f, 0.85f);
- textureMatrices.push_back() = textureMatrices[0];
- textureMatrices.back().preRotate(45.f, texture->width() / 2.f, texture->height() / 2.f);
+ textureMatrices.push_back() = SkMatrix::I();
+ textureMatrices.push_back() = SkMatrix::MakeScale(1.5f, 0.85f);
+ textureMatrices.push_back();
+ textureMatrices.back().setRotate(45.f, texture->width() / 2.f, texture->height() / 2.f);
const SkIRect texelDomains[] = {
fBmp.bounds(),
sk_sp<GrTexture> texture[3];
texture[0].reset(
- GrRefCachedBitmapTexture(context, fBmp[0], GrSamplerParams::ClampBilerp()));
+ GrRefCachedBitmapTexture(context, fBmp[0], GrSamplerParams::ClampBilerp(), nullptr));
texture[1].reset(
- GrRefCachedBitmapTexture(context, fBmp[1], GrSamplerParams::ClampBilerp()));
+ GrRefCachedBitmapTexture(context, fBmp[1], GrSamplerParams::ClampBilerp(), nullptr));
texture[2].reset(
- GrRefCachedBitmapTexture(context, fBmp[2], GrSamplerParams::ClampBilerp()));
+ GrRefCachedBitmapTexture(context, fBmp[2], GrSamplerParams::ClampBilerp(), nullptr));
if (!texture[0] || !texture[1] || !texture[2]) {
return;
sk_sp<GrTexture> texture[3];
texture[0].reset(
- GrRefCachedBitmapTexture(context, fBmp[0], GrSamplerParams::ClampBilerp()));
+ GrRefCachedBitmapTexture(context, fBmp[0], GrSamplerParams::ClampBilerp(), nullptr));
texture[1].reset(
- GrRefCachedBitmapTexture(context, fBmp[1], GrSamplerParams::ClampBilerp()));
+ GrRefCachedBitmapTexture(context, fBmp[1], GrSamplerParams::ClampBilerp(), nullptr));
texture[2].reset(
- GrRefCachedBitmapTexture(context, fBmp[1], GrSamplerParams::ClampBilerp()));
+ GrRefCachedBitmapTexture(context, fBmp[1], GrSamplerParams::ClampBilerp(), nullptr));
if (!texture[0] || !texture[1] || !texture[2]) {
return;
*/
class GrCoordTransform : SkNoncopyable {
public:
- GrCoordTransform() { SkDEBUGCODE(fInProcessor = false); }
+ GrCoordTransform()
+ : fTexture(nullptr)
+ , fNormalize(false) {
+ SkDEBUGCODE(fInProcessor = false);
+ }
/**
* Create a transformation that maps [0, 1] to a texture's boundaries. The precision is inferred
GrCoordTransform(const GrTexture* texture, GrSamplerParams::FilterMode filter) {
SkASSERT(texture);
SkDEBUGCODE(fInProcessor = false);
- this->reset(texture, filter);
+ this->reset(SkMatrix::I(), texture, filter);
}
/**
this->reset(m, precision);
}
- void reset(const GrTexture* texture, GrSamplerParams::FilterMode filter) {
+ void reset(const SkMatrix&, const GrTexture*, GrSamplerParams::FilterMode filter,
+ bool normalize = true);
+
+ void reset(const SkMatrix& m, GrSLPrecision precision = kDefault_GrSLPrecision) {
SkASSERT(!fInProcessor);
- SkASSERT(texture);
- this->reset(MakeDivByTextureWHMatrix(texture), texture, filter);
+ fMatrix = m;
+ fTexture = nullptr;
+ fNormalize = false;
+ fReverseY = false;
+ fPrecision = precision;
}
- void reset(const SkMatrix&, const GrTexture*, GrSamplerParams::FilterMode filter);
- void reset(const SkMatrix& m, GrSLPrecision precision = kDefault_GrSLPrecision);
-
GrCoordTransform& operator= (const GrCoordTransform& that) {
SkASSERT(!fInProcessor);
fMatrix = that.fMatrix;
+ fTexture = that.fTexture;
+ fNormalize = that.fNormalize;
fReverseY = that.fReverseY;
fPrecision = that.fPrecision;
return *this;
return &fMatrix;
}
- bool operator==(const GrCoordTransform& that) const {
- return fMatrix.cheapEqualTo(that.fMatrix) &&
- fReverseY == that.fReverseY &&
- fPrecision == that.fPrecision;
+ bool hasSameEffectAs(const GrCoordTransform& that) const {
+ if (fNormalize != that.fNormalize ||
+ fReverseY != that.fReverseY ||
+ fPrecision != that.fPrecision ||
+ !fMatrix.cheapEqualTo(that.fMatrix)) {
+ return false;
+ }
+
+ if (fNormalize) {
+ SkASSERT(fTexture && that.fTexture);
+ return fTexture->width() == that.fTexture->width() &&
+ fTexture->height() == that.fTexture->height();
+ }
+
+ return true;
}
- bool operator!=(const GrCoordTransform& that) const { return !(*this == that); }
-
const SkMatrix& getMatrix() const { return fMatrix; }
+ const GrTexture* texture() const { return fTexture; }
+ bool normalize() const { return fNormalize; }
bool reverseY() const { return fReverseY; }
GrSLPrecision precision() const { return fPrecision; }
- /** Useful for effects that want to insert a texture matrix that is implied by the texture
- dimensions */
- static inline SkMatrix MakeDivByTextureWHMatrix(const GrTexture* texture) {
- SkASSERT(texture);
- SkMatrix mat;
- (void)mat.setIDiv(texture->width(), texture->height());
- return mat;
- }
-
private:
+ // The textures' effect is to optionally normalize the final matrix, so a blind
+ // equality check could be misleading
+ bool operator==(const GrCoordTransform& that) const;
+ bool operator!=(const GrCoordTransform& that) const;
+
SkMatrix fMatrix;
+ const GrTexture* fTexture;
+ bool fNormalize;
bool fReverseY;
GrSLPrecision fPrecision;
typedef SkNoncopyable INHERITED;
////////////////////////////////////////////////////////////////////////////////
/** Returns a texture representing the bitmap that is compatible with the GrSamplerParams. The
- texture is inserted into the cache (unless the bitmap is marked volatile) and can be
- retrieved again via this function. */
-GrTexture* GrRefCachedBitmapTexture(GrContext*, const SkBitmap&, const GrSamplerParams&);
+ * texture is inserted into the cache (unless the bitmap is marked volatile) and can be
+ * retrieved again via this function.
+ * The 'scaleAdjust' in/out parameter will be updated to hold any rescaling that needs to be
+ * performed on the absolute texture coordinates (e.g., if the texture is resized out to
+ * the next power of two). It can be null if the caller is sure the bitmap won't be resized.
+ */
+GrTexture* GrRefCachedBitmapTexture(GrContext*, const SkBitmap&,
+ const GrSamplerParams&, SkScalar scaleAdjust[2]);
-sk_sp<GrTexture> GrMakeCachedBitmapTexture(GrContext*, const SkBitmap&, const GrSamplerParams&);
+sk_sp<GrTexture> GrMakeCachedBitmapTexture(GrContext*, const SkBitmap&,
+ const GrSamplerParams&, SkScalar scaleAdjust[2]);
// TODO: Move SkImageInfo2GrPixelConfig to SkGrPriv.h (requires cleanup to SkWindow its subclasses).
GrPixelConfig SkImageInfo2GrPixelConfig(const SkImageInfo& info, const GrCaps& caps);
for (int i = 1; i < scaleFactorX || i < scaleFactorY; i *= 2) {
GrPaint paint;
paint.setGammaCorrect(dstRenderTargetContext->isGammaCorrect());
- // TODO: this matrix relies on the final instantiated size of the texture. This
- // will have to be deferred for TextureProxys
- SkMatrix matrix;
- matrix.setIDiv(srcTexture->width(), srcTexture->height());
SkIRect dstRect(srcRect);
if (srcBounds && i == 1) {
SkRect domain = SkRect::Make(*srcBounds);
sk_sp<GrFragmentProcessor> fp(GrTextureDomainEffect::Make(
srcTexture.get(),
nullptr,
- matrix,
+ SkMatrix::I(),
domain,
GrTextureDomain::kDecal_Mode,
GrSamplerParams::kBilerp_FilterMode));
srcOffset.set(0, 0);
} else {
GrSamplerParams params(SkShader::kClamp_TileMode, GrSamplerParams::kBilerp_FilterMode);
- paint.addColorTextureProcessor(srcTexture.get(), nullptr, matrix, params);
+ paint.addColorTextureProcessor(srcTexture.get(), nullptr, SkMatrix::I(), params);
}
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
shrink_irect_by_2(&dstRect, i < scaleFactorX, i < scaleFactorY);
return nullptr;
}
- // TODO: this matrix relies on the final instantiated size of the texture. This
- // will have to be deferred for TextureProxys
- SkMatrix matrix;
- matrix.setIDiv(tex->width(), tex->height());
-
- paint.addColorTextureProcessor(tex.get(), nullptr, matrix, params);
+ paint.addColorTextureProcessor(tex.get(), nullptr, SkMatrix::I(), params);
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
SkIRect dstRect(srcRect);
GrTexture* SkImageCacherator::lockAsTexture(GrContext* ctx, const GrSamplerParams& params,
SkColorSpace* dstColorSpace,
sk_sp<SkColorSpace>* texColorSpace,
- const SkImage* client, SkImage::CachingHint chint) {
+ const SkImage* client,
+ SkScalar scaleAdjust[2],
+ SkImage::CachingHint chint) {
if (!ctx) {
return nullptr;
}
return GrImageTextureMaker(ctx, this, client, chint).refTextureForParams(params, dstColorSpace,
- texColorSpace);
+ texColorSpace,
+ scaleAdjust);
}
#else
GrTexture* SkImageCacherator::lockAsTexture(GrContext* ctx, const GrSamplerParams&,
SkColorSpace* dstColorSpace,
sk_sp<SkColorSpace>* texColorSpace,
- const SkImage* client, SkImage::CachingHint) {
+ const SkImage* client,
+ SkScalar scaleAdjust[2], SkImage::CachingHint) {
return nullptr;
}
* added to the cache on its behalf.
*
* The caller is responsible for calling texture->unref() when they are done.
+ *
+ * The scaleAdjust in/out parameter will return any scale adjustment that needs
+ * to be applied to the absolute texture coordinates in the case where the image
+ * was resized to meet the sampling requirements (e.g., resized out to the next power of 2).
+ * It can be null if the caller knows resizing will not be required.
*/
GrTexture* lockAsTexture(GrContext*, const GrSamplerParams&, SkColorSpace* dstColorSpace,
sk_sp<SkColorSpace>* texColorSpace, const SkImage* client,
+ SkScalar scaleAdjust[2],
SkImage::CachingHint = SkImage::kAllow_CachingHint);
/**
const SkMatrix::MapPtsProc SkMatrix::gMapPtsProcs[] = {
SkMatrix::Identity_pts, SkMatrix::Trans_pts,
- SkMatrix::Scale_pts, SkMatrix::Scale_pts,
+ SkMatrix::Scale_pts, SkMatrix::Scale_pts,
SkMatrix::Affine_vpts, SkMatrix::Affine_vpts,
SkMatrix::Affine_vpts, SkMatrix::Affine_vpts,
// repeat the persp proc 8 times
}
sk_sp<GrTexture> resultTex(
- GrRefCachedBitmapTexture(context, bmp, GrSamplerParams::ClampNoFilter()));
+ GrRefCachedBitmapTexture(context, bmp, GrSamplerParams::ClampNoFilter(), nullptr));
if (!resultTex) {
return nullptr;
}
#if SK_SUPPORT_GPU
sk_sp<GrTexture> onAsTextureRef(GrContext* context) const override {
if (context) {
- return sk_ref_sp(
- GrRefCachedBitmapTexture(context, fBitmap, GrSamplerParams::ClampNoFilter()));
+ return sk_ref_sp(GrRefCachedBitmapTexture(context, fBitmap,
+ GrSamplerParams::ClampNoFilter(), nullptr));
}
return nullptr;
sk_sp<GrTextureProxy> onAsTextureProxy(GrContext* context) const override {
if (context) {
sk_sp<GrTexture> tex(sk_ref_sp(GrRefCachedBitmapTexture(
- context, fBitmap, GrSamplerParams::ClampNoFilter())));
+ context, fBitmap, GrSamplerParams::ClampNoFilter(), nullptr)));
sk_sp<GrSurfaceProxy> sProxy = GrSurfaceProxy::MakeWrapped(std::move(tex));
return sk_ref_sp(sProxy->asTextureProxy());
}
bounds));
}
-static SkMatrix make_div_and_translate_matrix(GrTexture* texture, int x, int y) {
- SkMatrix matrix = GrCoordTransform::MakeDivByTextureWHMatrix(texture);
- matrix.preTranslate(SkIntToScalar(x), SkIntToScalar(y));
- return matrix;
-}
-
GrAlphaThresholdFragmentProcessor::GrAlphaThresholdFragmentProcessor(
GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkIRect& bounds)
: fInnerThreshold(innerThreshold)
, fOuterThreshold(outerThreshold)
- , fImageCoordTransform(GrCoordTransform::MakeDivByTextureWHMatrix(texture), texture,
- GrSamplerParams::kNone_FilterMode)
+ , fImageCoordTransform(SkMatrix::I(), texture, GrSamplerParams::kNone_FilterMode)
, fImageTextureSampler(texture)
, fColorSpaceXform(std::move(colorSpaceXform))
- , fMaskCoordTransform(make_div_and_translate_matrix(maskTexture, -bounds.x(), -bounds.y()),
+ , fMaskCoordTransform(SkMatrix::MakeTrans(SkIntToScalar(-bounds.x()),
+ SkIntToScalar(-bounds.y())),
maskTexture,
GrSamplerParams::kNone_FilterMode)
, fMaskTextureSampler(maskTexture) {
sk_sp<GrFragmentProcessor> bgFP;
if (backgroundTex) {
- SkMatrix backgroundMatrix;
- backgroundMatrix.setIDiv(backgroundTex->width(), backgroundTex->height());
- backgroundMatrix.preTranslate(-SkIntToScalar(backgroundOffset.fX),
- -SkIntToScalar(backgroundOffset.fY));
+ SkMatrix backgroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
+ -SkIntToScalar(backgroundOffset.fY));
sk_sp<GrColorSpaceXform> bgXform =
GrColorSpaceXform::Make(background->getColorSpace(), outputProperties.colorSpace());
bgFP = GrTextureDomainEffect::Make(
}
if (foregroundTex) {
- SkMatrix foregroundMatrix;
- foregroundMatrix.setIDiv(foregroundTex->width(), foregroundTex->height());
- foregroundMatrix.preTranslate(-SkIntToScalar(foregroundOffset.fX),
- -SkIntToScalar(foregroundOffset.fY));
+ SkMatrix foregroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(foregroundOffset.fX),
+ -SkIntToScalar(foregroundOffset.fY));
sk_sp<GrColorSpaceXform> fgXform =
GrColorSpaceXform::Make(foreground->getColorSpace(), outputProperties.colorSpace());
sk_sp<GrFragmentProcessor> foregroundFP;
if (!isNormalBlur) {
GrPaint paint;
- SkMatrix matrix;
- matrix.setIDiv(src->width(), src->height());
// Blend pathTexture over blurTexture.
- paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(src, nullptr, matrix));
+ paint.addCoverageFragmentProcessor(
+ GrSimpleTextureEffect::Make(src, nullptr, SkMatrix::I()));
if (kInner_SkBlurStyle == fBlurStyle) {
// inner: dst = dst * src
paint.setCoverageSetOpXPFactory(SkRegion::kIntersect_Op);
return nullptr;
}
- SkMatrix offsetMatrix = GrCoordTransform::MakeDivByTextureWHMatrix(displTexture.get());
- offsetMatrix.preTranslate(SkIntToScalar(colorOffset.fX - displOffset.fX),
- SkIntToScalar(colorOffset.fY - displOffset.fY));
+ SkMatrix offsetMatrix = SkMatrix::MakeTrans(SkIntToScalar(colorOffset.fX - displOffset.fX),
+ SkIntToScalar(colorOffset.fY - displOffset.fY));
SkColorSpace* colorSpace = ctx.outputProperties().colorSpace();
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(color->getColorSpace(),
colorSpace);
const SkMatrix& matrix,
BoundaryMode boundaryMode,
const SkIRect* srcBounds)
- : INHERITED(texture, nullptr, GrCoordTransform::MakeDivByTextureWHMatrix(texture))
+ : INHERITED(texture, nullptr, SkMatrix::I())
, fLight(light)
, fSurfaceScale(surfaceScale)
, fFilterMatrix(matrix)
float yInvZoom,
float xInvInset,
float yInvInset)
- : INHERITED(texture, std::move(colorSpaceXform),
- GrCoordTransform::MakeDivByTextureWHMatrix(texture))
+ : INHERITED(texture, std::move(colorSpaceXform), SkMatrix::I())
, fBounds(bounds)
, fXOffset(xOffset)
, fYOffset(yOffset)
bool stitchTiles() const { return fStitchTiles; }
const SkVector& baseFrequency() const { return fPaintingData->fBaseFrequency; }
int numOctaves() const { return fNumOctaves; }
- const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
GrTexture* permutationsTexture, GrTexture* noiseTexture,
const SkMatrix& matrix)
: fType(type)
+ , fCoordTransform(matrix)
, fNumOctaves(numOctaves)
, fStitchTiles(stitchTiles)
, fPermutationsSampler(permutationsTexture)
this->initClassID<GrPerlinNoiseEffect>();
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fNoiseSampler);
- fCoordTransform.reset(matrix);
this->addCoordTransform(&fCoordTransform);
}
new PaintingData(fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY, matrix);
sk_sp<GrTexture> permutationsTexture(
GrRefCachedBitmapTexture(args.fContext, paintingData->getPermutationsBitmap(),
- GrSamplerParams::ClampNoFilter()));
+ GrSamplerParams::ClampNoFilter(), nullptr));
sk_sp<GrTexture> noiseTexture(
GrRefCachedBitmapTexture(args.fContext, paintingData->getNoiseBitmap(),
- GrSamplerParams::ClampNoFilter()));
+ GrSamplerParams::ClampNoFilter(), nullptr));
SkMatrix m = *args.fViewMatrix;
m.setTranslateX(-localMatrix.getTranslateX() + SK_Scalar1);
if (-1 == row) {
atlas = nullptr;
texture.reset(
- GrRefCachedBitmapTexture(context, bitmap, GrSamplerParams::ClampNoFilter()));
+ GrRefCachedBitmapTexture(context, bitmap, GrSamplerParams::ClampNoFilter(), nullptr));
} else {
texture.reset(SkRef(atlas->getTexture()));
}
sk_sp<GrFragmentProcessor> bgFP;
if (backgroundTex) {
- SkMatrix backgroundMatrix;
- backgroundMatrix.setIDiv(backgroundTex->width(), backgroundTex->height());
- backgroundMatrix.preTranslate(-SkIntToScalar(backgroundOffset.fX),
- -SkIntToScalar(backgroundOffset.fY));
+ SkMatrix backgroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(backgroundOffset.fX),
+ -SkIntToScalar(backgroundOffset.fY));
sk_sp<GrColorSpaceXform> bgXform = GrColorSpaceXform::Make(background->getColorSpace(),
outputProperties.colorSpace());
bgFP = GrTextureDomainEffect::Make(
}
if (foregroundTex) {
- SkMatrix foregroundMatrix;
- foregroundMatrix.setIDiv(foregroundTex->width(), foregroundTex->height());
- foregroundMatrix.preTranslate(-SkIntToScalar(foregroundOffset.fX),
- -SkIntToScalar(foregroundOffset.fY));
+ SkMatrix foregroundMatrix = SkMatrix::MakeTrans(-SkIntToScalar(foregroundOffset.fX),
+ -SkIntToScalar(foregroundOffset.fY));
sk_sp<GrColorSpaceXform> fgXform = GrColorSpaceXform::Make(foreground->getColorSpace(),
outputProperties.colorSpace());
sk_sp<GrFragmentProcessor> foregroundFP;
fRow = fAtlas->lockRow(bitmap);
if (-1 != fRow) {
fYCoord = fAtlas->getYOffset(fRow)+SK_ScalarHalf*fAtlas->getNormalizedTexelHeight();
- fCoordTransform.reset(*args.fMatrix, fAtlas->getTexture(), params.filterMode());
+ // This is 1/2 places where auto-normalization is disabled
+ fCoordTransform.reset(*args.fMatrix, fAtlas->getTexture(),
+ params.filterMode(), false);
fTextureSampler.reset(fAtlas->getTexture(), params);
} else {
- sk_sp<GrTexture> texture(GrRefCachedBitmapTexture(args.fContext, bitmap, params));
+ sk_sp<GrTexture> texture(GrRefCachedBitmapTexture(args.fContext, bitmap,
+ params, nullptr));
if (!texture) {
return;
}
- fCoordTransform.reset(*args.fMatrix, texture.get(), params.filterMode());
+ // This is 2/2 places where auto-normalization is disabled
+ fCoordTransform.reset(*args.fMatrix, texture.get(), params.filterMode(), false);
fTextureSampler.reset(texture.get(), params);
fYCoord = SK_ScalarHalf;
}
return false;
}
- SkMatrix matrix;
- matrix.setTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(maskRect.fTop));
- // TODO: this divide relies on the instantiated texture's size!
- matrix.postIDiv(maskTex->width(), maskTex->height());
+ SkMatrix matrix = SkMatrix::MakeTrans(-SkIntToScalar(maskRect.fLeft),
+ -SkIntToScalar(maskRect.fTop));
matrix.preConcat(viewMatrix);
paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(maskTex, nullptr, matrix));
SkAutoSTMalloc<128 * 128, uint32_t> tmpPixels(0);
if (tempTexture) {
sk_sp<GrFragmentProcessor> fp;
- SkMatrix textureMatrix;
- textureMatrix.setIDiv(tempTexture->width(), tempTexture->height());
if (applyPremulToSrc) {
- fp = this->createUPMToPMEffect(tempTexture.get(), tempDrawInfo.fSwizzle, textureMatrix);
+ fp = this->createUPMToPMEffect(tempTexture.get(), tempDrawInfo.fSwizzle, SkMatrix::I());
// If premultiplying was the only reason for the draw, fall back to a straight write.
if (!fp) {
if (GrGpu::kCallerPrefersDraw_DrawPreference == drawPreference) {
if (!fp) {
fp = GrConfigConversionEffect::Make(tempTexture.get(), tempDrawInfo.fSwizzle,
GrConfigConversionEffect::kNone_PMConversion,
- textureMatrix);
+ SkMatrix::I());
if (!fp) {
return false;
}
tempDrawInfo.fTempSurfaceDesc.fSampleCnt,
tempDrawInfo.fTempSurfaceDesc.fOrigin);
if (tempRTC) {
- SkMatrix textureMatrix;
- textureMatrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
- textureMatrix.postIDiv(src->width(), src->height());
+ SkMatrix textureMatrix = SkMatrix::MakeTrans(SkIntToScalar(left), SkIntToScalar(top));
sk_sp<GrFragmentProcessor> fp;
if (unpremul) {
fp = this->createPMToUPMEffect(src->asTexture(), tempDrawInfo.fSwizzle,
#include "GrGpu.h"
void GrCoordTransform::reset(const SkMatrix& m, const GrTexture* texture,
- GrSamplerParams::FilterMode filter) {
+ GrSamplerParams::FilterMode filter, bool normalize) {
SkASSERT(texture);
SkASSERT(!fInProcessor);
fMatrix = m;
+ fTexture = texture;
+ fNormalize = normalize;
fReverseY = kBottomLeft_GrSurfaceOrigin == texture->origin();
// Always start at kDefault. Then if precisions differ we see if the precision needs to be
}
}
-void GrCoordTransform::reset(const SkMatrix& m, GrSLPrecision precision) {
- SkASSERT(!fInProcessor);
- fMatrix = m;
- fReverseY = false;
- fPrecision = precision;
-}
}
int count = this->numCoordTransforms();
for (int i = 0; i < count; ++i) {
- if (this->coordTransform(i) != that.coordTransform(i)) {
+ if (!this->coordTransform(i).hasSameEffectAs(that.coordTransform(i))) {
return false;
}
}
////////////////////////////////////////////////////////////////////////////////
bool GrGpu::makeCopyForTextureParams(int width, int height, const GrSamplerParams& textureParams,
- GrTextureProducer::CopyParams* copyParams) const {
+ GrTextureProducer::CopyParams* copyParams,
+ SkScalar scaleAdjust[2]) const {
const GrCaps& caps = *this->caps();
if (textureParams.isTiled() && !caps.npotTextureTileSupport() &&
(!SkIsPow2(width) || !SkIsPow2(height))) {
+ SkASSERT(scaleAdjust);
copyParams->fWidth = GrNextPow2(width);
copyParams->fHeight = GrNextPow2(height);
+ scaleAdjust[0] = ((SkScalar) copyParams->fWidth) / width;
+ scaleAdjust[1] = ((SkScalar) copyParams->fHeight) / height;
switch (textureParams.filterMode()) {
case GrSamplerParams::kNone_FilterMode:
copyParams->fFilter = GrSamplerParams::kNone_FilterMode;
// GrSamplerParams. This variation is called when the caller will create a new texture using the
// texture provider from a non-texture src (cpu-backed image, ...).
bool makeCopyForTextureParams(int width, int height, const GrSamplerParams&,
- GrTextureProducer::CopyParams*) const;
+ GrTextureProducer::CopyParams*, SkScalar scaleAdjust[2]) const;
// Like the above but this variation should be called when the caller is not creating the
// original texture but rather was handed the original texture. It adds additional checks
// relevant to original textures that were created external to Skia via
// GrTextureProvider::wrap methods.
bool makeCopyForTextureParams(GrTexture* texture, const GrSamplerParams& params,
- GrTextureProducer::CopyParams* copyParams) const {
+ GrTextureProducer::CopyParams* copyParams,
+ SkScalar scaleAdjust[2]) const {
if (this->makeCopyForTextureParams(texture->width(), texture->height(), params,
- copyParams)) {
+ copyParams, scaleAdjust)) {
return true;
}
- return this->onMakeCopyForTextureParams(texture, params, copyParams);
+ return this->onMakeCopyForTextureParams(texture, params, copyParams, scaleAdjust);
}
// This is only to be used in GL-specific tests.
virtual gr_instanced::InstancedRendering* onCreateInstancedRendering() = 0;
virtual bool onMakeCopyForTextureParams(GrTexture* texture, const GrSamplerParams&,
- GrTextureProducer::CopyParams*) const { return false; }
+ GrTextureProducer::CopyParams*,
+ SkScalar scaleAdjust[2]) const { return false; }
virtual bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight,
size_t rowBytes, GrPixelConfig readConfig, DrawPreference*,
// We use device coords to compute the texture coordinates. We take the device coords and apply
// a translation so that the top-left of the device bounds maps to 0,0, and then a scaling
// matrix to normalized coords.
- SkMatrix maskMatrix;
- maskMatrix.setIDiv(texture->width(), texture->height());
- maskMatrix.preTranslate(SkIntToScalar(-textureOriginInDeviceSpace.fX),
- SkIntToScalar(-textureOriginInDeviceSpace.fY));
+ SkMatrix maskMatrix = SkMatrix::MakeTrans(SkIntToScalar(-textureOriginInDeviceSpace.fX),
+ SkIntToScalar(-textureOriginInDeviceSpace.fY));
maskMatrix.preConcat(viewMatrix);
std::unique_ptr<GrDrawOp> op = GrRectOpFactory::MakeNonAAFill(paint.getColor(), SkMatrix::I(),
dstRect, nullptr, &invert);
}
GrTexture* GrTextureAdjuster::refTextureSafeForParams(const GrSamplerParams& params,
- SkIPoint* outOffset) {
+ SkIPoint* outOffset,
+ SkScalar scaleAdjust[2]) {
GrTexture* texture = this->originalTexture();
GrContext* context = texture->getContext();
CopyParams copyParams;
copyParams.fWidth = contentArea->width();
copyParams.fHeight = contentArea->height();
copyParams.fFilter = GrSamplerParams::kBilerp_FilterMode;
- } else if (!context->getGpu()->makeCopyForTextureParams(texture, params, ©Params)) {
+ } else if (!context->getGpu()->makeCopyForTextureParams(texture, params, ©Params,
+ scaleAdjust)) {
if (outOffset) {
if (contentArea) {
outOffset->set(contentArea->fLeft, contentArea->fRight);
if (filterOrNullForBicubic) {
params.setFilterMode(*filterOrNullForBicubic);
}
- sk_sp<GrTexture> texture(this->refTextureSafeForParams(params, nullptr));
+ SkScalar scaleAdjust[2] = { 1.0f, 1.0f };
+ sk_sp<GrTexture> texture(this->refTextureSafeForParams(params, nullptr, scaleAdjust));
if (!texture) {
return nullptr;
}
// content.
if (texture.get() != this->originalTexture()) {
contentArea = nullptr;
+ textureMatrix.postScale(scaleAdjust[0], scaleAdjust[1]);
}
DomainMode domainMode =
}
SkASSERT(kNoDomain_DomainMode == domainMode ||
(domain.fLeft <= domain.fRight && domain.fTop <= domain.fBottom));
- textureMatrix.postIDiv(texture->width(), texture->height());
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(fColorSpace,
dstColorSpace);
return CreateFragmentProcessorForDomainAndFilter(texture.get(), std::move(colorSpaceXform),
outOffset will be the top-left corner of the subset if a copy is not made. Otherwise,
the copy will be tight to the contents and outOffset will be (0, 0). If the copy's size
does not match subset's dimensions then the contents are scaled to fit the copy.*/
- GrTexture* refTextureSafeForParams(const GrSamplerParams&, SkIPoint* outOffset);
+ GrTexture* refTextureSafeForParams(const GrSamplerParams&, SkIPoint* outOffset,
+ SkScalar scaleAdjust[2]);
sk_sp<GrFragmentProcessor> createFragmentProcessor(
const SkMatrix& textureMatrix,
GrTexture* GrTextureMaker::refTextureForParams(const GrSamplerParams& params,
SkColorSpace* dstColorSpace,
- sk_sp<SkColorSpace>* texColorSpace) {
+ sk_sp<SkColorSpace>* texColorSpace,
+ SkScalar scaleAdjust[2]) {
CopyParams copyParams;
bool willBeMipped = params.filterMode() == GrSamplerParams::kMipMap_FilterMode;
}
if (!fContext->getGpu()->makeCopyForTextureParams(this->width(), this->height(), params,
- ©Params)) {
+ ©Params, scaleAdjust)) {
return this->refOriginalTexture(willBeMipped, dstColorSpace);
}
GrUniqueKey copyKey;
params.reset(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode);
}
sk_sp<SkColorSpace> texColorSpace;
- sk_sp<GrTexture> texture(this->refTextureForParams(params, dstColorSpace, &texColorSpace));
+ SkScalar scaleAdjust[2] = { 1.0f, 1.0f };
+ sk_sp<GrTexture> texture(this->refTextureForParams(params, dstColorSpace, &texColorSpace,
+ scaleAdjust));
if (!texture) {
return nullptr;
}
+ SkMatrix adjustedMatrix = textureMatrix;
+ adjustedMatrix.postScale(scaleAdjust[0], scaleAdjust[1]);
SkRect domain;
DomainMode domainMode =
DetermineDomainMode(constraintRect, filterConstraint, coordsLimitedToConstraintRect,
texture->width(), texture->height(),
nullptr, fmForDetermineDomain, &domain);
SkASSERT(kTightCopy_DomainMode != domainMode);
- SkMatrix normalizedTextureMatrix = textureMatrix;
- normalizedTextureMatrix.postIDiv(texture->width(), texture->height());
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(texColorSpace.get(),
dstColorSpace);
return CreateFragmentProcessorForDomainAndFilter(texture.get(), std::move(colorSpaceXform),
- normalizedTextureMatrix, domainMode, domain,
+ adjustedMatrix, domainMode, domain,
filterOrNullForBicubic);
}
/**
* Returns a texture that is safe for use with the params. If the size of the returned texture
* does not match width()/height() then the contents of the original must be scaled to fit
- * the texture. Places the color space of the texture in (*texColorSpace).
+ * the texture. Additionally, the 'scaleAdjust' must be applied to the texture matrix
+ * in order to correct the absolute texture coordinates.
+ * Places the color space of the texture in (*texColorSpace).
*/
GrTexture* refTextureForParams(const GrSamplerParams&, SkColorSpace* dstColorSpace,
- sk_sp<SkColorSpace>* texColorSpace);
+ sk_sp<SkColorSpace>* texColorSpace, SkScalar scaleAdjust[2]);
sk_sp<GrFragmentProcessor> createFragmentProcessor(
const SkMatrix& textureMatrix,
SkRect localRect;
if (subset) {
- SkScalar sx = SK_Scalar1 / inputTexture->width();
- SkScalar sy = SK_Scalar1 / inputTexture->height();
-
localRect = SkRect::Make(*subset);
- localRect.fLeft *= sx;
- localRect.fTop *= sy;
- localRect.fRight *= sx;
- localRect.fBottom *= sy;
} else {
- localRect = SkRect::MakeWH(1.f, 1.f);
+ localRect = SkRect::MakeWH(inputTexture->width(), inputTexture->height());
}
SkRect dstRect = SkRect::MakeIWH(copyParams.fWidth, copyParams.fHeight);
static bool convert_texture(GrTexture* src, GrRenderTargetContext* dst, int dstW, int dstH,
SkYUVColorSpace colorSpace, MakeFPProc proc) {
- SkScalar xScale = SkIntToScalar(src->width()) / dstW / src->width();
- SkScalar yScale = SkIntToScalar(src->height()) / dstH / src->height();
+ SkScalar xScale = SkIntToScalar(src->width()) / dstW;
+ SkScalar yScale = SkIntToScalar(src->height()) / dstH;
GrSamplerParams::FilterMode filter;
if (dstW == src->width() && dstW == src->height()) {
filter = GrSamplerParams::kNone_FilterMode;
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
const SkRect r = SkRect::MakeIWH(yuvInfo.fSizeInfo.fSizes[SkYUVSizeInfo::kY].fWidth,
- yuvInfo.fSizeInfo.fSizes[SkYUVSizeInfo::kY].fHeight);
+ yuvInfo.fSizeInfo.fSizes[SkYUVSizeInfo::kY].fHeight);
renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(), r);
SkASSERT(bitmap.width() <= fContext->caps()->maxTileSize() &&
bitmap.height() <= fContext->caps()->maxTileSize());
- sk_sp<GrTexture> texture = GrMakeCachedBitmapTexture(fContext.get(), bitmap, params);
+ SkScalar scaleAdjust[2] = { 1.0f, 1.0f };
+ sk_sp<GrTexture> texture = GrMakeCachedBitmapTexture(fContext.get(), bitmap,
+ params, scaleAdjust);
if (nullptr == texture) {
return;
}
sk_sp<GrColorSpaceXform> colorSpaceXform =
GrColorSpaceXform::Make(bitmap.colorSpace(), fRenderTargetContext->getColorSpace());
- SkScalar iw = 1.f / texture->width();
- SkScalar ih = 1.f / texture->height();
-
- SkMatrix texMatrix;
// Compute a matrix that maps the rect we will draw to the src rect.
- texMatrix.setRectToRect(dstRect, srcRect, SkMatrix::kFill_ScaleToFit);
- texMatrix.postScale(iw, ih);
+ SkMatrix texMatrix = SkMatrix::MakeRectToRect(dstRect, srcRect, SkMatrix::kFill_ScaleToFit);
+ texMatrix.postScale(scaleAdjust[0], scaleAdjust[1]);
// Construct a GrPaint by setting the bitmap texture as the first effect and then configuring
// the rest from the SkPaint.
}
// draw sprite neither filters nor tiles.
- texture.reset(
- GrRefCachedBitmapTexture(fContext.get(), bitmap, GrSamplerParams::ClampNoFilter()));
+ texture.reset(GrRefCachedBitmapTexture(fContext.get(), bitmap,
+ GrSamplerParams::ClampNoFilter(), nullptr));
if (!texture) {
return;
}
SkMatrix::I(),
SkRect::Make(SkIRect::MakeXYWH(
left + offset.fX, top + offset.fY, subset.width(), subset.height())),
- SkRect::MakeXYWH(SkIntToScalar(subset.fLeft) / texture->width(),
- SkIntToScalar(subset.fTop) / texture->height(),
- SkIntToScalar(subset.width()) / texture->width(),
- SkIntToScalar(subset.height()) / texture->height()));
+ SkRect::Make(subset));
}
void SkGpuDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
return nullptr;
}
- sk_sp<GrTexture> texture =
- GrMakeCachedBitmapTexture(fContext.get(), bitmap, GrSamplerParams::ClampNoFilter());
+ sk_sp<GrTexture> texture = GrMakeCachedBitmapTexture(fContext.get(), bitmap,
+ GrSamplerParams::ClampNoFilter(), nullptr);
if (!texture) {
return nullptr;
}
}
GrTexture* GrRefCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap,
- const GrSamplerParams& params) {
+ const GrSamplerParams& params, SkScalar scaleAdjust[2]) {
// Caller doesn't care about the texture's color space (they can always get it from the bitmap)
- return GrBitmapTextureMaker(ctx, bitmap).refTextureForParams(params, nullptr, nullptr);
+ return GrBitmapTextureMaker(ctx, bitmap).refTextureForParams(params, nullptr,
+ nullptr, scaleAdjust);
}
sk_sp<GrTexture> GrMakeCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap,
- const GrSamplerParams& params) {
+ const GrSamplerParams& params, SkScalar scaleAdjust[2]) {
// Caller doesn't care about the texture's color space (they can always get it from the bitmap)
GrTexture* tex = GrBitmapTextureMaker(ctx, bitmap).refTextureForParams(params, nullptr,
- nullptr);
+ nullptr, scaleAdjust);
return sk_sp<GrTexture>(tex);
}
Gr1DKernelEffect(GrTexture* texture,
Direction direction,
int radius)
- : INHERITED(texture, nullptr, GrCoordTransform::MakeDivByTextureWHMatrix(texture))
+ : INHERITED(texture, nullptr, SkMatrix::I())
, fDirection(direction)
, fRadius(radius) {}
static const SkShader::TileMode kClampClamp[] =
{ SkShader::kClamp_TileMode, SkShader::kClamp_TileMode };
return GrBicubicEffect::Make(d->fTextures[texIdx], colorSpaceXform,
- GrCoordTransform::MakeDivByTextureWHMatrix(d->fTextures[texIdx]),
- kClampClamp);
+ SkMatrix::I(), kClampClamp);
}
//////////////////////////////////////////////////////////////////////////////
*upmToPMRule = kConversionRules[i][1];
static const SkRect kDstRect = SkRect::MakeIWH(kSize, kSize);
- static const SkRect kSrcRect = SkRect::MakeIWH(1, 1);
+ static const SkRect kSrcRect = SkRect::MakeIWH(kSize, kSize);
// We do a PM->UPM draw from dataTex to readTex and read the data. Then we do a UPM->PM draw
// from readTex to tempTex followed by a PM->UPM draw to readTex and finally read the data.
// We then verify that two reads produced the same values.
const SkIPoint& kernelOffset,
GrTextureDomain::Mode tileMode,
bool convolveAlpha)
- : INHERITED(texture, nullptr, GrCoordTransform::MakeDivByTextureWHMatrix(texture)),
+ : INHERITED(texture, nullptr, SkMatrix::I()),
fKernelSize(kernelSize),
fGain(SkScalarToFloat(gain)),
fBias(SkScalarToFloat(bias) / 255.0f),
GrTexture* vTexture, const SkISize sizes[3],
SkYUVColorSpace colorSpace, bool nv12) {
SkScalar w[3], h[3];
- w[0] = SkIntToScalar(sizes[0].fWidth) / SkIntToScalar(yTexture->width());
- h[0] = SkIntToScalar(sizes[0].fHeight) / SkIntToScalar(yTexture->height());
- w[1] = SkIntToScalar(sizes[1].fWidth) / SkIntToScalar(uTexture->width());
- h[1] = SkIntToScalar(sizes[1].fHeight) / SkIntToScalar(uTexture->height());
- w[2] = SkIntToScalar(sizes[2].fWidth) / SkIntToScalar(vTexture->width());
- h[2] = SkIntToScalar(sizes[2].fHeight) / SkIntToScalar(vTexture->height());
- SkMatrix yuvMatrix[3];
- yuvMatrix[0] = GrCoordTransform::MakeDivByTextureWHMatrix(yTexture);
- yuvMatrix[1] = yuvMatrix[0];
- yuvMatrix[1].preScale(w[1] / w[0], h[1] / h[0]);
- yuvMatrix[2] = yuvMatrix[0];
- yuvMatrix[2].preScale(w[2] / w[0], h[2] / h[0]);
+ w[0] = SkIntToScalar(sizes[0].fWidth);
+ h[0] = SkIntToScalar(sizes[0].fHeight);
+ w[1] = SkIntToScalar(sizes[1].fWidth);
+ h[1] = SkIntToScalar(sizes[1].fHeight);
+ w[2] = SkIntToScalar(sizes[2].fWidth);
+ h[2] = SkIntToScalar(sizes[2].fHeight);
+ const SkMatrix yuvMatrix[3] = {
+ SkMatrix::I(),
+ SkMatrix::MakeScale(w[1] / w[0], h[1] / h[0]),
+ SkMatrix::MakeScale(w[2] / w[0], h[2] / h[0])
+ };
GrSamplerParams::FilterMode uvFilterMode =
((sizes[1].fWidth != sizes[0].fWidth) ||
(sizes[1].fHeight != sizes[0].fHeight) ||
}
bool GrGLGpu::onMakeCopyForTextureParams(GrTexture* texture, const GrSamplerParams& textureParams,
- GrTextureProducer::CopyParams* copyParams) const {
+ GrTextureProducer::CopyParams* copyParams,
+ SkScalar scaleAdjust[2]) const {
if (textureParams.isTiled() ||
GrSamplerParams::kMipMap_FilterMode == textureParams.filterMode()) {
GrGLTexture* glTexture = static_cast<GrGLTexture*>(texture);
const SkTArray<GrMipLevel>& texels);
bool onMakeCopyForTextureParams(GrTexture*, const GrSamplerParams&,
- GrTextureProducer::CopyParams*) const override;
+ GrTextureProducer::CopyParams*,
+ SkScalar scaleAdjust[2]) const override;
// Checks whether glReadPixels can be called to get pixel values in readConfig from the
// render target.
const GrCoordTransform& coordTransform) {
SkMatrix combined;
combined.setConcat(coordTransform.getMatrix(), localMatrix);
+ if (coordTransform.normalize()) {
+ SkASSERT(coordTransform.texture());
+ combined.postIDiv(coordTransform.texture()->width(), coordTransform.texture()->height());
+ }
+
if (coordTransform.reverseY()) {
// combined.postScale(1,-1);
// combined.postTranslate(0,1);
#include "effects/GrSimpleTextureEffect.h"
sk_sp<GrFragmentProcessor> SkImageShader::asFragmentProcessor(const AsFPArgs& args) const {
- SkMatrix matrix;
- matrix.setIDiv(fImage->width(), fImage->height());
SkMatrix lmInverse;
if (!this->getLocalMatrix().invert(&lmInverse)) {
}
lmInverse.postConcat(inv);
}
- matrix.preConcat(lmInverse);
SkShader::TileMode tm[] = { fTileModeX, fTileModeY };
&doBicubic);
GrSamplerParams params(tm, textureFilterMode);
sk_sp<SkColorSpace> texColorSpace;
+ SkScalar scaleAdjust[2] = { 1.0f, 1.0f };
sk_sp<GrTexture> texture(as_IB(fImage)->asTextureRef(args.fContext, params, args.fDstColorSpace,
- &texColorSpace));
+ &texColorSpace, scaleAdjust));
if (!texture) {
return nullptr;
}
+ lmInverse.postScale(scaleAdjust[0], scaleAdjust[1]);
+
sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(texColorSpace.get(),
args.fDstColorSpace);
sk_sp<GrFragmentProcessor> inner;
if (doBicubic) {
- inner = GrBicubicEffect::Make(texture.get(), std::move(colorSpaceXform), matrix, tm);
+ inner = GrBicubicEffect::Make(texture.get(), std::move(colorSpaceXform), lmInverse, tm);
} else {
inner = GrSimpleTextureEffect::Make(texture.get(), std::move(colorSpaceXform),
- matrix, params);
+ lmInverse, params);
}
if (GrPixelConfigIsAlphaOnly(texture->config())) {
// Caller must call unref when they are done.
virtual GrTexture* asTextureRef(GrContext*, const GrSamplerParams&, SkColorSpace*,
- sk_sp<SkColorSpace>*) const = 0;
+ sk_sp<SkColorSpace>*, SkScalar scaleAdjust[2]) const = 0;
virtual sk_sp<SkImage> onMakeSubset(const SkIRect&) const = 0;
sk_sp<SkImage> onMakeSubset(const SkIRect&) const override;
bool getROPixels(SkBitmap*, SkColorSpace* dstColorSpace, CachingHint) const override;
GrTexture* asTextureRef(GrContext*, const GrSamplerParams&, SkColorSpace*,
- sk_sp<SkColorSpace>*) const override;
+ sk_sp<SkColorSpace>*, SkScalar scaleAdjust[2]) const override;
bool onIsLazyGenerated() const override { return true; }
private:
GrTexture* SkImage_Generator::asTextureRef(GrContext* ctx, const GrSamplerParams& params,
SkColorSpace* dstColorSpace,
- sk_sp<SkColorSpace>* texColorSpace) const {
- return fCache.lockAsTexture(ctx, params, dstColorSpace, texColorSpace, this);
+ sk_sp<SkColorSpace>* texColorSpace,
+ SkScalar scaleAdjust[2]) const {
+ return fCache.lockAsTexture(ctx, params, dstColorSpace, texColorSpace, this, scaleAdjust);
}
sk_sp<SkImage> SkImage_Generator::onMakeSubset(const SkIRect& subset) const {
GrTexture* SkImage_Gpu::asTextureRef(GrContext* ctx, const GrSamplerParams& params,
SkColorSpace* dstColorSpace,
- sk_sp<SkColorSpace>* texColorSpace) const {
+ sk_sp<SkColorSpace>* texColorSpace,
+ SkScalar scaleAdjust[2]) const {
if (texColorSpace) {
*texColorSpace = this->fColorSpace;
}
GrTextureAdjuster adjuster(this->peekTexture(), this->alphaType(), this->bounds(),
this->uniqueID(), this->fColorSpace.get());
- return adjuster.refTextureSafeForParams(params, nullptr);
+ return adjuster.refTextureSafeForParams(params, nullptr, scaleAdjust);
}
static void apply_premul(const SkImageInfo& info, void* pixels, size_t rowBytes) {
bool getROPixels(SkBitmap*, SkColorSpace* dstColorSpace, CachingHint) const override;
GrTexture* asTextureRef(GrContext* ctx, const GrSamplerParams& params, SkColorSpace*,
- sk_sp<SkColorSpace>*) const override;
+ sk_sp<SkColorSpace>*, SkScalar scaleAdjust[2]) const override;
sk_sp<SkImage> onMakeSubset(const SkIRect&) const override;
sk_sp<GrSurfaceProxy> refProxy() const;
bool getROPixels(SkBitmap*, SkColorSpace* dstColorSpace, CachingHint) const override;
GrTexture* asTextureRef(GrContext*, const GrSamplerParams&, SkColorSpace*,
- sk_sp<SkColorSpace>*) const override;
+ sk_sp<SkColorSpace>*, SkScalar scaleAdjust[2]) const override;
sk_sp<SkImage> onMakeSubset(const SkIRect&) const override;
SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); }
GrTexture* SkImage_Raster::asTextureRef(GrContext* ctx, const GrSamplerParams& params,
SkColorSpace* dstColorSpace,
- sk_sp<SkColorSpace>* texColorSpace) const {
+ sk_sp<SkColorSpace>* texColorSpace,
+ SkScalar scaleAdjust[2]) const {
#if SK_SUPPORT_GPU
if (!ctx) {
return nullptr;
if (tex) {
GrTextureAdjuster adjuster(fPinnedTexture.get(), fBitmap.alphaType(), fBitmap.bounds(),
fPinnedUniqueID, fBitmap.colorSpace());
- return adjuster.refTextureSafeForParams(params, nullptr);
+ return adjuster.refTextureSafeForParams(params, nullptr, scaleAdjust);
}
- return GrRefCachedBitmapTexture(ctx, fBitmap, params);
+ return GrRefCachedBitmapTexture(ctx, fBitmap, params, scaleAdjust);
#endif
return nullptr;
SkASSERT(fPinnedCount == 0);
SkASSERT(fPinnedUniqueID == 0);
fPinnedTexture.reset(
- GrRefCachedBitmapTexture(ctx, fBitmap, GrSamplerParams::ClampNoFilter()));
+ GrRefCachedBitmapTexture(ctx, fBitmap, GrSamplerParams::ClampNoFilter(), nullptr));
if (!fPinnedTexture) {
return false;
}
#include "GrContext.h"
#endif
-void testBitmapEquality(skiatest::Reporter* reporter, SkBitmap& bm1, SkBitmap& bm2) {
+static void test_bitmap_equality(skiatest::Reporter* reporter, SkBitmap& bm1, SkBitmap& bm2) {
SkAutoLockPixels lockBm1(bm1);
SkAutoLockPixels lockBm2(bm2);
REPORTER_ASSERT(reporter, 0 == memcmp(bm1.getPixels(), bm2.getPixels(), bm1.getSize()));
}
-void paintSource(SkSurface* sourceSurface) {
+static void paint_source(SkSurface* sourceSurface) {
SkCanvas* sourceCanvas = sourceSurface->getCanvas();
sourceCanvas->clear(0xFFDEDEDE);
sourceCanvas->drawRect(rect, paintColor);
}
-void runShaderTest(skiatest::Reporter* reporter, SkSurface* sourceSurface, SkSurface* destinationSurface, SkImageInfo& info) {
- paintSource(sourceSurface);
+static void run_shader_test(skiatest::Reporter* reporter, SkSurface* sourceSurface,
+ SkSurface* destinationSurface, SkImageInfo& info) {
+ paint_source(sourceSurface);
sk_sp<SkImage> sourceImage(sourceSurface->makeImageSnapshot());
sk_sp<SkShader> sourceShader = sourceImage->makeShader(
SkBitmap bm;
destinationCanvas->readPixels(rect, &bm);
- testBitmapEquality(reporter, bmOrig, bm);
-
-
+ test_bitmap_equality(reporter, bmOrig, bm);
// Test with a translated shader
SkMatrix matrix;
auto sourceSurface(SkSurface::MakeRaster(info));
auto destinationSurface(SkSurface::MakeRaster(info));
- runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
+ run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}
#if SK_SUPPORT_GPU
-void gpuToGpu(skiatest::Reporter* reporter, GrContext* context) {
+static void gpu_to_gpu(skiatest::Reporter* reporter, GrContext* context) {
SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
auto sourceSurface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
auto destinationSurface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
- runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
+ run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}
-void gpuToRaster(skiatest::Reporter* reporter, GrContext* context) {
+static void gpu_to_raster(skiatest::Reporter* reporter, GrContext* context) {
SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
auto sourceSurface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
auto destinationSurface(SkSurface::MakeRaster(info));
- runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
+ run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}
-void rasterToGpu(skiatest::Reporter* reporter, GrContext* context) {
+static void raster_to_gpu(skiatest::Reporter* reporter, GrContext* context) {
SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
auto sourceSurface(SkSurface::MakeRaster(info));
auto destinationSurface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
- runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
+ run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageNewShader_GPU, reporter, ctxInfo) {
// GPU -> GPU
- gpuToGpu(reporter, ctxInfo.grContext());
+ gpu_to_gpu(reporter, ctxInfo.grContext());
// GPU -> RASTER
- gpuToRaster(reporter, ctxInfo.grContext());
+ gpu_to_raster(reporter, ctxInfo.grContext());
// RASTER -> GPU
- rasterToGpu(reporter, ctxInfo.grContext());
+ raster_to_gpu(reporter, ctxInfo.grContext());
}
#endif
};
for (auto filter : kNamedFilters) {
- SkMatrix m;
- m.setIDiv(kS, kS);
- sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(texture.get(), nullptr, m,
+ sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(texture.get(), nullptr,
+ SkMatrix::I(),
filter.fMode));
REPORTER_ASSERT(reporter, fp);
if (!fp) {
context->makeRenderTargetContext(SkBackingFit::kExact, rectangleTexture->width(),
rectangleTexture->height(), rectangleTexture->config(),
nullptr));
- SkMatrix m;
- m.setIDiv(rectangleTexture->width(), rectangleTexture->height());
for (auto filter : {GrSamplerParams::kNone_FilterMode,
GrSamplerParams::kBilerp_FilterMode,
GrSamplerParams::kMipMap_FilterMode}) {
rtContext->clear(nullptr, 0xDDCCBBAA, true);
- sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(rectangleTexture,
- nullptr, m, filter));
+ sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(rectangleTexture, nullptr,
+ SkMatrix::I(), filter));
GrPaint paint;
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
paint.addColorFragmentProcessor(std::move(fp));
GrPaint paint;
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
GrSamplerParams mipMapParams(SkShader::kRepeat_TileMode, GrSamplerParams::kMipMap_FilterMode);
- paint.addColorTextureProcessor(texture.get(), nullptr, SkMatrix::MakeScale(0.5f), mipMapParams);
+ paint.addColorTextureProcessor(texture.get(), nullptr, SkMatrix::MakeScale(rtS), mipMapParams);
// 1) Draw texture to S32 surface (should generate/use sRGB mips)
paint.setGammaCorrect(true);
projects / platform / upstream / libSkiaSharp.git / commitdiff