jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 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" |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 9 | #include "GrFontAtlasSizes.h" |
egdaniel | 605dd0f | 2014-11-12 08:35:25 -0800 | [diff] [blame] | 10 | #include "GrInvariantOutput.h" |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 11 | #include "GrTexture.h" |
| 12 | #include "SkDistanceFieldGen.h" |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 13 | #include "gl/GrGLProcessor.h" |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 14 | #include "gl/GrGLSL.h" |
| 15 | #include "gl/GrGLTexture.h" |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 16 | #include "gl/GrGLGeometryProcessor.h" |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 17 | #include "gl/builders/GrGLProgramBuilder.h" |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 18 | |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 19 | // Assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2 |
| 20 | #define SK_DistanceFieldAAFactor "0.7071" |
| 21 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 22 | struct DistanceFieldBatchTracker { |
| 23 | GrGPInput fInputColorType; |
| 24 | GrColor fColor; |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 25 | bool fUsesLocalCoords; |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 26 | }; |
| 27 | |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 28 | class GrGLDistanceFieldTextureEffect : public GrGLGeometryProcessor { |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 29 | public: |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 30 | GrGLDistanceFieldTextureEffect(const GrGeometryProcessor&, |
joshualitt | 87f48d9 | 2014-12-04 10:41:40 -0800 | [diff] [blame] | 31 | const GrBatchTracker&) |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 32 | : fColor(GrColor_ILLEGAL) |
jvanverth | 9564ce6 | 2014-09-16 05:45:19 -0700 | [diff] [blame] | 33 | #ifdef SK_GAMMA_APPLY_TO_A8 |
| 34 | , fLuminance(-1.0f) |
| 35 | #endif |
| 36 | {} |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 37 | |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 38 | void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{ |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 39 | const GrDistanceFieldTextureEffect& dfTexEffect = |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 40 | args.fGP.cast<GrDistanceFieldTextureEffect>(); |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 41 | const DistanceFieldBatchTracker& local = args.fBT.cast<DistanceFieldBatchTracker>(); |
| 42 | GrGLGPBuilder* pb = args.fPB; |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 43 | GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 44 | SkAssertResult(fsBuilder->enableFeature( |
| 45 | GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)); |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 46 | |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 47 | GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 48 | |
| 49 | // emit attributes |
| 50 | vsBuilder->emitAttributes(dfTexEffect); |
| 51 | |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 52 | GrGLVertToFrag st(kVec2f_GrSLType); |
jvanverth | 9671ecd | 2015-02-23 13:08:39 -0800 | [diff] [blame^] | 53 | args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 54 | vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTextureCoords()->fName); |
| 55 | |
| 56 | GrGLVertToFrag uv(kVec2f_GrSLType); |
jvanverth | 9671ecd | 2015-02-23 13:08:39 -0800 | [diff] [blame^] | 57 | args.fPB->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 58 | // this is only used with text, so our texture bounds always match the glyph atlas |
| 59 | vsBuilder->codeAppendf("%s = vec2(" GR_FONT_ATLAS_RECIP_WIDTH ", " |
| 60 | GR_FONT_ATLAS_RECIP_HEIGHT ")*%s;", uv.vsOut(), |
| 61 | dfTexEffect.inTextureCoords()->fName); |
commit-bot@chromium.org | 6c89c34 | 2014-02-14 21:48:29 +0000 | [diff] [blame] | 62 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 63 | // Setup pass through color |
| 64 | this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, |
| 65 | dfTexEffect.inColor(), &fColorUniform); |
commit-bot@chromium.org | 6c89c34 | 2014-02-14 21:48:29 +0000 | [diff] [blame] | 66 | |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 67 | // Setup position |
joshualitt | dd21987 | 2015-02-12 14:48:42 -0800 | [diff] [blame] | 68 | this->setupPosition(pb, gpArgs, dfTexEffect.inPosition()->fName, dfTexEffect.viewMatrix()); |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 69 | |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 70 | // emit transforms |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 71 | this->emitTransforms(args.fPB, gpArgs->fPositionVar, dfTexEffect.inPosition()->fName, |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 72 | dfTexEffect.localMatrix(), args.fTransformsIn, args.fTransformsOut); |
joshualitt | 4973d9d | 2014-11-08 09:24:25 -0800 | [diff] [blame] | 73 | |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 74 | // Use highp to work around aliasing issues |
| 75 | fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision, |
| 76 | pb->ctxInfo().standard())); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 77 | fsBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn()); |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 78 | |
| 79 | fsBuilder->codeAppend("\tfloat texColor = "); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 80 | fsBuilder->appendTextureLookup(args.fSamplers[0], |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 81 | "uv", |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 82 | kVec2f_GrSLType); |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 83 | fsBuilder->codeAppend(".r;\n"); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 84 | fsBuilder->codeAppend("\tfloat distance = " |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 85 | SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");"); |
commit-bot@chromium.org | 6c89c34 | 2014-02-14 21:48:29 +0000 | [diff] [blame] | 86 | |
| 87 | // we adjust for the effect of the transformation on the distance by using |
| 88 | // the length of the gradient of the texture coordinates. We use st coordinates |
| 89 | // to ensure we're mapping 1:1 from texel space to pixel space. |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 90 | fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision, |
| 91 | pb->ctxInfo().standard())); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 92 | fsBuilder->codeAppendf("vec2 st = %s;\n", st.fsIn()); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 93 | fsBuilder->codeAppend("\tfloat afwidth;\n"); |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 94 | if (dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag) { |
commit-bot@chromium.org | 4362a38 | 2014-03-26 19:49:03 +0000 | [diff] [blame] | 95 | // this gives us a smooth step across approximately one fragment |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 96 | fsBuilder->codeAppend("\tafwidth = abs(" SK_DistanceFieldAAFactor "*dFdx(st.x));\n"); |
commit-bot@chromium.org | 4362a38 | 2014-03-26 19:49:03 +0000 | [diff] [blame] | 97 | } else { |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 98 | fsBuilder->codeAppend("\tvec2 Jdx = dFdx(st);\n"); |
| 99 | fsBuilder->codeAppend("\tvec2 Jdy = dFdy(st);\n"); |
commit-bot@chromium.org | 6c89c34 | 2014-02-14 21:48:29 +0000 | [diff] [blame] | 100 | |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 101 | fsBuilder->codeAppend("\tvec2 uv_grad;\n"); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 102 | if (args.fPB->ctxInfo().caps()->dropsTileOnZeroDivide()) { |
commit-bot@chromium.org | 4362a38 | 2014-03-26 19:49:03 +0000 | [diff] [blame] | 103 | // this is to compensate for the Adreno, which likes to drop tiles on division by 0 |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 104 | fsBuilder->codeAppend("\tfloat uv_len2 = dot(uv, uv);\n"); |
| 105 | fsBuilder->codeAppend("\tif (uv_len2 < 0.0001) {\n"); |
| 106 | fsBuilder->codeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n"); |
| 107 | fsBuilder->codeAppend("\t} else {\n"); |
| 108 | fsBuilder->codeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n"); |
| 109 | fsBuilder->codeAppend("\t}\n"); |
commit-bot@chromium.org | 4362a38 | 2014-03-26 19:49:03 +0000 | [diff] [blame] | 110 | } else { |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 111 | fsBuilder->codeAppend("\tuv_grad = normalize(uv);\n"); |
commit-bot@chromium.org | 4362a38 | 2014-03-26 19:49:03 +0000 | [diff] [blame] | 112 | } |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 113 | fsBuilder->codeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n"); |
| 114 | fsBuilder->codeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n"); |
commit-bot@chromium.org | 4362a38 | 2014-03-26 19:49:03 +0000 | [diff] [blame] | 115 | |
| 116 | // this gives us a smooth step across approximately one fragment |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 117 | fsBuilder->codeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n"); |
commit-bot@chromium.org | 4362a38 | 2014-03-26 19:49:03 +0000 | [diff] [blame] | 118 | } |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 119 | fsBuilder->codeAppend("\tfloat val = smoothstep(-afwidth, afwidth, distance);\n"); |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 120 | |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 121 | #ifdef SK_GAMMA_APPLY_TO_A8 |
| 122 | // adjust based on gamma |
| 123 | const char* luminanceUniName = NULL; |
| 124 | // width, height, 1/(3*width) |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 125 | fLuminanceUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
bsalomon | 422f56f | 2014-12-09 10:18:12 -0800 | [diff] [blame] | 126 | kFloat_GrSLType, kDefault_GrSLPrecision, |
| 127 | "Luminance", &luminanceUniName); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 128 | |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 129 | fsBuilder->codeAppendf("\tuv = vec2(val, %s);\n", luminanceUniName); |
| 130 | fsBuilder->codeAppend("\tvec4 gammaColor = "); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 131 | fsBuilder->appendTextureLookup(args.fSamplers[1], "uv", kVec2f_GrSLType); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 132 | fsBuilder->codeAppend(";\n"); |
| 133 | fsBuilder->codeAppend("\tval = gammaColor.r;\n"); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 134 | #endif |
| 135 | |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 136 | fsBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage); |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 137 | } |
| 138 | |
kkinnunen | 7510b22 | 2014-07-30 00:04:16 -0700 | [diff] [blame] | 139 | virtual void setData(const GrGLProgramDataManager& pdman, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 140 | const GrPrimitiveProcessor& proc, |
| 141 | const GrBatchTracker& bt) SK_OVERRIDE { |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 142 | #ifdef SK_GAMMA_APPLY_TO_A8 |
| 143 | const GrDistanceFieldTextureEffect& dfTexEffect = |
joshualitt | 87f48d9 | 2014-12-04 10:41:40 -0800 | [diff] [blame] | 144 | proc.cast<GrDistanceFieldTextureEffect>(); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 145 | float luminance = dfTexEffect.getLuminance(); |
| 146 | if (luminance != fLuminance) { |
kkinnunen | 7510b22 | 2014-07-30 00:04:16 -0700 | [diff] [blame] | 147 | pdman.set1f(fLuminanceUni, luminance); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 148 | fLuminance = luminance; |
| 149 | } |
| 150 | #endif |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 151 | |
joshualitt | ee2af95 | 2014-12-30 09:04:15 -0800 | [diff] [blame] | 152 | this->setUniformViewMatrix(pdman, proc.viewMatrix()); |
| 153 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 154 | const DistanceFieldBatchTracker& local = bt.cast<DistanceFieldBatchTracker>(); |
| 155 | if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { |
| 156 | GrGLfloat c[4]; |
| 157 | GrColorToRGBAFloat(local.fColor, c); |
| 158 | pdman.set4fv(fColorUniform, 1, c); |
| 159 | fColor = local.fColor; |
| 160 | } |
commit-bot@chromium.org | 8fe2ee1 | 2014-03-26 18:03:05 +0000 | [diff] [blame] | 161 | } |
| 162 | |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 163 | static inline void GenKey(const GrGeometryProcessor& gp, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 164 | const GrBatchTracker& bt, |
joshualitt | 87f48d9 | 2014-12-04 10:41:40 -0800 | [diff] [blame] | 165 | const GrGLCaps&, |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 166 | GrProcessorKeyBuilder* b) { |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 167 | const GrDistanceFieldTextureEffect& dfTexEffect = gp.cast<GrDistanceFieldTextureEffect>(); |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 168 | const DistanceFieldBatchTracker& local = bt.cast<DistanceFieldBatchTracker>(); |
joshualitt | 8fc6c2d | 2014-12-22 15:27:05 -0800 | [diff] [blame] | 169 | uint32_t key = dfTexEffect.getFlags(); |
| 170 | key |= local.fInputColorType << 16; |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 171 | key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 << 24: 0x0; |
| 172 | key |= ComputePosKey(gp.viewMatrix()) << 25; |
joshualitt | 8fc6c2d | 2014-12-22 15:27:05 -0800 | [diff] [blame] | 173 | b->add32(key); |
commit-bot@chromium.org | 4362a38 | 2014-03-26 19:49:03 +0000 | [diff] [blame] | 174 | } |
| 175 | |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 176 | private: |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 177 | GrColor fColor; |
| 178 | UniformHandle fColorUniform; |
mtklein | 50282b4 | 2015-01-22 07:59:52 -0800 | [diff] [blame] | 179 | #ifdef SK_GAMMA_APPLY_TO_A8 |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 180 | UniformHandle fLuminanceUni; |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 181 | float fLuminance; |
mtklein | 50282b4 | 2015-01-22 07:59:52 -0800 | [diff] [blame] | 182 | #endif |
commit-bot@chromium.org | 6c89c34 | 2014-02-14 21:48:29 +0000 | [diff] [blame] | 183 | |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 184 | typedef GrGLGeometryProcessor INHERITED; |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 185 | }; |
| 186 | |
| 187 | /////////////////////////////////////////////////////////////////////////////// |
| 188 | |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 189 | GrDistanceFieldTextureEffect::GrDistanceFieldTextureEffect(GrColor color, |
joshualitt | 8059eb9 | 2014-12-29 15:10:07 -0800 | [diff] [blame] | 190 | const SkMatrix& viewMatrix, |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 191 | GrTexture* texture, |
commit-bot@chromium.org | 6c89c34 | 2014-02-14 21:48:29 +0000 | [diff] [blame] | 192 | const GrTextureParams& params, |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 193 | #ifdef SK_GAMMA_APPLY_TO_A8 |
| 194 | GrTexture* gamma, |
| 195 | const GrTextureParams& gammaParams, |
| 196 | float luminance, |
| 197 | #endif |
joshualitt | 56995b5 | 2014-12-11 15:44:02 -0800 | [diff] [blame] | 198 | uint32_t flags, bool opaqueVertexColors) |
joshualitt | 8059eb9 | 2014-12-29 15:10:07 -0800 | [diff] [blame] | 199 | : INHERITED(color, viewMatrix, SkMatrix::I(), opaqueVertexColors) |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 200 | , fTextureAccess(texture, params) |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 201 | #ifdef SK_GAMMA_APPLY_TO_A8 |
| 202 | , fGammaTextureAccess(gamma, gammaParams) |
| 203 | , fLuminance(luminance) |
| 204 | #endif |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 205 | , fFlags(flags & kNonLCD_DistanceFieldEffectMask) |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 206 | , fInColor(NULL) { |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 207 | SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask)); |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 208 | this->initClassID<GrDistanceFieldTextureEffect>(); |
joshualitt | 71c9260 | 2015-01-14 08:12:47 -0800 | [diff] [blame] | 209 | fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 210 | if (flags & kColorAttr_DistanceFieldEffectFlag) { |
joshualitt | 71c9260 | 2015-01-14 08:12:47 -0800 | [diff] [blame] | 211 | fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType)); |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 212 | this->setHasVertexColor(); |
| 213 | } |
joshualitt | 71c9260 | 2015-01-14 08:12:47 -0800 | [diff] [blame] | 214 | fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords", |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 215 | kVec2s_GrVertexAttribType)); |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 216 | this->addTextureAccess(&fTextureAccess); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 217 | #ifdef SK_GAMMA_APPLY_TO_A8 |
| 218 | this->addTextureAccess(&fGammaTextureAccess); |
| 219 | #endif |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 220 | } |
| 221 | |
bsalomon | 0e08fc1 | 2014-10-15 08:19:04 -0700 | [diff] [blame] | 222 | bool GrDistanceFieldTextureEffect::onIsEqual(const GrGeometryProcessor& other) const { |
joshualitt | 49586be | 2014-09-16 08:21:41 -0700 | [diff] [blame] | 223 | const GrDistanceFieldTextureEffect& cte = other.cast<GrDistanceFieldTextureEffect>(); |
bsalomon | 420d7e9 | 2014-10-16 09:18:09 -0700 | [diff] [blame] | 224 | return |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 225 | #ifdef SK_GAMMA_APPLY_TO_A8 |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 226 | fLuminance == cte.fLuminance && |
| 227 | #endif |
| 228 | fFlags == cte.fFlags; |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 229 | } |
| 230 | |
joshualitt | 56995b5 | 2014-12-11 15:44:02 -0800 | [diff] [blame] | 231 | void GrDistanceFieldTextureEffect::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const { |
| 232 | out->setUnknownSingleComponent(); |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 233 | } |
| 234 | |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 235 | void GrDistanceFieldTextureEffect::getGLProcessorKey(const GrBatchTracker& bt, |
| 236 | const GrGLCaps& caps, |
| 237 | GrProcessorKeyBuilder* b) const { |
| 238 | GrGLDistanceFieldTextureEffect::GenKey(*this, bt, caps, b); |
| 239 | } |
| 240 | |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 241 | GrGLPrimitiveProcessor* |
| 242 | GrDistanceFieldTextureEffect::createGLInstance(const GrBatchTracker& bt, |
| 243 | const GrGLCaps&) const { |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 244 | return SkNEW_ARGS(GrGLDistanceFieldTextureEffect, (*this, bt)); |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 245 | } |
| 246 | |
joshualitt | 4d8da81 | 2015-01-28 12:53:54 -0800 | [diff] [blame] | 247 | void GrDistanceFieldTextureEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const { |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 248 | DistanceFieldBatchTracker* local = bt->cast<DistanceFieldBatchTracker>(); |
| 249 | local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, |
| 250 | SkToBool(fInColor)); |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 251 | local->fUsesLocalCoords = init.fUsesLocalCoords; |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 252 | } |
| 253 | |
| 254 | bool GrDistanceFieldTextureEffect::onCanMakeEqual(const GrBatchTracker& m, |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 255 | const GrGeometryProcessor& that, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 256 | const GrBatchTracker& t) const { |
| 257 | const DistanceFieldBatchTracker& mine = m.cast<DistanceFieldBatchTracker>(); |
| 258 | const DistanceFieldBatchTracker& theirs = t.cast<DistanceFieldBatchTracker>(); |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 259 | return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords, |
| 260 | that, theirs.fUsesLocalCoords) && |
| 261 | CanCombineOutput(mine.fInputColorType, mine.fColor, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 262 | theirs.fInputColorType, theirs.fColor); |
| 263 | } |
| 264 | |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 265 | /////////////////////////////////////////////////////////////////////////////// |
| 266 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 267 | GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldTextureEffect); |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 268 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 269 | GrGeometryProcessor* GrDistanceFieldTextureEffect::TestCreate(SkRandom* random, |
| 270 | GrContext*, |
| 271 | const GrDrawTargetCaps&, |
| 272 | GrTexture* textures[]) { |
| 273 | int texIdx = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : |
| 274 | GrProcessorUnitTest::kAlphaTextureIdx; |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 275 | #ifdef SK_GAMMA_APPLY_TO_A8 |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 276 | int texIdx2 = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : |
| 277 | GrProcessorUnitTest::kAlphaTextureIdx; |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 278 | #endif |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 279 | static const SkShader::TileMode kTileModes[] = { |
| 280 | SkShader::kClamp_TileMode, |
| 281 | SkShader::kRepeat_TileMode, |
| 282 | SkShader::kMirror_TileMode, |
| 283 | }; |
| 284 | SkShader::TileMode tileModes[] = { |
| 285 | kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], |
| 286 | kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], |
| 287 | }; |
| 288 | GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode : |
| 289 | GrTextureParams::kNone_FilterMode); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 290 | #ifdef SK_GAMMA_APPLY_TO_A8 |
| 291 | GrTextureParams params2(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode : |
| 292 | GrTextureParams::kNone_FilterMode); |
| 293 | #endif |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 294 | |
joshualitt | 8059eb9 | 2014-12-29 15:10:07 -0800 | [diff] [blame] | 295 | return GrDistanceFieldTextureEffect::Create(GrRandomColor(random), |
| 296 | GrProcessorUnitTest::TestMatrix(random), |
| 297 | textures[texIdx], params, |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 298 | #ifdef SK_GAMMA_APPLY_TO_A8 |
| 299 | textures[texIdx2], params2, |
| 300 | random->nextF(), |
| 301 | #endif |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 302 | random->nextBool() ? |
joshualitt | 56995b5 | 2014-12-11 15:44:02 -0800 | [diff] [blame] | 303 | kSimilarity_DistanceFieldEffectFlag : 0, |
| 304 | random->nextBool()); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 305 | } |
| 306 | |
| 307 | /////////////////////////////////////////////////////////////////////////////// |
| 308 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 309 | struct DistanceFieldNoGammaBatchTracker { |
| 310 | GrGPInput fInputColorType; |
| 311 | GrColor fColor; |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 312 | bool fUsesLocalCoords; |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 313 | }; |
| 314 | |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 315 | class GrGLDistanceFieldNoGammaTextureEffect : public GrGLGeometryProcessor { |
| 316 | public: |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 317 | GrGLDistanceFieldNoGammaTextureEffect(const GrGeometryProcessor&, |
joshualitt | 87f48d9 | 2014-12-04 10:41:40 -0800 | [diff] [blame] | 318 | const GrBatchTracker&) |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 319 | : fColor(GrColor_ILLEGAL), fTextureSize(SkISize::Make(-1, -1)) {} |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 320 | |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 321 | void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{ |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 322 | const GrDistanceFieldNoGammaTextureEffect& dfTexEffect = |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 323 | args.fGP.cast<GrDistanceFieldNoGammaTextureEffect>(); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 324 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 325 | const DistanceFieldNoGammaBatchTracker& local = |
| 326 | args.fBT.cast<DistanceFieldNoGammaBatchTracker>(); |
| 327 | GrGLGPBuilder* pb = args.fPB; |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 328 | GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 329 | SkAssertResult(fsBuilder->enableFeature( |
| 330 | GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)); |
| 331 | |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 332 | GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 333 | |
| 334 | // emit attributes |
| 335 | vsBuilder->emitAttributes(dfTexEffect); |
| 336 | |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 337 | GrGLVertToFrag v(kVec2f_GrSLType); |
jvanverth | 9671ecd | 2015-02-23 13:08:39 -0800 | [diff] [blame^] | 338 | args.fPB->addVarying("TextureCoords", &v, kHigh_GrSLPrecision); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 339 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 340 | // setup pass through color |
| 341 | this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, |
| 342 | dfTexEffect.inColor(), &fColorUniform); |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 343 | |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 344 | vsBuilder->codeAppendf("%s = %s;", v.vsOut(), dfTexEffect.inTextureCoords()->fName); |
| 345 | |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 346 | // Setup position |
joshualitt | dd21987 | 2015-02-12 14:48:42 -0800 | [diff] [blame] | 347 | this->setupPosition(pb, gpArgs, dfTexEffect.inPosition()->fName, dfTexEffect.viewMatrix()); |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 348 | |
| 349 | // emit transforms |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 350 | this->emitTransforms(args.fPB, gpArgs->fPositionVar, dfTexEffect.inPosition()->fName, |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 351 | dfTexEffect.localMatrix(), args.fTransformsIn, args.fTransformsOut); |
joshualitt | 4973d9d | 2014-11-08 09:24:25 -0800 | [diff] [blame] | 352 | |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 353 | const char* textureSizeUniName = NULL; |
| 354 | fTextureSizeUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
| 355 | kVec2f_GrSLType, kDefault_GrSLPrecision, |
| 356 | "TextureSize", &textureSizeUniName); |
| 357 | |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 358 | // Use highp to work around aliasing issues |
| 359 | fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision, |
| 360 | pb->ctxInfo().standard())); |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 361 | fsBuilder->codeAppendf("vec2 uv = %s;", v.fsIn()); |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 362 | |
| 363 | fsBuilder->codeAppend("float texColor = "); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 364 | fsBuilder->appendTextureLookup(args.fSamplers[0], |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 365 | "uv", |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 366 | kVec2f_GrSLType); |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 367 | fsBuilder->codeAppend(".r;"); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 368 | fsBuilder->codeAppend("float distance = " |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 369 | SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");"); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 370 | |
| 371 | // we adjust for the effect of the transformation on the distance by using |
| 372 | // the length of the gradient of the texture coordinates. We use st coordinates |
| 373 | // to ensure we're mapping 1:1 from texel space to pixel space. |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 374 | fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision, |
| 375 | pb->ctxInfo().standard())); |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 376 | fsBuilder->codeAppendf("vec2 st = uv*%s;", textureSizeUniName); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 377 | fsBuilder->codeAppend("float afwidth;"); |
| 378 | if (dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag) { |
| 379 | // this gives us a smooth step across approximately one fragment |
| 380 | fsBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*dFdx(st.x));"); |
| 381 | } else { |
| 382 | fsBuilder->codeAppend("vec2 Jdx = dFdx(st);"); |
| 383 | fsBuilder->codeAppend("vec2 Jdy = dFdy(st);"); |
| 384 | |
| 385 | fsBuilder->codeAppend("vec2 uv_grad;"); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 386 | if (args.fPB->ctxInfo().caps()->dropsTileOnZeroDivide()) { |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 387 | // this is to compensate for the Adreno, which likes to drop tiles on division by 0 |
| 388 | fsBuilder->codeAppend("float uv_len2 = dot(uv, uv);"); |
| 389 | fsBuilder->codeAppend("if (uv_len2 < 0.0001) {"); |
| 390 | fsBuilder->codeAppend("uv_grad = vec2(0.7071, 0.7071);"); |
| 391 | fsBuilder->codeAppend("} else {"); |
| 392 | fsBuilder->codeAppend("uv_grad = uv*inversesqrt(uv_len2);"); |
| 393 | fsBuilder->codeAppend("}"); |
| 394 | } else { |
| 395 | fsBuilder->codeAppend("uv_grad = normalize(uv);"); |
| 396 | } |
| 397 | fsBuilder->codeAppend("vec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,"); |
| 398 | fsBuilder->codeAppend(" uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);"); |
| 399 | |
| 400 | // this gives us a smooth step across approximately one fragment |
| 401 | fsBuilder->codeAppend("afwidth = " SK_DistanceFieldAAFactor "*length(grad);"); |
| 402 | } |
| 403 | fsBuilder->codeAppend("float val = smoothstep(-afwidth, afwidth, distance);"); |
| 404 | |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 405 | fsBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 406 | } |
| 407 | |
| 408 | virtual void setData(const GrGLProgramDataManager& pdman, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 409 | const GrPrimitiveProcessor& proc, |
| 410 | const GrBatchTracker& bt) SK_OVERRIDE { |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 411 | SkASSERT(fTextureSizeUni.isValid()); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 412 | |
joshualitt | 87f48d9 | 2014-12-04 10:41:40 -0800 | [diff] [blame] | 413 | GrTexture* texture = proc.texture(0); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 414 | if (texture->width() != fTextureSize.width() || |
| 415 | texture->height() != fTextureSize.height()) { |
| 416 | fTextureSize = SkISize::Make(texture->width(), texture->height()); |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 417 | pdman.set2f(fTextureSizeUni, |
| 418 | SkIntToScalar(fTextureSize.width()), |
| 419 | SkIntToScalar(fTextureSize.height())); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 420 | } |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 421 | |
joshualitt | ee2af95 | 2014-12-30 09:04:15 -0800 | [diff] [blame] | 422 | this->setUniformViewMatrix(pdman, proc.viewMatrix()); |
| 423 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 424 | const DistanceFieldNoGammaBatchTracker& local = bt.cast<DistanceFieldNoGammaBatchTracker>(); |
| 425 | if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { |
| 426 | GrGLfloat c[4]; |
| 427 | GrColorToRGBAFloat(local.fColor, c); |
| 428 | pdman.set4fv(fColorUniform, 1, c); |
| 429 | fColor = local.fColor; |
| 430 | } |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 431 | } |
| 432 | |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 433 | static inline void GenKey(const GrGeometryProcessor& gp, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 434 | const GrBatchTracker& bt, |
joshualitt | 87f48d9 | 2014-12-04 10:41:40 -0800 | [diff] [blame] | 435 | const GrGLCaps&, |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 436 | GrProcessorKeyBuilder* b) { |
| 437 | const GrDistanceFieldNoGammaTextureEffect& dfTexEffect = |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 438 | gp.cast<GrDistanceFieldNoGammaTextureEffect>(); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 439 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 440 | const DistanceFieldNoGammaBatchTracker& local = bt.cast<DistanceFieldNoGammaBatchTracker>(); |
joshualitt | 8fc6c2d | 2014-12-22 15:27:05 -0800 | [diff] [blame] | 441 | uint32_t key = dfTexEffect.getFlags(); |
| 442 | key |= local.fInputColorType << 16; |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 443 | key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 << 24: 0x0; |
| 444 | key |= ComputePosKey(gp.viewMatrix()) << 25; |
joshualitt | 8fc6c2d | 2014-12-22 15:27:05 -0800 | [diff] [blame] | 445 | b->add32(key); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 446 | } |
| 447 | |
| 448 | private: |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 449 | UniformHandle fColorUniform; |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 450 | UniformHandle fTextureSizeUni; |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 451 | GrColor fColor; |
| 452 | SkISize fTextureSize; |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 453 | |
| 454 | typedef GrGLGeometryProcessor INHERITED; |
| 455 | }; |
| 456 | |
| 457 | /////////////////////////////////////////////////////////////////////////////// |
| 458 | |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 459 | GrDistanceFieldNoGammaTextureEffect::GrDistanceFieldNoGammaTextureEffect( |
| 460 | GrColor color, |
joshualitt | 8059eb9 | 2014-12-29 15:10:07 -0800 | [diff] [blame] | 461 | const SkMatrix& viewMatrix, |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 462 | GrTexture* texture, |
| 463 | const GrTextureParams& params, |
joshualitt | 56995b5 | 2014-12-11 15:44:02 -0800 | [diff] [blame] | 464 | uint32_t flags, |
| 465 | bool opaqueVertexColors) |
joshualitt | 8059eb9 | 2014-12-29 15:10:07 -0800 | [diff] [blame] | 466 | : INHERITED(color, viewMatrix, SkMatrix::I(), opaqueVertexColors) |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 467 | , fTextureAccess(texture, params) |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 468 | , fFlags(flags & kNonLCD_DistanceFieldEffectMask) |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 469 | , fInColor(NULL) { |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 470 | SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask)); |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 471 | this->initClassID<GrDistanceFieldNoGammaTextureEffect>(); |
joshualitt | 71c9260 | 2015-01-14 08:12:47 -0800 | [diff] [blame] | 472 | fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 473 | if (flags & kColorAttr_DistanceFieldEffectFlag) { |
joshualitt | 71c9260 | 2015-01-14 08:12:47 -0800 | [diff] [blame] | 474 | fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType)); |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 475 | this->setHasVertexColor(); |
| 476 | } |
joshualitt | 71c9260 | 2015-01-14 08:12:47 -0800 | [diff] [blame] | 477 | fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords", |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 478 | kVec2f_GrVertexAttribType)); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 479 | this->addTextureAccess(&fTextureAccess); |
| 480 | } |
| 481 | |
bsalomon | 0e08fc1 | 2014-10-15 08:19:04 -0700 | [diff] [blame] | 482 | bool GrDistanceFieldNoGammaTextureEffect::onIsEqual(const GrGeometryProcessor& other) const { |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 483 | const GrDistanceFieldNoGammaTextureEffect& cte = |
| 484 | other.cast<GrDistanceFieldNoGammaTextureEffect>(); |
bsalomon | 420d7e9 | 2014-10-16 09:18:09 -0700 | [diff] [blame] | 485 | return fFlags == cte.fFlags; |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 486 | } |
| 487 | |
joshualitt | 56995b5 | 2014-12-11 15:44:02 -0800 | [diff] [blame] | 488 | void GrDistanceFieldNoGammaTextureEffect::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const{ |
| 489 | out->setUnknownSingleComponent(); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 490 | } |
| 491 | |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 492 | void GrDistanceFieldNoGammaTextureEffect::getGLProcessorKey(const GrBatchTracker& bt, |
| 493 | const GrGLCaps& caps, |
| 494 | GrProcessorKeyBuilder* b) const { |
| 495 | GrGLDistanceFieldNoGammaTextureEffect::GenKey(*this, bt, caps, b); |
| 496 | } |
| 497 | |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 498 | GrGLPrimitiveProcessor* |
| 499 | GrDistanceFieldNoGammaTextureEffect::createGLInstance(const GrBatchTracker& bt, |
| 500 | const GrGLCaps&) const { |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 501 | return SkNEW_ARGS(GrGLDistanceFieldNoGammaTextureEffect, (*this, bt)); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 502 | } |
| 503 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 504 | void GrDistanceFieldNoGammaTextureEffect::initBatchTracker(GrBatchTracker* bt, |
joshualitt | 4d8da81 | 2015-01-28 12:53:54 -0800 | [diff] [blame] | 505 | const GrPipelineInfo& init) const { |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 506 | DistanceFieldNoGammaBatchTracker* local = bt->cast<DistanceFieldNoGammaBatchTracker>(); |
| 507 | local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, |
| 508 | SkToBool(fInColor)); |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 509 | local->fUsesLocalCoords = init.fUsesLocalCoords; |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 510 | } |
| 511 | |
| 512 | bool GrDistanceFieldNoGammaTextureEffect::onCanMakeEqual(const GrBatchTracker& m, |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 513 | const GrGeometryProcessor& that, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 514 | const GrBatchTracker& t) const { |
| 515 | const DistanceFieldNoGammaBatchTracker& mine = m.cast<DistanceFieldNoGammaBatchTracker>(); |
| 516 | const DistanceFieldNoGammaBatchTracker& theirs = t.cast<DistanceFieldNoGammaBatchTracker>(); |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 517 | return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords, |
| 518 | that, theirs.fUsesLocalCoords) && |
| 519 | CanCombineOutput(mine.fInputColorType, mine.fColor, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 520 | theirs.fInputColorType, theirs.fColor); |
| 521 | } |
| 522 | |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 523 | /////////////////////////////////////////////////////////////////////////////// |
| 524 | |
| 525 | GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldNoGammaTextureEffect); |
| 526 | |
| 527 | GrGeometryProcessor* GrDistanceFieldNoGammaTextureEffect::TestCreate(SkRandom* random, |
| 528 | GrContext*, |
| 529 | const GrDrawTargetCaps&, |
| 530 | GrTexture* textures[]) { |
| 531 | int texIdx = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx |
| 532 | : GrProcessorUnitTest::kAlphaTextureIdx; |
| 533 | static const SkShader::TileMode kTileModes[] = { |
| 534 | SkShader::kClamp_TileMode, |
| 535 | SkShader::kRepeat_TileMode, |
| 536 | SkShader::kMirror_TileMode, |
| 537 | }; |
| 538 | SkShader::TileMode tileModes[] = { |
| 539 | kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], |
| 540 | kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], |
| 541 | }; |
| 542 | GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode |
| 543 | : GrTextureParams::kNone_FilterMode); |
| 544 | |
joshualitt | 8059eb9 | 2014-12-29 15:10:07 -0800 | [diff] [blame] | 545 | return GrDistanceFieldNoGammaTextureEffect::Create(GrRandomColor(random), |
| 546 | GrProcessorUnitTest::TestMatrix(random), |
| 547 | textures[texIdx], |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 548 | params, |
joshualitt | 56995b5 | 2014-12-11 15:44:02 -0800 | [diff] [blame] | 549 | random->nextBool() ? kSimilarity_DistanceFieldEffectFlag : 0, random->nextBool()); |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 550 | } |
| 551 | |
| 552 | /////////////////////////////////////////////////////////////////////////////// |
| 553 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 554 | struct DistanceFieldLCDBatchTracker { |
| 555 | GrGPInput fInputColorType; |
| 556 | GrColor fColor; |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 557 | bool fUsesLocalCoords; |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 558 | }; |
| 559 | |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 560 | class GrGLDistanceFieldLCDTextureEffect : public GrGLGeometryProcessor { |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 561 | public: |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 562 | GrGLDistanceFieldLCDTextureEffect(const GrGeometryProcessor&, |
joshualitt | 87f48d9 | 2014-12-04 10:41:40 -0800 | [diff] [blame] | 563 | const GrBatchTracker&) |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 564 | : fColor(GrColor_ILLEGAL) |
jvanverth | 9564ce6 | 2014-09-16 05:45:19 -0700 | [diff] [blame] | 565 | , fTextColor(GrColor_ILLEGAL) {} |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 566 | |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 567 | void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) SK_OVERRIDE{ |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 568 | const GrDistanceFieldLCDTextureEffect& dfTexEffect = |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 569 | args.fGP.cast<GrDistanceFieldLCDTextureEffect>(); |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 570 | const DistanceFieldLCDBatchTracker& local = args.fBT.cast<DistanceFieldLCDBatchTracker>(); |
| 571 | GrGLGPBuilder* pb = args.fPB; |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 572 | |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 573 | GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder(); |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 574 | |
| 575 | // emit attributes |
| 576 | vsBuilder->emitAttributes(dfTexEffect); |
| 577 | |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 578 | GrGLVertToFrag st(kVec2f_GrSLType); |
jvanverth | 9671ecd | 2015-02-23 13:08:39 -0800 | [diff] [blame^] | 579 | args.fPB->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 580 | vsBuilder->codeAppendf("%s = %s;", st.vsOut(), dfTexEffect.inTextureCoords()->fName); |
| 581 | |
| 582 | GrGLVertToFrag uv(kVec2f_GrSLType); |
jvanverth | 9671ecd | 2015-02-23 13:08:39 -0800 | [diff] [blame^] | 583 | args.fPB->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 584 | // this is only used with text, so our texture bounds always match the glyph atlas |
| 585 | vsBuilder->codeAppendf("%s = vec2(" GR_FONT_ATLAS_RECIP_WIDTH ", " |
| 586 | GR_FONT_ATLAS_RECIP_HEIGHT ")*%s;", uv.vsOut(), |
| 587 | dfTexEffect.inTextureCoords()->fName); |
| 588 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 589 | // setup pass through color |
| 590 | this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, |
| 591 | &fColorUniform); |
| 592 | |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 593 | // Setup position |
joshualitt | dd21987 | 2015-02-12 14:48:42 -0800 | [diff] [blame] | 594 | this->setupPosition(pb, gpArgs, dfTexEffect.inPosition()->fName, dfTexEffect.viewMatrix()); |
joshualitt | 4973d9d | 2014-11-08 09:24:25 -0800 | [diff] [blame] | 595 | |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 596 | // emit transforms |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 597 | this->emitTransforms(args.fPB, gpArgs->fPositionVar, dfTexEffect.inPosition()->fName, |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 598 | dfTexEffect.localMatrix(), args.fTransformsIn, args.fTransformsOut); |
| 599 | |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 600 | GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder(); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 601 | |
| 602 | SkAssertResult(fsBuilder->enableFeature( |
| 603 | GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)); |
| 604 | |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 605 | // create LCD offset adjusted by inverse of transform |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 606 | // Use highp to work around aliasing issues |
| 607 | fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision, |
| 608 | pb->ctxInfo().standard())); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 609 | fsBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn()); |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 610 | fsBuilder->codeAppend(GrGLShaderVar::PrecisionString(kHigh_GrSLPrecision, |
| 611 | pb->ctxInfo().standard())); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 612 | fsBuilder->codeAppendf("vec2 st = %s;\n", st.fsIn()); |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 613 | bool isUniformScale = !!(dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 614 | |
| 615 | if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) { |
| 616 | fsBuilder->codeAppend("float delta = -" GR_FONT_ATLAS_LCD_DELTA ";\n"); |
| 617 | } else { |
| 618 | fsBuilder->codeAppend("float delta = " GR_FONT_ATLAS_LCD_DELTA ";\n"); |
| 619 | } |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 620 | if (isUniformScale) { |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 621 | fsBuilder->codeAppend("\tfloat dx = dFdx(st.x);\n"); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 622 | fsBuilder->codeAppend("\tvec2 offset = vec2(dx*delta, 0.0);\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 623 | } else { |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 624 | fsBuilder->codeAppend("\tvec2 Jdx = dFdx(st);\n"); |
| 625 | fsBuilder->codeAppend("\tvec2 Jdy = dFdy(st);\n"); |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 626 | fsBuilder->codeAppend("\tvec2 offset = delta*Jdx;\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 627 | } |
| 628 | |
| 629 | // green is distance to uv center |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 630 | fsBuilder->codeAppend("\tvec4 texColor = "); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 631 | fsBuilder->appendTextureLookup(args.fSamplers[0], "uv", kVec2f_GrSLType); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 632 | fsBuilder->codeAppend(";\n"); |
| 633 | fsBuilder->codeAppend("\tvec3 distance;\n"); |
| 634 | fsBuilder->codeAppend("\tdistance.y = texColor.r;\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 635 | // red is distance to left offset |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 636 | fsBuilder->codeAppend("\tvec2 uv_adjusted = uv - offset;\n"); |
| 637 | fsBuilder->codeAppend("\ttexColor = "); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 638 | fsBuilder->appendTextureLookup(args.fSamplers[0], "uv_adjusted", kVec2f_GrSLType); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 639 | fsBuilder->codeAppend(";\n"); |
| 640 | fsBuilder->codeAppend("\tdistance.x = texColor.r;\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 641 | // blue is distance to right offset |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 642 | fsBuilder->codeAppend("\tuv_adjusted = uv + offset;\n"); |
| 643 | fsBuilder->codeAppend("\ttexColor = "); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 644 | fsBuilder->appendTextureLookup(args.fSamplers[0], "uv_adjusted", kVec2f_GrSLType); |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 645 | fsBuilder->codeAppend(";\n"); |
| 646 | fsBuilder->codeAppend("\tdistance.z = texColor.r;\n"); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 647 | |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 648 | fsBuilder->codeAppend("\tdistance = " |
jvanverth | ada68ef | 2014-11-03 14:00:24 -0800 | [diff] [blame] | 649 | "vec3(" SK_DistanceFieldMultiplier ")*(distance - vec3(" SK_DistanceFieldThreshold"));"); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 650 | |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 651 | // we adjust for the effect of the transformation on the distance by using |
| 652 | // the length of the gradient of the texture coordinates. We use st coordinates |
| 653 | // to ensure we're mapping 1:1 from texel space to pixel space. |
| 654 | |
| 655 | // To be strictly correct, we should compute the anti-aliasing factor separately |
| 656 | // for each color component. However, this is only important when using perspective |
| 657 | // transformations, and even then using a single factor seems like a reasonable |
| 658 | // trade-off between quality and speed. |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 659 | fsBuilder->codeAppend("\tfloat afwidth;\n"); |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 660 | if (isUniformScale) { |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 661 | // this gives us a smooth step across approximately one fragment |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 662 | fsBuilder->codeAppend("\tafwidth = abs(" SK_DistanceFieldAAFactor "*dx);\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 663 | } else { |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 664 | fsBuilder->codeAppend("\tvec2 uv_grad;\n"); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 665 | if (args.fPB->ctxInfo().caps()->dropsTileOnZeroDivide()) { |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 666 | // this is to compensate for the Adreno, which likes to drop tiles on division by 0 |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 667 | fsBuilder->codeAppend("\tfloat uv_len2 = dot(uv, uv);\n"); |
| 668 | fsBuilder->codeAppend("\tif (uv_len2 < 0.0001) {\n"); |
| 669 | fsBuilder->codeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n"); |
| 670 | fsBuilder->codeAppend("\t} else {\n"); |
| 671 | fsBuilder->codeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n"); |
| 672 | fsBuilder->codeAppend("\t}\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 673 | } else { |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 674 | fsBuilder->codeAppend("\tuv_grad = normalize(uv);\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 675 | } |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 676 | fsBuilder->codeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n"); |
| 677 | fsBuilder->codeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 678 | |
| 679 | // this gives us a smooth step across approximately one fragment |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 680 | fsBuilder->codeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 681 | } |
| 682 | |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 683 | fsBuilder->codeAppend("\tvec4 val = vec4(smoothstep(vec3(-afwidth), vec3(afwidth), distance), 1.0);\n"); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 684 | |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 685 | // adjust based on gamma |
| 686 | const char* textColorUniName = NULL; |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 687 | fTextColorUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
bsalomon | 422f56f | 2014-12-09 10:18:12 -0800 | [diff] [blame] | 688 | kVec3f_GrSLType, kDefault_GrSLPrecision, |
| 689 | "TextColor", &textColorUniName); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 690 | |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 691 | fsBuilder->codeAppendf("\tuv = vec2(val.x, %s.x);\n", textColorUniName); |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 692 | fsBuilder->codeAppend("float gammaColor = "); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 693 | fsBuilder->appendTextureLookup(args.fSamplers[1], "uv", kVec2f_GrSLType); |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 694 | fsBuilder->codeAppend(".r;\n"); |
| 695 | fsBuilder->codeAppend("\tval.x = gammaColor;\n"); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 696 | |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 697 | fsBuilder->codeAppendf("\tuv = vec2(val.y, %s.y);\n", textColorUniName); |
| 698 | fsBuilder->codeAppend("\tgammaColor = "); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 699 | fsBuilder->appendTextureLookup(args.fSamplers[1], "uv", kVec2f_GrSLType); |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 700 | fsBuilder->codeAppend(".r;\n"); |
| 701 | fsBuilder->codeAppend("\tval.y = gammaColor;\n"); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 702 | |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 703 | fsBuilder->codeAppendf("\tuv = vec2(val.z, %s.z);\n", textColorUniName); |
| 704 | fsBuilder->codeAppend("\tgammaColor = "); |
joshualitt | c369e7c | 2014-10-22 10:56:26 -0700 | [diff] [blame] | 705 | fsBuilder->appendTextureLookup(args.fSamplers[1], "uv", kVec2f_GrSLType); |
jvanverth | fdf7ccc | 2015-01-27 08:19:33 -0800 | [diff] [blame] | 706 | fsBuilder->codeAppend(".r;\n"); |
| 707 | fsBuilder->codeAppend("\tval.z = gammaColor;\n"); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 708 | |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 709 | fsBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 710 | } |
| 711 | |
kkinnunen | 7510b22 | 2014-07-30 00:04:16 -0700 | [diff] [blame] | 712 | virtual void setData(const GrGLProgramDataManager& pdman, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 713 | const GrPrimitiveProcessor& processor, |
| 714 | const GrBatchTracker& bt) SK_OVERRIDE { |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 715 | SkASSERT(fTextColorUni.isValid()); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 716 | |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 717 | const GrDistanceFieldLCDTextureEffect& dfTexEffect = |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 718 | processor.cast<GrDistanceFieldLCDTextureEffect>(); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 719 | GrColor textColor = dfTexEffect.getTextColor(); |
| 720 | if (textColor != fTextColor) { |
| 721 | static const float ONE_OVER_255 = 1.f / 255.f; |
kkinnunen | 7510b22 | 2014-07-30 00:04:16 -0700 | [diff] [blame] | 722 | pdman.set3f(fTextColorUni, |
| 723 | GrColorUnpackR(textColor) * ONE_OVER_255, |
| 724 | GrColorUnpackG(textColor) * ONE_OVER_255, |
| 725 | GrColorUnpackB(textColor) * ONE_OVER_255); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 726 | fTextColor = textColor; |
| 727 | } |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 728 | |
joshualitt | ee2af95 | 2014-12-30 09:04:15 -0800 | [diff] [blame] | 729 | this->setUniformViewMatrix(pdman, processor.viewMatrix()); |
| 730 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 731 | const DistanceFieldLCDBatchTracker& local = bt.cast<DistanceFieldLCDBatchTracker>(); |
| 732 | if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) { |
| 733 | GrGLfloat c[4]; |
| 734 | GrColorToRGBAFloat(local.fColor, c); |
| 735 | pdman.set4fv(fColorUniform, 1, c); |
| 736 | fColor = local.fColor; |
| 737 | } |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 738 | } |
| 739 | |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 740 | static inline void GenKey(const GrGeometryProcessor& gp, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 741 | const GrBatchTracker& bt, |
joshualitt | 87f48d9 | 2014-12-04 10:41:40 -0800 | [diff] [blame] | 742 | const GrGLCaps&, |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 743 | GrProcessorKeyBuilder* b) { |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 744 | const GrDistanceFieldLCDTextureEffect& dfTexEffect = |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 745 | gp.cast<GrDistanceFieldLCDTextureEffect>(); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 746 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 747 | const DistanceFieldLCDBatchTracker& local = bt.cast<DistanceFieldLCDBatchTracker>(); |
joshualitt | 8fc6c2d | 2014-12-22 15:27:05 -0800 | [diff] [blame] | 748 | uint32_t key = dfTexEffect.getFlags(); |
| 749 | key |= local.fInputColorType << 16; |
robertphillips | 46d36f0 | 2015-01-18 08:14:14 -0800 | [diff] [blame] | 750 | key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 << 24: 0x0; |
| 751 | key |= ComputePosKey(gp.viewMatrix()) << 25; |
joshualitt | 8fc6c2d | 2014-12-22 15:27:05 -0800 | [diff] [blame] | 752 | b->add32(key); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 753 | } |
| 754 | |
| 755 | private: |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 756 | GrColor fColor; |
| 757 | UniformHandle fColorUniform; |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 758 | UniformHandle fTextColorUni; |
| 759 | SkColor fTextColor; |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 760 | |
joshualitt | 249af15 | 2014-09-15 11:41:13 -0700 | [diff] [blame] | 761 | typedef GrGLGeometryProcessor INHERITED; |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 762 | }; |
| 763 | |
| 764 | /////////////////////////////////////////////////////////////////////////////// |
| 765 | |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 766 | GrDistanceFieldLCDTextureEffect::GrDistanceFieldLCDTextureEffect( |
joshualitt | 8059eb9 | 2014-12-29 15:10:07 -0800 | [diff] [blame] | 767 | GrColor color, const SkMatrix& viewMatrix, |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 768 | GrTexture* texture, const GrTextureParams& params, |
| 769 | GrTexture* gamma, const GrTextureParams& gParams, |
| 770 | SkColor textColor, |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 771 | uint32_t flags) |
joshualitt | 8059eb9 | 2014-12-29 15:10:07 -0800 | [diff] [blame] | 772 | : INHERITED(color, viewMatrix, SkMatrix::I()) |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 773 | , fTextureAccess(texture, params) |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 774 | , fGammaTextureAccess(gamma, gParams) |
| 775 | , fTextColor(textColor) |
joshualitt | 2dd1ae0 | 2014-12-03 06:24:10 -0800 | [diff] [blame] | 776 | , fFlags(flags & kLCD_DistanceFieldEffectMask){ |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 777 | SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_DistanceFieldEffectFlag)); |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 778 | this->initClassID<GrDistanceFieldLCDTextureEffect>(); |
joshualitt | 71c9260 | 2015-01-14 08:12:47 -0800 | [diff] [blame] | 779 | fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType)); |
| 780 | fInTextureCoords = &this->addVertexAttrib(Attribute("inTextureCoords", |
jvanverth | 5a105ff | 2015-02-18 11:36:35 -0800 | [diff] [blame] | 781 | kVec2s_GrVertexAttribType)); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 782 | this->addTextureAccess(&fTextureAccess); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 783 | this->addTextureAccess(&fGammaTextureAccess); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 784 | } |
| 785 | |
bsalomon | 0e08fc1 | 2014-10-15 08:19:04 -0700 | [diff] [blame] | 786 | bool GrDistanceFieldLCDTextureEffect::onIsEqual(const GrGeometryProcessor& other) const { |
joshualitt | 49586be | 2014-09-16 08:21:41 -0700 | [diff] [blame] | 787 | const GrDistanceFieldLCDTextureEffect& cte = other.cast<GrDistanceFieldLCDTextureEffect>(); |
bsalomon | 420d7e9 | 2014-10-16 09:18:09 -0700 | [diff] [blame] | 788 | return (fTextColor == cte.fTextColor && |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 789 | fFlags == cte.fFlags); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 790 | } |
| 791 | |
joshualitt | 56995b5 | 2014-12-11 15:44:02 -0800 | [diff] [blame] | 792 | void GrDistanceFieldLCDTextureEffect::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const { |
| 793 | out->setUnknownFourComponents(); |
| 794 | out->setUsingLCDCoverage(); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 795 | } |
| 796 | |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 797 | void GrDistanceFieldLCDTextureEffect::getGLProcessorKey(const GrBatchTracker& bt, |
| 798 | const GrGLCaps& caps, |
| 799 | GrProcessorKeyBuilder* b) const { |
| 800 | GrGLDistanceFieldLCDTextureEffect::GenKey(*this, bt, caps, b); |
| 801 | } |
| 802 | |
joshualitt | abb52a1 | 2015-01-13 15:02:10 -0800 | [diff] [blame] | 803 | GrGLPrimitiveProcessor* |
| 804 | GrDistanceFieldLCDTextureEffect::createGLInstance(const GrBatchTracker& bt, |
| 805 | const GrGLCaps&) const { |
joshualitt | eb2a676 | 2014-12-04 11:35:33 -0800 | [diff] [blame] | 806 | return SkNEW_ARGS(GrGLDistanceFieldLCDTextureEffect, (*this, bt)); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 807 | } |
| 808 | |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 809 | void GrDistanceFieldLCDTextureEffect::initBatchTracker(GrBatchTracker* bt, |
joshualitt | 4d8da81 | 2015-01-28 12:53:54 -0800 | [diff] [blame] | 810 | const GrPipelineInfo& init) const { |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 811 | DistanceFieldLCDBatchTracker* local = bt->cast<DistanceFieldLCDBatchTracker>(); |
| 812 | local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false); |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 813 | local->fUsesLocalCoords = init.fUsesLocalCoords; |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 814 | } |
| 815 | |
| 816 | bool GrDistanceFieldLCDTextureEffect::onCanMakeEqual(const GrBatchTracker& m, |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 817 | const GrGeometryProcessor& that, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 818 | const GrBatchTracker& t) const { |
| 819 | const DistanceFieldLCDBatchTracker& mine = m.cast<DistanceFieldLCDBatchTracker>(); |
| 820 | const DistanceFieldLCDBatchTracker& theirs = t.cast<DistanceFieldLCDBatchTracker>(); |
joshualitt | 290c09b | 2014-12-19 13:45:20 -0800 | [diff] [blame] | 821 | return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords, |
| 822 | that, theirs.fUsesLocalCoords) && |
| 823 | CanCombineOutput(mine.fInputColorType, mine.fColor, |
joshualitt | 9b98932 | 2014-12-15 14:16:27 -0800 | [diff] [blame] | 824 | theirs.fInputColorType, theirs.fColor); |
| 825 | } |
| 826 | |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 827 | /////////////////////////////////////////////////////////////////////////////// |
| 828 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 829 | GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldLCDTextureEffect); |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 830 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 831 | GrGeometryProcessor* GrDistanceFieldLCDTextureEffect::TestCreate(SkRandom* random, |
| 832 | GrContext*, |
| 833 | const GrDrawTargetCaps&, |
| 834 | GrTexture* textures[]) { |
| 835 | int texIdx = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : |
| 836 | GrProcessorUnitTest::kAlphaTextureIdx; |
| 837 | int texIdx2 = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx : |
| 838 | GrProcessorUnitTest::kAlphaTextureIdx; |
commit-bot@chromium.org | 609ced4 | 2014-04-03 18:25:48 +0000 | [diff] [blame] | 839 | static const SkShader::TileMode kTileModes[] = { |
| 840 | SkShader::kClamp_TileMode, |
| 841 | SkShader::kRepeat_TileMode, |
| 842 | SkShader::kMirror_TileMode, |
| 843 | }; |
| 844 | SkShader::TileMode tileModes[] = { |
| 845 | kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], |
| 846 | kTileModes[random->nextULessThan(SK_ARRAY_COUNT(kTileModes))], |
| 847 | }; |
| 848 | GrTextureParams params(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode : |
| 849 | GrTextureParams::kNone_FilterMode); |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 850 | GrTextureParams params2(tileModes, random->nextBool() ? GrTextureParams::kBilerp_FilterMode : |
| 851 | GrTextureParams::kNone_FilterMode); |
| 852 | GrColor textColor = GrColorPackRGBA(random->nextULessThan(256), |
| 853 | random->nextULessThan(256), |
| 854 | random->nextULessThan(256), |
| 855 | random->nextULessThan(256)); |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 856 | uint32_t flags = kUseLCD_DistanceFieldEffectFlag; |
| 857 | flags |= random->nextBool() ? kUniformScale_DistanceFieldEffectMask : 0; |
| 858 | flags |= random->nextBool() ? kBGR_DistanceFieldEffectFlag : 0; |
joshualitt | 8059eb9 | 2014-12-29 15:10:07 -0800 | [diff] [blame] | 859 | return GrDistanceFieldLCDTextureEffect::Create(GrRandomColor(random), |
| 860 | GrProcessorUnitTest::TestMatrix(random), |
| 861 | textures[texIdx], params, |
jvanverth | 2d2a68c | 2014-06-10 06:42:56 -0700 | [diff] [blame] | 862 | textures[texIdx2], params2, |
| 863 | textColor, |
jvanverth | 78f0718 | 2014-07-30 06:17:59 -0700 | [diff] [blame] | 864 | flags); |
jvanverth@google.com | d830d13 | 2013-11-11 20:54:09 +0000 | [diff] [blame] | 865 | } |