src/third_party/skia/src/gpu/effects/GrDistanceFieldTextureEffect.cpp

   1 /*
   2  * Copyright 2013 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "GrDistanceFieldTextureEffect.h"
   9 #include "gl/GrGLEffect.h"
  10 #include "gl/GrGLSL.h"
  11 #include "gl/GrGLTexture.h"
  12 #include "gl/GrGLVertexEffect.h"
  13 #include "GrTBackendEffectFactory.h"
  14 #include "GrTexture.h"
  15
  16 // The distance field is constructed as unsigned char values, so that the zero value is at 128,
  17 // and the range is [-4, 4 - 1/255). Hence our multiplier is 8 - 1/32 and zero threshold is 128/255.
  18 #define MULTIPLIER "7.96875"
  19 #define THRESHOLD "0.50196078431"
  20
  21 class GrGLDistanceFieldTextureEffect : public GrGLVertexEffect {
  22 public:
  23     GrGLDistanceFieldTextureEffect(const GrBackendEffectFactory& factory,
  24                                    const GrDrawEffect& drawEffect)
  25         : INHERITED (factory)
  26         , fTextureSize(SkISize::Make(-1,-1)) {}
  27
  28     virtual void emitCode(GrGLFullShaderBuilder* builder,
  29                           const GrDrawEffect& drawEffect,
  30                           EffectKey key,
  31                           const char* outputColor,
  32                           const char* inputColor,
  33                           const TransformedCoordsArray&,
  34                           const TextureSamplerArray& samplers) SK_OVERRIDE {
  35         SkASSERT(1 == drawEffect.castEffect<GrDistanceFieldTextureEffect>().numVertexAttribs());
  36
  37         SkAssertResult(builder->enableFeature(GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
  38         const GrDistanceFieldTextureEffect& dfTexEffect =
  39                                               drawEffect.castEffect<GrDistanceFieldTextureEffect>();
  40
  41         SkString fsCoordName;
  42         const char* vsCoordName;
  43         const char* fsCoordNamePtr;
  44         builder->addVarying(kVec2f_GrSLType, "textureCoords", &vsCoordName, &fsCoordNamePtr);
  45         fsCoordName = fsCoordNamePtr;
  46
  47         const char* attrName0 =
  48             builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0])->c_str();
  49         builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attrName0);
  50
  51         const char* textureSizeUniName = NULL;
  52         fTextureSizeUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
  53                                               kVec2f_GrSLType, "TextureSize",
  54                                               &textureSizeUniName);
  55
  56         builder->fsCodeAppend("\tvec4 texColor = ");
  57         builder->fsAppendTextureLookup(samplers[0],
  58                                        fsCoordName.c_str(),
  59                                        kVec2f_GrSLType);
  60         builder->fsCodeAppend(";\n");
  61         builder->fsCodeAppend("\tfloat distance = " MULTIPLIER "*(texColor.r - " THRESHOLD ");\n");
  62
  63         // we adjust for the effect of the transformation on the distance by using
  64         // the length of the gradient of the texture coordinates. We use st coordinates
  65         // to ensure we're mapping 1:1 from texel space to pixel space.
  66         builder->fsCodeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str());
  67         builder->fsCodeAppendf("\tvec2 st = uv*%s;\n", textureSizeUniName);
  68         builder->fsCodeAppend("\tfloat afwidth;\n");
  69         if (dfTexEffect.isUniformScale()) {
  70             // this gives us a smooth step across approximately one fragment
  71             // (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
  72             builder->fsCodeAppend("\tafwidth = 0.7071*dFdx(st.x);\n");
  73         } else {
  74             builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
  75             builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
  76
  77             builder->fsCodeAppend("\tvec2 uv_grad;\n");
  78             if (builder->ctxInfo().caps()->dropsTileOnZeroDivide()) {
  79                 // this is to compensate for the Adreno, which likes to drop tiles on division by 0
  80                 builder->fsCodeAppend("\tfloat uv_len2 = dot(uv, uv);\n");
  81                 builder->fsCodeAppend("\tif (uv_len2 < 0.0001) {\n");
  82                 builder->fsCodeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n");
  83                 builder->fsCodeAppend("\t} else {\n");
  84                 builder->fsCodeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n");
  85                 builder->fsCodeAppend("\t}\n");
  86             } else {
  87                 builder->fsCodeAppend("\tuv_grad = normalize(uv);\n");
  88             }
  89             builder->fsCodeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n");
  90             builder->fsCodeAppend("\t                 uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
  91
  92             // this gives us a smooth step across approximately one fragment
  93             // (assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2)
  94             builder->fsCodeAppend("\tafwidth = 0.7071*length(grad);\n");
  95         }
  96
  97         builder->fsCodeAppend("\tfloat val = smoothstep(-afwidth, afwidth, distance);\n");
  98
  99         builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
 100                                    (GrGLSLExpr4(inputColor) * GrGLSLExpr1("val")).c_str());
 101     }
 102
 103     virtual void setData(const GrGLUniformManager& uman,
 104                          const GrDrawEffect& drawEffect) SK_OVERRIDE {
 105         SkASSERT(fTextureSizeUni.isValid());
 106
 107         GrTexture* texture = drawEffect.effect()->get()->texture(0);
 108         if (texture->width() != fTextureSize.width() ||
 109             texture->height() != fTextureSize.height()) {
 110             fTextureSize = SkISize::Make(texture->width(), texture->height());
 111             uman.set2f(fTextureSizeUni,
 112                        SkIntToScalar(fTextureSize.width()),
 113                        SkIntToScalar(fTextureSize.height()));
 114         }
 115     }
 116
 117     static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
 118         const GrDistanceFieldTextureEffect& dfTexEffect =
 119                                               drawEffect.castEffect<GrDistanceFieldTextureEffect>();
 120
 121         return dfTexEffect.isUniformScale() ? 0x1 : 0x0;
 122     }
 123
 124 private:
 125     GrGLUniformManager::UniformHandle fTextureSizeUni;
 126     SkISize                           fTextureSize;
 127
 128     typedef GrGLVertexEffect INHERITED;
 129 };
 130
 131 ///////////////////////////////////////////////////////////////////////////////
 132
 133 GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrTexture* texture,
 134                                                            const GrTextureParams& params,
 135                                                            bool uniformScale)
 136     : fTextureAccess(texture, params)
 137     , fUniformScale(uniformScale) {
 138     this->addTextureAccess(&fTextureAccess);
 139     this->addVertexAttrib(kVec2f_GrSLType);
 140 }
 141
 142 bool GrDistanceFieldTextureEffect::onIsEqual(const GrEffect& other) const {
 143     const GrDistanceFieldTextureEffect& cte = CastEffect<GrDistanceFieldTextureEffect>(other);
 144     return fTextureAccess == cte.fTextureAccess;
 145 }
 146
 147 void GrDistanceFieldTextureEffect::getConstantColorComponents(GrColor* color,
 148                                                              uint32_t* validFlags) const {
 149     if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
 150         GrPixelConfigIsOpaque(this->texture(0)->config())) {
 151         *validFlags = kA_GrColorComponentFlag;
 152     } else {
 153         *validFlags = 0;
 154     }
 155 }
 156
 157 const GrBackendEffectFactory& GrDistanceFieldTextureEffect::getFactory() const {
 158     return GrTBackendEffectFactory<GrDistanceFieldTextureEffect>::getInstance();
 159 }
 160
 161 ///////////////////////////////////////////////////////////////////////////////
 162
 163 GR_DEFINE_EFFECT_TEST(GrDistanceFieldTextureEffect);
 164
 165 GrEffectRef* GrDistanceFieldTextureEffect::TestCreate(SkRandom* random,
 166                                                      GrContext*,
 167                                                      const GrDrawTargetCaps&,
 168                                                      GrTexture* textures[]) {
 169     int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
 170                                       GrEffectUnitTest::kAlphaTextureIdx;
 171     static const SkShader::TileMode kTileModes[] = {
 172         SkShader::kClamp_TileMode,
 173         SkShader::kRepeat_TileMode,
 174         SkShader::kMirror_TileMode,
 175     };
 176     SkShader::TileMode tileModes[] = {
 177         kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
 178         kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))],
 179     };
 180     GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode :
 181                                                            GrTextureParams::kNone_FilterMode);
 182
 183     return GrDistanceFieldTextureEffect::Create(textures[texIdx], params, random->nextBool());
 184 }