src/effects/SkBitmapAlphaThresholdShader.cpp - platform/external/skqp - Gitiles

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

 #include "SkBitmapAlphaThresholdShader.h"

 class BATShader : public SkShader {
 public:
     SK_DECLARE_INST_COUNT(BATShader);

     BATShader(const SkBitmap& bitmap, SkRegion region, U8CPU);
     BATShader(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
         // We should probably do something here.
     }


     virtual void shadeSpan(int x, int y, SkPMColor[], int count) SK_OVERRIDE {};

 #if SK_SUPPORT_GPU
     virtual GrEffectRef* asNewEffect(GrContext* context, const SkPaint& paint) const SK_OVERRIDE;
 #endif

     SK_DEVELOPER_TO_STRING();
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(BATShader)

 private:
     SkBitmap fBitmap;
     SkRegion fRegion;
     U8CPU    fThreshold;

     typedef SkShader INHERITED;
 };

 SkShader* SkBitmapAlphaThresholdShader::Create(const SkBitmap& bitmap,
                                                const SkRegion& region,
                                                U8CPU threshold) {
     SkASSERT(threshold < 256);
     return SkNEW_ARGS(BATShader, (bitmap, region, threshold));
 }

 BATShader::BATShader(const SkBitmap& bitmap, SkRegion region, U8CPU threshold)
 : fBitmap(bitmap)
 , fRegion(region)
 , fThreshold(threshold) {
 };


 #ifdef SK_DEVELOPER
 void BATShader::toString(SkString* str) const {
     str->append("BATShader: (");

     fBitmap.toString(str);

     this->INHERITED::toString(str);

     str->append(")");
 }
 #endif

 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrEffect.h"
 #include "gl/GrGLEffect.h"
 #include "GrTBackendEffectFactory.h"
 #include "GrTextureAccess.h"

 #include "SkGr.h"

 /**
  * Could create specializations for some simple cases:
  *  - The region is empty.
  *  - The region fully contains the bitmap.
  *  - The regions is 1 rect (or maybe a small number of rects).
  */
 class ThresholdEffect : public GrEffect {
 public:
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendEffectFactory<ThresholdEffect>::getInstance();
     }

     static GrEffectRef* Create(GrTexture* bmpTexture, const SkMatrix& bmpMatrix,
                                GrTexture* maskTexture, const SkMatrix& maskMatrix,
                                U8CPU threshold) {
         SkScalar thresh = SkIntToScalar(threshold) / 255;

         AutoEffectUnref effect(SkNEW_ARGS(ThresholdEffect, (bmpTexture, bmpMatrix,
                                                             maskTexture, maskMatrix,
                                                             thresh)));
         return CreateEffectRef(effect);
     }

     virtual void getConstantColorComponents(GrColor* color,
                                             uint32_t* validFlags) const SK_OVERRIDE {
         if ((kA_GrColorComponentFlag & *validFlags) && 0 == GrColorUnpackA(*color)) {
             return;
         }
         *validFlags = 0;
         return;
     }

     static const char* Name() { return "Bitmap Alpha Threshold"; }

     class GLEffect : public GrGLEffect {
     public:
         GLEffect(const GrBackendEffectFactory& factory,
                     const GrDrawEffect& e)
         : GrGLEffect(factory)
         , fPrevThreshold(-SK_Scalar1) {
         }

         virtual void emitCode(GrGLShaderBuilder* builder,
                               const GrDrawEffect& drawEffect,
                               EffectKey key,
                               const char* outputColor,
                               const char* inputColor,
                               const TransformedCoordsArray& coords,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
             // put bitmap color in "color"
             builder->fsCodeAppend("\t\tvec4 color = ");
             builder->fsAppendTextureLookup(samplers[0], coords[0].c_str(), coords[0].type());
             builder->fsCodeAppend(";\n");

             // put alpha from mask texture in "mask"
             builder->fsCodeAppend("\t\tfloat mask = ");
             builder->fsAppendTextureLookup(samplers[1], coords[1].c_str(), coords[1].type());
             builder->fsCodeAppend(".a;\n");

             const char* threshold;

             fThresholdUniHandle = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                                       kFloat_GrSLType,
                                                       "threshold",
                                                       &threshold);
             builder->fsCodeAppendf("\t\tfloat thresh = %s;\n", threshold);

             builder->fsCodeAppend("\t\tif (mask < 0.5) {\n"
                                     "\t\t\tif (color.a > thresh) {\n"
                                     "\t\t\t\tfloat scale = thresh / color.a;\n"
                                     "\t\t\t\tcolor.rgb *= scale;\n"
                                     "\t\t\t\tcolor.a = thresh;\n"
                                     "\t\t\t}\n"
                                     "\t\t} else if (color.a < thresh) {\n"
                                     "\t\t\tfloat scale = thresh / color.a;\n"
                                     "\t\t\tcolor.rgb *= scale;\n"
                                     "\t\t\tcolor.a = thresh;\n"
                                     "\t\t}\n");

             builder->fsCodeAppendf("color = %s = %s;\n", outputColor,
                                    (GrGLSLExpr4(inputColor) * GrGLSLExpr4("color")).c_str());
         }

         virtual void setData(const GrGLUniformManager& uman, const GrDrawEffect& e) SK_OVERRIDE {
             const ThresholdEffect& effect = e.castEffect<ThresholdEffect>();
             if (fPrevThreshold != effect.fThreshold) {
                 uman.set1f(fThresholdUniHandle, effect.fThreshold);
             }
         }

     private:
         GrGLUniformManager::UniformHandle fThresholdUniHandle;
         SkScalar                          fPrevThreshold;
     };

     GR_DECLARE_EFFECT_TEST;

 private:
     ThresholdEffect(GrTexture* bmpTexture, const SkMatrix& bmpMatrix,
                     GrTexture* maskTexture, const SkMatrix& maskMatrix,
                     SkScalar threshold)
     : fBmpTransform(kLocal_GrCoordSet, bmpMatrix, bmpTexture)
     , fBmpAccess(bmpTexture, GrTextureParams())
     , fMaskTransform(kLocal_GrCoordSet, maskMatrix, maskTexture)
     , fMaskAccess(maskTexture, GrTextureParams())
     , fThreshold(threshold) {
         this->addCoordTransform(&fBmpTransform);
         this->addTextureAccess(&fBmpAccess);
         this->addCoordTransform(&fMaskTransform);
         this->addTextureAccess(&fMaskAccess);
     }

     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
         const ThresholdEffect& e = CastEffect<ThresholdEffect>(other);
         return e.fBmpAccess.getTexture() == fBmpAccess.getTexture() &&
                e.fMaskAccess.getTexture() == fMaskAccess.getTexture() &&
                e.fBmpTransform.getMatrix() == fBmpTransform.getMatrix() &&
                e.fMaskTransform.getMatrix() == fMaskTransform.getMatrix() &&
                e.fThreshold == fThreshold;
     }

     GrCoordTransform fBmpTransform;
     GrTextureAccess  fBmpAccess;
     GrCoordTransform fMaskTransform;
     GrTextureAccess  fMaskAccess;

     SkScalar fThreshold;
 };

 GR_DEFINE_EFFECT_TEST(ThresholdEffect);

 GrEffectRef* ThresholdEffect::TestCreate(SkRandom* rand,
                                          GrContext*,
                                          const GrDrawTargetCaps&,
                                          GrTexture* textures[]) {
     GrTexture* bmpTex = textures[GrEffectUnitTest::kSkiaPMTextureIdx];
     GrTexture* maskTex = textures[GrEffectUnitTest::kAlphaTextureIdx];
     U8CPU thresh = rand->nextU() % 0xff;
     return ThresholdEffect::Create(bmpTex, SkMatrix::I(), maskTex, SkMatrix::I(), thresh);
 }

 GrEffectRef* BATShader::asNewEffect(GrContext* context, const SkPaint& paint) const {
     SkMatrix localInverse;
     if (!this->getLocalMatrix().invert(&localInverse)) {
         return NULL;
     }

     GrTextureDesc maskDesc;
     if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
         maskDesc.fConfig = kAlpha_8_GrPixelConfig;
     } else {
         maskDesc.fConfig = kRGBA_8888_GrPixelConfig;
     }
     maskDesc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
     const SkIRect& bounds = fRegion.getBounds();
     // Add one pixel of border to ensure that clamp mode will be all zeros
     // the outside.
     maskDesc.fWidth = bounds.width() + 2;
     maskDesc.fHeight = bounds.height() + 2;
     GrAutoScratchTexture ast(context, maskDesc, GrContext::kApprox_ScratchTexMatch);
     GrTexture*  maskTexture = ast.texture();
     if (NULL == maskTexture) {
         return NULL;
     }

     GrPaint grPaint;
     grPaint.setBlendFunc(kOne_GrBlendCoeff, kZero_GrBlendCoeff);
     SkRegion::Iterator iter(fRegion);
     context->setRenderTarget(maskTexture->asRenderTarget());
     context->clear(NULL, 0x0, true);

     // offset to ensure border is zero on top/left
     SkMatrix matrix;
     matrix.setTranslate(SK_Scalar1, SK_Scalar1);
     context->setMatrix(matrix);

     while (!iter.done()) {
         SkRect rect = SkRect::Make(iter.rect());
         context->drawRect(grPaint, rect);
         iter.next();
     }

     GrTexture* bmpTexture = GrLockAndRefCachedBitmapTexture(context, fBitmap, NULL);
     if (NULL == bmpTexture) {
         return NULL;
     }

     SkMatrix bmpMatrix = localInverse;
     bmpMatrix.postIDiv(bmpTexture->width(), bmpTexture->height());

     SkMatrix maskMatrix = localInverse;
     // compensate for the border
     maskMatrix.postTranslate(SK_Scalar1, SK_Scalar1);
     maskMatrix.postIDiv(maskTexture->width(), maskTexture->height());

     GrEffectRef* effect = ThresholdEffect::Create(bmpTexture, bmpMatrix,
                                                   maskTexture, maskMatrix,
                                                   fThreshold);

     GrUnlockAndUnrefCachedBitmapTexture(bmpTexture);

     return effect;
 }

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

	#include "SkBitmapAlphaThresholdShader.h"

	class BATShader : public SkShader {
	public:
	SK_DECLARE_INST_COUNT(BATShader);

	BATShader(const SkBitmap& bitmap, SkRegion region, U8CPU);
	BATShader(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
	// We should probably do something here.
	}


	virtual void shadeSpan(int x, int y, SkPMColor[], int count) SK_OVERRIDE {};

	#if SK_SUPPORT_GPU
	virtual GrEffectRef* asNewEffect(GrContext* context, const SkPaint& paint) const SK_OVERRIDE;
	#endif

	SK_DEVELOPER_TO_STRING();
	SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(BATShader)

	private:
	SkBitmap fBitmap;
	SkRegion fRegion;
	U8CPU fThreshold;

	typedef SkShader INHERITED;
	};

	SkShader* SkBitmapAlphaThresholdShader::Create(const SkBitmap& bitmap,
	const SkRegion& region,
	U8CPU threshold) {
	SkASSERT(threshold < 256);
	return SkNEW_ARGS(BATShader, (bitmap, region, threshold));
	}

	BATShader::BATShader(const SkBitmap& bitmap, SkRegion region, U8CPU threshold)
	: fBitmap(bitmap)
	, fRegion(region)
	, fThreshold(threshold) {
	};


	#ifdef SK_DEVELOPER
	void BATShader::toString(SkString* str) const {
	str->append("BATShader: (");

	fBitmap.toString(str);

	this->INHERITED::toString(str);

	str->append(")");
	}
	#endif

	#if SK_SUPPORT_GPU
	#include "GrContext.h"
	#include "GrCoordTransform.h"
	#include "GrEffect.h"
	#include "gl/GrGLEffect.h"
	#include "GrTBackendEffectFactory.h"
	#include "GrTextureAccess.h"

	#include "SkGr.h"

	/**
	* Could create specializations for some simple cases:
	* - The region is empty.
	* - The region fully contains the bitmap.
	* - The regions is 1 rect (or maybe a small number of rects).
	*/
	class ThresholdEffect : public GrEffect {
	public:
	virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
	return GrTBackendEffectFactory<ThresholdEffect>::getInstance();
	}

	static GrEffectRef* Create(GrTexture* bmpTexture, const SkMatrix& bmpMatrix,
	GrTexture* maskTexture, const SkMatrix& maskMatrix,
	U8CPU threshold) {
	SkScalar thresh = SkIntToScalar(threshold) / 255;

	AutoEffectUnref effect(SkNEW_ARGS(ThresholdEffect, (bmpTexture, bmpMatrix,
	maskTexture, maskMatrix,
	thresh)));
	return CreateEffectRef(effect);
	}

	virtual void getConstantColorComponents(GrColor* color,
	uint32_t* validFlags) const SK_OVERRIDE {
	if ((kA_GrColorComponentFlag & validFlags) && 0 == GrColorUnpackA(color)) {
	return;
	}
	*validFlags = 0;
	return;
	}

	static const char* Name() { return "Bitmap Alpha Threshold"; }

	class GLEffect : public GrGLEffect {
	public:
	GLEffect(const GrBackendEffectFactory& factory,
	const GrDrawEffect& e)
	: GrGLEffect(factory)
	, fPrevThreshold(-SK_Scalar1) {
	}

	virtual void emitCode(GrGLShaderBuilder* builder,
	const GrDrawEffect& drawEffect,
	EffectKey key,
	const char* outputColor,
	const char* inputColor,
	const TransformedCoordsArray& coords,
	const TextureSamplerArray& samplers) SK_OVERRIDE {
	// put bitmap color in "color"
	builder->fsCodeAppend("\t\tvec4 color = ");
	builder->fsAppendTextureLookup(samplers[0], coords[0].c_str(), coords[0].type());
	builder->fsCodeAppend(";\n");

	// put alpha from mask texture in "mask"
	builder->fsCodeAppend("\t\tfloat mask = ");
	builder->fsAppendTextureLookup(samplers[1], coords[1].c_str(), coords[1].type());
	builder->fsCodeAppend(".a;\n");

	const char* threshold;

	fThresholdUniHandle = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
	kFloat_GrSLType,
	"threshold",
	&threshold);
	builder->fsCodeAppendf("\t\tfloat thresh = %s;\n", threshold);

	builder->fsCodeAppend("\t\tif (mask < 0.5) {\n"
	"\t\t\tif (color.a > thresh) {\n"
	"\t\t\t\tfloat scale = thresh / color.a;\n"
	"\t\t\t\tcolor.rgb *= scale;\n"
	"\t\t\t\tcolor.a = thresh;\n"
	"\t\t\t}\n"
	"\t\t} else if (color.a < thresh) {\n"
	"\t\t\tfloat scale = thresh / color.a;\n"
	"\t\t\tcolor.rgb *= scale;\n"
	"\t\t\tcolor.a = thresh;\n"
	"\t\t}\n");

	builder->fsCodeAppendf("color = %s = %s;\n", outputColor,
	(GrGLSLExpr4(inputColor) * GrGLSLExpr4("color")).c_str());
	}

	virtual void setData(const GrGLUniformManager& uman, const GrDrawEffect& e) SK_OVERRIDE {
	const ThresholdEffect& effect = e.castEffect<ThresholdEffect>();
	if (fPrevThreshold != effect.fThreshold) {
	uman.set1f(fThresholdUniHandle, effect.fThreshold);
	}
	}

	private:
	GrGLUniformManager::UniformHandle fThresholdUniHandle;
	SkScalar fPrevThreshold;
	};

	GR_DECLARE_EFFECT_TEST;

	private:
	ThresholdEffect(GrTexture* bmpTexture, const SkMatrix& bmpMatrix,
	GrTexture* maskTexture, const SkMatrix& maskMatrix,
	SkScalar threshold)
	: fBmpTransform(kLocal_GrCoordSet, bmpMatrix, bmpTexture)
	, fBmpAccess(bmpTexture, GrTextureParams())
	, fMaskTransform(kLocal_GrCoordSet, maskMatrix, maskTexture)
	, fMaskAccess(maskTexture, GrTextureParams())
	, fThreshold(threshold) {
	this->addCoordTransform(&fBmpTransform);
	this->addTextureAccess(&fBmpAccess);
	this->addCoordTransform(&fMaskTransform);
	this->addTextureAccess(&fMaskAccess);
	}

	virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
	const ThresholdEffect& e = CastEffect<ThresholdEffect>(other);
	return e.fBmpAccess.getTexture() == fBmpAccess.getTexture() &&
	e.fMaskAccess.getTexture() == fMaskAccess.getTexture() &&
	e.fBmpTransform.getMatrix() == fBmpTransform.getMatrix() &&
	e.fMaskTransform.getMatrix() == fMaskTransform.getMatrix() &&
	e.fThreshold == fThreshold;
	}

	GrCoordTransform fBmpTransform;
	GrTextureAccess fBmpAccess;
	GrCoordTransform fMaskTransform;
	GrTextureAccess fMaskAccess;

	SkScalar fThreshold;
	};

	GR_DEFINE_EFFECT_TEST(ThresholdEffect);

	GrEffectRef* ThresholdEffect::TestCreate(SkRandom* rand,
	GrContext*,
	const GrDrawTargetCaps&,
	GrTexture* textures[]) {
	GrTexture* bmpTex = textures[GrEffectUnitTest::kSkiaPMTextureIdx];
	GrTexture* maskTex = textures[GrEffectUnitTest::kAlphaTextureIdx];
	U8CPU thresh = rand->nextU() % 0xff;
	return ThresholdEffect::Create(bmpTex, SkMatrix::I(), maskTex, SkMatrix::I(), thresh);
	}

	GrEffectRef* BATShader::asNewEffect(GrContext* context, const SkPaint& paint) const {
	SkMatrix localInverse;
	if (!this->getLocalMatrix().invert(&localInverse)) {
	return NULL;
	}

	GrTextureDesc maskDesc;
	if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
	maskDesc.fConfig = kAlpha_8_GrPixelConfig;
	} else {
	maskDesc.fConfig = kRGBA_8888_GrPixelConfig;
	}
	maskDesc.fFlags = kRenderTarget_GrTextureFlagBit \| kNoStencil_GrTextureFlagBit;
	const SkIRect& bounds = fRegion.getBounds();
	// Add one pixel of border to ensure that clamp mode will be all zeros
	// the outside.
	maskDesc.fWidth = bounds.width() + 2;
	maskDesc.fHeight = bounds.height() + 2;
	GrAutoScratchTexture ast(context, maskDesc, GrContext::kApprox_ScratchTexMatch);
	GrTexture* maskTexture = ast.texture();
	if (NULL == maskTexture) {
	return NULL;
	}

	GrPaint grPaint;
	grPaint.setBlendFunc(kOne_GrBlendCoeff, kZero_GrBlendCoeff);
	SkRegion::Iterator iter(fRegion);
	context->setRenderTarget(maskTexture->asRenderTarget());
	context->clear(NULL, 0x0, true);

	// offset to ensure border is zero on top/left
	SkMatrix matrix;
	matrix.setTranslate(SK_Scalar1, SK_Scalar1);
	context->setMatrix(matrix);

	while (!iter.done()) {
	SkRect rect = SkRect::Make(iter.rect());
	context->drawRect(grPaint, rect);
	iter.next();
	}

	GrTexture* bmpTexture = GrLockAndRefCachedBitmapTexture(context, fBitmap, NULL);
	if (NULL == bmpTexture) {
	return NULL;
	}

	SkMatrix bmpMatrix = localInverse;
	bmpMatrix.postIDiv(bmpTexture->width(), bmpTexture->height());

	SkMatrix maskMatrix = localInverse;
	// compensate for the border
	maskMatrix.postTranslate(SK_Scalar1, SK_Scalar1);
	maskMatrix.postIDiv(maskTexture->width(), maskTexture->height());

	GrEffectRef* effect = ThresholdEffect::Create(bmpTexture, bmpMatrix,
	maskTexture, maskMatrix,
	fThreshold);

	GrUnlockAndUnrefCachedBitmapTexture(bmpTexture);

	return effect;
	}

	#endif