diff options
Diffstat (limited to 'src/gpu/effects')
28 files changed, 175 insertions, 171 deletions
diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp index d45cd75cb8..50c47e8d78 100644 --- a/src/gpu/effects/GrBezierEffect.cpp +++ b/src/gpu/effects/GrBezierEffect.cpp @@ -146,7 +146,7 @@ void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { v.fsIn(), dklmdy.c_str(), v.fsIn(), dklmdy.c_str(), v.fsIn(), dklmdy.c_str()); - fragBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str()); + fragBuilder->codeAppendf("%s = float2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str()); fragBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", gFM.c_str(), gF.c_str(), gF.c_str()); fragBuilder->codeAppendf("%s = %s.x*%s.x - %s.y*%s.z;", @@ -175,7 +175,7 @@ void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { v.fsIn(), dklmdy.c_str(), v.fsIn(), dklmdy.c_str(), v.fsIn(), dklmdy.c_str()); - fragBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str()); + fragBuilder->codeAppendf("%s = float2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str()); fragBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", gFM.c_str(), gF.c_str(), gF.c_str()); fragBuilder->codeAppendf("%s = %s.x * %s.x - %s.y * %s.z;", @@ -207,10 +207,10 @@ void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { kHigh_GrSLPrecision, "Coverage", &coverageScale); - fragBuilder->codeAppendf("%s = vec4(%s * %s);", + fragBuilder->codeAppendf("%s = float4(%s * %s);", args.fOutputCoverage, coverageScale, edgeAlpha.c_str()); } else { - fragBuilder->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, edgeAlpha.c_str()); + fragBuilder->codeAppendf("%s = float4(%s);", args.fOutputCoverage, edgeAlpha.c_str()); } } @@ -367,9 +367,9 @@ void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { switch (fEdgeType) { case kHairlineAA_GrProcessorEdgeType: { - fragBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn()); - fragBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", v.fsIn()); - fragBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.y," + fragBuilder->codeAppendf("float2 duvdx = dFdx(%s.xy);", v.fsIn()); + fragBuilder->codeAppendf("float2 duvdy = dFdy(%s.xy);", v.fsIn()); + fragBuilder->codeAppendf("float2 gF = float2(2.0 * %s.x * duvdx.x - duvdx.y," " 2.0 * %s.x * duvdy.x - duvdy.y);", v.fsIn(), v.fsIn()); fragBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", @@ -381,9 +381,9 @@ void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { break; } case kFillAA_GrProcessorEdgeType: { - fragBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn()); - fragBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", v.fsIn()); - fragBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.y," + fragBuilder->codeAppendf("float2 duvdx = dFdx(%s.xy);", v.fsIn()); + fragBuilder->codeAppendf("float2 duvdy = dFdy(%s.xy);", v.fsIn()); + fragBuilder->codeAppendf("float2 gF = float2(2.0 * %s.x * duvdx.x - duvdx.y," " 2.0 * %s.x * duvdy.x - duvdy.y);", v.fsIn(), v.fsIn()); fragBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", @@ -411,9 +411,9 @@ void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { kDefault_GrSLPrecision, "Coverage", &coverageScale); - fragBuilder->codeAppendf("%s = vec4(%s * edgeAlpha);", args.fOutputCoverage, coverageScale); + fragBuilder->codeAppendf("%s = float4(%s * edgeAlpha);", args.fOutputCoverage, coverageScale); } else { - fragBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage); + fragBuilder->codeAppendf("%s = float4(edgeAlpha);", args.fOutputCoverage); } } @@ -565,7 +565,7 @@ void GrGLCubicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { kHigh_GrSLPrecision, "KLM", &devkLMMatrixName); GrGLSLVertToFrag v(kVec3f_GrSLType); varyingHandler->addVarying("CubicCoeffs", &v, kHigh_GrSLPrecision); - vertBuilder->codeAppendf("%s = %s * vec3(%s, 1);", + vertBuilder->codeAppendf("%s = %s * float3(%s, 1);", v.vsOut(), devkLMMatrixName, gpArgs->fPositionVar.c_str()); @@ -574,12 +574,12 @@ void GrGLCubicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { varyingHandler->addVarying("GradCoeffs", &gradCoeffs, kHigh_GrSLPrecision); vertBuilder->codeAppendf("highp float k = %s[0], l = %s[1], m = %s[2];", v.vsOut(), v.vsOut(), v.vsOut()); - vertBuilder->codeAppendf("highp vec2 gk = vec2(%s[0][0], %s[1][0]), " - "gl = vec2(%s[0][1], %s[1][1]), " - "gm = vec2(%s[0][2], %s[1][2]);", + vertBuilder->codeAppendf("highp float2 gk = float2(%s[0][0], %s[1][0]), " + "gl = float2(%s[0][1], %s[1][1]), " + "gm = float2(%s[0][2], %s[1][2]);", devkLMMatrixName, devkLMMatrixName, devkLMMatrixName, devkLMMatrixName, devkLMMatrixName, devkLMMatrixName); - vertBuilder->codeAppendf("%s = vec4(3 * k * gk, -m * gl - l * gm);", + vertBuilder->codeAppendf("%s = float4(3 * k * gk, -m * gl - l * gm);", gradCoeffs.vsOut()); } @@ -646,7 +646,7 @@ void GrGLCubicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { } - fragBuilder->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, edgeAlpha.c_str()); + fragBuilder->codeAppendf("%s = float4(%s);", args.fOutputCoverage, edgeAlpha.c_str()); } void GrGLCubicEffect::GenKey(const GrGeometryProcessor& gp, diff --git a/src/gpu/effects/GrBicubicEffect.cpp b/src/gpu/effects/GrBicubicEffect.cpp index 4095f93e7a..28fcd9e1dc 100644 --- a/src/gpu/effects/GrBicubicEffect.cpp +++ b/src/gpu/effects/GrBicubicEffect.cpp @@ -71,26 +71,26 @@ void GrGLBicubicEffect::emitCode(EmitArgs& args) { * * This is GLSL, so the matrix is column-major (transposed from standard matrix notation). */ - fragBuilder->codeAppend("mat4 kMitchellCoefficients = mat4(" + fragBuilder->codeAppend("float4x4 kMitchellCoefficients = float4x4(" " 1.0 / 18.0, 16.0 / 18.0, 1.0 / 18.0, 0.0 / 18.0," "-9.0 / 18.0, 0.0 / 18.0, 9.0 / 18.0, 0.0 / 18.0," "15.0 / 18.0, -36.0 / 18.0, 27.0 / 18.0, -6.0 / 18.0," "-7.0 / 18.0, 21.0 / 18.0, -21.0 / 18.0, 7.0 / 18.0);"); - fragBuilder->codeAppendf("vec2 coord = %s - %s * vec2(0.5);", coords2D.c_str(), imgInc); + fragBuilder->codeAppendf("float2 coord = %s - %s * float2(0.5);", coords2D.c_str(), imgInc); // We unnormalize the coord in order to determine our fractional offset (f) within the texel // We then snap coord to a texel center and renormalize. The snap prevents cases where the // starting coords are near a texel boundary and accumulations of imgInc would cause us to skip/ // double hit a texel. fragBuilder->codeAppendf("coord /= %s;", imgInc); - fragBuilder->codeAppend("vec2 f = fract(coord);"); - fragBuilder->codeAppendf("coord = (coord - f + vec2(0.5)) * %s;", imgInc); - fragBuilder->codeAppend("vec4 wx = kMitchellCoefficients * vec4(1.0, f.x, f.x * f.x, f.x * f.x * f.x);"); - fragBuilder->codeAppend("vec4 wy = kMitchellCoefficients * vec4(1.0, f.y, f.y * f.y, f.y * f.y * f.y);"); - fragBuilder->codeAppend("vec4 rowColors[4];"); + fragBuilder->codeAppend("float2 f = fract(coord);"); + fragBuilder->codeAppendf("coord = (coord - f + float2(0.5)) * %s;", imgInc); + fragBuilder->codeAppend("float4 wx = kMitchellCoefficients * float4(1.0, f.x, f.x * f.x, f.x * f.x * f.x);"); + fragBuilder->codeAppend("float4 wy = kMitchellCoefficients * float4(1.0, f.y, f.y * f.y, f.y * f.y * f.y);"); + fragBuilder->codeAppend("float4 rowColors[4];"); for (int y = 0; y < 4; ++y) { for (int x = 0; x < 4; ++x) { SkString coord; - coord.printf("coord + %s * vec2(%d, %d)", imgInc, x - 1, y - 1); + coord.printf("coord + %s * float2(%d, %d)", imgInc, x - 1, y - 1); SkString sampleVar; sampleVar.printf("rowColors[%d]", x); fDomain.sampleTexture(fragBuilder, @@ -102,7 +102,7 @@ void GrGLBicubicEffect::emitCode(EmitArgs& args) { args.fTexSamplers[0]); } fragBuilder->codeAppendf( - "vec4 s%d = wx.x * rowColors[0] + wx.y * rowColors[1] + wx.z * rowColors[2] + wx.w * rowColors[3];", + "float4 s%d = wx.x * rowColors[0] + wx.y * rowColors[1] + wx.z * rowColors[2] + wx.w * rowColors[3];", y); } SkString bicubicColor("(wy.x * s0 + wy.y * s1 + wy.z * s2 + wy.w * s3)"); diff --git a/src/gpu/effects/GrBitmapTextGeoProc.cpp b/src/gpu/effects/GrBitmapTextGeoProc.cpp index 9de3b463c4..151c529ef8 100644 --- a/src/gpu/effects/GrBitmapTextGeoProc.cpp +++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp @@ -67,7 +67,7 @@ public: v.fsIn(), kVec2f_GrSLType); fragBuilder->codeAppend(";"); - fragBuilder->codeAppendf("%s = vec4(1);", args.fOutputCoverage); + fragBuilder->codeAppendf("%s = float4(1);", args.fOutputCoverage); } else { fragBuilder->codeAppendf("%s = ", args.fOutputCoverage); fragBuilder->appendTextureLookup(args.fTexSamplers[0], v.fsIn(), kVec2f_GrSLType); diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp index aa39d95a79..f63422ffcd 100644 --- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp +++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp @@ -28,8 +28,9 @@ public: "float factor = 1.0 - %s.w;\n@switch (%d) {\n case 0:\n factor = " "exp((-factor * factor) * 4.0) - 0.017999999999999999;\n break;\n case " "1:\n factor = smoothstep(1.0, 0.0, factor);\n break;\n}\n%s = " - "vec4(factor);\n", - args.fInputColor ? args.fInputColor : "vec4(1)", _outer.mode(), args.fOutputColor); + "float4(factor);\n", + args.fInputColor ? args.fInputColor : "float4(1)", _outer.mode(), + args.fOutputColor); } private: diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.fp b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.fp index 2c4d5ef582..3ff233a705 100644 --- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.fp +++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.fp @@ -24,5 +24,5 @@ void main() { factor = smoothstep(1.0, 0.0, factor); break; } - sk_OutColor = vec4(factor); + sk_OutColor = float4(factor); } diff --git a/src/gpu/effects/GrCircleEffect.cpp b/src/gpu/effects/GrCircleEffect.cpp index 638d94d357..97bfda4dbb 100644 --- a/src/gpu/effects/GrCircleEffect.cpp +++ b/src/gpu/effects/GrCircleEffect.cpp @@ -27,11 +27,11 @@ public: fCircleVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType, kDefault_GrSLPrecision, "circle"); fragBuilder->codeAppendf( - "vec2 prevCenter;\nfloat prevRadius = %f;\nfloat d;\n@if (%d == 2 || %d == 3) {\n " - " d = (length((%s.xy - sk_FragCoord.xy) * %s.w) - 1.0) * %s.z;\n} else {\n d = " - "(1.0 - length((%s.xy - sk_FragCoord.xy) * %s.w)) * %s.z;\n}\n@if ((%d == 1 || %d " - "== 3) || %d == 4) {\n d = clamp(d, 0.0, 1.0);\n} else {\n d = d > 0.5 ? 1.0 " - ": 0.0;\n}\n%s = %s * d;\n", + "float2 prevCenter;\nfloat prevRadius = %f;\nfloat d;\n@if (%d == 2 || %d == 3) " + "{\n d = (length((%s.xy - sk_FragCoord.xy) * %s.w) - 1.0) * %s.z;\n} else {\n " + " d = (1.0 - length((%s.xy - sk_FragCoord.xy) * %s.w)) * %s.z;\n}\n@if ((%d == 1 " + "|| %d == 3) || %d == 4) {\n d = clamp(d, 0.0, 1.0);\n} else {\n d = d > 0.5 " + "? 1.0 : 0.0;\n}\n%s = %s * d;\n", prevRadius, _outer.edgeType(), _outer.edgeType(), args.fUniformHandler->getUniformCStr(fCircleVar), args.fUniformHandler->getUniformCStr(fCircleVar), @@ -40,7 +40,7 @@ public: args.fUniformHandler->getUniformCStr(fCircleVar), args.fUniformHandler->getUniformCStr(fCircleVar), _outer.edgeType(), _outer.edgeType(), _outer.edgeType(), args.fOutputColor, - args.fInputColor ? args.fInputColor : "vec4(1)"); + args.fInputColor ? args.fInputColor : "float4(1)"); } private: diff --git a/src/gpu/effects/GrCircleEffect.fp b/src/gpu/effects/GrCircleEffect.fp index 74973ca064..884112ecc9 100644 --- a/src/gpu/effects/GrCircleEffect.fp +++ b/src/gpu/effects/GrCircleEffect.fp @@ -6,14 +6,14 @@ */ layout(key) in int edgeType; -in vec2 center; +in float2 center; in float radius; -vec2 prevCenter; +float2 prevCenter; float prevRadius = -1; // The circle uniform is (center.x, center.y, radius + 0.5, 1 / (radius + 0.5)) for regular // fills and (..., radius - 0.5, 1 / (radius - 0.5)) for inverse fills. -uniform vec4 circle; +uniform float4 circle; @optimizationFlags { kCompatibleWithCoverageAsAlpha_OptimizationFlag } diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp index d83e82d8d9..880648199e 100644 --- a/src/gpu/effects/GrConfigConversionEffect.cpp +++ b/src/gpu/effects/GrConfigConversionEffect.cpp @@ -25,12 +25,12 @@ public: if (nullptr == args.fInputColor) { // could optimize this case, but we aren't for now. - args.fInputColor = "vec4(1)"; + args.fInputColor = "float4(1)"; } // Aggressively round to the nearest exact (N / 255) floating point value. This lets us // find a round-trip preserving pair on some GPUs that do odd byte to float conversion. - fragBuilder->codeAppendf("vec4 color = floor(%s * 255.0 + 0.5) / 255.0;", args.fInputColor); + fragBuilder->codeAppendf("float4 color = floor(%s * 255.0 + 0.5) / 255.0;", args.fInputColor); switch (cce.pmConversion()) { case GrConfigConversionEffect::kToPremul_PMConversion: @@ -40,7 +40,7 @@ public: case GrConfigConversionEffect::kToUnpremul_PMConversion: fragBuilder->codeAppend( - "color.rgb = color.a <= 0.0 ? vec3(0,0,0) : floor(color.rgb / color.a * 255.0 + 0.5) / 255.0;"); + "color.rgb = color.a <= 0.0 ? float3(0,0,0) : floor(color.rgb / color.a * 255.0 + 0.5) / 255.0;"); break; default: diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp index 7dba3de04d..bb61cc1f20 100644 --- a/src/gpu/effects/GrConvexPolyEffect.cpp +++ b/src/gpu/effects/GrConvexPolyEffect.cpp @@ -199,7 +199,7 @@ void GrGLConvexPolyEffect::emitCode(EmitArgs& args) { fragBuilder->codeAppend("\t\tfloat alpha = 1.0;\n"); fragBuilder->codeAppend("\t\tfloat edge;\n"); for (int i = 0; i < cpe.getEdgeCount(); ++i) { - fragBuilder->codeAppendf("\t\tedge = dot(%s[%d], vec3(sk_FragCoord.x, sk_FragCoord.y, " + fragBuilder->codeAppendf("\t\tedge = dot(%s[%d], float3(sk_FragCoord.x, sk_FragCoord.y, " "1));\n", edgeArrayName, i); if (GrProcessorEdgeTypeIsAA(cpe.getEdgeType())) { diff --git a/src/gpu/effects/GrDisableColorXP.cpp b/src/gpu/effects/GrDisableColorXP.cpp index 14464f78e3..2d66e1e1b6 100644 --- a/src/gpu/effects/GrDisableColorXP.cpp +++ b/src/gpu/effects/GrDisableColorXP.cpp @@ -53,7 +53,7 @@ private: // you do not give gl_FragColor a value, the gl context is lost and we end up drawing // nothing. So this fix just sets the gl_FragColor arbitrarily to 0. GrGLSLXPFragmentBuilder* fragBuilder = args.fXPFragBuilder; - fragBuilder->codeAppendf("%s = vec4(0);", args.fOutputPrimary); + fragBuilder->codeAppendf("%s = float4(0);", args.fOutputPrimary); } void onSetData(const GrGLSLProgramDataManager&, const GrXferProcessor&) override {} diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.cpp b/src/gpu/effects/GrDistanceFieldGeoProc.cpp index c8dd4ebd77..0dfb315960 100644 --- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp +++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp @@ -89,12 +89,12 @@ public: GrGLSLVertToFrag st(kVec2f_GrSLType); varyingHandler->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision); - vertBuilder->codeAppendf("%s = vec2(%d, %d) * %s;", st.vsOut(), + vertBuilder->codeAppendf("%s = float2(%d, %d) * %s;", st.vsOut(), atlas->width(), atlas->height(), dfTexEffect.inTextureCoords()->fName); // Use highp to work around aliasing issues - fragBuilder->codeAppendf("highp vec2 uv = %s;\n", uv.fsIn()); + fragBuilder->codeAppendf("highp float2 uv = %s;\n", uv.fsIn()); fragBuilder->codeAppend("\tfloat texColor = "); fragBuilder->appendTextureLookup(args.fTexSamplers[0], @@ -141,19 +141,19 @@ public: // For general transforms, to determine the amount of correction we multiply a unit // vector pointing along the SDF gradient direction by the Jacobian of the st coords // (which is the inverse transform for this fragment) and take the length of the result. - fragBuilder->codeAppend("vec2 dist_grad = vec2(dFdx(distance), dFdy(distance));"); + fragBuilder->codeAppend("float2 dist_grad = float2(dFdx(distance), dFdy(distance));"); // the length of the gradient may be 0, so we need to check for this // this also compensates for the Adreno, which likes to drop tiles on division by 0 fragBuilder->codeAppend("float dg_len2 = dot(dist_grad, dist_grad);"); fragBuilder->codeAppend("if (dg_len2 < 0.0001) {"); - fragBuilder->codeAppend("dist_grad = vec2(0.7071, 0.7071);"); + fragBuilder->codeAppend("dist_grad = float2(0.7071, 0.7071);"); fragBuilder->codeAppend("} else {"); fragBuilder->codeAppend("dist_grad = dist_grad*inversesqrt(dg_len2);"); fragBuilder->codeAppend("}"); - fragBuilder->codeAppendf("vec2 Jdx = dFdx(%s);", st.fsIn()); - fragBuilder->codeAppendf("vec2 Jdy = dFdy(%s);", st.fsIn()); - fragBuilder->codeAppend("vec2 grad = vec2(dist_grad.x*Jdx.x + dist_grad.y*Jdy.x,"); + fragBuilder->codeAppendf("float2 Jdx = dFdx(%s);", st.fsIn()); + fragBuilder->codeAppendf("float2 Jdy = dFdy(%s);", st.fsIn()); + fragBuilder->codeAppend("float2 grad = float2(dist_grad.x*Jdx.x + dist_grad.y*Jdy.x,"); fragBuilder->codeAppend(" dist_grad.x*Jdx.y + dist_grad.y*Jdy.y);"); // this gives us a smooth step across approximately one fragment @@ -172,7 +172,7 @@ public: fragBuilder->codeAppend("float val = smoothstep(-afwidth, afwidth, distance);"); } - fragBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage); + fragBuilder->codeAppendf("%s = float4(val);", args.fOutputCoverage); } void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& proc, @@ -352,7 +352,7 @@ public: "TextureSize", &textureSizeUniName); // Use highp to work around aliasing issues - fragBuilder->codeAppendf("highp vec2 uv = %s;", v.fsIn()); + fragBuilder->codeAppendf("highp float2 uv = %s;", v.fsIn()); fragBuilder->codeAppend("float texColor = "); fragBuilder->appendTextureLookup(args.fTexSamplers[0], @@ -362,7 +362,7 @@ public: fragBuilder->codeAppend("float distance = " SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");"); - fragBuilder->codeAppendf("highp vec2 st = uv*%s;", textureSizeUniName); + fragBuilder->codeAppendf("highp float2 st = uv*%s;", textureSizeUniName); fragBuilder->codeAppend("float afwidth;"); bool isUniformScale = (dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask) == kUniformScale_DistanceFieldEffectMask; @@ -398,19 +398,19 @@ public: // For general transforms, to determine the amount of correction we multiply a unit // vector pointing along the SDF gradient direction by the Jacobian of the st coords // (which is the inverse transform for this fragment) and take the length of the result. - fragBuilder->codeAppend("vec2 dist_grad = vec2(dFdx(distance), dFdy(distance));"); + fragBuilder->codeAppend("float2 dist_grad = float2(dFdx(distance), dFdy(distance));"); // the length of the gradient may be 0, so we need to check for this // this also compensates for the Adreno, which likes to drop tiles on division by 0 fragBuilder->codeAppend("float dg_len2 = dot(dist_grad, dist_grad);"); fragBuilder->codeAppend("if (dg_len2 < 0.0001) {"); - fragBuilder->codeAppend("dist_grad = vec2(0.7071, 0.7071);"); + fragBuilder->codeAppend("dist_grad = float2(0.7071, 0.7071);"); fragBuilder->codeAppend("} else {"); fragBuilder->codeAppend("dist_grad = dist_grad*inversesqrt(dg_len2);"); fragBuilder->codeAppend("}"); - fragBuilder->codeAppend("vec2 Jdx = dFdx(st);"); - fragBuilder->codeAppend("vec2 Jdy = dFdy(st);"); - fragBuilder->codeAppend("vec2 grad = vec2(dist_grad.x*Jdx.x + dist_grad.y*Jdy.x,"); + fragBuilder->codeAppend("float2 Jdx = dFdx(st);"); + fragBuilder->codeAppend("float2 Jdy = dFdy(st);"); + fragBuilder->codeAppend("float2 grad = float2(dist_grad.x*Jdx.x + dist_grad.y*Jdy.x,"); fragBuilder->codeAppend(" dist_grad.x*Jdx.y + dist_grad.y*Jdy.y);"); // this gives us a smooth step across approximately one fragment @@ -426,7 +426,7 @@ public: fragBuilder->codeAppend("float val = smoothstep(-afwidth, afwidth, distance);"); } - fragBuilder->codeAppendf("%s = vec4(val);", args.fOutputCoverage); + fragBuilder->codeAppendf("%s = float4(val);", args.fOutputCoverage); } void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& proc, @@ -601,7 +601,7 @@ public: GrGLSLVertToFrag st(kVec2f_GrSLType); varyingHandler->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision); - vertBuilder->codeAppendf("%s = vec2(%d, %d) * %s;", st.vsOut(), + vertBuilder->codeAppendf("%s = float2(%d, %d) * %s;", st.vsOut(), atlas->width(), atlas->height(), dfTexEffect.inTextureCoords()->fName); @@ -609,7 +609,7 @@ public: // create LCD offset adjusted by inverse of transform // Use highp to work around aliasing issues - fragBuilder->codeAppendf("highp vec2 uv = %s;\n", uv.fsIn()); + fragBuilder->codeAppendf("highp float2 uv = %s;\n", uv.fsIn()); SkScalar lcdDelta = 1.0f / (3.0f * atlas->width()); if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) { @@ -624,36 +624,36 @@ public: // We use the y gradient because there is a bug in the Mali 400 in the x direction. fragBuilder->codeAppendf("float st_grad_len = abs(dFdy(%s.y));", st.fsIn()); #endif - fragBuilder->codeAppend("vec2 offset = vec2(st_grad_len*delta, 0.0);"); + fragBuilder->codeAppend("float2 offset = float2(st_grad_len*delta, 0.0);"); } else if (isSimilarity) { // For a similarity matrix with rotation, the gradient will not be aligned // with the texel coordinate axes, so we need to calculate it. #ifdef SK_VULKAN - fragBuilder->codeAppendf("vec2 st_grad = dFdx(%s);", st.fsIn()); - fragBuilder->codeAppend("vec2 offset = delta*st_grad;"); + fragBuilder->codeAppendf("float2 st_grad = dFdx(%s);", st.fsIn()); + fragBuilder->codeAppend("float2 offset = delta*st_grad;"); #else // We use dFdy because of a Mali 400 bug, and rotate -90 degrees to // get the gradient in the x direction. - fragBuilder->codeAppendf("vec2 st_grad = dFdy(%s);", st.fsIn()); - fragBuilder->codeAppend("vec2 offset = delta*vec2(st_grad.y, -st_grad.x);"); + fragBuilder->codeAppendf("float2 st_grad = dFdy(%s);", st.fsIn()); + fragBuilder->codeAppend("float2 offset = delta*float2(st_grad.y, -st_grad.x);"); #endif fragBuilder->codeAppend("float st_grad_len = length(st_grad);"); } else { - fragBuilder->codeAppendf("vec2 st = %s;\n", st.fsIn()); + fragBuilder->codeAppendf("float2 st = %s;\n", st.fsIn()); - fragBuilder->codeAppend("vec2 Jdx = dFdx(st);"); - fragBuilder->codeAppend("vec2 Jdy = dFdy(st);"); - fragBuilder->codeAppend("vec2 offset = delta*Jdx;"); + fragBuilder->codeAppend("float2 Jdx = dFdx(st);"); + fragBuilder->codeAppend("float2 Jdy = dFdy(st);"); + fragBuilder->codeAppend("float2 offset = delta*Jdx;"); } // green is distance to uv center - fragBuilder->codeAppend("\tvec4 texColor = "); + fragBuilder->codeAppend("\tfloat4 texColor = "); fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv", kVec2f_GrSLType); fragBuilder->codeAppend(";\n"); - fragBuilder->codeAppend("\tvec3 distance;\n"); + fragBuilder->codeAppend("\tfloat3 distance;\n"); fragBuilder->codeAppend("\tdistance.y = texColor.r;\n"); // red is distance to left offset - fragBuilder->codeAppend("\tvec2 uv_adjusted = uv - offset;\n"); + fragBuilder->codeAppend("\tfloat2 uv_adjusted = uv - offset;\n"); fragBuilder->codeAppend("\ttexColor = "); fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv_adjusted", kVec2f_GrSLType); fragBuilder->codeAppend(";\n"); @@ -666,7 +666,7 @@ public: fragBuilder->codeAppend("\tdistance.z = texColor.r;\n"); fragBuilder->codeAppend("\tdistance = " - "vec3(" SK_DistanceFieldMultiplier ")*(distance - vec3(" SK_DistanceFieldThreshold"));"); + "float3(" SK_DistanceFieldMultiplier ")*(distance - float3(" SK_DistanceFieldThreshold"));"); // adjust width based on gamma const char* distanceAdjustUniName = nullptr; @@ -692,16 +692,16 @@ public: // For general transforms, to determine the amount of correction we multiply a unit // vector pointing along the SDF gradient direction by the Jacobian of the st coords // (which is the inverse transform for this fragment) and take the length of the result. - fragBuilder->codeAppend("vec2 dist_grad = vec2(dFdx(distance.r), dFdy(distance.r));"); + fragBuilder->codeAppend("float2 dist_grad = float2(dFdx(distance.r), dFdy(distance.r));"); // the length of the gradient may be 0, so we need to check for this // this also compensates for the Adreno, which likes to drop tiles on division by 0 fragBuilder->codeAppend("float dg_len2 = dot(dist_grad, dist_grad);"); fragBuilder->codeAppend("if (dg_len2 < 0.0001) {"); - fragBuilder->codeAppend("dist_grad = vec2(0.7071, 0.7071);"); + fragBuilder->codeAppend("dist_grad = float2(0.7071, 0.7071);"); fragBuilder->codeAppend("} else {"); fragBuilder->codeAppend("dist_grad = dist_grad*inversesqrt(dg_len2);"); fragBuilder->codeAppend("}"); - fragBuilder->codeAppend("vec2 grad = vec2(dist_grad.x*Jdx.x + dist_grad.y*Jdy.x,"); + fragBuilder->codeAppend("float2 grad = float2(dist_grad.x*Jdx.x + dist_grad.y*Jdy.x,"); fragBuilder->codeAppend(" dist_grad.x*Jdx.y + dist_grad.y*Jdy.y);"); // this gives us a smooth step across approximately one fragment @@ -713,11 +713,11 @@ public: // mapped linearly to coverage, so use a linear step: if (isGammaCorrect) { fragBuilder->codeAppendf("%s = " - "vec4(clamp((distance + vec3(afwidth)) / vec3(2.0 * afwidth), 0.0, 1.0), 1.0);", + "float4(clamp((distance + float3(afwidth)) / float3(2.0 * afwidth), 0.0, 1.0), 1.0);", args.fOutputCoverage); } else { fragBuilder->codeAppendf( - "%s = vec4(smoothstep(vec3(-afwidth), vec3(afwidth), distance), 1.0);", + "%s = float4(smoothstep(float3(-afwidth), float3(afwidth), distance), 1.0);", args.fOutputCoverage); } } diff --git a/src/gpu/effects/GrDitherEffect.cpp b/src/gpu/effects/GrDitherEffect.cpp index 73ab1812a9..38e4c77564 100644 --- a/src/gpu/effects/GrDitherEffect.cpp +++ b/src/gpu/effects/GrDitherEffect.cpp @@ -31,13 +31,13 @@ public: "int x = int(sk_FragCoord.x);\n int y = int(sk_FragCoord.y);\n uint m = " "uint((((((y & 1) << 5 | (x & 1) << 4) | (y & 2) << 2) | (x & 2) << 1) | (y & 4) " ">> 1) | (x & 4) >> 2);\n value = float(m) / 64.0 - 0.4921875;\n} else {\n " - "value = fract(sin(dot(sk_FragCoord.xy, vec2(12.989800000000001, " - "78.233000000000004))) * 43758.545299999998) - 0.5;\n}\n%s = vec4(clamp(%s.xyz + " + "value = fract(sin(dot(sk_FragCoord.xy, float2(12.989800000000001, " + "78.233000000000004))) * 43758.545299999998) - 0.5;\n}\n%s = float4(clamp(%s.xyz + " "value * range, 0.0, %s.w), %s.w);\n", _outer.rangeType(), args.fOutputColor, - args.fInputColor ? args.fInputColor : "vec4(1)", - args.fInputColor ? args.fInputColor : "vec4(1)", - args.fInputColor ? args.fInputColor : "vec4(1)"); + args.fInputColor ? args.fInputColor : "float4(1)", + args.fInputColor ? args.fInputColor : "float4(1)", + args.fInputColor ? args.fInputColor : "float4(1)"); } private: diff --git a/src/gpu/effects/GrDitherEffect.fp b/src/gpu/effects/GrDitherEffect.fp index 937efae264..f983702f2b 100644 --- a/src/gpu/effects/GrDitherEffect.fp +++ b/src/gpu/effects/GrDitherEffect.fp @@ -61,11 +61,11 @@ void main() { // the assumption that sin(<big number>) oscillates with high frequency // and sampling it will generate "randomness". Since we're using this // for rendering and not cryptography it should be OK. - value = fract(sin(dot(sk_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453) - .5; + value = fract(sin(dot(sk_FragCoord.xy, float2(12.9898, 78.233))) * 43758.5453) - .5; } // For each color channel, add the random offset to the channel value and then clamp // between 0 and alpha to keep the color premultiplied. - sk_OutColor = vec4(clamp(sk_InColor.rgb + value * range, 0, sk_InColor.a), sk_InColor.a); + sk_OutColor = float4(clamp(sk_InColor.rgb + value * range, 0, sk_InColor.a), sk_InColor.a); } @test(testData) { diff --git a/src/gpu/effects/GrEllipseEffect.cpp b/src/gpu/effects/GrEllipseEffect.cpp index 020c34e644..ebc3bf7e37 100644 --- a/src/gpu/effects/GrEllipseEffect.cpp +++ b/src/gpu/effects/GrEllipseEffect.cpp @@ -23,7 +23,7 @@ public: GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; const GrEllipseEffect& _outer = args.fFp.cast<GrEllipseEffect>(); (void)_outer; - prevRadii = vec2(-1.0); + prevRadii = float2(-1.0); useScale = sk_Caps.floatPrecisionVaries; fEllipseVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType, kHigh_GrSLPrecision, "ellipse"); @@ -32,23 +32,26 @@ public: kDefault_GrSLPrecision, "scale"); } fragBuilder->codeAppendf( - "vec2 prevCenter;\nvec2 prevRadii = vec2(%f, %f);\nbool useScale = %s;\nvec2 d = " - "sk_FragCoord.xy - %s.xy;\n@if (useScale) {\n d *= %s.y;\n}\nvec2 Z = d * " - "%s.zw;\nfloat implicit = dot(Z, d) - 1.0;\nfloat grad_dot = 4.0 * dot(Z, " - "Z);\ngrad_dot = max(grad_dot, 0.0001);\nfloat approx_dist = implicit * " - "inversesqrt(grad_dot);\n@if (useScale) {\n approx_dist *= %s.x;\n}\nfloat " - "alpha;\n@switch (%d) {\n case 0:\n alpha = approx_dist > 0.0 ? 0.0 : " - "1.0;\n break;\n case 1:\n alpha = clamp(0.5 - approx_dist, 0.0, " - "1.0);\n break;\n case 2:\n alpha = approx_dist > 0.0 ? 1.0 : " - "0.0;\n break;\n case 3:\n alpha = clamp(0.5 + approx_dist, 0.0, " - "1.0);\n break;\n default:\n discard;\n}\n%s = %s * alpha;\n", + "float2 prevCenter;\nfloat2 prevRadii = float2(%f, %f);\nbool useScale = " + "%s;\nfloat2 d = sk_FragCoord.xy - %s.xy;\n@if (useScale) {\n d *= " + "%s.y;\n}\nfloat2 Z = d * %s.zw;\nfloat implicit = dot(Z, d) - 1.0;\nfloat " + "grad_dot = 4.0 * dot(Z, Z);\ngrad_dot = max(grad_dot, 0.0001);\nfloat approx_dist " + "= implicit * inversesqrt(grad_dot);\n@if (useScale) {\n approx_dist *= " + "%s.x;\n}\nfloat alpha;\n@switch (%d) {\n case 0:\n alpha = approx_dist " + "> 0.0 ? 0.0 : 1.0;\n break;\n case 1:\n alpha = clamp(0.5 - " + "approx_dist, 0.0, 1.0);\n break;\n case 2:\n alpha = approx_dist " + "> 0.0 ? 1.0 : 0.0;\n break;\n case 3:\n alpha = clamp(0.5 + " + "approx_dist, 0.0, 1.0);\n break;\n default:\n discard;\n}\n%s = " + "%s * alpha;\n", prevRadii.fX, prevRadii.fY, (useScale ? "true" : "false"), args.fUniformHandler->getUniformCStr(fEllipseVar), - fScaleVar.isValid() ? args.fUniformHandler->getUniformCStr(fScaleVar) : "vec2(0.0)", + fScaleVar.isValid() ? args.fUniformHandler->getUniformCStr(fScaleVar) + : "float2(0.0)", args.fUniformHandler->getUniformCStr(fEllipseVar), - fScaleVar.isValid() ? args.fUniformHandler->getUniformCStr(fScaleVar) : "vec2(0.0)", + fScaleVar.isValid() ? args.fUniformHandler->getUniformCStr(fScaleVar) + : "float2(0.0)", _outer.edgeType(), args.fOutputColor, - args.fInputColor ? args.fInputColor : "vec4(1)"); + args.fInputColor ? args.fInputColor : "float4(1)"); } private: diff --git a/src/gpu/effects/GrEllipseEffect.fp b/src/gpu/effects/GrEllipseEffect.fp index 7bf32206fb..85c4c96f75 100644 --- a/src/gpu/effects/GrEllipseEffect.fp +++ b/src/gpu/effects/GrEllipseEffect.fp @@ -6,17 +6,17 @@ */ layout(key) in int edgeType; -in vec2 center; -in vec2 radii; +in float2 center; +in float2 radii; -vec2 prevCenter; -vec2 prevRadii = vec2(-1); +float2 prevCenter; +float2 prevRadii = float2(-1); // The ellipse uniform is (center.x, center.y, 1 / rx^2, 1 / ry^2) // The last two terms can underflow on mediump, so we use highp. -uniform highp vec4 ellipse; +uniform highp float4 ellipse; bool useScale = sk_Caps.floatPrecisionVaries; -layout(when=useScale) uniform vec2 scale; +layout(when=useScale) uniform float2 scale; @optimizationFlags { kCompatibleWithCoverageAsAlpha_OptimizationFlag } @@ -50,7 +50,7 @@ layout(when=useScale) uniform vec2 scale; void main() { // d is the offset to the ellipse center - vec2 d = sk_FragCoord.xy - ellipse.xy; + float2 d = sk_FragCoord.xy - ellipse.xy; // If we're on a device with a "real" mediump then we'll do the distance computation in a space // that is normalized by the larger radius. The scale uniform will be scale, 1/scale. The // inverse squared radii uniform values are already in this normalized space. The center is @@ -58,7 +58,7 @@ void main() { @if (useScale) { d *= scale.y; } - vec2 Z = d * ellipse.zw; + float2 Z = d * ellipse.zw; // implicit is the evaluation of (x/rx)^2 + (y/ry)^2 - 1. float implicit = dot(Z, d) - 1; // grad_dot is the squared length of the gradient of the implicit. diff --git a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp index ebe86dd8f7..eb6f49f7ad 100644 --- a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp +++ b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp @@ -59,13 +59,13 @@ void GrGLConvolutionEffect::emitCode(EmitArgs& args) { GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]); - fragBuilder->codeAppendf("%s = vec4(0, 0, 0, 0);", args.fOutputColor); + fragBuilder->codeAppendf("%s = float4(0, 0, 0, 0);", args.fOutputColor); const GrShaderVar& kernel = uniformHandler->getUniformVariable(fKernelUni); const char* imgInc = uniformHandler->getUniformCStr(fImageIncrementUni); - fragBuilder->codeAppendf("vec2 coord = %s - %d.0 * %s;", coords2D.c_str(), ce.radius(), imgInc); - fragBuilder->codeAppend("vec2 coordSampled = vec2(0, 0);"); + fragBuilder->codeAppendf("float2 coord = %s - %d.0 * %s;", coords2D.c_str(), ce.radius(), imgInc); + fragBuilder->codeAppend("float2 coordSampled = float2(0, 0);"); // Manually unroll loop because some drivers don't; yields 20-30% speedup. const char* kVecSuffix[4] = {".x", ".y", ".z", ".w"}; diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.cpp b/src/gpu/effects/GrMatrixConvolutionEffect.cpp index 46dc2d8cb9..9d8e793c13 100644 --- a/src/gpu/effects/GrMatrixConvolutionEffect.cpp +++ b/src/gpu/effects/GrMatrixConvolutionEffect.cpp @@ -70,9 +70,9 @@ void GrGLMatrixConvolutionEffect::emitCode(EmitArgs& args) { GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]); - fragBuilder->codeAppend("vec4 sum = vec4(0, 0, 0, 0);"); - fragBuilder->codeAppendf("vec2 coord = %s - %s * %s;", coords2D.c_str(), kernelOffset, imgInc); - fragBuilder->codeAppend("vec4 c;"); + fragBuilder->codeAppend("float4 sum = float4(0, 0, 0, 0);"); + fragBuilder->codeAppendf("float2 coord = %s - %s * %s;", coords2D.c_str(), kernelOffset, imgInc); + fragBuilder->codeAppend("float4 c;"); const char* kVecSuffix[4] = { ".x", ".y", ".z", ".w" }; for (int y = 0; y < kHeight; y++) { @@ -83,7 +83,7 @@ void GrGLMatrixConvolutionEffect::emitCode(EmitArgs& args) { fragBuilder->codeAppendf("float k = %s[%d]%s;", kernel, offset / 4, kVecSuffix[offset & 0x3]); SkString coord; - coord.printf("coord + vec2(%d, %d) * %s", x, y, imgInc); + coord.printf("coord + float2(%d, %d) * %s", x, y, imgInc); fDomain.sampleTexture(fragBuilder, uniformHandler, args.fShaderCaps, diff --git a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp index d26377b691..6ae770b820 100644 --- a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp +++ b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp @@ -71,13 +71,13 @@ public: } if (nullptr == args.fInputColor) { - args.fInputColor = "vec4(1)"; + args.fInputColor = "float4(1)"; } - fragBuilder->codeAppendf("vec4 color = %s;", args.fInputColor); + fragBuilder->codeAppendf("float4 color = %s;", args.fInputColor); // 1: Un-premultiply the input color (if necessary) fragBuilder->codeAppendf("float nonZeroAlpha = max(color.a, 0.00001);"); - fragBuilder->codeAppendf("color = vec4(color.rgb / nonZeroAlpha, nonZeroAlpha);"); + fragBuilder->codeAppendf("color = float4(color.rgb / nonZeroAlpha, nonZeroAlpha);"); // 2: Apply src transfer function (to get to linear RGB) if (srcCoeffsName) { @@ -89,7 +89,7 @@ public: // 3: Apply gamut matrix if (gamutXformName) { fragBuilder->codeAppendf( - "color.rgb = (%s * vec4(color.rgb, 1.0)).rgb;", gamutXformName); + "color.rgb = (%s * float4(color.rgb, 1.0)).rgb;", gamutXformName); } // 4: Apply dst transfer fn @@ -100,7 +100,7 @@ public: } // 5: Premultiply again - fragBuilder->codeAppendf("%s = vec4(color.rgb * color.a, color.a);", args.fOutputColor); + fragBuilder->codeAppendf("%s = float4(color.rgb * color.a, color.a);", args.fOutputColor); } static inline void GenKey(const GrProcessor& processor, const GrShaderCaps&, diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp index ffb91cc6d1..c571b837fd 100644 --- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp +++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp @@ -440,7 +440,7 @@ static void append_color_output(const PorterDuffXferProcessor& xp, SkASSERT(inColor); switch (outputType) { case BlendFormula::kNone_OutputType: - fragBuilder->codeAppendf("%s = vec4(0.0);", output); + fragBuilder->codeAppendf("%s = float4(0.0);", output); break; case BlendFormula::kCoverage_OutputType: // We can have a coverage formula while not reading coverage if there are mixed samples. @@ -456,7 +456,7 @@ static void append_color_output(const PorterDuffXferProcessor& xp, fragBuilder->codeAppendf("%s = (1.0 - %s.a) * %s;", output, inColor, inCoverage); break; case BlendFormula::kISCModulate_OutputType: - fragBuilder->codeAppendf("%s = (vec4(1.0) - %s) * %s;", output, inColor, inCoverage); + fragBuilder->codeAppendf("%s = (float4(1.0) - %s) * %s;", output, inColor, inCoverage); break; default: SkFAIL("Unsupported output type."); diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp index edf8eb6c37..8dde914bb4 100644 --- a/src/gpu/effects/GrRRectEffect.cpp +++ b/src/gpu/effects/GrRRectEffect.cpp @@ -197,13 +197,13 @@ void GLCircularRRectEffect::emitCode(EmitArgs& args) { // alphas together. switch (crre.getCircularCornerFlags()) { case CircularRRectEffect::kAll_CornerFlags: - fragBuilder->codeAppendf("vec2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName); - fragBuilder->codeAppendf("vec2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName); - fragBuilder->codeAppend("vec2 dxy = max(max(dxy0, dxy1), 0.0);"); + fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName); + fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName); + fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);"); fragBuilder->codeAppendf("float alpha = %s;", clampedCircleDistance.c_str()); break; case CircularRRectEffect::kTopLeft_CornerFlag: - fragBuilder->codeAppendf("vec2 dxy = max(%s.xy - sk_FragCoord.xy, 0.0);", + fragBuilder->codeAppendf("float2 dxy = max(%s.xy - sk_FragCoord.xy, 0.0);", rectName); fragBuilder->codeAppendf("float rightAlpha = clamp(%s.z - sk_FragCoord.x, 0.0, 1.0);", rectName); @@ -213,7 +213,7 @@ void GLCircularRRectEffect::emitCode(EmitArgs& args) { clampedCircleDistance.c_str()); break; case CircularRRectEffect::kTopRight_CornerFlag: - fragBuilder->codeAppendf("vec2 dxy = max(vec2(sk_FragCoord.x - %s.z, " + fragBuilder->codeAppendf("float2 dxy = max(float2(sk_FragCoord.x - %s.z, " "%s.y - sk_FragCoord.y), 0.0);", rectName, rectName); fragBuilder->codeAppendf("float leftAlpha = clamp(sk_FragCoord.x - %s.x, 0.0, 1.0);", @@ -224,7 +224,7 @@ void GLCircularRRectEffect::emitCode(EmitArgs& args) { clampedCircleDistance.c_str()); break; case CircularRRectEffect::kBottomRight_CornerFlag: - fragBuilder->codeAppendf("vec2 dxy = max(sk_FragCoord.xy - %s.zw, 0.0);", + fragBuilder->codeAppendf("float2 dxy = max(sk_FragCoord.xy - %s.zw, 0.0);", rectName); fragBuilder->codeAppendf("float leftAlpha = clamp(sk_FragCoord.x - %s.x, 0.0, 1.0);", rectName); @@ -234,7 +234,7 @@ void GLCircularRRectEffect::emitCode(EmitArgs& args) { clampedCircleDistance.c_str()); break; case CircularRRectEffect::kBottomLeft_CornerFlag: - fragBuilder->codeAppendf("vec2 dxy = max(vec2(%s.x - sk_FragCoord.x, sk_FragCoord.y - " + fragBuilder->codeAppendf("float2 dxy = max(float2(%s.x - sk_FragCoord.x, sk_FragCoord.y - " "%s.w), 0.0);", rectName, rectName); fragBuilder->codeAppendf("float rightAlpha = clamp(%s.z - sk_FragCoord.x, 0.0, 1.0);", @@ -245,18 +245,18 @@ void GLCircularRRectEffect::emitCode(EmitArgs& args) { clampedCircleDistance.c_str()); break; case CircularRRectEffect::kLeft_CornerFlags: - fragBuilder->codeAppendf("vec2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName); + fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName); fragBuilder->codeAppendf("float dy1 = sk_FragCoord.y - %s.w;", rectName); - fragBuilder->codeAppend("vec2 dxy = max(vec2(dxy0.x, max(dxy0.y, dy1)), 0.0);"); + fragBuilder->codeAppend("float2 dxy = max(float2(dxy0.x, max(dxy0.y, dy1)), 0.0);"); fragBuilder->codeAppendf("float rightAlpha = clamp(%s.z - sk_FragCoord.x, 0.0, 1.0);", rectName); fragBuilder->codeAppendf("float alpha = rightAlpha * %s;", clampedCircleDistance.c_str()); break; case CircularRRectEffect::kTop_CornerFlags: - fragBuilder->codeAppendf("vec2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName); + fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName); fragBuilder->codeAppendf("float dx1 = sk_FragCoord.x - %s.z;", rectName); - fragBuilder->codeAppend("vec2 dxy = max(vec2(max(dxy0.x, dx1), dxy0.y), 0.0);"); + fragBuilder->codeAppend("float2 dxy = max(float2(max(dxy0.x, dx1), dxy0.y), 0.0);"); fragBuilder->codeAppendf("float bottomAlpha = clamp(%s.w - sk_FragCoord.y, 0.0, 1.0);", rectName); fragBuilder->codeAppendf("float alpha = bottomAlpha * %s;", @@ -264,8 +264,8 @@ void GLCircularRRectEffect::emitCode(EmitArgs& args) { break; case CircularRRectEffect::kRight_CornerFlags: fragBuilder->codeAppendf("float dy0 = %s.y - sk_FragCoord.y;", rectName); - fragBuilder->codeAppendf("vec2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName); - fragBuilder->codeAppend("vec2 dxy = max(vec2(dxy1.x, max(dy0, dxy1.y)), 0.0);"); + fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName); + fragBuilder->codeAppend("float2 dxy = max(float2(dxy1.x, max(dy0, dxy1.y)), 0.0);"); fragBuilder->codeAppendf("float leftAlpha = clamp(sk_FragCoord.x - %s.x, 0.0, 1.0);", rectName); fragBuilder->codeAppendf("float alpha = leftAlpha * %s;", @@ -273,8 +273,8 @@ void GLCircularRRectEffect::emitCode(EmitArgs& args) { break; case CircularRRectEffect::kBottom_CornerFlags: fragBuilder->codeAppendf("float dx0 = %s.x - sk_FragCoord.x;", rectName); - fragBuilder->codeAppendf("vec2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName); - fragBuilder->codeAppend("vec2 dxy = max(vec2(max(dx0, dxy1.x), dxy1.y), 0.0);"); + fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName); + fragBuilder->codeAppend("float2 dxy = max(float2(max(dx0, dxy1.x), dxy1.y), 0.0);"); fragBuilder->codeAppendf("float topAlpha = clamp(sk_FragCoord.y - %s.y, 0.0, 1.0);", rectName); fragBuilder->codeAppendf("float alpha = topAlpha * %s;", @@ -532,8 +532,8 @@ void GLEllipticalRRectEffect::emitCode(EmitArgs& args) { // The code below is a simplified version of the above that performs maxs on the vector // components before computing distances and alpha values so that only one distance computation // need be computed to determine the min alpha. - fragBuilder->codeAppendf("vec2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName); - fragBuilder->codeAppendf("vec2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName); + fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName); + fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName); // If we're on a device with a "real" mediump then we'll do the distance computation in a space // that is normalized by the largest radius. The scale uniform will be scale, 1/scale. The @@ -554,12 +554,12 @@ void GLEllipticalRRectEffect::emitCode(EmitArgs& args) { kDefault_GrSLPrecision, "invRadiiXY", &invRadiiXYSqdName); - fragBuilder->codeAppend("vec2 dxy = max(max(dxy0, dxy1), 0.0);"); + fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);"); if (scaleName) { fragBuilder->codeAppendf("dxy *= %s.y;", scaleName); } // Z is the x/y offsets divided by squared radii. - fragBuilder->codeAppendf("vec2 Z = dxy * %s.xy;", invRadiiXYSqdName); + fragBuilder->codeAppendf("float2 Z = dxy * %s.xy;", invRadiiXYSqdName); break; } case SkRRect::kNinePatch_Type: { @@ -573,11 +573,11 @@ void GLEllipticalRRectEffect::emitCode(EmitArgs& args) { fragBuilder->codeAppendf("dxy0 *= %s.y;", scaleName); fragBuilder->codeAppendf("dxy1 *= %s.y;", scaleName); } - fragBuilder->codeAppend("vec2 dxy = max(max(dxy0, dxy1), 0.0);"); + fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);"); // Z is the x/y offsets divided by squared radii. We only care about the (at most) one // corner where both the x and y offsets are positive, hence the maxes. (The inverse // squared radii will always be positive.) - fragBuilder->codeAppendf("vec2 Z = max(max(dxy0 * %s.xy, dxy1 * %s.zw), 0.0);", + fragBuilder->codeAppendf("float2 Z = max(max(dxy0 * %s.xy, dxy1 * %s.zw), 0.0);", invRadiiLTRBSqdName, invRadiiLTRBSqdName); break; diff --git a/src/gpu/effects/GrSRGBEffect.cpp b/src/gpu/effects/GrSRGBEffect.cpp index ed924b35ff..1cffb9eef0 100644 --- a/src/gpu/effects/GrSRGBEffect.cpp +++ b/src/gpu/effects/GrSRGBEffect.cpp @@ -44,20 +44,20 @@ public: } if (nullptr == args.fInputColor) { - args.fInputColor = "vec4(1)"; + args.fInputColor = "float4(1)"; } - fragBuilder->codeAppendf("vec4 color = %s;", args.fInputColor); + fragBuilder->codeAppendf("float4 color = %s;", args.fInputColor); if (srgbe.alpha() == GrSRGBEffect::Alpha::kPremul) { fragBuilder->codeAppendf("float nonZeroAlpha = max(color.a, 0.00001);"); - fragBuilder->codeAppendf("color = vec4(color.rgb / nonZeroAlpha, color.a);"); + fragBuilder->codeAppendf("color = float4(color.rgb / nonZeroAlpha, color.a);"); } - fragBuilder->codeAppendf("color = vec4(%s(color.r), %s(color.g), %s(color.b), color.a);", + fragBuilder->codeAppendf("color = float4(%s(color.r), %s(color.g), %s(color.b), color.a);", srgbFuncName.c_str(), srgbFuncName.c_str(), srgbFuncName.c_str()); if (srgbe.alpha() == GrSRGBEffect::Alpha::kPremul) { - fragBuilder->codeAppendf("color = vec4(color.rgb, 1) * color.a;"); + fragBuilder->codeAppendf("color = float4(color.rgb, 1) * color.a;"); } fragBuilder->codeAppendf("%s = color;", args.fOutputColor); } diff --git a/src/gpu/effects/GrShadowGeoProc.cpp b/src/gpu/effects/GrShadowGeoProc.cpp index 6ab993a857..046240cb1d 100644 --- a/src/gpu/effects/GrShadowGeoProc.cpp +++ b/src/gpu/effects/GrShadowGeoProc.cpp @@ -26,7 +26,7 @@ public: // emit attributes varyingHandler->emitAttributes(rsgp); - fragBuilder->codeAppend("vec4 shadowParams;"); + fragBuilder->codeAppend("float4 shadowParams;"); varyingHandler->addPassThroughAttribute(rsgp.inShadowParams(), "shadowParams"); // setup pass through color @@ -48,7 +48,7 @@ public: fragBuilder->codeAppend("float factor = 1.0 - clamp(distance, 0.0, shadowParams.w);"); fragBuilder->codeAppend("factor = exp(-factor * factor * 4.0) - 0.018;"); - fragBuilder->codeAppendf("%s = vec4(factor);", + fragBuilder->codeAppendf("%s = float4(factor);", args.fOutputCoverage); } diff --git a/src/gpu/effects/GrSimpleTextureEffect.cpp b/src/gpu/effects/GrSimpleTextureEffect.cpp index cab078b109..bbac5b5f4c 100644 --- a/src/gpu/effects/GrSimpleTextureEffect.cpp +++ b/src/gpu/effects/GrSimpleTextureEffect.cpp @@ -27,15 +27,15 @@ public: SkSL::String sk_TransformedCoords2D_0 = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]); fragBuilder->codeAppendf( - "vec4 _tmpVar1;%s = %s * %stexture(%s, %s).%s%s;\n", args.fOutputColor, - args.fInputColor ? args.fInputColor : "vec4(1)", + "float4 _tmpVar1;%s = %s * %stexture(%s, %s).%s%s;\n", args.fOutputColor, + args.fInputColor ? args.fInputColor : "float4(1)", fColorSpaceHelper.isValid() ? "(_tmpVar1 = " : "", fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(), sk_TransformedCoords2D_0.c_str(), fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str(), fColorSpaceHelper.isValid() - ? SkStringPrintf(", vec4(clamp((%s * vec4(_tmpVar1.rgb, 1.0)).rgb, 0.0, " - "_tmpVar1.a), _tmpVar1.a))", + ? SkStringPrintf(", float4(clamp((%s * float4(_tmpVar1.rgb, 1.0)).rgb, " + "0.0, _tmpVar1.a), _tmpVar1.a))", args.fUniformHandler->getUniformCStr( fColorSpaceHelper.gamutXformUniform())) .c_str() diff --git a/src/gpu/effects/GrSimpleTextureEffect.fp b/src/gpu/effects/GrSimpleTextureEffect.fp index 20944447ce..6f7c818672 100644 --- a/src/gpu/effects/GrSimpleTextureEffect.fp +++ b/src/gpu/effects/GrSimpleTextureEffect.fp @@ -7,7 +7,7 @@ in uniform sampler2D image; in uniform colorSpaceXform colorXform; -in mat4 matrix; +in float4x4 matrix; @constructorParams { GrSamplerParams samplerParams diff --git a/src/gpu/effects/GrTextureDomain.cpp b/src/gpu/effects/GrTextureDomain.cpp index fa560580e4..ee7985c14e 100644 --- a/src/gpu/effects/GrTextureDomain.cpp +++ b/src/gpu/effects/GrTextureDomain.cpp @@ -115,8 +115,8 @@ void GrTextureDomain::GLDomain::sampleTexture(GrGLSLShaderBuilder* builder, // may return undefined results". This appears to be an issue with // the 'any' call since even the simple "result=black; if (any()) // result=white;" code fails to compile. - builder->codeAppend("vec4 outside = vec4(0.0, 0.0, 0.0, 0.0);"); - builder->codeAppend("vec4 inside = "); + builder->codeAppend("float4 outside = float4(0.0, 0.0, 0.0, 0.0);"); + builder->codeAppend("float4 inside = "); builder->appendTextureLookupAndModulate(inModulateColor, sampler, inCoords.c_str(), kVec2f_GrSLType, colorXformHelper); builder->codeAppend(";"); @@ -131,12 +131,12 @@ void GrTextureDomain::GLDomain::sampleTexture(GrGLSLShaderBuilder* builder, builder->codeAppend("float blend = step(1.0, max(x, y));"); builder->codeAppendf("%s = mix(inside, outside, blend);", outColor); } else { - builder->codeAppend("bvec4 outside;\n"); + builder->codeAppend("bool4 outside;\n"); builder->codeAppendf("outside.xy = lessThan(%s, %s.xy);", inCoords.c_str(), domain); builder->codeAppendf("outside.zw = greaterThan(%s, %s.zw);", inCoords.c_str(), domain); - builder->codeAppendf("%s = any(outside) ? vec4(0.0, 0.0, 0.0, 0.0) : ", + builder->codeAppendf("%s = any(outside) ? float4(0.0, 0.0, 0.0, 0.0) : ", outColor); builder->appendTextureLookupAndModulate(inModulateColor, sampler, inCoords.c_str(), kVec2f_GrSLType, colorXformHelper); @@ -385,7 +385,7 @@ GrGLSLFragmentProcessor* GrDeviceSpaceTextureDecalFragmentProcessor::onCreateGLS kDefault_GrSLPrecision, "scaleAndTranslate", &scaleAndTranslateName); - args.fFragBuilder->codeAppendf("vec2 coords = sk_FragCoord.xy * %s.xy + %s.zw;", + args.fFragBuilder->codeAppendf("float2 coords = sk_FragCoord.xy * %s.xy + %s.zw;", scaleAndTranslateName, scaleAndTranslateName); fGLDomain.sampleTexture(args.fFragBuilder, args.fUniformHandler, diff --git a/src/gpu/effects/GrTextureDomain.h b/src/gpu/effects/GrTextureDomain.h index 96bbc235c3..10c2e563c0 100644 --- a/src/gpu/effects/GrTextureDomain.h +++ b/src/gpu/effects/GrTextureDomain.h @@ -23,7 +23,7 @@ struct SkRect; /** * Limits a texture's lookup coordinates to a domain. Samples outside the domain are either clamped - * the edge of the domain or result in a vec4 of zeros (decal mode). The domain is clipped to + * the edge of the domain or result in a float4 of zeros (decal mode). The domain is clipped to * normalized texture coords ([0,1]x[0,1] square). Bilinear filtering can cause texels outside the * domain to affect the read value unless the caller considers this when calculating the domain. */ @@ -98,8 +98,8 @@ public: * Call this from GrGLSLFragmentProcessor::emitCode() to sample the texture W.R.T. the * domain and mode. * - * @param outcolor name of vec4 variable to hold the sampled color. - * @param inCoords name of vec2 variable containing the coords to be used with the domain. + * @param outcolor name of float4 variable to hold the sampled color. + * @param inCoords name of float2 variable containing the coords to be used with the domain. * It is assumed that this is a variable and not an expression. * @param inModulateColor if non-nullptr the sampled color will be modulated with this * expression before being written to outColor. diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp index 80de68f4c2..88a09e6d7a 100644 --- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp +++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp @@ -220,7 +220,7 @@ void GLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) { const char* inputColor = nullptr; if (args.fInputColor) { inputColor = "inputColor"; - fragBuilder->codeAppendf("vec4 inputColor = vec4(%s.rgb, 1.0);", args.fInputColor); + fragBuilder->codeAppendf("float4 inputColor = float4(%s.rgb, 1.0);", args.fInputColor); } // declare outputColor and emit the code for each of the two children @@ -454,7 +454,7 @@ public: const char* inputColor = args.fInputColor; // We don't try to optimize for this case at all if (!inputColor) { - fragBuilder->codeAppendf("const vec4 ones = vec4(1);"); + fragBuilder->codeAppendf("const float4 ones = float4(1);"); inputColor = "ones"; } diff --git a/src/gpu/effects/GrYUVEffect.cpp b/src/gpu/effects/GrYUVEffect.cpp index 0d7f218e20..93f268a13c 100644 --- a/src/gpu/effects/GrYUVEffect.cpp +++ b/src/gpu/effects/GrYUVEffect.cpp @@ -112,7 +112,7 @@ public: fMatrixUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kMat44f_GrSLType, kDefault_GrSLPrecision, "ColorSpaceMatrix", &colorSpaceMatrix); - fragBuilder->codeAppendf("%s = vec4(", args.fOutputColor); + fragBuilder->codeAppendf("%s = float4(", args.fOutputColor); fragBuilder->appendTextureLookup(args.fTexSamplers[0], args.fTransformedCoords[0].c_str(), args.fTransformedCoords[0].getType()); @@ -279,7 +279,7 @@ public: kFragment_GrShaderFlag, kVec4f_GrSLType, kDefault_GrSLPrecision, "RGBToYUV", 3, &uniName); - fragBuilder->codeAppendf("%s = vec4(dot(rgbColor.rgb, %s[0].rgb) + %s[0].a," + fragBuilder->codeAppendf("%s = float4(dot(rgbColor.rgb, %s[0].rgb) + %s[0].a," "dot(rgbColor.rgb, %s[1].rgb) + %s[1].a," "dot(rgbColor.rgb, %s[2].rgb) + %s[2].a," "rgbColor.a);", @@ -291,7 +291,7 @@ public: kFragment_GrShaderFlag, kVec4f_GrSLType, kDefault_GrSLPrecision, "RGBToUV", 2, &uniName); - fragBuilder->codeAppendf("%s = vec4(dot(rgbColor.rgb, %s[0].rgb) + %s[0].a," + fragBuilder->codeAppendf("%s = float4(dot(rgbColor.rgb, %s[0].rgb) + %s[0].a," "dot(rgbColor.rgb, %s[1].rgb) + %s[1].a," "0.0," "rgbColor.a);", @@ -304,7 +304,7 @@ public: kFragment_GrShaderFlag, kVec4f_GrSLType, kDefault_GrSLPrecision, "RGBToYUorV", &uniName); - fragBuilder->codeAppendf("%s = vec4(dot(rgbColor.rgb, %s.rgb) + %s.a);\n", + fragBuilder->codeAppendf("%s = float4(dot(rgbColor.rgb, %s.rgb) + %s.a);\n", args.fOutputColor, uniName, uniName); break; } |