diff options
29 files changed, 174 insertions, 786 deletions
diff --git a/gm/texdata.cpp b/gm/texdata.cpp index 18c600f722..cc3476d1f6 100644 --- a/gm/texdata.cpp +++ b/gm/texdata.cpp @@ -114,7 +114,7 @@ protected: tm = vm; tm.postIDiv(2*S, 2*S); paint.colorStage(0)->setEffect(SkNEW_ARGS(GrSingleTextureEffect, - (texture, tm)))->unref(); + (texture)), tm)->unref(); ctx->drawRect(paint, GrRect::MakeWH(2*S, 2*S)); diff --git a/gyp/gpu.gypi b/gyp/gpu.gypi index fae91c245e..2febe4dd2f 100644 --- a/gyp/gpu.gypi +++ b/gyp/gpu.gypi @@ -147,8 +147,6 @@ '<(skia_src_path)/gpu/gl/GrGLDefines.h', '<(skia_src_path)/gpu/gl/GrGLEffect.cpp', '<(skia_src_path)/gpu/gl/GrGLEffect.h', - '<(skia_src_path)/gpu/gl/GrGLEffectMatrix.cpp', - '<(skia_src_path)/gpu/gl/GrGLEffectMatrix.h', '<(skia_src_path)/gpu/gl/GrGLIndexBuffer.cpp', '<(skia_src_path)/gpu/gl/GrGLIndexBuffer.h', '<(skia_src_path)/gpu/gl/GrGLInterface.cpp', diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h index 89cd171a5c..29ac95a918 100644 --- a/include/gpu/GrContext.h +++ b/include/gpu/GrContext.h @@ -928,14 +928,8 @@ private: // for use with textures released from an GrAutoScratchTexture. void addExistingTextureToCache(GrTexture* texture); - bool installPMToUPMEffect(GrTexture* texture, - bool swapRAndB, - const GrMatrix& matrix, - GrEffectStage* stage); - bool installUPMToPMEffect(GrTexture* texture, - bool swapRAndB, - const GrMatrix& matrix, - GrEffectStage* stage); + GrEffect* createPMToUPMEffect(GrTexture* texture, bool swapRAndB); + GrEffect* createUPMToPMEffect(GrTexture* texture, bool swapRAndB); typedef GrRefCnt INHERITED; }; diff --git a/include/gpu/GrEffectUnitTest.h b/include/gpu/GrEffectUnitTest.h index 8cc2689d91..427260c664 100644 --- a/include/gpu/GrEffectUnitTest.h +++ b/include/gpu/GrEffectUnitTest.h @@ -12,20 +12,12 @@ #include "GrNoncopyable.h" #include "SkTArray.h" -class SkMatrix; - namespace GrEffectUnitTest { // Used to access the dummy textures in TestCreate procs. enum { kSkiaPMTextureIdx = 0, kAlphaTextureIdx = 1, }; - -/** - * A helper for use in GrEffect::TestCreate functions. - */ -const SkMatrix& TestMatrix(SkRandom*); - } #if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS @@ -64,13 +56,12 @@ private: static GrEffectTestFactory gTestFactory; \ static GrEffect* TestCreate(SkRandom*, GrContext*, GrTexture* dummyTextures[2]) -/** GrEffect subclasses should insert this macro in their implementation file. They must then +/** GrEffect subclasses should insert this macro in their implemenation file. They must then * also implement this static function: * GrEffect* TestCreate(SkRandom*, GrContext*, GrTexture* dummyTextures[2]); - * dummyTextures[] are valid textures that can optionally be used to construct GrTextureAccesses. - * The first texture has config kSkia8888_PM_GrPixelConfig and the second has - * kAlpha_8_GrPixelConfig. TestCreate functions are also free to create additional textures using - * the GrContext. + * dummyTextures[] are valied textures that they can optionally use for their texture accesses. The + * first texture has config kSkia8888_PM_GrPixelConfig and the second has kAlpha_8_GrPixelConfig. + * TestCreate functions are also free to create additional textures using the GrContext. */ #define GR_DEFINE_EFFECT_TEST(Effect) \ GrEffectTestFactory Effect :: gTestFactory(Effect :: TestCreate) diff --git a/src/effects/SkBlendImageFilter.cpp b/src/effects/SkBlendImageFilter.cpp index 9ce5726892..fb0e4d089a 100644 --- a/src/effects/SkBlendImageFilter.cpp +++ b/src/effects/SkBlendImageFilter.cpp @@ -13,7 +13,6 @@ #include "SkGr.h" #include "SkGrPixelRef.h" #include "gl/GrGLEffect.h" -#include "gl/GrGLEffectMatrix.h" #include "GrTBackendEffectFactory.h" #endif @@ -128,19 +127,16 @@ public: static inline EffectKey GenKey(const GrEffectStage&, const GrGLCaps&); - virtual void setData(const GrGLUniformManager&, const GrEffectStage&); - private: typedef GrGLEffect INHERITED; SkBlendImageFilter::Mode fMode; - GrGLEffectMatrix fEffectMatrix; }; /////////////////////////////////////////////////////////////////////////////// class GrBlendEffect : public GrSingleTextureEffect { public: - GrBlendEffect(SkBlendImageFilter::Mode mode, GrTexture* foreground, const SkMatrix&); + GrBlendEffect(SkBlendImageFilter::Mode mode, GrTexture* foreground); virtual ~GrBlendEffect(); virtual bool isEqual(const GrEffect&) const SK_OVERRIDE; @@ -213,19 +209,17 @@ GrTexture* SkBlendImageFilter::onFilterImageGPU(Proxy* proxy, GrTexture* src, co foregroundTexMatrix.setIDiv(foreground->width(), foreground->height()); GrPaint paint; paint.colorStage(0)->setEffect( - SkNEW_ARGS(GrSingleTextureEffect, (background.get(), backgroundTexMatrix)))->unref(); + SkNEW_ARGS(GrSingleTextureEffect, (background.get())), backgroundTexMatrix)->unref(); paint.colorStage(1)->setEffect( - SkNEW_ARGS(GrBlendEffect, (fMode, foreground.get(), foregroundTexMatrix)))->unref(); + SkNEW_ARGS(GrBlendEffect, (fMode, foreground.get())), foregroundTexMatrix)->unref(); context->drawRect(paint, rect); return dst; } /////////////////////////////////////////////////////////////////////////////// -GrBlendEffect::GrBlendEffect(SkBlendImageFilter::Mode mode, - GrTexture* foreground, - const SkMatrix& matrix) - : INHERITED(foreground, matrix), fMode(mode) { +GrBlendEffect::GrBlendEffect(SkBlendImageFilter::Mode mode, GrTexture* foreground) + : INHERITED(foreground), fMode(mode) { } GrBlendEffect::~GrBlendEffect() { @@ -233,7 +227,8 @@ GrBlendEffect::~GrBlendEffect() { bool GrBlendEffect::isEqual(const GrEffect& sBase) const { const GrBlendEffect& s = static_cast<const GrBlendEffect&>(sBase); - return INHERITED::isEqual(sBase) && fMode == s.fMode; + return INHERITED::isEqual(sBase) && + fMode == s.fMode; } const GrBackendEffectFactory& GrBlendEffect::getFactory() const { @@ -246,7 +241,6 @@ GrGLBlendEffect::GrGLBlendEffect(const GrBackendEffectFactory& factory, const GrEffect& effect) : INHERITED(factory), fMode(static_cast<const GrBlendEffect&>(effect).mode()) { - fRequiresTextureMatrix = false; } GrGLBlendEffect::~GrGLBlendEffect() { @@ -254,19 +248,16 @@ GrGLBlendEffect::~GrGLBlendEffect() { void GrGLBlendEffect::emitCode(GrGLShaderBuilder* builder, const GrEffectStage&, - EffectKey key, + EffectKey, const char* vertexCoords, const char* outputColor, const char* inputColor, const TextureSamplerArray& samplers) { - const char* coords; - GrSLType coordsType = fEffectMatrix.emitCode(builder, key, vertexCoords, &coords); - SkString* code = &builder->fFSCode; const char* bgColor = inputColor; const char* fgColor = "fgColor"; code->appendf("\t\tvec4 %s = ", fgColor); - builder->appendTextureLookup(code, samplers[0], coords, coordsType); + builder->appendTextureLookup(code, samplers[0]); code->append(";\n"); code->appendf("\t\t%s.a = 1.0 - (1.0 - %s.a) * (1.0 - %s.b);\n", outputColor, bgColor, fgColor); switch (fMode) { @@ -288,16 +279,7 @@ void GrGLBlendEffect::emitCode(GrGLShaderBuilder* builder, } } -void GrGLBlendEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) { - const GrBlendEffect& blend = static_cast<const GrBlendEffect&>(*stage.getEffect()); - fEffectMatrix.setData(uman, blend.getMatrix(), stage.getCoordChangeMatrix(), blend.texture(0)); -} - -GrGLEffect::EffectKey GrGLBlendEffect::GenKey(const GrEffectStage& stage, const GrGLCaps&) { - const GrBlendEffect& blend = static_cast<const GrBlendEffect&>(*stage.getEffect()); - EffectKey key = - GrGLEffectMatrix::GenKey(blend.getMatrix(), stage.getCoordChangeMatrix(), blend.texture(0)); - key |= (blend.mode() << GrGLEffectMatrix::kKeyBits); - return key; +GrGLEffect::EffectKey GrGLBlendEffect::GenKey(const GrEffectStage& s, const GrGLCaps&) { + return static_cast<const GrBlendEffect&>(*s.getEffect()).mode(); } #endif diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp index fa724cad11..58d26735a1 100644 --- a/src/effects/SkColorMatrixFilter.cpp +++ b/src/effects/SkColorMatrixFilter.cpp @@ -350,8 +350,6 @@ public: : INHERITED(factory) , fMatrixHandle(GrGLUniformManager::kInvalidUniformHandle) , fVectorHandle(GrGLUniformManager::kInvalidUniformHandle) { - // no texture - fRequiresTextureMatrix = false; } virtual void emitCode(GrGLShaderBuilder* builder, diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp index 78c7e34a74..60eff91d65 100644 --- a/src/effects/gradients/SkGradientShader.cpp +++ b/src/effects/gradients/SkGradientShader.cpp @@ -678,9 +678,7 @@ SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END GrGLGradientEffect::GrGLGradientEffect(const GrBackendEffectFactory& factory) : INHERITED(factory) , fCachedYCoord(GR_ScalarMax) - , fFSYUni(GrGLUniformManager::kInvalidUniformHandle) { - fRequiresTextureMatrix = false; -} + , fFSYUni(GrGLUniformManager::kInvalidUniformHandle) { } GrGLGradientEffect::~GrGLGradientEffect() { } @@ -690,37 +688,13 @@ void GrGLGradientEffect::emitYCoordUniform(GrGLShaderBuilder* builder) { } void GrGLGradientEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) { - const GrGradientEffect& e = static_cast<const GrGradientEffect&>(*stage.getEffect()); - const GrTexture* texture = e.texture(0); - fEffectMatrix.setData(uman, e.getMatrix(), stage.getCoordChangeMatrix(), texture); - - GrScalar yCoord = e.getYCoord(); + GrScalar yCoord = static_cast<const GrGradientEffect&>(*stage.getEffect()).getYCoord(); if (yCoord != fCachedYCoord) { uman.set1f(fFSYUni, yCoord); fCachedYCoord = yCoord; } } -GrGLEffect::EffectKey GrGLGradientEffect::GenMatrixKey(const GrEffectStage& s) { - const GrGradientEffect& e = static_cast<const GrGradientEffect&>(*s.getEffect()); - const GrTexture* texture = e.texture(0); - return GrGLEffectMatrix::GenKey(e.getMatrix(), s.getCoordChangeMatrix(), texture); -} - -void GrGLGradientEffect::setupMatrix(GrGLShaderBuilder* builder, - EffectKey key, - const char* vertexCoords, - const char** fsCoordName, - const char** vsVaryingName, - GrSLType* vsVaryingType) { - fEffectMatrix.emitCodeMakeFSCoords2D(builder, - key & kMatrixKeyMask, - vertexCoords, - fsCoordName, - vsVaryingName, - vsVaryingType); -} - void GrGLGradientEffect::emitColorLookup(GrGLShaderBuilder* builder, const char* gradientTValue, const char* outputColor, @@ -740,7 +714,6 @@ void GrGLGradientEffect::emitColorLookup(GrGLShaderBuilder* builder, GrGradientEffect::GrGradientEffect(GrContext* ctx, const SkGradientShaderBase& shader, - const SkMatrix& matrix, SkShader::TileMode tileMode) : INHERITED(1) { // TODO: check for simple cases where we don't need a texture: @@ -748,8 +721,6 @@ GrGradientEffect::GrGradientEffect(GrContext* ctx, //shader.asAGradient(&info); //if (info.fColorCount == 2) { ... - fMatrix = matrix; - SkBitmap bitmap; shader.getGradientTableBitmap(&bitmap); diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h index 24379110ee..9f14e7f727 100644 --- a/src/effects/gradients/SkGradientShaderPriv.h +++ b/src/effects/gradients/SkGradientShaderPriv.h @@ -193,13 +193,12 @@ private: #if SK_SUPPORT_GPU #include "gl/GrGLEffect.h" -#include "gl/GrGLEffectMatrix.h" class GrEffectStage; class GrBackendEffectFactory; /* - * The interpretation of the texture matrix depends on the sample mode. The + * The intepretation of the texture matrix depends on the sample mode. The * texture matrix is applied both when the texture coordinates are explicit * and when vertex positions are used as texture coordinates. In the latter * case the texture matrix is applied to the pre-view-matrix position @@ -229,7 +228,6 @@ public: GrGradientEffect(GrContext* ctx, const SkGradientShaderBase& shader, - const SkMatrix& matrix, SkShader::TileMode tileMode); virtual ~GrGradientEffect(); @@ -238,12 +236,11 @@ public: bool useAtlas() const { return SkToBool(-1 != fRow); } GrScalar getYCoord() const { return fYCoord; }; - const SkMatrix& getMatrix() const { return fMatrix;} virtual bool isEqual(const GrEffect& effect) const SK_OVERRIDE { const GrGradientEffect& s = static_cast<const GrGradientEffect&>(effect); return INHERITED::isEqual(effect) && this->useAtlas() == s.useAtlas() && - fYCoord == s.getYCoord() && fMatrix.cheapEqualTo(s.getMatrix()); + fYCoord == s.getYCoord(); } protected: @@ -266,7 +263,6 @@ private: GrScalar fYCoord; GrTextureStripAtlas* fAtlas; int fRow; - SkMatrix fMatrix; typedef GrEffect INHERITED; @@ -283,36 +279,6 @@ public: virtual void setData(const GrGLUniformManager&, const GrEffectStage&) SK_OVERRIDE; protected: - /** - * Subclasses must reserve the lower kMatrixKeyBitCnt of their key for use by - * GrGLGradientEffect. - */ - enum { - kMatrixKeyBitCnt = GrGLEffectMatrix::kKeyBits, - kMatrixKeyMask = (1 << kMatrixKeyBitCnt) - 1, - }; - - /** - * Subclasses must call this. It will return a value restricted to the lower kMatrixKeyBitCnt - * bits. - */ - static EffectKey GenMatrixKey(const GrEffectStage& s); - - /** - * Inserts code to implement the GrGradientEffect's matrix. This should be called before a - * subclass emits its own code. The name of the 2D coords is output via fsCoordName and already - * incorporates any perspective division. The caller can also optionally retrieve the name of - * the varying inserted in the VS and its type, which may be either vec2f or vec3f depending - * upon whether the matrix has perspective or not. It is not necessary to mask the key before - * calling. - */ - void setupMatrix(GrGLShaderBuilder* builder, - EffectKey key, - const char* vertexCoords, - const char** fsCoordName, - const char** vsVaryingName = NULL, - GrSLType* vsVaryingType = NULL); - // Emits the uniform used as the y-coord to texture samples in derived classes. Subclasses // should call this method from their emitCode(). void emitYCoordUniform(GrGLShaderBuilder* builder); @@ -329,7 +295,6 @@ protected: private: GrScalar fCachedYCoord; GrGLUniformManager::UniformHandle fFSYUni; - GrGLEffectMatrix fEffectMatrix; typedef GrGLEffect INHERITED; }; diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp index 71614505a1..d9576565b5 100644 --- a/src/effects/gradients/SkLinearGradient.cpp +++ b/src/effects/gradients/SkLinearGradient.cpp @@ -495,9 +495,7 @@ public: const char* inputColor, const TextureSamplerArray&) SK_OVERRIDE; - static EffectKey GenKey(const GrEffectStage& stage, const GrGLCaps&) { - return GenMatrixKey(stage); - } + static EffectKey GenKey(const GrEffectStage&, const GrGLCaps& caps) { return 0; } private: @@ -509,11 +507,8 @@ private: class GrLinearGradient : public GrGradientEffect { public: - GrLinearGradient(GrContext* ctx, - const SkLinearGradient& shader, - const SkMatrix& matrix, - SkShader::TileMode tm) - : INHERITED(ctx, shader, matrix, tm) { } + GrLinearGradient(GrContext* ctx, const SkLinearGradient& shader, SkShader::TileMode tm) + : INHERITED(ctx, shader, tm) { } virtual ~GrLinearGradient() { } static const char* Name() { return "Linear Gradient"; } @@ -558,18 +553,15 @@ GrEffect* GrLinearGradient::TestCreate(SkRandom* random, ///////////////////////////////////////////////////////////////////// void GrGLLinearGradient::emitCode(GrGLShaderBuilder* builder, - const GrEffectStage& stage, - EffectKey key, + const GrEffectStage&, + EffectKey, const char* vertexCoords, const char* outputColor, const char* inputColor, const TextureSamplerArray& samplers) { this->emitYCoordUniform(builder); - const char* coords; - this->setupMatrix(builder, key, vertexCoords, &coords); SkString t; - t.append(coords); - t.append(".x"); + t.printf("%s.x", builder->defaultTexCoordsName()); this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplers[0]); } @@ -582,7 +574,7 @@ bool SkLinearGradient::asNewEffect(GrContext* context, GrEffectStage* stage) con return false; } matrix.postConcat(fPtsToUnit); - stage->setEffect(SkNEW_ARGS(GrLinearGradient, (context, *this, matrix, fTileMode)))->unref(); + stage->setEffect(SkNEW_ARGS(GrLinearGradient, (context, *this, fTileMode)), matrix)->unref(); return true; } diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp index 02a56da588..a20ea35a1a 100644 --- a/src/effects/gradients/SkRadialGradient.cpp +++ b/src/effects/gradients/SkRadialGradient.cpp @@ -490,9 +490,7 @@ public: const char* inputColor, const TextureSamplerArray&) SK_OVERRIDE; - static EffectKey GenKey(const GrEffectStage& stage, const GrGLCaps&) { - return GenMatrixKey(stage); - } + static EffectKey GenKey(const GrEffectStage&, const GrGLCaps& caps) { return 0; } private: @@ -505,11 +503,8 @@ private: class GrRadialGradient : public GrGradientEffect { public: - GrRadialGradient(GrContext* ctx, - const SkRadialGradient& shader, - const SkMatrix& matrix, - SkShader::TileMode tm) - : INHERITED(ctx, shader, matrix, tm) { + GrRadialGradient(GrContext* ctx, const SkRadialGradient& shader, SkShader::TileMode tm) + : INHERITED(ctx, shader, tm) { } virtual ~GrRadialGradient() { } @@ -556,18 +551,15 @@ GrEffect* GrRadialGradient::TestCreate(SkRandom* random, ///////////////////////////////////////////////////////////////////// void GrGLRadialGradient::emitCode(GrGLShaderBuilder* builder, - const GrEffectStage& stage, - EffectKey key, + const GrEffectStage&, + EffectKey, const char* vertexCoords, const char* outputColor, const char* inputColor, const TextureSamplerArray& samplers) { this->emitYCoordUniform(builder); - const char* coords; - this->setupMatrix(builder, key, vertexCoords, &coords); - SkString t("length("); - t.append(coords); - t.append(")"); + SkString t; + t.printf("length(%s.xy)", builder->defaultTexCoordsName()); this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplers[0]); } @@ -581,7 +573,7 @@ bool SkRadialGradient::asNewEffect(GrContext* context, GrEffectStage* stage) con return false; } matrix.postConcat(fPtsToUnit); - stage->setEffect(SkNEW_ARGS(GrRadialGradient, (context, *this, matrix, fTileMode)))->unref(); + stage->setEffect(SkNEW_ARGS(GrRadialGradient, (context, *this, fTileMode)), matrix)->unref(); return true; } diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp index 589cf4ad14..a783e3757c 100644 --- a/src/effects/gradients/SkSweepGradient.cpp +++ b/src/effects/gradients/SkSweepGradient.cpp @@ -399,9 +399,7 @@ public: const char* inputColor, const TextureSamplerArray&) SK_OVERRIDE; - static EffectKey GenKey(const GrEffectStage& stage, const GrGLCaps&) { - return GenMatrixKey(stage); - } + static EffectKey GenKey(const GrEffectStage&, const GrGLCaps& caps) { return 0; } private: @@ -415,9 +413,8 @@ class GrSweepGradient : public GrGradientEffect { public: GrSweepGradient(GrContext* ctx, - const SkSweepGradient& shader, - const SkMatrix& matrix) - : INHERITED(ctx, shader, matrix, SkShader::kClamp_TileMode) { } + const SkSweepGradient& shader) + : INHERITED(ctx, shader, SkShader::kClamp_TileMode) { } virtual ~GrSweepGradient() { } static const char* Name() { return "Sweep Gradient"; } @@ -460,17 +457,16 @@ GrEffect* GrSweepGradient::TestCreate(SkRandom* random, ///////////////////////////////////////////////////////////////////// void GrGLSweepGradient::emitCode(GrGLShaderBuilder* builder, - const GrEffectStage& stage, - EffectKey key, + const GrEffectStage&, + EffectKey, const char* vertexCoords, const char* outputColor, const char* inputColor, const TextureSamplerArray& samplers) { this->emitYCoordUniform(builder); - const char* coords; - this->setupMatrix(builder, key, vertexCoords, &coords); SkString t; - t.printf("atan(- %s.y, - %s.x) * 0.1591549430918 + 0.5", coords, coords); + t.printf("atan(- %s.y, - %s.x) * 0.1591549430918 + 0.5", + builder->defaultTexCoordsName(), builder->defaultTexCoordsName()); this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplers[0]); } @@ -482,7 +478,7 @@ bool SkSweepGradient::asNewEffect(GrContext* context, GrEffectStage* stage) cons return false; } matrix.postConcat(fPtsToUnit); - stage->setEffect(SkNEW_ARGS(GrSweepGradient, (context, *this, matrix)))->unref(); + stage->setEffect(SkNEW_ARGS(GrSweepGradient, (context, *this)), matrix)->unref(); return true; } diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp index 41292bb43a..f93f660837 100644 --- a/src/effects/gradients/SkTwoPointConicalGradient.cpp +++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp @@ -371,9 +371,8 @@ public: GrConical2Gradient(GrContext* ctx, const SkTwoPointConicalGradient& shader, - const SkMatrix& matrix, SkShader::TileMode tm) - : INHERITED(ctx, shader, matrix, tm) + : INHERITED(ctx, shader, tm) , fCenterX1(shader.getCenterX1()) , fRadius0(shader.getStartRadius()) , fDiffRadius(shader.getDiffRadius()) { } @@ -469,17 +468,12 @@ GrGLConical2Gradient::GrGLConical2Gradient( } void GrGLConical2Gradient::emitCode(GrGLShaderBuilder* builder, - const GrEffectStage& stage, - EffectKey key, + const GrEffectStage&, + EffectKey, const char* vertexCoords, const char* outputColor, const char* inputColor, const TextureSamplerArray& samplers) { - const char* fsCoords; - const char* vsCoordsVarying; - GrSLType coordsVaryingType; - this->setupMatrix(builder, key, vertexCoords, &fsCoords, &vsCoordsVarying, &coordsVaryingType); - this->emitYCoordUniform(builder); // 2 copies of uniform array, 1 for each of vertex & fragment shader, // to work around Xoom bug. Doesn't seem to cause performance decrease @@ -491,7 +485,7 @@ void GrGLConical2Gradient::emitCode(GrGLShaderBuilder* builder, // For radial gradients without perspective we can pass the linear // part of the quadratic as a varying. - if (kVec2f_GrSLType == coordsVaryingType) { + if (!builder->defaultTextureMatrixIsPerspective()) { builder->addVarying(kFloat_GrSLType, "Conical2BCoeff", &fVSVaryingName, &fFSVaryingName); } @@ -508,11 +502,11 @@ void GrGLConical2Gradient::emitCode(GrGLShaderBuilder* builder, // For radial gradients without perspective we can pass the linear // part of the quadratic as a varying. - if (kVec2f_GrSLType == coordsVaryingType) { + if (!builder->defaultTextureMatrixIsPerspective()) { // r2Var = -2 * (r2Parm[2] * varCoord.x - r2Param[3] * r2Param[5]) code->appendf("\t%s = -2.0 * (%s * %s.x + %s * %s);\n", fVSVaryingName, p2.c_str(), - vsCoordsVarying, p3.c_str(), p5.c_str()); + vertexCoords, p3.c_str(), p5.c_str()); } } @@ -544,12 +538,12 @@ void GrGLConical2Gradient::emitCode(GrGLShaderBuilder* builder, // If we we're able to interpolate the linear component, // bVar is the varying; otherwise compute it SkString bVar; - if (kVec2f_GrSLType == coordsVaryingType) { + if (!builder->defaultTextureMatrixIsPerspective()) { bVar = fFSVaryingName; } else { bVar = "b"; code->appendf("\tfloat %s = -2.0 * (%s * %s.x + %s * %s);\n", - bVar.c_str(), p2.c_str(), fsCoords, + bVar.c_str(), p2.c_str(), builder->defaultTexCoordsName(), p3.c_str(), p5.c_str()); } @@ -559,7 +553,7 @@ void GrGLConical2Gradient::emitCode(GrGLShaderBuilder* builder, // c = (x^2)+(y^2) - params[4] code->appendf("\tfloat %s = dot(%s, %s) - %s;\n", cName.c_str(), - fsCoords, fsCoords, + builder->defaultTexCoordsName(), builder->defaultTexCoordsName(), p4.c_str()); // Non-degenerate case (quadratic) @@ -675,15 +669,7 @@ void GrGLConical2Gradient::setData(const GrGLUniformManager& uman, const GrEffec } GrGLEffect::EffectKey GrGLConical2Gradient::GenKey(const GrEffectStage& s, const GrGLCaps&) { - enum { - kIsDegenerate = 1 << kMatrixKeyBitCnt, - }; - - EffectKey key = GenMatrixKey(s); - if (static_cast<const GrConical2Gradient&>(*s.getEffect()).isDegenerate()) { - key |= kIsDegenerate; - } - return key; + return (static_cast<const GrConical2Gradient&>(*s.getEffect()).isDegenerate()); } ///////////////////////////////////////////////////////////////////// @@ -709,7 +695,7 @@ bool SkTwoPointConicalGradient::asNewEffect(GrContext* context, matrix.postConcat(rot); } - stage->setEffect(SkNEW_ARGS(GrConical2Gradient, (context, *this, matrix, fTileMode)))->unref(); + stage->setEffect(SkNEW_ARGS(GrConical2Gradient, (context, *this, fTileMode)), matrix)->unref(); return true; } diff --git a/src/effects/gradients/SkTwoPointRadialGradient.cpp b/src/effects/gradients/SkTwoPointRadialGradient.cpp index d0186291f2..659bce0099 100644 --- a/src/effects/gradients/SkTwoPointRadialGradient.cpp +++ b/src/effects/gradients/SkTwoPointRadialGradient.cpp @@ -404,11 +404,8 @@ private: class GrRadial2Gradient : public GrGradientEffect { public: - GrRadial2Gradient(GrContext* ctx, - const SkTwoPointRadialGradient& shader, - const SkMatrix& matrix, - SkShader::TileMode tm) - : INHERITED(ctx, shader, matrix, tm) + GrRadial2Gradient(GrContext* ctx, const SkTwoPointRadialGradient& shader, SkShader::TileMode tm) + : INHERITED(ctx, shader, tm) , fCenterX1(shader.getCenterX1()) , fRadius0(shader.getStartRadius()) , fPosRoot(shader.getDiffRadius() < 0) { } @@ -504,19 +501,14 @@ GrGLRadial2Gradient::GrGLRadial2Gradient( } void GrGLRadial2Gradient::emitCode(GrGLShaderBuilder* builder, - const GrEffectStage& stage, - EffectKey key, + const GrEffectStage&, + EffectKey, const char* vertexCoords, const char* outputColor, const char* inputColor, const TextureSamplerArray& samplers) { this->emitYCoordUniform(builder); - const char* fsCoords; - const char* vsCoordsVarying; - GrSLType coordsVaryingType; - this->setupMatrix(builder, key, vertexCoords, &fsCoords, &vsCoordsVarying, &coordsVaryingType); - // 2 copies of uniform array, 1 for each of vertex & fragment shader, // to work around Xoom bug. Doesn't seem to cause performance decrease // in test apps, but need to keep an eye on it. @@ -527,8 +519,9 @@ void GrGLRadial2Gradient::emitCode(GrGLShaderBuilder* builder, // For radial gradients without perspective we can pass the linear // part of the quadratic as a varying. - if (kVec2f_GrSLType == coordsVaryingType) { - builder->addVarying(kFloat_GrSLType, "Radial2BCoeff", &fVSVaryingName, &fFSVaryingName); + if (!builder->defaultTextureMatrixIsPerspective()) { + builder->addVarying(kFloat_GrSLType, "Radial2BCoeff", + &fVSVaryingName, &fFSVaryingName); } // VS @@ -541,11 +534,11 @@ void GrGLRadial2Gradient::emitCode(GrGLShaderBuilder* builder, // For radial gradients without perspective we can pass the linear // part of the quadratic as a varying. - if (kVec2f_GrSLType == coordsVaryingType) { + if (!builder->defaultTextureMatrixIsPerspective()) { // r2Var = 2 * (r2Parm[2] * varCoord.x - r2Param[3]) code->appendf("\t%s = 2.0 *(%s * %s.x - %s);\n", fVSVaryingName, p2.c_str(), - vsCoordsVarying, p3.c_str()); + vertexCoords, p3.c_str()); } } @@ -572,19 +565,20 @@ void GrGLRadial2Gradient::emitCode(GrGLShaderBuilder* builder, // If we we're able to interpolate the linear component, // bVar is the varying; otherwise compute it SkString bVar; - if (kVec2f_GrSLType == coordsVaryingType) { + if (!builder->defaultTextureMatrixIsPerspective()) { bVar = fFSVaryingName; } else { bVar = "b"; code->appendf("\tfloat %s = 2.0 * (%s * %s.x - %s);\n", - bVar.c_str(), p2.c_str(), fsCoords, p3.c_str()); + bVar.c_str(), p2.c_str(), + builder->defaultTexCoordsName(), p3.c_str()); } // c = (x^2)+(y^2) - params[4] code->appendf("\tfloat %s = dot(%s, %s) - %s;\n", cName.c_str(), - fsCoords, - fsCoords, + builder->defaultTexCoordsName(), + builder->defaultTexCoordsName(), p4.c_str()); // If we aren't degenerate, emit some extra code, and accept a slightly @@ -649,15 +643,7 @@ void GrGLRadial2Gradient::setData(const GrGLUniformManager& uman, const GrEffect } GrGLEffect::EffectKey GrGLRadial2Gradient::GenKey(const GrEffectStage& s, const GrGLCaps&) { - enum { - kIsDegenerate = 1 << kMatrixKeyBitCnt, - }; - - EffectKey key = GenMatrixKey(s); - if (static_cast<const GrRadial2Gradient&>(*s.getEffect()).isDegenerate()) { - key |= kIsDegenerate; - } - return key; + return (static_cast<const GrRadial2Gradient&>(*s.getEffect()).isDegenerate()); } ///////////////////////////////////////////////////////////////////// @@ -681,7 +667,7 @@ bool SkTwoPointRadialGradient::asNewEffect(GrContext* context, matrix.postConcat(rot); } - stage->setEffect(SkNEW_ARGS(GrRadial2Gradient, (context, *this, matrix, fTileMode)))->unref(); + stage->setEffect(SkNEW_ARGS(GrRadial2Gradient, (context, *this, fTileMode)), matrix)->unref(); return true; } diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp index 2a39fad722..f7f6b0c0b7 100644 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -1307,44 +1307,35 @@ bool GrContext::readRenderTargetPixels(GrRenderTarget* target, ast.set(this, desc, match); GrTexture* texture = ast.texture(); if (texture) { - GrEffectStage stage; - // compute a matrix to perform the draw - GrMatrix textureMatrix; - if (flipY) { - textureMatrix.setTranslate(SK_Scalar1 * left, - SK_Scalar1 * (top + height)); - textureMatrix.set(GrMatrix::kMScaleY, -GR_Scalar1); - } else { - textureMatrix.setTranslate(SK_Scalar1 *left, SK_Scalar1 *top); - } - textureMatrix.postIDiv(src->width(), src->height()); - - bool effectInstalled = false; + SkAutoTUnref<GrEffect> effect; if (unpremul) { - if (this->installPMToUPMEffect(src, swapRAndB, textureMatrix, &stage)) { - effectInstalled = true; - unpremul = false; // we no longer need to do this on CPU after the readback. - } + effect.reset(this->createPMToUPMEffect(src, swapRAndB)); } // If we failed to create a PM->UPM effect and have no other conversions to perform then // there is no longer any point to using the scratch. - if (effectInstalled || flipY || swapRAndB) { - if (!effectInstalled) { - SkAssertResult(GrConfigConversionEffect::InstallEffect( - src, - swapRAndB, - GrConfigConversionEffect::kNone_PMConversion, - textureMatrix, - &stage)); + if (NULL != effect || flipY || swapRAndB) { + if (NULL == effect) { + effect.reset(GrConfigConversionEffect::Create(src, swapRAndB)); + GrAssert(NULL != effect); + } else { + unpremul = false; // we will handle the UPM conversion in the draw } swapRAndB = false; // we will handle the swap in the draw. - flipY = false; // we already incorporated the y flip in the matrix GrDrawTarget::AutoStateRestore asr(fGpu, GrDrawTarget::kReset_ASRInit); GrDrawState* drawState = fGpu->drawState(); - *drawState->stage(0) = stage; - drawState->setRenderTarget(texture->asRenderTarget()); + GrMatrix matrix; + if (flipY) { + matrix.setTranslate(SK_Scalar1 * left, + SK_Scalar1 * (top + height)); + matrix.set(GrMatrix::kMScaleY, -GR_Scalar1); + flipY = false; // the y flip will be handled in the draw + } else { + matrix.setTranslate(SK_Scalar1 *left, SK_Scalar1 *top); + } + matrix.postIDiv(src->width(), src->height()); + drawState->stage(0)->setEffect(effect, matrix); GrRect rect = GrRect::MakeWH(GrIntToScalar(width), GrIntToScalar(height)); fGpu->drawSimpleRect(rect, NULL); // we want to read back from the scratch's origin @@ -1359,7 +1350,7 @@ bool GrContext::readRenderTargetPixels(GrRenderTarget* target, readConfig, buffer, rowBytes, readUpsideDown)) { return false; } - // Perform any conversions we weren't able to perform using a scratch texture. + // Perform any conversions we weren't able to perfom using a scratch texture. if (unpremul || swapRAndB || flipY) { // These are initialized to suppress a warning SkCanvas::Config8888 srcC8888 = SkCanvas::kNative_Premul_Config8888; @@ -1489,7 +1480,7 @@ void GrContext::writeRenderTargetPixels(GrRenderTarget* target, return; } #endif - + SkAutoTUnref<GrEffect> effect; bool swapRAndB = (fGpu->preferredReadPixelsConfig(config) == GrPixelConfigSwapRAndB(config)); GrPixelConfig textureConfig; @@ -1508,24 +1499,15 @@ void GrContext::writeRenderTargetPixels(GrRenderTarget* target, if (NULL == texture) { return; } - - GrEffectStage stage; - GrMatrix textureMatrix; - textureMatrix.setIDiv(texture->width(), texture->height()); - // allocate a tmp buffer and sw convert the pixels to premul SkAutoSTMalloc<128 * 128, uint32_t> tmpPixels(0); - bool effectInstalled = false; if (kUnpremul_PixelOpsFlag & flags) { if (kRGBA_8888_GrPixelConfig != config && kBGRA_8888_GrPixelConfig != config) { return; } - effectInstalled = this->installUPMToPMEffect(texture, - swapRAndB, - textureMatrix, - &stage); - if (!effectInstalled) { + effect.reset(this->createUPMToPMEffect(texture, swapRAndB)); + if (NULL == effect) { SkCanvas::Config8888 srcConfig8888, dstConfig8888; GR_DEBUGCODE(bool success = ) grconfig_to_config8888(config, true, &srcConfig8888); @@ -1542,13 +1524,9 @@ void GrContext::writeRenderTargetPixels(GrRenderTarget* target, rowBytes = 4 * width; } } - if (!effectInstalled) { - SkAssertResult(GrConfigConversionEffect::InstallEffect( - texture, - swapRAndB, - GrConfigConversionEffect::kNone_PMConversion, - textureMatrix, - &stage)); + if (NULL == effect) { + effect.reset(GrConfigConversionEffect::Create(texture, swapRAndB)); + GrAssert(NULL != effect); } this->writeTexturePixels(texture, @@ -1558,13 +1536,15 @@ void GrContext::writeRenderTargetPixels(GrRenderTarget* target, GrDrawTarget::AutoStateRestore asr(fGpu, GrDrawTarget::kReset_ASRInit); GrDrawState* drawState = fGpu->drawState(); - *drawState->stage(0) = stage; GrMatrix matrix; matrix.setTranslate(GrIntToScalar(left), GrIntToScalar(top)); drawState->setViewMatrix(matrix); drawState->setRenderTarget(target); + matrix.setIDiv(texture->width(), texture->height()); + drawState->stage(0)->setEffect(effect, matrix); + fGpu->drawSimpleRect(GrRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)), NULL); } //////////////////////////////////////////////////////////////////////////////// @@ -1746,10 +1726,7 @@ void test_pm_conversions(GrContext* ctx, int* pmToUPMValue, int* upmToPMValue) { } } -bool GrContext::installPMToUPMEffect(GrTexture* texture, - bool swapRAndB, - const GrMatrix& matrix, - GrEffectStage* stage) { +GrEffect* GrContext::createPMToUPMEffect(GrTexture* texture, bool swapRAndB) { if (!fDidTestPMConversions) { test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion); fDidTestPMConversions = true; @@ -1757,17 +1734,13 @@ bool GrContext::installPMToUPMEffect(GrTexture* texture, GrConfigConversionEffect::PMConversion pmToUPM = static_cast<GrConfigConversionEffect::PMConversion>(fPMToUPMConversion); if (GrConfigConversionEffect::kNone_PMConversion != pmToUPM) { - GrConfigConversionEffect::InstallEffect(texture, swapRAndB, pmToUPM, matrix, stage); - return true; + return GrConfigConversionEffect::Create(texture, swapRAndB, pmToUPM); } else { - return false; + return NULL; } } -bool GrContext::installUPMToPMEffect(GrTexture* texture, - bool swapRAndB, - const GrMatrix& matrix, - GrEffectStage* stage) { +GrEffect* GrContext::createUPMToPMEffect(GrTexture* texture, bool swapRAndB) { if (!fDidTestPMConversions) { test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion); fDidTestPMConversions = true; @@ -1775,10 +1748,9 @@ bool GrContext::installUPMToPMEffect(GrTexture* texture, GrConfigConversionEffect::PMConversion upmToPM = static_cast<GrConfigConversionEffect::PMConversion>(fUPMToPMConversion); if (GrConfigConversionEffect::kNone_PMConversion != upmToPM) { - GrConfigConversionEffect::InstallEffect(texture, swapRAndB, upmToPM, matrix, stage); - return true; + return GrConfigConversionEffect::Create(texture, swapRAndB, upmToPM); } else { - return false; + return NULL; } } @@ -1836,7 +1808,7 @@ GrTexture* GrContext::gaussianBlur(GrTexture* srcTexture, i < scaleFactorY ? 0.5f : 1.0f); paint.colorStage(0)->setEffect(SkNEW_ARGS(GrSingleTextureEffect, - (srcTexture, matrix, true)))->unref(); + (srcTexture, true)), matrix)->unref(); this->drawRectToRect(paint, dstRect, srcRect); srcRect = dstRect; srcTexture = dstTexture; @@ -1893,8 +1865,8 @@ GrTexture* GrContext::gaussianBlur(GrTexture* srcTexture, // FIXME: This should be mitchell, not bilinear. matrix.setIDiv(srcTexture->width(), srcTexture->height()); this->setRenderTarget(dstTexture->asRenderTarget()); - paint.colorStage(0)->setEffect(SkNEW_ARGS(GrSingleTextureEffect,(srcTexture, - matrix, true)))->unref(); + paint.colorStage(0)->setEffect(SkNEW_ARGS(GrSingleTextureEffect,(srcTexture, true)), + matrix)->unref(); SkRect dstRect(srcRect); scale_rect(&dstRect, (float) scaleFactorX, (float) scaleFactorY); this->drawRectToRect(paint, dstRect, srcRect); diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h index b53944189a..3c6c3a371a 100644 --- a/src/gpu/GrDrawState.h +++ b/src/gpu/GrDrawState.h @@ -198,16 +198,16 @@ public: } void createTextureEffect(int stageIdx, GrTexture* texture, const GrMatrix& matrix) { GrAssert(!this->getStage(stageIdx).getEffect()); - GrEffect* effect = SkNEW_ARGS(GrSingleTextureEffect, (texture, matrix)); - this->stage(stageIdx)->setEffect(effect)->unref(); + GrEffect* effect = SkNEW_ARGS(GrSingleTextureEffect, (texture)); + this->stage(stageIdx)->setEffect(effect, matrix)->unref(); } void createTextureEffect(int stageIdx, GrTexture* texture, const GrMatrix& matrix, const GrTextureParams& params) { GrAssert(!this->getStage(stageIdx).getEffect()); - GrEffect* effect = SkNEW_ARGS(GrSingleTextureEffect, (texture, matrix, params)); - this->stage(stageIdx)->setEffect(effect)->unref(); + GrEffect* effect = SkNEW_ARGS(GrSingleTextureEffect, (texture, params)); + this->stage(stageIdx)->setEffect(effect, matrix)->unref(); } diff --git a/src/gpu/GrEffect.cpp b/src/gpu/GrEffect.cpp index d470c9cc5f..09032bf0f9 100644 --- a/src/gpu/GrEffect.cpp +++ b/src/gpu/GrEffect.cpp @@ -20,26 +20,6 @@ SkTArray<GrEffectTestFactory*, true>* GrEffectTestFactory::GetFactories() { } #endif -namespace GrEffectUnitTest { -const SkMatrix& TestMatrix(SkRandom* random) { - static SkMatrix gMatrices[5]; - static bool gOnce; - if (!gOnce) { - gMatrices[0].reset(); - gMatrices[1].setTranslate(SkIntToScalar(-100), SkIntToScalar(100)); - gMatrices[2].setRotate(SkIntToScalar(17)); - gMatrices[3].setRotate(SkIntToScalar(185)); - gMatrices[3].postTranslate(SkIntToScalar(66), SkIntToScalar(-33)); - gMatrices[3].postScale(SkIntToScalar(2), SK_ScalarHalf); - gMatrices[4].setRotate(SkIntToScalar(215)); - gMatrices[4].set(SkMatrix::kMPersp0, SkFloatToScalar(0.00013f)); - gMatrices[4].set(SkMatrix::kMPersp1, SkFloatToScalar(-0.000039f)); - gOnce = true; - } - return gMatrices[random->nextULessThan(static_cast<uint32_t>(SK_ARRAY_COUNT(gMatrices)))]; -} -} - class GrEffect_Globals { public: static GrMemoryPool* GetTLS() { diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp index 946d54dcc8..cdccbcd049 100644 --- a/src/gpu/SkGpuDevice.cpp +++ b/src/gpu/SkGpuDevice.cpp @@ -608,7 +608,7 @@ inline bool skPaint2GrPaintShader(SkGpuDevice* dev, GrScalar sy = SkFloatToScalar(1.f / bitmap.height()); matrix.postScale(sx, sy); } - stage->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (texture, matrix, params)))->unref(); + stage->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (texture, params)), matrix)->unref(); return true; } @@ -875,7 +875,7 @@ bool drawWithGPUMaskFilter(GrContext* context, const SkPath& devPath, matrix.setIDiv(pathTexture->width(), pathTexture->height()); // Blend pathTexture over blurTexture. context->setRenderTarget(blurTexture->asRenderTarget()); - paint.colorStage(0)->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (pathTexture, matrix)))->unref(); + paint.colorStage(0)->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (pathTexture)), matrix)->unref(); if (SkMaskFilter::kInner_BlurType == blurType) { // inner: dst = dst * src paint.setBlendFunc(kDC_GrBlendCoeff, kZero_GrBlendCoeff); @@ -906,7 +906,7 @@ bool drawWithGPUMaskFilter(GrContext* context, const SkPath& devPath, matrix.postIDiv(blurTexture->width(), blurTexture->height()); grp->coverageStage(MASK_IDX)->reset(); - grp->coverageStage(MASK_IDX)->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (blurTexture, matrix)))->unref(); + grp->coverageStage(MASK_IDX)->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (blurTexture)), matrix)->unref(); context->drawRect(*grp, finalRect); return true; } @@ -962,7 +962,7 @@ bool drawWithMaskFilter(GrContext* context, const SkPath& devPath, m.setTranslate(-dstM.fBounds.fLeft*SK_Scalar1, -dstM.fBounds.fTop*SK_Scalar1); m.postIDiv(texture->width(), texture->height()); - grp->coverageStage(MASK_IDX)->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (texture, m)))->unref(); + grp->coverageStage(MASK_IDX)->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (texture)), m)->unref(); GrRect d; d.setLTRB(GrIntToScalar(dstM.fBounds.fLeft), GrIntToScalar(dstM.fBounds.fTop), diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp index 54d7285c93..086064545e 100644 --- a/src/gpu/effects/GrConfigConversionEffect.cpp +++ b/src/gpu/effects/GrConfigConversionEffect.cpp @@ -218,27 +218,21 @@ void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context } } -bool GrConfigConversionEffect::InstallEffect(GrTexture* texture, - bool swapRedAndBlue, - PMConversion pmConversion, - const GrMatrix& matrix, - GrEffectStage* stage) { +GrEffect* GrConfigConversionEffect::Create(GrTexture* texture, + bool swapRedAndBlue, + PMConversion pmConversion) { if (!swapRedAndBlue && kNone_PMConversion == pmConversion) { // If we returned a GrConfigConversionEffect that was equivalent to a GrSingleTextureEffect // then we may pollute our texture cache with redundant shaders. So in the case that no // conversions were requested we instead return a GrSingleTextureEffect. - stage->setEffect(SkNEW_ARGS(GrSingleTextureEffect, (texture, matrix)), matrix)->unref(); - return true; + return SkNEW_ARGS(GrSingleTextureEffect, (texture)); } else { if (kRGBA_8888_GrPixelConfig != texture->config() && kBGRA_8888_GrPixelConfig != texture->config() && kNone_PMConversion != pmConversion) { // The PM conversions assume colors are 0..255 - return false; + return NULL; } - stage->setEffect(SkNEW_ARGS(GrConfigConversionEffect, (texture, - swapRedAndBlue, - pmConversion)), matrix)->unref(); - return true; + return SkNEW_ARGS(GrConfigConversionEffect, (texture, swapRedAndBlue, pmConversion)); } } diff --git a/src/gpu/effects/GrConfigConversionEffect.h b/src/gpu/effects/GrConfigConversionEffect.h index 5b531d4d58..7c5f03fa2b 100644 --- a/src/gpu/effects/GrConfigConversionEffect.h +++ b/src/gpu/effects/GrConfigConversionEffect.h @@ -33,12 +33,10 @@ public: kPMConversionCnt }; - // Installs an effect in the GrEffectStage to perform a config conversion. - static bool InstallEffect(GrTexture*, - bool swapRedAndBlue, - PMConversion pmConversion, - const GrMatrix& matrix, - GrEffectStage* stage); + // This will fail if the config is not 8888 and a PM conversion is requested. + static GrEffect* Create(GrTexture*, + bool swapRedAndBlue, + PMConversion pmConversion = kNone_PMConversion); static const char* Name() { return "Config Conversion"; } typedef GrGLConfigConversionEffect GLEffect; diff --git a/src/gpu/effects/GrSingleTextureEffect.cpp b/src/gpu/effects/GrSingleTextureEffect.cpp index 0f3b614dd7..8866153962 100644 --- a/src/gpu/effects/GrSingleTextureEffect.cpp +++ b/src/gpu/effects/GrSingleTextureEffect.cpp @@ -7,7 +7,6 @@ #include "effects/GrSingleTextureEffect.h" #include "gl/GrGLEffect.h" -#include "gl/GrGLEffectMatrix.h" #include "gl/GrGLSL.h" #include "gl/GrGLTexture.h" #include "GrTBackendEffectFactory.h" @@ -17,43 +16,25 @@ class GrGLSingleTextureEffect : public GrGLEffect { public: GrGLSingleTextureEffect(const GrBackendEffectFactory& factory, const GrEffect&) : INHERITED (factory) { - fRequiresTextureMatrix = false; } virtual void emitCode(GrGLShaderBuilder* builder, const GrEffectStage&, - EffectKey key, + EffectKey, const char* vertexCoords, const char* outputColor, const char* inputColor, const TextureSamplerArray& samplers) SK_OVERRIDE { - const char* coordName; - GrSLType coordType = fEffectMatrix.emitCode(builder, key, vertexCoords, &coordName); + builder->fFSCode.appendf("\t%s = ", outputColor); - builder->appendTextureLookupAndModulate(&builder->fFSCode, - inputColor, - samplers[0], - coordName, - coordType); + builder->appendTextureLookupAndModulate(&builder->fFSCode, inputColor, samplers[0]); builder->fFSCode.append(";\n"); } - static inline EffectKey GenKey(const GrEffectStage& stage, const GrGLCaps&) { - const GrSingleTextureEffect& ste = - static_cast<const GrSingleTextureEffect&>(*stage.getEffect()); - return GrGLEffectMatrix::GenKey(ste.getMatrix(), - stage.getCoordChangeMatrix(), - ste.texture(0)); - } - - virtual void setData(const GrGLUniformManager& uman, const GrEffectStage& stage) SK_OVERRIDE { - const GrSingleTextureEffect& ste = - static_cast<const GrSingleTextureEffect&>(*stage.getEffect()); - fEffectMatrix.setData(uman, ste.getMatrix(), stage.getCoordChangeMatrix(), ste.texture(0)); - } + static inline EffectKey GenKey(const GrEffectStage&, const GrGLCaps&) { return 0; } private: - GrGLEffectMatrix fEffectMatrix; + typedef GrGLEffect INHERITED; }; @@ -62,39 +43,16 @@ private: GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture) : INHERITED(1) , fTextureAccess(texture) { - fMatrix.reset(); } GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture, bool bilerp) : INHERITED(1) , fTextureAccess(texture, bilerp) { - fMatrix.reset(); } GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture, const GrTextureParams& params) : INHERITED(1) , fTextureAccess(texture, params) { - fMatrix.reset(); -} - -GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture, const GrMatrix& m) - : INHERITED(1) - , fTextureAccess(texture) - , fMatrix(m) { -} - -GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture, const GrMatrix& m, bool bilerp) - : INHERITED(1) - , fTextureAccess(texture, bilerp) - , fMatrix(m) { -} - -GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture, - const GrMatrix& m, - const GrTextureParams& params) - : INHERITED(1) - , fTextureAccess(texture, params) - , fMatrix(m) { } GrSingleTextureEffect::~GrSingleTextureEffect() { @@ -118,6 +76,5 @@ GrEffect* GrSingleTextureEffect::TestCreate(SkRandom* random, GrTexture* textures[]) { int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx : GrEffectUnitTest::kAlphaTextureIdx; - const SkMatrix& matrix = GrEffectUnitTest::TestMatrix(random); - return SkNEW_ARGS(GrSingleTextureEffect, (textures[texIdx], matrix)); + return SkNEW_ARGS(GrSingleTextureEffect, (textures[texIdx])); } diff --git a/src/gpu/effects/GrSingleTextureEffect.h b/src/gpu/effects/GrSingleTextureEffect.h index 23b416d3b3..346a6f48d8 100644 --- a/src/gpu/effects/GrSingleTextureEffect.h +++ b/src/gpu/effects/GrSingleTextureEffect.h @@ -9,7 +9,6 @@ #define GrSingleTextureEffect_DEFINED #include "GrEffect.h" -#include "GrMatrix.h" class GrGLSingleTextureEffect; @@ -19,15 +18,13 @@ class GrGLSingleTextureEffect; class GrSingleTextureEffect : public GrEffect { public: - /** These three constructors assume an identity matrix */ - GrSingleTextureEffect(GrTexture* texture); /* unfiltered, clamp mode */ - GrSingleTextureEffect(GrTexture* texture, bool bilerp); /* clamp mode */ - GrSingleTextureEffect(GrTexture* texture, const GrTextureParams&); + /** Uses default texture params (unfiltered, clamp) */ + GrSingleTextureEffect(GrTexture* texture); + + /** Uses default tile mode (clamp) */ + GrSingleTextureEffect(GrTexture* texture, bool bilerp); - /** These three constructors take an explicit matrix */ - GrSingleTextureEffect(GrTexture*, const GrMatrix&); /* unfiltered, clamp mode */ - GrSingleTextureEffect(GrTexture*, const GrMatrix&, bool bilerp); /* clamp mode */ - GrSingleTextureEffect(GrTexture*, const GrMatrix&, const GrTextureParams&); + GrSingleTextureEffect(GrTexture* texture, const GrTextureParams&); virtual ~GrSingleTextureEffect(); @@ -35,21 +32,14 @@ public: static const char* Name() { return "Single Texture"; } - const GrMatrix& getMatrix() const { return fMatrix; } - typedef GrGLSingleTextureEffect GLEffect; virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; - virtual bool isEqual(const GrEffect& effect) const SK_OVERRIDE { - const GrSingleTextureEffect& ste = static_cast<const GrSingleTextureEffect&>(effect); - return INHERITED::isEqual(effect) && fMatrix.cheapEqualTo(ste.getMatrix()); - } private: GR_DECLARE_EFFECT_TEST; GrTextureAccess fTextureAccess; - GrMatrix fMatrix; typedef GrEffect INHERITED; }; diff --git a/src/gpu/gl/GrGLEffect.cpp b/src/gpu/gl/GrGLEffect.cpp index 5e0875b71c..0bbf1f7ccb 100644 --- a/src/gpu/gl/GrGLEffect.cpp +++ b/src/gpu/gl/GrGLEffect.cpp @@ -10,8 +10,6 @@ GrGLEffect::GrGLEffect(const GrBackendEffectFactory& factory) : fFactory(factory) { - - fRequiresTextureMatrix = true; } GrGLEffect::~GrGLEffect() { diff --git a/src/gpu/gl/GrGLEffect.h b/src/gpu/gl/GrGLEffect.h index 0fd5722cb8..30b8455a68 100644 --- a/src/gpu/gl/GrGLEffect.h +++ b/src/gpu/gl/GrGLEffect.h @@ -51,9 +51,7 @@ public: @param builder Interface used to emit code in the shaders. @param stage The effect stage that generated this program stage. - @param key The key that was computed by GenKey() from the generating GrEffect. - Only the bits indicated by GrBackendEffectFactory::kEffectKeyBits are - guaranteed to match the value produced by GenKey(); + @param key The key that was computed by EffectKey() from the generating GrEffect. @param vertexCoords A vec2 of texture coordinates in the VS, which may be altered. This will be removed soon and stages will be responsible for computing their own coords. @@ -87,14 +85,7 @@ public: static EffectKey GenTextureKey(const GrEffect&, const GrGLCaps&); - bool requiresTextureMatrix() const { return fRequiresTextureMatrix; } - - protected: - // HACK: This is a temporary field that allows GrGLEffect subclasses to opt into the new - // shader gen where a texture matrix is not automatically inserted. It defaults to true and is - // set to false in a subclass to opt into the new behavior. - bool fRequiresTextureMatrix; const GrBackendEffectFactory& fFactory; }; diff --git a/src/gpu/gl/GrGLEffectMatrix.cpp b/src/gpu/gl/GrGLEffectMatrix.cpp deleted file mode 100644 index 0db87f9773..0000000000 --- a/src/gpu/gl/GrGLEffectMatrix.cpp +++ /dev/null @@ -1,213 +0,0 @@ -/* - * Copyright 2012 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#include "GrGLEffectMatrix.h" -#include "GrTexture.h" - -GrGLEffect::EffectKey GrGLEffectMatrix::GenKey(const SkMatrix& effectMatrix, - const SkMatrix& coordChangeMatrix, - const GrTexture* texture) { - SkMatrix::TypeMask type0 = effectMatrix.getType(); - SkMatrix::TypeMask type1 = coordChangeMatrix.getType(); - - static const int kNonTransMask = SkMatrix::kAffine_Mask | - SkMatrix::kScale_Mask | - SkMatrix::kPerspective_Mask; - int combinedTypes = type0 | type1; - - bool reverseY = (NULL != texture) && GrSurface::kBottomLeft_Origin == texture->origin(); - - if (SkMatrix::kPerspective_Mask & combinedTypes) { - return kGeneral_Key; - } else if ((kNonTransMask & combinedTypes) || reverseY) { - return kNoPersp_Key; - } else if (kTrans_Key & combinedTypes) { - return kTrans_Key; - } else { - GrAssert(effectMatrix.isIdentity() && coordChangeMatrix.isIdentity()); - return kIdentity_Key; - } -} - -GrSLType GrGLEffectMatrix::emitCode(GrGLShaderBuilder* builder, - EffectKey key, - const char* vertexCoords, - const char** fsCoordName, - const char** vsCoordName, - const char* suffix) { - GrSLType varyingType; - const char* uniName; - key &= kKeyMask; - switch (key) { - case kIdentity_Key: - fUniType = kVoid_GrSLType; - varyingType = kVec2f_GrSLType; - break; - case kTrans_Key: - fUniType = kVec2f_GrSLType; - uniName = "StageTranslate"; - varyingType = kVec2f_GrSLType; - break; - case kNoPersp_Key: - fUniType = kMat33f_GrSLType; - uniName = "StageMatrix"; - varyingType = kVec2f_GrSLType; - break; - case kGeneral_Key: - fUniType = kMat33f_GrSLType; - uniName = "StageMatrix"; - varyingType = kVec3f_GrSLType; - break; - default: - GrCrash("Unexpected key."); - } - SkString suffixedUniName; - if (NULL != suffix) { - suffixedUniName.append(uniName); - suffixedUniName.append(suffix); - uniName = suffixedUniName.c_str(); - } - if (kVoid_GrSLType != fUniType) { - fUni = builder->addUniform(GrGLShaderBuilder::kVertex_ShaderType, - fUniType, - uniName, - &uniName); - } - - const char* varyingName = "StageCoord"; - SkString suffixedVaryingName; - if (NULL != suffix) { - suffixedVaryingName.append(varyingName); - suffixedVaryingName.append(suffix); - varyingName = suffixedVaryingName.c_str(); - } - const char* vsVaryingName; - const char* fsVaryingName; - builder->addVarying(varyingType, varyingName, &vsVaryingName, &fsVaryingName); - - // varying = matrix * vertex-coords (logically) - switch (fUniType) { - case kVoid_GrSLType: - GrAssert(kVec2f_GrSLType == varyingType); - builder->fVSCode.appendf("\t%s = %s;\n", vsVaryingName, vertexCoords); - break; - case kVec2f_GrSLType: - GrAssert(kVec2f_GrSLType == varyingType); - builder->fVSCode.appendf("\t%s = %s + %s;\n", vsVaryingName, uniName, vertexCoords); - break; - case kMat33f_GrSLType: { - GrAssert(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType); - if (kVec2f_GrSLType == varyingType) { - builder->fVSCode.appendf("\t%s = (%s * vec3(%s, 1)).xy;\n", - vsVaryingName, uniName, vertexCoords); - } else { - builder->fVSCode.appendf("\t%s = %s * vec3(%s, 1);\n", - vsVaryingName, uniName, vertexCoords); - } - break; - } - default: - GrCrash("Unexpected uniform type."); - } - if (NULL != vsCoordName) { - *vsCoordName = vsVaryingName; - } - if (NULL != fsCoordName) { - *fsCoordName = fsVaryingName; - } - return varyingType; -} - -/** - * This is similar to emitCode except that it performs perspective division in the FS if the - * texture coordinates have a w coordinate. The fsCoordName always refers to a vec2f. - */ -void GrGLEffectMatrix::emitCodeMakeFSCoords2D(GrGLShaderBuilder* builder, - EffectKey key, - const char* vertexCoords, - const char** fsCoordName, - const char** vsVaryingName, - GrSLType* vsVaryingType, - const char* suffix) { - const char* fsVaryingName; - - GrSLType varyingType = this->emitCode(builder, - key, - vertexCoords, - &fsVaryingName, - vsVaryingName, - suffix); - if (kVec3f_GrSLType == varyingType) { - - const char* coordName = "coords2D"; - SkString suffixedCoordName; - if (NULL != suffix) { - suffixedCoordName.append(coordName); - suffixedCoordName.append(suffix); - coordName = suffixedCoordName.c_str(); - } - builder->fFSCode.appendf("\tvec2 %s = %s.xy / %s.z;", - coordName, fsVaryingName, fsVaryingName); - if (NULL != fsCoordName) { - *fsCoordName = coordName; - } - } else if(NULL != fsCoordName) { - *fsCoordName = fsVaryingName; - } - if (NULL != vsVaryingType) { - *vsVaryingType = varyingType; - } -} - -void GrGLEffectMatrix::setData(const GrGLUniformManager& uniformManager, - const SkMatrix& matrix, - const SkMatrix& coordChangeMatrix, - const GrTexture* texture) { - GrAssert((GrGLUniformManager::kInvalidUniformHandle == fUni) == - (kVoid_GrSLType == fUniType)); - switch (fUniType) { - case kVoid_GrSLType: - GrAssert(matrix.isIdentity()); - GrAssert(coordChangeMatrix.isIdentity()); - GrAssert(NULL == texture || GrSurface::kTopLeft_Origin == texture->origin()); - return; - case kVec2f_GrSLType: { - GrAssert(SkMatrix::kTranslate_Mask == (matrix.getType() | coordChangeMatrix.getType())); - GrAssert(NULL == texture || GrSurface::kTopLeft_Origin == texture->origin()); - SkScalar tx = matrix[SkMatrix::kMTransX] + coordChangeMatrix[SkMatrix::kMTransX]; - SkScalar ty = matrix[SkMatrix::kMTransY] + coordChangeMatrix[SkMatrix::kMTransY]; - if (fPrevMatrix.get(SkMatrix::kMTransX) != tx || - fPrevMatrix.get(SkMatrix::kMTransY) != ty) { - uniformManager.set2f(fUni, tx, ty); - fPrevMatrix.set(SkMatrix::kMTransX, tx); - fPrevMatrix.set(SkMatrix::kMTransY, ty); - } - break; - } - case kMat33f_GrSLType: { - SkMatrix combined; - combined.setConcat(matrix, coordChangeMatrix); - if (NULL != texture && GrSurface::kBottomLeft_Origin == texture->origin()) { - // combined.postScale(1,-1); - // combined.postTranslate(0,1); - combined.set(SkMatrix::kMSkewY, - combined[SkMatrix::kMPersp0] - combined[SkMatrix::kMSkewY]); - combined.set(SkMatrix::kMScaleY, - combined[SkMatrix::kMPersp1] - combined[SkMatrix::kMScaleY]); - combined.set(SkMatrix::kMTransY, - combined[SkMatrix::kMPersp2] - combined[SkMatrix::kMTransY]); - } - if (!fPrevMatrix.cheapEqualTo(combined)) { - uniformManager.setSkMatrix(fUni, combined); - fPrevMatrix = combined; - } - break; - } - default: - GrCrash("Unexpected uniform type."); - } -} diff --git a/src/gpu/gl/GrGLEffectMatrix.h b/src/gpu/gl/GrGLEffectMatrix.h deleted file mode 100644 index 9e45f3ef82..0000000000 --- a/src/gpu/gl/GrGLEffectMatrix.h +++ /dev/null @@ -1,97 +0,0 @@ -/* - * Copyright 2012 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#ifndef GrGLEffectMatrix_DEFINED -#define GrGLEffectMatrix_DEFINED - -#include "GrGLEffect.h" -#include "SkMatrix.h" - -class GrTexture; -class SkRandom; - -/** - * This is a helper to implement a texture matrix in a GrGLEffect. - */ -class GrGLEffectMatrix { -public: - typedef GrGLEffect::EffectKey EffectKey; - /** - * The matrix uses kKeyBits of the effect's EffectKey. A GrGLEffect may place these bits at an - * arbitrary shift in its final key. However, when GrGLEffectMatrix::emitCode*() code is called - * the relevant bits must be in the lower kKeyBits of the key parameter. - */ - enum { - kKeyBits = 2, - kKeyMask = (1 << kKeyBits) - 1, - }; - - GrGLEffectMatrix() : fUni(GrGLUniformManager::kInvalidUniformHandle) { - fPrevMatrix = SkMatrix::InvalidMatrix(); - } - - /** - * Generates the key for the portion of the code emitted by this class's emitCode() function. - * Pass a texture to make GrGLEffectMatrix automatically adjust for the texture's origin. Pass - * NULL when not using the EffectMatrix for a texture lookups, or if the GrGLEffect subclass - * wants to handle origin adjustments in some other manner. coordChangeMatrix is the matrix - * from GrEffectStage. - */ - static EffectKey GenKey(const SkMatrix& effectMatrix, - const SkMatrix& coordChangeMatrix, - const GrTexture*); - - /** - * Emits code to implement the matrix in the VS. A varying is added as an output of the VS and - * input to the FS. The varying may be either a vec2f or vec3f depending upon whether - * perspective interpolation is required or not. The names of the varying in the VS and FS are - * are returned as output parameters and the type of the varying is the return value. The suffix - * is an optional parameter that can be used to make all variables emitted by the object - * unique within a stage. It is only necessary if multiple GrGLEffectMatrix objects are used by - * a GrGLEffect. - */ - GrSLType emitCode(GrGLShaderBuilder*, - EffectKey, - const char* vertexCoords, - const char** fsCoordName, /* optional */ - const char** vsCoordName = NULL, - const char* suffix = NULL); - - /** - * This is similar to emitCode except that it performs perspective division in the FS if the - * texture coordinates have a w coordinate. The fsCoordName always refers to a vec2f. - */ - void emitCodeMakeFSCoords2D(GrGLShaderBuilder*, - EffectKey, - const char* vertexCoords, - const char** fsCoordName, /* optional */ - const char** vsVaryingName = NULL, - GrSLType* vsVaryingType = NULL, - const char* suffix = NULL); - /** - * Call from a GrGLEffect's subclass to update the texture matrix. The matrix, - * coordChangeMatrix, and texture params should match those used with GenKey. - */ - void setData(const GrGLUniformManager& uniformManager, - const SkMatrix& effectMatrix, - const SkMatrix& coordChangeMatrix, - const GrTexture*); - -private: - enum { - kIdentity_Key = 0, - kTrans_Key = 1, - kNoPersp_Key = 2, - kGeneral_Key = 3, - }; - - GrGLUniformManager::UniformHandle fUni; - GrSLType fUniType; - SkMatrix fPrevMatrix; -}; - -#endif
\ No newline at end of file diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp index 120bd1e3ad..cd16d9e24f 100644 --- a/src/gpu/gl/GrGLProgram.cpp +++ b/src/gpu/gl/GrGLProgram.cpp @@ -909,64 +909,57 @@ GrGLEffect* GrGLProgram::GenStageCode(const GrEffectStage& stage, /// Vertex Shader Stuff - const char* vertexCoords; - - // Has the effect not yet been updated to insert its own texture matrix if necessary. - if (glEffect->requiresTextureMatrix()) { - // Decide whether we need a matrix to transform texture coords and whether the varying needs - // a perspective coord. - const char* matName = NULL; - GrSLType texCoordVaryingType; - if (desc.fOptFlags & StageDesc::kIdentityMatrix_OptFlagBit) { - texCoordVaryingType = kVec2f_GrSLType; - } else { - uniforms->fTextureMatrixUni = builder->addUniform(GrGLShaderBuilder::kVertex_ShaderType, - kMat33f_GrSLType, "TexM", &matName); - builder->getUniformVariable(uniforms->fTextureMatrixUni); + // decide whether we need a matrix to transform texture coords and whether the varying needs a + // perspective coord. + const char* matName = NULL; + GrSLType texCoordVaryingType; + if (desc.fOptFlags & StageDesc::kIdentityMatrix_OptFlagBit) { + texCoordVaryingType = kVec2f_GrSLType; + } else { + uniforms->fTextureMatrixUni = builder->addUniform(GrGLShaderBuilder::kVertex_ShaderType, + kMat33f_GrSLType, "TexM", &matName); + builder->getUniformVariable(uniforms->fTextureMatrixUni); - if (desc.fOptFlags & StageDesc::kNoPerspective_OptFlagBit) { - texCoordVaryingType = kVec2f_GrSLType; - } else { - texCoordVaryingType = kVec3f_GrSLType; - } - } - const char *varyingVSName, *varyingFSName; - builder->addVarying(texCoordVaryingType, - "Stage", - &varyingVSName, - &varyingFSName); - builder->setupTextureAccess(varyingFSName, texCoordVaryingType); - - if (!matName) { - GrAssert(kVec2f_GrSLType == texCoordVaryingType); - builder->fVSCode.appendf("\t%s = %s;\n", varyingVSName, vsInCoord); + if (desc.fOptFlags & StageDesc::kNoPerspective_OptFlagBit) { + texCoordVaryingType = kVec2f_GrSLType; } else { - // varying = texMatrix * texCoord - builder->fVSCode.appendf("\t%s = (%s * vec3(%s, 1))%s;\n", - varyingVSName, matName, vsInCoord, - vector_all_coords(GrSLTypeToVecLength(texCoordVaryingType))); + texCoordVaryingType = kVec3f_GrSLType; } - vertexCoords = varyingVSName; - } else { - vertexCoords = vsInCoord; } + const char *varyingVSName, *varyingFSName; + builder->addVarying(texCoordVaryingType, + "Stage", + &varyingVSName, + &varyingFSName); + builder->setupTextureAccess(varyingFSName, texCoordVaryingType); - // setup texture samplers for gl effect int numTextures = effect->numTextures(); SkSTArray<8, GrGLShaderBuilder::TextureSampler> textureSamplers; + textureSamplers.push_back_n(numTextures); + for (int i = 0; i < numTextures; ++i) { textureSamplers[i].init(builder, &effect->textureAccess(i)); uniforms->fSamplerUniforms.push_back(textureSamplers[i].fSamplerUniform); } + if (!matName) { + GrAssert(kVec2f_GrSLType == texCoordVaryingType); + builder->fVSCode.appendf("\t%s = %s;\n", varyingVSName, vsInCoord); + } else { + // varying = texMatrix * texCoord + builder->fVSCode.appendf("\t%s = (%s * vec3(%s, 1))%s;\n", + varyingVSName, matName, vsInCoord, + vector_all_coords(GrSLTypeToVecLength(texCoordVaryingType))); + } + // Enclose custom code in a block to avoid namespace conflicts builder->fVSCode.appendf("\t{ // %s\n", glEffect->name()); builder->fFSCode.appendf("\t{ // %s \n", glEffect->name()); glEffect->emitCode(builder, stage, desc.fEffectKey, - vertexCoords, + varyingVSName, fsOutColor, fsInColor, textureSamplers); diff --git a/src/gpu/gl/GrGLUniformManager.cpp b/src/gpu/gl/GrGLUniformManager.cpp index 7a92d25b28..684ef8c37e 100644 --- a/src/gpu/gl/GrGLUniformManager.cpp +++ b/src/gpu/gl/GrGLUniformManager.cpp @@ -8,7 +8,6 @@ #include "gl/GrGLShaderBuilder.h" #include "gl/GrGLProgram.h" #include "gl/GrGLUniformHandle.h" -#include "SkMatrix.h" #define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, OFFSET, COUNT) \ GrAssert(offset + arrayCount <= uni.fArrayCount || \ @@ -232,23 +231,6 @@ void GrGLUniformManager::setMatrix4fv(UniformHandle u, } } -void GrGLUniformManager::setSkMatrix(UniformHandle u, const SkMatrix& matrix) const { - GR_STATIC_ASSERT(SK_SCALAR_IS_FLOAT); - GrGLfloat mt[] = { - matrix.get(SkMatrix::kMScaleX), - matrix.get(SkMatrix::kMSkewY), - matrix.get(SkMatrix::kMPersp0), - matrix.get(SkMatrix::kMSkewX), - matrix.get(SkMatrix::kMScaleY), - matrix.get(SkMatrix::kMPersp1), - matrix.get(SkMatrix::kMTransX), - matrix.get(SkMatrix::kMTransY), - matrix.get(SkMatrix::kMPersp2), - }; - this->setMatrix3f(u, mt); -} - - void GrGLUniformManager::getUniformLocations(GrGLuint programID, const BuilderUniformArray& uniforms) { GrAssert(uniforms.count() == fUniforms.count()); int count = fUniforms.count(); diff --git a/src/gpu/gl/GrGLUniformManager.h b/src/gpu/gl/GrGLUniformManager.h index 8f435d3037..e9856c6ea3 100644 --- a/src/gpu/gl/GrGLUniformManager.h +++ b/src/gpu/gl/GrGLUniformManager.h @@ -15,7 +15,6 @@ #include "SkTArray.h" class GrGLContextInfo; -class SkMatrix; /** Manages a program's uniforms. */ @@ -48,9 +47,6 @@ public: void setMatrix3fv(UniformHandle, int offset, int arrayCount, const GrGLfloat matrices[]) const; void setMatrix4fv(UniformHandle, int offset, int arrayCount, const GrGLfloat matrices[]) const; - // convenience method for uploading a SkMatrix to a 3x3 matrix uniform - void setSkMatrix(UniformHandle, const SkMatrix&) const; - struct BuilderUniform { GrGLShaderVar fVariable; uint32_t fVisibility; diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp index 6812d2790d..9c001fbbd8 100644 --- a/tests/GLProgramsTest.cpp +++ b/tests/GLProgramsTest.cpp @@ -184,11 +184,7 @@ void forceLinking(); void forceLinking() { SkLightingImageFilter::CreateDistantLitDiffuse(SkPoint3(0,0,0), 0, 0, 0); SkMagnifierImageFilter mag(SkRect::MakeWH(SK_Scalar1, SK_Scalar1), SK_Scalar1); - GrConfigConversionEffect::InstallEffect(NULL, - false, - GrConfigConversionEffect::kNone_PMConversion, - GrMatrix::I(), - &GrEffectStage()); + GrConfigConversionEffect::Create(NULL, false); SkScalar matrix[20]; SkColorMatrixFilter cmf(matrix); } |