Switched highp float to highfloat and mediump float to half.
The ultimate goal is to end up with "float" and "half", but this
intermediate step uses "highfloat" so that it is clear if I missed a
"float" somewhere. Once this lands, a subsequent CL will switch all
"highfloats" back to "floats".
Bug: skia:
Change-Id: Ia13225c7a0a0a2901e07665891c473d2500ddcca
Reviewed-on: https://skia-review.googlesource.com/31000
Commit-Queue: Ethan Nicholas <ethannicholas@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
diff --git a/bench/GLInstancedArraysBench.cpp b/bench/GLInstancedArraysBench.cpp
index 37d1f2c..a5348d5 100644
--- a/bench/GLInstancedArraysBench.cpp
+++ b/bench/GLInstancedArraysBench.cpp
@@ -111,9 +111,9 @@
const char* version = shaderCaps->versionDeclString();
// setup vertex shader
- GrShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kIn_TypeModifier);
- GrShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kIn_TypeModifier);
- GrShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kOut_TypeModifier);
+ GrShaderVar aPosition("a_position", kHalf2_GrSLType, GrShaderVar::kIn_TypeModifier);
+ GrShaderVar aColor("a_color", kHalf3_GrSLType, GrShaderVar::kIn_TypeModifier);
+ GrShaderVar oColor("o_color", kHalf3_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(shaderCaps, &vshaderTxt);
@@ -126,14 +126,13 @@
vshaderTxt.append(
"void main()\n"
"{\n"
- "gl_Position = float4(a_position, 0., 1.);\n"
+ "gl_Position = highfloat4(a_position, 0., 1.);\n"
"o_color = a_color;\n"
"}\n");
// setup fragment shader
- GrShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
+ GrShaderVar oFragColor("o_FragColor", kHalf4_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
- GrGLSLAppendDefaultFloatPrecisionDeclaration(kMedium_GrSLPrecision, *shaderCaps, &fshaderTxt);
oColor.setTypeModifier(GrShaderVar::kIn_TypeModifier);
oColor.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
@@ -150,7 +149,7 @@
fshaderTxt.appendf(
"void main()\n"
"{\n"
- "%s = float4(o_color, 1.0);\n"
+ "%s = highfloat4(o_color, 1.0);\n"
"}\n", fsOutName);
return CreateProgram(ctx, vshaderTxt.c_str(), fshaderTxt.c_str());
diff --git a/bench/GLVec4ScalarBench.cpp b/bench/GLVec4ScalarBench.cpp
index fab397b..413e766 100644
--- a/bench/GLVec4ScalarBench.cpp
+++ b/bench/GLVec4ScalarBench.cpp
@@ -101,10 +101,10 @@
// corner of the screen than the previous circle.
// set up vertex shader; this is a trivial vertex shader that passes through position and color
- GrShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kIn_TypeModifier);
- GrShaderVar oPosition("o_position", kVec2f_GrSLType, GrShaderVar::kOut_TypeModifier);
- GrShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kIn_TypeModifier);
- GrShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kOut_TypeModifier);
+ GrShaderVar aPosition("a_position", kHalf2_GrSLType, GrShaderVar::kIn_TypeModifier);
+ GrShaderVar oPosition("o_position", kHalf2_GrSLType, GrShaderVar::kOut_TypeModifier);
+ GrShaderVar aColor("a_color", kHalf3_GrSLType, GrShaderVar::kIn_TypeModifier);
+ GrShaderVar oColor("o_color", kHalf3_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(shaderCaps, &vshaderTxt);
@@ -119,7 +119,7 @@
vshaderTxt.append(
"void main()\n"
"{\n"
- " gl_Position = float4(a_position, 0.0, 1.0);\n"
+ " gl_Position = highfloat4(a_position, 0.0, 1.0);\n"
" o_position = a_position;\n"
" o_color = a_color;\n"
"}\n");
@@ -129,9 +129,8 @@
// coded center and compare that to some hard-coded circle radius to compute a coverage.
// Then, this coverage is mixed with the coverage from the previous stage and passed to the
// next stage.
- GrShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
+ GrShaderVar oFragColor("o_FragColor", kHalf4_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
- GrGLSLAppendDefaultFloatPrecisionDeclaration(kMedium_GrSLPrecision, *shaderCaps, &fshaderTxt);
oPosition.setTypeModifier(GrShaderVar::kIn_TypeModifier);
oPosition.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
@@ -152,13 +151,13 @@
fshaderTxt.appendf(
"void main()\n"
"{\n"
- " float4 outputColor;\n"
+ " half4 outputColor;\n"
" %s outputCoverage;\n"
- " outputColor = float4(%s, 1.0);\n"
+ " outputColor = half4(%s, 1.0);\n"
" outputCoverage = %s;\n",
- fCoverageSetup == kUseVec4_CoverageSetup ? "float4" : "float",
+ fCoverageSetup == kUseVec4_CoverageSetup ? "half4" : "half",
oColor.getName().c_str(),
- fCoverageSetup == kUseVec4_CoverageSetup ? "float4(1.0)" : "1.0"
+ fCoverageSetup == kUseVec4_CoverageSetup ? "half4(1.0)" : "1.0"
);
float radius = 1.0f;
@@ -167,13 +166,13 @@
float centerY = 1.0f - radius;
fshaderTxt.appendf(
" {\n"
- " float d = length(%s - float2(%f, %f));\n"
- " float edgeAlpha = clamp(100.0 * (%f - d), 0.0, 1.0);\n"
+ " half d = length(%s - half2(%f, %f));\n"
+ " half edgeAlpha = clamp(100.0 * (%f - d), 0.0, 1.0);\n"
" outputCoverage = 0.5 * outputCoverage + 0.5 * %s;\n"
" }\n",
oPosition.getName().c_str(), centerX, centerY,
radius,
- fCoverageSetup == kUseVec4_CoverageSetup ? "float4(edgeAlpha)" : "edgeAlpha"
+ fCoverageSetup == kUseVec4_CoverageSetup ? "half4(edgeAlpha)" : "edgeAlpha"
);
radius *= 0.8f;
}
diff --git a/bench/GLVertexAttributesBench.cpp b/bench/GLVertexAttributesBench.cpp
index 3980a0b..f10bd11 100644
--- a/bench/GLVertexAttributesBench.cpp
+++ b/bench/GLVertexAttributesBench.cpp
@@ -69,7 +69,7 @@
const char* version = shaderCaps->versionDeclString();
// setup vertex shader
- GrShaderVar aPosition("a_position", kVec4f_GrSLType, GrShaderVar::kIn_TypeModifier);
+ GrShaderVar aPosition("a_position", kHighFloat4_GrSLType, GrShaderVar::kIn_TypeModifier);
SkTArray<GrShaderVar> aVars;
SkTArray<GrShaderVar> oVars;
@@ -81,7 +81,7 @@
SkString aname;
aname.appendf("a_color_%d", i);
aVars.push_back(GrShaderVar(aname.c_str(),
- kVec4f_GrSLType,
+ kHalf4_GrSLType,
GrShaderVar::kIn_TypeModifier));
aVars.back().appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
@@ -92,7 +92,7 @@
SkString oname;
oname.appendf("o_color_%d", i);
oVars.push_back(GrShaderVar(oname.c_str(),
- kVec4f_GrSLType,
+ kHalf4_GrSLType,
GrShaderVar::kOut_TypeModifier));
oVars.back().appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
@@ -109,15 +109,14 @@
// Passthrough position as a dummy
for (uint32_t i = attribs; i < maxAttribs; i++) {
- vshaderTxt.appendf("%s = float4(0, 0, 0, 1);\n", oVars[i].c_str());
+ vshaderTxt.appendf("%s = highfloat4(0, 0, 0, 1);\n", oVars[i].c_str());
}
vshaderTxt.append("}\n");
// setup fragment shader
- GrShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
+ GrShaderVar oFragColor("o_FragColor", kHalf4_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
- GrGLSLAppendDefaultFloatPrecisionDeclaration(kMedium_GrSLPrecision, *shaderCaps, &fshaderTxt);
const char* fsOutName;
if (shaderCaps->mustDeclareFragmentShaderOutput()) {
diff --git a/include/private/GrGLSL.h b/include/private/GrGLSL.h
index 087b869..975f9ad 100644
--- a/include/private/GrGLSL.h
+++ b/include/private/GrGLSL.h
@@ -89,26 +89,34 @@
switch (t) {
case kVoid_GrSLType:
return "void";
- case kFloat_GrSLType:
- return "float";
- case kVec2f_GrSLType:
- return "float2";
- case kVec3f_GrSLType:
- return "float3";
- case kVec4f_GrSLType:
- return "float4";
- case kVec2i_GrSLType:
- return "int2";
- case kVec3i_GrSLType:
- return "int3";
- case kVec4i_GrSLType:
- return "int4";
- case kMat22f_GrSLType:
- return "float2x2";
- case kMat33f_GrSLType:
- return "float3x3";
- case kMat44f_GrSLType:
- return "float4x4";
+ case kHighFloat_GrSLType:
+ return "highfloat";
+ case kHighFloat2_GrSLType:
+ return "highfloat2";
+ case kHighFloat3_GrSLType:
+ return "highfloat3";
+ case kHighFloat4_GrSLType:
+ return "highfloat4";
+ case kHalf_GrSLType:
+ return "half";
+ case kHalf2_GrSLType:
+ return "half2";
+ case kHalf3_GrSLType:
+ return "half3";
+ case kHalf4_GrSLType:
+ return "half4";
+ case kHighFloat2x2_GrSLType:
+ return "highfloat2x2";
+ case kHighFloat3x3_GrSLType:
+ return "highfloat3x3";
+ case kHighFloat4x4_GrSLType:
+ return "highfloat4x4";
+ case kHalf2x2_GrSLType:
+ return "half2x2";
+ case kHalf3x3_GrSLType:
+ return "half3x3";
+ case kHalf4x4_GrSLType:
+ return "half4x4";
case kTexture2DSampler_GrSLType:
return "sampler2D";
case kITexture2DSampler_GrSLType:
@@ -121,8 +129,18 @@
return "samplerBuffer";
case kBool_GrSLType:
return "bool";
+ case kShort_GrSLType:
+ return "short";
+ case kUShort_GrSLType:
+ return "ushort";
case kInt_GrSLType:
return "int";
+ case kInt2_GrSLType:
+ return "int2";
+ case kInt3_GrSLType:
+ return "int3";
+ case kInt4_GrSLType:
+ return "int4";
case kUint_GrSLType:
return "uint";
case kTexture2D_GrSLType:
diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h
index d2df9b2..b83a733 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -78,18 +78,27 @@
enum GrSLType {
kVoid_GrSLType,
kBool_GrSLType,
- kInt_GrSLType,
kUint_GrSLType,
- kFloat_GrSLType,
- kVec2f_GrSLType,
- kVec3f_GrSLType,
- kVec4f_GrSLType,
- kVec2i_GrSLType,
- kVec3i_GrSLType,
- kVec4i_GrSLType,
- kMat22f_GrSLType,
- kMat33f_GrSLType,
- kMat44f_GrSLType,
+ kShort_GrSLType,
+ kUShort_GrSLType,
+ kHighFloat_GrSLType,
+ kHighFloat2_GrSLType,
+ kHighFloat3_GrSLType,
+ kHighFloat4_GrSLType,
+ kHighFloat2x2_GrSLType,
+ kHighFloat3x3_GrSLType,
+ kHighFloat4x4_GrSLType,
+ kHalf_GrSLType,
+ kHalf2_GrSLType,
+ kHalf3_GrSLType,
+ kHalf4_GrSLType,
+ kHalf2x2_GrSLType,
+ kHalf3x3_GrSLType,
+ kHalf4x4_GrSLType,
+ kInt_GrSLType,
+ kInt2_GrSLType,
+ kInt3_GrSLType,
+ kInt4_GrSLType,
kTexture2DSampler_GrSLType,
kITexture2DSampler_GrSLType,
kTextureExternalSampler_GrSLType,
@@ -143,13 +152,20 @@
/** Is the shading language type float (including vectors/matrices)? */
static inline bool GrSLTypeIsFloatType(GrSLType type) {
switch (type) {
- case kFloat_GrSLType:
- case kVec2f_GrSLType:
- case kVec3f_GrSLType:
- case kVec4f_GrSLType:
- case kMat22f_GrSLType:
- case kMat33f_GrSLType:
- case kMat44f_GrSLType:
+ case kHighFloat_GrSLType:
+ case kHighFloat2_GrSLType:
+ case kHighFloat3_GrSLType:
+ case kHighFloat4_GrSLType:
+ case kHighFloat2x2_GrSLType:
+ case kHighFloat3x3_GrSLType:
+ case kHighFloat4x4_GrSLType:
+ case kHalf_GrSLType:
+ case kHalf2_GrSLType:
+ case kHalf3_GrSLType:
+ case kHalf4_GrSLType:
+ case kHalf2x2_GrSLType:
+ case kHalf3x3_GrSLType:
+ case kHalf4x4_GrSLType:
return true;
case kVoid_GrSLType:
@@ -159,11 +175,13 @@
case kTexture2DRectSampler_GrSLType:
case kBufferSampler_GrSLType:
case kBool_GrSLType:
- case kInt_GrSLType:
case kUint_GrSLType:
- case kVec2i_GrSLType:
- case kVec3i_GrSLType:
- case kVec4i_GrSLType:
+ case kShort_GrSLType:
+ case kUShort_GrSLType:
+ case kInt_GrSLType:
+ case kInt2_GrSLType:
+ case kInt3_GrSLType:
+ case kInt4_GrSLType:
case kTexture2D_GrSLType:
case kSampler_GrSLType:
case kImageStorage2D_GrSLType:
@@ -183,20 +201,29 @@
return true;
case kVoid_GrSLType:
- case kFloat_GrSLType:
- case kVec2f_GrSLType:
- case kVec3f_GrSLType:
- case kVec4f_GrSLType:
- case kVec2i_GrSLType:
- case kVec3i_GrSLType:
- case kVec4i_GrSLType:
- case kMat22f_GrSLType:
- case kMat33f_GrSLType:
- case kMat44f_GrSLType:
- case kBufferSampler_GrSLType:
+ case kHighFloat_GrSLType:
+ case kHighFloat2_GrSLType:
+ case kHighFloat3_GrSLType:
+ case kHighFloat4_GrSLType:
+ case kHighFloat2x2_GrSLType:
+ case kHighFloat3x3_GrSLType:
+ case kHighFloat4x4_GrSLType:
+ case kHalf_GrSLType:
+ case kHalf2_GrSLType:
+ case kHalf3_GrSLType:
+ case kHalf4_GrSLType:
+ case kHalf2x2_GrSLType:
+ case kHalf3x3_GrSLType:
+ case kHalf4x4_GrSLType:
case kInt_GrSLType:
+ case kInt2_GrSLType:
+ case kInt3_GrSLType:
+ case kInt4_GrSLType:
+ case kBufferSampler_GrSLType:
case kUint_GrSLType:
case kBool_GrSLType:
+ case kShort_GrSLType:
+ case kUShort_GrSLType:
case kTexture2D_GrSLType:
case kSampler_GrSLType:
case kImageStorage2D_GrSLType:
@@ -217,19 +244,28 @@
return true;
case kVoid_GrSLType:
- case kFloat_GrSLType:
- case kVec2f_GrSLType:
- case kVec3f_GrSLType:
- case kVec4f_GrSLType:
- case kVec2i_GrSLType:
- case kVec3i_GrSLType:
- case kVec4i_GrSLType:
- case kMat22f_GrSLType:
- case kMat33f_GrSLType:
- case kMat44f_GrSLType:
+ case kHighFloat_GrSLType:
+ case kHighFloat2_GrSLType:
+ case kHighFloat3_GrSLType:
+ case kHighFloat4_GrSLType:
+ case kHighFloat2x2_GrSLType:
+ case kHighFloat3x3_GrSLType:
+ case kHighFloat4x4_GrSLType:
+ case kHalf_GrSLType:
+ case kHalf2_GrSLType:
+ case kHalf3_GrSLType:
+ case kHalf4_GrSLType:
+ case kHalf2x2_GrSLType:
+ case kHalf3x3_GrSLType:
+ case kHalf4x4_GrSLType:
case kInt_GrSLType:
+ case kInt2_GrSLType:
+ case kInt3_GrSLType:
+ case kInt4_GrSLType:
case kUint_GrSLType:
case kBool_GrSLType:
+ case kShort_GrSLType:
+ case kUShort_GrSLType:
case kTexture2D_GrSLType:
case kSampler_GrSLType:
case kImageStorage2D_GrSLType:
@@ -247,19 +283,28 @@
return true;
case kVoid_GrSLType:
- case kFloat_GrSLType:
- case kVec2f_GrSLType:
- case kVec3f_GrSLType:
- case kVec4f_GrSLType:
- case kVec2i_GrSLType:
- case kVec3i_GrSLType:
- case kVec4i_GrSLType:
- case kMat22f_GrSLType:
- case kMat33f_GrSLType:
- case kMat44f_GrSLType:
+ case kHighFloat_GrSLType:
+ case kHighFloat2_GrSLType:
+ case kHighFloat3_GrSLType:
+ case kHighFloat4_GrSLType:
+ case kHighFloat2x2_GrSLType:
+ case kHighFloat3x3_GrSLType:
+ case kHighFloat4x4_GrSLType:
+ case kHalf_GrSLType:
+ case kHalf2_GrSLType:
+ case kHalf3_GrSLType:
+ case kHalf4_GrSLType:
+ case kHalf2x2_GrSLType:
+ case kHalf3x3_GrSLType:
+ case kHalf4x4_GrSLType:
+ case kInt2_GrSLType:
+ case kInt3_GrSLType:
+ case kInt4_GrSLType:
case kInt_GrSLType:
case kUint_GrSLType:
case kBool_GrSLType:
+ case kShort_GrSLType:
+ case kUShort_GrSLType:
case kTexture2D_GrSLType:
case kSampler_GrSLType:
case kTexture2DSampler_GrSLType:
@@ -275,18 +320,71 @@
static inline bool GrSLTypeAcceptsPrecision(GrSLType type) {
switch (type) {
- case kInt_GrSLType:
+ case kTexture2DSampler_GrSLType:
+ case kITexture2DSampler_GrSLType:
+ case kTextureExternalSampler_GrSLType:
+ case kTexture2DRectSampler_GrSLType:
+ case kBufferSampler_GrSLType:
+ case kTexture2D_GrSLType:
+ case kSampler_GrSLType:
+ case kImageStorage2D_GrSLType:
+ case kIImageStorage2D_GrSLType:
+ return true;
+
+ case kVoid_GrSLType:
+ case kBool_GrSLType:
case kUint_GrSLType:
- case kFloat_GrSLType:
- case kVec2f_GrSLType:
- case kVec3f_GrSLType:
- case kVec4f_GrSLType:
- case kVec2i_GrSLType:
- case kVec3i_GrSLType:
- case kVec4i_GrSLType:
- case kMat22f_GrSLType:
- case kMat33f_GrSLType:
- case kMat44f_GrSLType:
+ case kShort_GrSLType:
+ case kUShort_GrSLType:
+ case kHighFloat_GrSLType:
+ case kHighFloat2_GrSLType:
+ case kHighFloat3_GrSLType:
+ case kHighFloat4_GrSLType:
+ case kHighFloat2x2_GrSLType:
+ case kHighFloat3x3_GrSLType:
+ case kHighFloat4x4_GrSLType:
+ case kHalf_GrSLType:
+ case kHalf2_GrSLType:
+ case kHalf3_GrSLType:
+ case kHalf4_GrSLType:
+ case kHalf2x2_GrSLType:
+ case kHalf3x3_GrSLType:
+ case kHalf4x4_GrSLType:
+ case kInt_GrSLType:
+ case kInt2_GrSLType:
+ case kInt3_GrSLType:
+ case kInt4_GrSLType:
+ return false;
+ }
+ SkFAIL("Unexpected type");
+ return false;
+}
+
+// temporarily accepting (but ignoring) precision modifiers on the new types; this will be killed
+// in a future CL
+static inline bool GrSLTypeTemporarilyAcceptsPrecision(GrSLType type) {
+ switch (type) {
+ case kUint_GrSLType:
+ case kShort_GrSLType:
+ case kUShort_GrSLType:
+ case kHighFloat_GrSLType:
+ case kHighFloat2_GrSLType:
+ case kHighFloat3_GrSLType:
+ case kHighFloat4_GrSLType:
+ case kHighFloat2x2_GrSLType:
+ case kHighFloat3x3_GrSLType:
+ case kHighFloat4x4_GrSLType:
+ case kHalf_GrSLType:
+ case kHalf2_GrSLType:
+ case kHalf3_GrSLType:
+ case kHalf4_GrSLType:
+ case kHalf2x2_GrSLType:
+ case kHalf3x3_GrSLType:
+ case kHalf4x4_GrSLType:
+ case kInt_GrSLType:
+ case kInt2_GrSLType:
+ case kInt3_GrSLType:
+ case kInt4_GrSLType:
case kTexture2DSampler_GrSLType:
case kITexture2DSampler_GrSLType:
case kTextureExternalSampler_GrSLType:
@@ -408,21 +506,21 @@
switch (type) {
case kUByte_GrVertexAttribType:
case kFloat_GrVertexAttribType:
- return kFloat_GrSLType;
+ return kHighFloat_GrSLType;
case kVec2us_GrVertexAttribType:
case kVec2f_GrVertexAttribType:
- return kVec2f_GrSLType;
+ return kHighFloat2_GrSLType;
case kVec3f_GrVertexAttribType:
- return kVec3f_GrSLType;
+ return kHighFloat3_GrSLType;
case kVec4ub_GrVertexAttribType:
case kVec4f_GrVertexAttribType:
- return kVec4f_GrSLType;
+ return kHighFloat4_GrSLType;
case kVec2i_GrVertexAttribType:
- return kVec2i_GrSLType;
+ return kInt2_GrSLType;
case kVec3i_GrVertexAttribType:
- return kVec3i_GrSLType;
+ return kInt3_GrSLType;
case kVec4i_GrVertexAttribType:
- return kVec4i_GrSLType;
+ return kInt4_GrSLType;
case kInt_GrVertexAttribType:
return kInt_GrSLType;
case kUint_GrVertexAttribType:
diff --git a/src/core/SkColorMatrixFilterRowMajor255.cpp b/src/core/SkColorMatrixFilterRowMajor255.cpp
index e2d6c37..1ac6701 100644
--- a/src/core/SkColorMatrixFilterRowMajor255.cpp
+++ b/src/core/SkColorMatrixFilterRowMajor255.cpp
@@ -201,23 +201,21 @@
void emitCode(EmitArgs& args) override {
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
- fMatrixHandle = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kMat44f_GrSLType, kDefault_GrSLPrecision,
+ fMatrixHandle = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4x4_GrSLType,
"ColorMatrix");
- fVectorHandle = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ fVectorHandle = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
"ColorMatrixVector");
if (nullptr == args.fInputColor) {
// could optimize this case, but we aren't for now.
- args.fInputColor = "float4(1)";
+ args.fInputColor = "half4(1)";
}
GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
// The max() is to guard against 0 / 0 during unpremul when the incoming color is
// transparent black.
- fragBuilder->codeAppendf("\tfloat nonZeroAlpha = max(%s.a, 0.00001);\n",
+ fragBuilder->codeAppendf("\thalf nonZeroAlpha = max(%s.a, 0.00001);\n",
args.fInputColor);
- fragBuilder->codeAppendf("\t%s = %s * float4(%s.rgb / nonZeroAlpha, nonZeroAlpha) + "
+ fragBuilder->codeAppendf("\t%s = %s * half4(%s.rgb / nonZeroAlpha, nonZeroAlpha) + "
"%s;\n",
args.fOutputColor,
uniformHandler->getUniformCStr(fMatrixHandle),
diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.cpp b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
index 96961cf..f96f0c5 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.cpp
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
@@ -36,24 +36,25 @@
(void)_outer;
fColorSpaceHelper.emitCode(args.fUniformHandler, _outer.colorXform().get());
fInnerThresholdVar = args.fUniformHandler->addUniform(
- kFragment_GrShaderFlag, kFloat_GrSLType, kDefault_GrSLPrecision, "innerThreshold");
+ kFragment_GrShaderFlag, kHalf_GrSLType, kDefault_GrSLPrecision, "innerThreshold");
fOuterThresholdVar = args.fUniformHandler->addUniform(
- kFragment_GrShaderFlag, kFloat_GrSLType, kDefault_GrSLPrecision, "outerThreshold");
+ kFragment_GrShaderFlag, kHalf_GrSLType, kDefault_GrSLPrecision, "outerThreshold");
SkString sk_TransformedCoords2D_0 = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
SkString sk_TransformedCoords2D_1 = fragBuilder->ensureCoords2D(args.fTransformedCoords[1]);
fragBuilder->codeAppendf(
- "float4 _tmpVar1;float4 color = %stexture(%s, %s).%s%s;\nfloat4 mask_color = "
- "texture(%s, %s).%s;\nif (mask_color.w < 0.5) {\n if (color.w > %s) {\n "
- "float scale = %s / color.w;\n color.xyz *= scale;\n color.w = %s;\n "
- " }\n} else if (color.w < %s) {\n float scale = %s / max(0.001, color.w);\n "
- " color.xyz *= scale;\n color.w = %s;\n}\n%s = color;\n",
+ "half4 _tmpVar1;half4 color = %stexture(%s, %s).%s%s;\nhalf4 mask_color = "
+ "texture(%s, %s).%s;\nif (highfloat(mask_color.w) < 0.5) {\n if (color.w > %s) "
+ "{\n half scale = %s / color.w;\n color.xyz *= scale;\n "
+ "color.w = %s;\n }\n} else if (color.w < %s) {\n half scale = highfloat(%s) "
+ "/ max(0.001, highfloat(color.w));\n color.xyz *= scale;\n color.w = "
+ "%s;\n}\n%s = color;\n",
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(", float4(clamp((%s * float4(_tmpVar1.rgb, 1.0)).rgb, "
- "0.0, _tmpVar1.a), _tmpVar1.a))",
+ ? SkStringPrintf(", half4(clamp((%s * half4(_tmpVar1.rgb, 1.0)).rgb, 0.0, "
+ "_tmpVar1.a), _tmpVar1.a))",
args.fUniformHandler->getUniformCStr(
fColorSpaceHelper.gamutXformUniform()))
.c_str()
diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.fp b/src/effects/GrAlphaThresholdFragmentProcessor.fp
index 481549e..c3b3fbf 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.fp
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.fp
@@ -1,8 +1,8 @@
in uniform sampler2D image;
in uniform colorSpaceXform colorXform;
in uniform sampler2D mask;
-in uniform float innerThreshold;
-in uniform float outerThreshold;
+in uniform half innerThreshold;
+in uniform half outerThreshold;
@class {
inline OptimizationFlags optFlags(float outerThreshold);
@@ -49,16 +49,16 @@
}
void main() {
- float4 color = texture(image, sk_TransformedCoords2D[0], colorXform);
- float4 mask_color = texture(mask, sk_TransformedCoords2D[1]);
+ half4 color = texture(image, sk_TransformedCoords2D[0], colorXform);
+ half4 mask_color = texture(mask, sk_TransformedCoords2D[1]);
if (mask_color.a < 0.5) {
if (color.a > outerThreshold) {
- float scale = outerThreshold / color.a;
+ half scale = outerThreshold / color.a;
color.rgb *= scale;
color.a = outerThreshold;
}
} else if (color.a < innerThreshold) {
- float scale = innerThreshold / max(0.001, color.a);
+ half scale = innerThreshold / max(0.001, color.a);
color.rgb *= scale;
color.a = innerThreshold;
}
diff --git a/src/effects/GrCircleBlurFragmentProcessor.cpp b/src/effects/GrCircleBlurFragmentProcessor.cpp
index 7cec3cc..19f1023 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.cpp
+++ b/src/effects/GrCircleBlurFragmentProcessor.cpp
@@ -232,19 +232,20 @@
const GrCircleBlurFragmentProcessor& _outer =
args.fFp.cast<GrCircleBlurFragmentProcessor>();
(void)_outer;
- fCircleDataVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType,
+ fCircleDataVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
kDefault_GrSLPrecision, "circleData");
fragBuilder->codeAppendf(
- "float2 vec = float2((sk_FragCoord.x - %s.x) * %s.w, (sk_FragCoord.y - %s.y) * "
- "%s.w);\nfloat dist = length(vec) + (0.5 - %s.z) * %s.w;\n%s = %s * texture(%s, "
- "float2(dist, 0.5)).%s.w;\n",
+ "half2 vec = half2(half((sk_FragCoord.x - highfloat(%s.x)) * highfloat(%s.w)), "
+ "half((sk_FragCoord.y - highfloat(%s.y)) * highfloat(%s.w)));\nhalf dist = "
+ "highfloat(length(vec)) + (0.5 - highfloat(%s.z)) * highfloat(%s.w);\n%s = %s * "
+ "texture(%s, highfloat2(half2(dist, 0.5))).%s.w;\n",
args.fUniformHandler->getUniformCStr(fCircleDataVar),
args.fUniformHandler->getUniformCStr(fCircleDataVar),
args.fUniformHandler->getUniformCStr(fCircleDataVar),
args.fUniformHandler->getUniformCStr(fCircleDataVar),
args.fUniformHandler->getUniformCStr(fCircleDataVar),
args.fUniformHandler->getUniformCStr(fCircleDataVar), args.fOutputColor,
- args.fInputColor ? args.fInputColor : "float4(1)",
+ args.fInputColor ? args.fInputColor : "half4(1)",
fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(),
fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str());
}
diff --git a/src/effects/GrCircleBlurFragmentProcessor.fp b/src/effects/GrCircleBlurFragmentProcessor.fp
index 856a468..d91bad8 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.fp
+++ b/src/effects/GrCircleBlurFragmentProcessor.fp
@@ -1,13 +1,13 @@
-in float4 circleRect;
-in float textureRadius;
-in float solidRadius;
+in half4 circleRect;
+in half textureRadius;
+in half solidRadius;
in uniform sampler2D blurProfileSampler;
// The data is formatted as:
// x, y - the center of the circle
// z - inner radius that should map to 0th entry in the texture.
// w - the inverse of the distance over which the texture is stretched.
-uniform float4 circleData;
+uniform half4 circleData;
@optimizationFlags {
kCompatibleWithCoverageAsAlpha_OptimizationFlag
@@ -273,10 +273,10 @@
void main() {
// We just want to compute "(length(vec) - circleData.z + 0.5) * circleData.w" but need to
// rearrange for precision.
- float2 vec = float2((sk_FragCoord.x - circleData.x) * circleData.w,
- (sk_FragCoord.y - circleData.y) * circleData.w);
- float dist = length(vec) + (0.5 - circleData.z) * circleData.w;
- sk_OutColor = sk_InColor * texture(blurProfileSampler, float2(dist, 0.5)).a;
+ half2 vec = half2((sk_FragCoord.x - circleData.x) * circleData.w,
+ (sk_FragCoord.y - circleData.y) * circleData.w);
+ half dist = length(vec) + (0.5 - circleData.z) * circleData.w;
+ sk_OutColor = sk_InColor * texture(blurProfileSampler, half2(dist, 0.5)).a;
}
@test(testData) {
diff --git a/src/effects/SkArithmeticImageFilter.cpp b/src/effects/SkArithmeticImageFilter.cpp
index 34df275..abdfe39 100644
--- a/src/effects/SkArithmeticImageFilter.cpp
+++ b/src/effects/SkArithmeticImageFilter.cpp
@@ -245,18 +245,18 @@
SkString dstColor("dstColor");
this->emitChild(0, &dstColor, args);
- fKUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType,
- kDefault_GrSLPrecision, "k");
+ fKUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+ "k");
const char* kUni = args.fUniformHandler->getUniformCStr(fKUni);
// We don't try to optimize for this case at all
if (!args.fInputColor) {
- fragBuilder->codeAppend("const float4 src = float4(1);");
+ fragBuilder->codeAppend("const half4 src = half4(1);");
} else {
- fragBuilder->codeAppendf("float4 src = %s;", args.fInputColor);
+ fragBuilder->codeAppendf("half4 src = %s;", args.fInputColor);
}
- fragBuilder->codeAppendf("float4 dst = %s;", dstColor.c_str());
+ fragBuilder->codeAppendf("half4 dst = %s;", dstColor.c_str());
fragBuilder->codeAppendf("%s = %s.x * src * dst + %s.y * src + %s.z * dst + %s.w;",
args.fOutputColor, kUni, kUni, kUni, kUni);
fragBuilder->codeAppendf("%s = clamp(%s, 0.0, 1.0);\n", args.fOutputColor,
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 2fc10ed..861a66d 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -862,12 +862,12 @@
const char *profileSize, const char *loc,
const char *blurred_width,
const char *sharp_width) {
- fragBuilder->codeAppendf("float %s;", output);
+ fragBuilder->codeAppendf("half %s;", output);
fragBuilder->codeAppendf("{");
- fragBuilder->codeAppendf("float coord = ((abs(%s - 0.5 * %s) - 0.5 * %s)) / %s;",
+ fragBuilder->codeAppendf("half coord = ((abs(%s - 0.5 * %s) - 0.5 * %s)) / %s;",
loc, blurred_width, sharp_width, profileSize);
fragBuilder->codeAppendf("%s = ", output);
- fragBuilder->appendTextureLookup(sampler, "float2(coord,0.5)");
+ fragBuilder->appendTextureLookup(sampler, "half2(coord,0.5)");
fragBuilder->codeAppend(".a;");
fragBuilder->codeAppendf("}");
}
@@ -889,49 +889,41 @@
const char *rectName;
const char *profileSizeName;
- SkString precisionString;
- if (args.fShaderCaps->usesPrecisionModifiers()) {
- precisionString.printf("%s ", GrGLSLPrecisionString(rbe.precision()));
- }
+ const char* floatType = rbe.precision() == kHigh_GrSLPrecision ? "highfloat" : "half";
fProxyRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType,
- rbe.precision(),
+ rbe.precision() == kHigh_GrSLPrecision ?
+ kHighFloat4_GrSLType : kHalf4_GrSLType,
"proxyRect",
&rectName);
fProfileSizeUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf_GrSLType,
"profileSize",
&profileSizeName);
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
if (args.fInputColor) {
- fragBuilder->codeAppendf("float4 src=%s;", args.fInputColor);
+ fragBuilder->codeAppendf("half4 src=%s;", args.fInputColor);
} else {
- fragBuilder->codeAppendf("float4 src=float4(1);");
+ fragBuilder->codeAppendf("half4 src=half4(1);");
}
- fragBuilder->codeAppendf("%s float2 translatedPos = sk_FragCoord.xy - %s.xy;",
- precisionString.c_str(), rectName);
- fragBuilder->codeAppendf("%s float width = %s.z - %s.x;", precisionString.c_str(), rectName,
- rectName);
- fragBuilder->codeAppendf("%s float height = %s.w - %s.y;", precisionString.c_str(), rectName,
- rectName);
+ fragBuilder->codeAppendf("%s2 translatedPos = sk_FragCoord.xy - %s.xy;", floatType, rectName);
+ fragBuilder->codeAppendf("%s width = %s.z - %s.x;", floatType, rectName, rectName);
+ fragBuilder->codeAppendf("%s height = %s.w - %s.y;", floatType, rectName, rectName);
- fragBuilder->codeAppendf("%s float2 smallDims = float2(width - %s, height - %s);",
- precisionString.c_str(), profileSizeName, profileSizeName);
- fragBuilder->codeAppendf("%s float center = 2.0 * floor(%s/2.0 + .25) - 1.0;",
- precisionString.c_str(), profileSizeName);
- fragBuilder->codeAppendf("%s float2 wh = smallDims - float2(center,center);",
- precisionString.c_str());
+ fragBuilder->codeAppendf("%s2 smallDims = half2(width - %s, height - %s);", floatType,
+ profileSizeName, profileSizeName);
+ fragBuilder->codeAppendf("%s center = 2.0 * floor(%s/2.0 + .25) - 1.0;", floatType,
+ profileSizeName);
+ fragBuilder->codeAppendf("%s2 wh = smallDims - half2(center,center);", floatType);
OutputRectBlurProfileLookup(fragBuilder, args.fTexSamplers[0], "horiz_lookup", profileSizeName,
"translatedPos.x", "width", "wh.x");
OutputRectBlurProfileLookup(fragBuilder, args.fTexSamplers[0], "vert_lookup", profileSizeName,
"translatedPos.y", "height", "wh.y");
- fragBuilder->codeAppendf("float final = horiz_lookup * vert_lookup;");
+ fragBuilder->codeAppendf("half final = horiz_lookup * vert_lookup;");
fragBuilder->codeAppendf("%s = src * final;", args.fOutputColor);
}
@@ -1277,18 +1269,15 @@
// components x, y, z, and w, respectively.
fProxyRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"proxyRect",
&rectName);
fCornerRadiusUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf_GrSLType,
"cornerRadius",
&cornerRadiusName);
fBlurRadiusUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf_GrSLType,
"blurRadius",
&blurRadiusName);
@@ -1296,10 +1285,10 @@
// warp the fragment position to the appropriate part of the 9patch blur texture
- fragBuilder->codeAppendf("float2 rectCenter = (%s.xy + %s.zw)/2.0;", rectName, rectName);
- fragBuilder->codeAppendf("float2 translatedFragPos = sk_FragCoord.xy - %s.xy;", rectName);
- fragBuilder->codeAppendf("float threshold = %s + 2.0*%s;", cornerRadiusName, blurRadiusName);
- fragBuilder->codeAppendf("float2 middle = %s.zw - %s.xy - 2.0*threshold;", rectName, rectName);
+ fragBuilder->codeAppendf("half2 rectCenter = (%s.xy + %s.zw)/2.0;", rectName, rectName);
+ fragBuilder->codeAppendf("half2 translatedFragPos = sk_FragCoord.xy - %s.xy;", rectName);
+ fragBuilder->codeAppendf("half threshold = %s + 2.0*%s;", cornerRadiusName, blurRadiusName);
+ fragBuilder->codeAppendf("half2 middle = %s.zw - %s.xy - 2.0*threshold;", rectName, rectName);
fragBuilder->codeAppendf(
"if (translatedFragPos.x >= threshold && translatedFragPos.x < (middle.x+threshold)) {");
@@ -1315,8 +1304,8 @@
fragBuilder->codeAppendf("translatedFragPos.y -= middle.y - 1.0;");
fragBuilder->codeAppendf("}");
- fragBuilder->codeAppendf("float2 proxyDims = float2(2.0*threshold+1.0);");
- fragBuilder->codeAppendf("float2 texCoord = translatedFragPos / proxyDims;");
+ fragBuilder->codeAppendf("half2 proxyDims = half2(2.0*threshold+1.0);");
+ fragBuilder->codeAppendf("half2 texCoord = translatedFragPos / proxyDims;");
fragBuilder->codeAppendf("%s = ", args.fOutputColor);
fragBuilder->appendTextureLookupAndModulate(args.fInputColor, args.fTexSamplers[0], "texCoord");
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index ff17af1..31f6dc5 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -552,8 +552,7 @@
const GrDisplacementMapEffect& displacementMap = args.fFp.cast<GrDisplacementMapEffect>();
const GrTextureDomain& domain = displacementMap.domain();
- fScaleUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision, "Scale");
+ fScaleUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType, "Scale");
const char* scaleUni = args.fUniformHandler->getUniformCStr(fScaleUni);
const char* dColor = "dColor";
const char* cCoords = "cCoords";
@@ -564,17 +563,17 @@
fColorSpaceHelper.emitCode(args.fUniformHandler, displacementMap.colorSpaceXform());
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
- fragBuilder->codeAppendf("\t\tfloat4 %s = ", dColor);
+ fragBuilder->codeAppendf("\t\thalf4 %s = ", dColor);
fragBuilder->appendTextureLookup(args.fTexSamplers[0], args.fTransformedCoords[0].c_str(),
args.fTransformedCoords[0].getType());
fragBuilder->codeAppend(";\n");
// Unpremultiply the displacement
fragBuilder->codeAppendf(
- "\t\t%s.rgb = (%s.a < %s) ? float3(0.0) : clamp(%s.rgb / %s.a, 0.0, 1.0);",
+ "\t\t%s.rgb = (%s.a < %s) ? half3(0.0) : clamp(%s.rgb / %s.a, 0.0, 1.0);",
dColor, dColor, nearZero, dColor, dColor);
SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[1]);
- fragBuilder->codeAppendf("\t\tfloat2 %s = %s + %s*(%s.",
+ fragBuilder->codeAppendf("\t\thighfloat2 %s = %s + %s*(%s.",
cCoords, coords2D.c_str(), scaleUni, dColor);
switch (displacementMap.xChannelSelector()) {
@@ -612,7 +611,7 @@
default:
SkDEBUGFAIL("Unknown Y channel selector");
}
- fragBuilder->codeAppend("-float2(0.5));\t\t");
+ fragBuilder->codeAppend("-half2(0.5));\t\t");
fGLDomain.sampleTexture(fragBuilder,
args.fUniformHandler,
diff --git a/src/effects/SkHighContrastFilter.cpp b/src/effects/SkHighContrastFilter.cpp
index 3de7603..7618861 100644
--- a/src/effects/SkHighContrastFilter.cpp
+++ b/src/effects/SkHighContrastFilter.cpp
@@ -247,47 +247,46 @@
void GLHighContrastFilterEffect::emitCode(EmitArgs& args) {
const char* contrast;
- fContrastUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ fContrastUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
"contrast", &contrast);
if (nullptr == args.fInputColor) {
- args.fInputColor = "float4(1)";
+ args.fInputColor = "half4(1)";
}
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
- fragBuilder->codeAppendf("float4 color = %s;", args.fInputColor);
+ fragBuilder->codeAppendf("half4 color = %s;", args.fInputColor);
// Unpremultiply. The max() is to guard against 0 / 0.
- fragBuilder->codeAppendf("float nonZeroAlpha = max(color.a, 0.00001);");
- fragBuilder->codeAppendf("color = float4(color.rgb / nonZeroAlpha, nonZeroAlpha);");
+ fragBuilder->codeAppendf("half nonZeroAlpha = max(color.a, 0.00001);");
+ fragBuilder->codeAppendf("color = half4(color.rgb / nonZeroAlpha, nonZeroAlpha);");
// Grayscale.
if (fConfig.fGrayscale) {
- fragBuilder->codeAppendf("float luma = dot(color, float4(%f, %f, %f, 0));",
+ fragBuilder->codeAppendf("half luma = dot(color, half4(%f, %f, %f, 0));",
SK_LUM_COEFF_R, SK_LUM_COEFF_G, SK_LUM_COEFF_B);
- fragBuilder->codeAppendf("color = float4(luma, luma, luma, 0);");
+ fragBuilder->codeAppendf("color = half4(luma, luma, luma, 0);");
}
if (fConfig.fInvertStyle == InvertStyle::kInvertBrightness) {
- fragBuilder->codeAppendf("color = float4(1, 1, 1, 1) - color;");
+ fragBuilder->codeAppendf("color = half4(1, 1, 1, 1) - color;");
}
if (fConfig.fInvertStyle == InvertStyle::kInvertLightness) {
// Convert from RGB to HSL.
- fragBuilder->codeAppendf("float fmax = max(color.r, max(color.g, color.b));");
- fragBuilder->codeAppendf("float fmin = min(color.r, min(color.g, color.b));");
- fragBuilder->codeAppendf("float l = (fmax + fmin) / 2;");
+ fragBuilder->codeAppendf("half fmax = max(color.r, max(color.g, color.b));");
+ fragBuilder->codeAppendf("half fmin = min(color.r, min(color.g, color.b));");
+ fragBuilder->codeAppendf("half l = (fmax + fmin) / 2;");
- fragBuilder->codeAppendf("float h;");
- fragBuilder->codeAppendf("float s;");
+ fragBuilder->codeAppendf("half h;");
+ fragBuilder->codeAppendf("half s;");
fragBuilder->codeAppendf("if (fmax == fmin) {");
fragBuilder->codeAppendf(" h = 0;");
fragBuilder->codeAppendf(" s = 0;");
fragBuilder->codeAppendf("} else {");
- fragBuilder->codeAppendf(" float d = fmax - fmin;");
+ fragBuilder->codeAppendf(" half d = fmax - fmin;");
fragBuilder->codeAppendf(" s = l > 0.5 ?");
fragBuilder->codeAppendf(" d / (2 - fmax - fmin) :");
fragBuilder->codeAppendf(" d / (fmax + fmin);");
@@ -305,11 +304,11 @@
// Convert back from HSL to RGB.
SkString hue2rgbFuncName;
static const GrShaderVar gHue2rgbArgs[] = {
- GrShaderVar("p", kFloat_GrSLType),
- GrShaderVar("q", kFloat_GrSLType),
- GrShaderVar("t", kFloat_GrSLType),
+ GrShaderVar("p", kHalf_GrSLType),
+ GrShaderVar("q", kHalf_GrSLType),
+ GrShaderVar("t", kHalf_GrSLType),
};
- fragBuilder->emitFunction(kFloat_GrSLType,
+ fragBuilder->emitFunction(kHalf_GrSLType,
"hue2rgb",
SK_ARRAY_COUNT(gHue2rgbArgs),
gHue2rgbArgs,
@@ -326,10 +325,10 @@
"return p;",
&hue2rgbFuncName);
fragBuilder->codeAppendf("if (s == 0) {");
- fragBuilder->codeAppendf(" color = float4(l, l, l, 0);");
+ fragBuilder->codeAppendf(" color = half4(l, l, l, 0);");
fragBuilder->codeAppendf("} else {");
- fragBuilder->codeAppendf(" float q = l < 0.5 ? l * (1 + s) : l + s - l * s;");
- fragBuilder->codeAppendf(" float p = 2 * l - q;");
+ fragBuilder->codeAppendf(" half q = l < 0.5 ? l * (1 + s) : l + s - l * s;");
+ fragBuilder->codeAppendf(" half p = 2 * l - q;");
fragBuilder->codeAppendf(" color.r = %s(p, q, h + 1/3.);", hue2rgbFuncName.c_str());
fragBuilder->codeAppendf(" color.g = %s(p, q, h);", hue2rgbFuncName.c_str());
fragBuilder->codeAppendf(" color.b = %s(p, q, h - 1/3.);", hue2rgbFuncName.c_str());
@@ -338,8 +337,8 @@
// Contrast.
fragBuilder->codeAppendf("if (%s != 0) {", contrast);
- fragBuilder->codeAppendf(" float m = (1 + %s) / (1 - %s);", contrast, contrast);
- fragBuilder->codeAppendf(" float off = (-0.5 * m + 0.5);");
+ fragBuilder->codeAppendf(" half m = (1 + %s) / (1 - %s);", contrast, contrast);
+ fragBuilder->codeAppendf(" half off = (-0.5 * m + 0.5);");
fragBuilder->codeAppendf(" color = m * color + off;");
fragBuilder->codeAppendf("}");
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 1b8849a..1c47f92 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -724,7 +724,7 @@
/**
* This is called by GrGLLightingEffect::emitCode() before either of the two virtual functions
- * below. It adds a vec3f uniform visible in the FS that represents the constant light color.
+ * below. It adds a half3 uniform visible in the FS that represents the constant light color.
*/
void emitLightColorUniform(GrGLSLUniformHandler*);
@@ -1827,63 +1827,61 @@
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
- "ImageIncrement");
+ kHalf2_GrSLType, "ImageIncrement");
fSurfaceScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
- "SurfaceScale");
+ kHalf_GrSLType, "SurfaceScale");
fLight->emitLightColorUniform(uniformHandler);
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
SkString lightFunc;
this->emitLightFunc(uniformHandler, fragBuilder, &lightFunc);
static const GrShaderVar gSobelArgs[] = {
- GrShaderVar("a", kFloat_GrSLType),
- GrShaderVar("b", kFloat_GrSLType),
- GrShaderVar("c", kFloat_GrSLType),
- GrShaderVar("d", kFloat_GrSLType),
- GrShaderVar("e", kFloat_GrSLType),
- GrShaderVar("f", kFloat_GrSLType),
- GrShaderVar("scale", kFloat_GrSLType),
+ GrShaderVar("a", kHalf_GrSLType),
+ GrShaderVar("b", kHalf_GrSLType),
+ GrShaderVar("c", kHalf_GrSLType),
+ GrShaderVar("d", kHalf_GrSLType),
+ GrShaderVar("e", kHalf_GrSLType),
+ GrShaderVar("f", kHalf_GrSLType),
+ GrShaderVar("scale", kHalf_GrSLType),
};
SkString sobelFuncName;
SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
- fragBuilder->emitFunction(kFloat_GrSLType,
+ fragBuilder->emitFunction(kHalf_GrSLType,
"sobel",
SK_ARRAY_COUNT(gSobelArgs),
gSobelArgs,
"\treturn (-a + b - 2.0 * c + 2.0 * d -e + f) * scale;\n",
&sobelFuncName);
static const GrShaderVar gPointToNormalArgs[] = {
- GrShaderVar("x", kFloat_GrSLType),
- GrShaderVar("y", kFloat_GrSLType),
- GrShaderVar("scale", kFloat_GrSLType),
+ GrShaderVar("x", kHalf_GrSLType),
+ GrShaderVar("y", kHalf_GrSLType),
+ GrShaderVar("scale", kHalf_GrSLType),
};
SkString pointToNormalName;
- fragBuilder->emitFunction(kVec3f_GrSLType,
+ fragBuilder->emitFunction(kHalf3_GrSLType,
"pointToNormal",
SK_ARRAY_COUNT(gPointToNormalArgs),
gPointToNormalArgs,
- "\treturn normalize(float3(-x * scale, -y * scale, 1));\n",
+ "\treturn normalize(half3(-x * scale, -y * scale, 1));\n",
&pointToNormalName);
static const GrShaderVar gInteriorNormalArgs[] = {
- GrShaderVar("m", kFloat_GrSLType, 9),
- GrShaderVar("surfaceScale", kFloat_GrSLType),
+ GrShaderVar("m", kHalf_GrSLType, 9),
+ GrShaderVar("surfaceScale", kHalf_GrSLType),
};
SkString normalBody = emitNormalFunc(le.boundaryMode(),
pointToNormalName.c_str(),
sobelFuncName.c_str());
SkString normalName;
- fragBuilder->emitFunction(kVec3f_GrSLType,
+ fragBuilder->emitFunction(kHalf3_GrSLType,
"normal",
SK_ARRAY_COUNT(gInteriorNormalArgs),
gInteriorNormalArgs,
normalBody.c_str(),
&normalName);
- fragBuilder->codeAppendf("\t\tfloat2 coord = %s;\n", coords2D.c_str());
- fragBuilder->codeAppend("\t\tfloat m[9];\n");
+ fragBuilder->codeAppendf("\t\thighfloat2 coord = %s;\n", coords2D.c_str());
+ fragBuilder->codeAppend("\t\thalf m[9];\n");
const char* imgInc = uniformHandler->getUniformCStr(fImageIncrementUni);
const char* surfScale = uniformHandler->getUniformCStr(fSurfaceScaleUni);
@@ -1892,10 +1890,10 @@
for (int dy = 1; dy >= -1; dy--) {
for (int dx = -1; dx <= 1; dx++) {
SkString texCoords;
- texCoords.appendf("coord + float2(%d, %d) * %s", dx, dy, imgInc);
+ texCoords.appendf("coord + half2(%d, %d) * %s", dx, dy, imgInc);
SkString temp;
temp.appendf("temp%d", index);
- fragBuilder->codeAppendf("float4 %s;", temp.c_str());
+ fragBuilder->codeAppendf("half4 %s;", temp.c_str());
fDomain.sampleTexture(fragBuilder,
args.fUniformHandler,
args.fShaderCaps,
@@ -1907,7 +1905,7 @@
index++;
}
}
- fragBuilder->codeAppend("\t\tfloat3 surfaceToLight = ");
+ fragBuilder->codeAppend("\t\thalf3 surfaceToLight = ");
SkString arg;
arg.appendf("%s * m[4]", surfScale);
fLight->emitSurfaceToLight(uniformHandler, fragBuilder, arg.c_str());
@@ -1953,19 +1951,17 @@
GrGLSLFPFragmentBuilder* fragBuilder,
SkString* funcName) {
const char* kd;
- fKDUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
- "KD", &kd);
+ fKDUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "KD", &kd);
static const GrShaderVar gLightArgs[] = {
- GrShaderVar("normal", kVec3f_GrSLType),
- GrShaderVar("surfaceToLight", kVec3f_GrSLType),
- GrShaderVar("lightColor", kVec3f_GrSLType)
+ GrShaderVar("normal", kHalf3_GrSLType),
+ GrShaderVar("surfaceToLight", kHalf3_GrSLType),
+ GrShaderVar("lightColor", kHalf3_GrSLType)
};
SkString lightBody;
- lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n", kd);
- lightBody.appendf("\treturn float4(lightColor * clamp(colorScale, 0.0, 1.0), 1.0);\n");
- fragBuilder->emitFunction(kVec4f_GrSLType,
+ lightBody.appendf("\thalf colorScale = %s * dot(normal, surfaceToLight);\n", kd);
+ lightBody.appendf("\treturn half4(lightColor * clamp(colorScale, 0.0, 1.0), 1.0);\n");
+ fragBuilder->emitFunction(kHalf4_GrSLType,
"light",
SK_ARRAY_COUNT(gLightArgs),
gLightArgs,
@@ -2051,26 +2047,24 @@
const char* ks;
const char* shininess;
- fKSUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision, "KS", &ks);
+ fKSUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "KS", &ks);
fShininessUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf_GrSLType,
"Shininess",
&shininess);
static const GrShaderVar gLightArgs[] = {
- GrShaderVar("normal", kVec3f_GrSLType),
- GrShaderVar("surfaceToLight", kVec3f_GrSLType),
- GrShaderVar("lightColor", kVec3f_GrSLType)
+ GrShaderVar("normal", kHalf3_GrSLType),
+ GrShaderVar("surfaceToLight", kHalf3_GrSLType),
+ GrShaderVar("lightColor", kHalf3_GrSLType)
};
SkString lightBody;
- lightBody.appendf("\tfloat3 halfDir = float3(normalize(surfaceToLight + float3(0, 0, 1)));\n");
- lightBody.appendf("\thighp float colorScale = %s * pow(dot(normal, halfDir), %s);\n",
+ lightBody.appendf("\thalf3 halfDir = half3(normalize(surfaceToLight + half3(0, 0, 1)));\n");
+ lightBody.appendf("\thighfloat colorScale = %s * pow(dot(normal, halfDir), %s);\n",
ks, shininess);
- lightBody.appendf("\tfloat3 color = lightColor * clamp(colorScale, 0.0, 1.0);\n");
- lightBody.appendf("\treturn float4(color, max(max(color.r, color.g), color.b));\n");
- fragBuilder->emitFunction(kVec4f_GrSLType,
+ lightBody.appendf("\thalf3 color = lightColor * clamp(colorScale, 0.0, 1.0);\n");
+ lightBody.appendf("\treturn half4(color, max(max(color.r, color.g), color.b));\n");
+ fragBuilder->emitFunction(kHalf4_GrSLType,
"light",
SK_ARRAY_COUNT(gLightArgs),
gLightArgs,
@@ -2088,9 +2082,7 @@
///////////////////////////////////////////////////////////////////////////////
void GrGLLight::emitLightColorUniform(GrGLSLUniformHandler* uniformHandler) {
- fColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec3f_GrSLType, kDefault_GrSLPrecision,
- "LightColor");
+ fColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType, "LightColor");
}
void GrGLLight::emitLightColor(GrGLSLUniformHandler* uniformHandler,
@@ -2119,8 +2111,7 @@
GrGLSLFPFragmentBuilder* fragBuilder,
const char* z) {
const char* dir;
- fDirectionUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec3f_GrSLType, kDefault_GrSLPrecision,
+ fDirectionUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
"LightDirection", &dir);
fragBuilder->codeAppend(dir);
}
@@ -2139,10 +2130,9 @@
GrGLSLFPFragmentBuilder* fragBuilder,
const char* z) {
const char* loc;
- fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec3f_GrSLType, kDefault_GrSLPrecision,
+ fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
"LightLocation", &loc);
- fragBuilder->codeAppendf("normalize(%s - float3(sk_FragCoord.xy, %s))",
+ fragBuilder->codeAppendf("normalize(%s - half3(sk_FragCoord.xy, %s))",
loc, z);
}
@@ -2165,11 +2155,10 @@
GrGLSLFPFragmentBuilder* fragBuilder,
const char* z) {
const char* location;
- fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec3f_GrSLType, kDefault_GrSLPrecision,
+ fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
"LightLocation", &location);
- fragBuilder->codeAppendf("normalize(%s - float3(sk_FragCoord.xy, %s))",
+ fragBuilder->codeAppendf("normalize(%s - half3(sk_FragCoord.xy, %s))",
location, z);
}
@@ -2184,36 +2173,31 @@
const char* cosOuter;
const char* coneScale;
const char* s;
- fExponentUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ fExponentUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
"Exponent", &exponent);
- fCosInnerConeAngleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ fCosInnerConeAngleUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
"CosInnerConeAngle", &cosInner);
- fCosOuterConeAngleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ fCosOuterConeAngleUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
"CosOuterConeAngle", &cosOuter);
- fConeScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ fConeScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
"ConeScale", &coneScale);
- fSUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec3f_GrSLType, kDefault_GrSLPrecision, "S", &s);
+ fSUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType, "S", &s);
static const GrShaderVar gLightColorArgs[] = {
- GrShaderVar("surfaceToLight", kVec3f_GrSLType)
+ GrShaderVar("surfaceToLight", kHalf3_GrSLType)
};
SkString lightColorBody;
- lightColorBody.appendf("\tfloat cosAngle = -dot(surfaceToLight, %s);\n", s);
+ lightColorBody.appendf("\thalf cosAngle = -dot(surfaceToLight, %s);\n", s);
lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosOuter);
- lightColorBody.appendf("\t\treturn float3(0);\n");
+ lightColorBody.appendf("\t\treturn half3(0);\n");
lightColorBody.appendf("\t}\n");
- lightColorBody.appendf("\tfloat scale = pow(cosAngle, %s);\n", exponent);
+ lightColorBody.appendf("\thalf scale = pow(cosAngle, %s);\n", exponent);
lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosInner);
lightColorBody.appendf("\t\treturn %s * scale * (cosAngle - %s) * %s;\n",
color, cosOuter, coneScale);
lightColorBody.appendf("\t}\n");
lightColorBody.appendf("\treturn %s;\n", color);
- fragBuilder->emitFunction(kVec3f_GrSLType,
+ fragBuilder->emitFunction(kHalf3_GrSLType,
"lightColor",
SK_ARRAY_COUNT(gLightColorArgs),
gLightColorArgs,
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index 4422733..f3d9f40 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -60,16 +60,16 @@
void emitCode(EmitArgs& args) override {
if (nullptr == args.fInputColor) {
- args.fInputColor = "float4(1)";
+ args.fInputColor = "half4(1)";
}
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
- fragBuilder->codeAppendf("\tfloat luma = dot(float3(%f, %f, %f), %s.rgb);\n",
+ fragBuilder->codeAppendf("\thalf luma = dot(half3(%f, %f, %f), %s.rgb);\n",
SK_ITU_BT709_LUM_COEFF_R,
SK_ITU_BT709_LUM_COEFF_G,
SK_ITU_BT709_LUM_COEFF_B,
args.fInputColor);
- fragBuilder->codeAppendf("\t%s = float4(0, 0, 0, luma);\n",
+ fragBuilder->codeAppendf("\t%s = half4(0, 0, 0, luma);\n",
args.fOutputColor);
}
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index ba01969..1ad41ae 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -180,48 +180,44 @@
void GrGLMagnifierEffect::emitCode(EmitArgs& args) {
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
fOffsetVar = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
- "Offset");
+ kHalf2_GrSLType, "Offset");
fInvZoomVar = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
- "InvZoom");
+ kHalf2_GrSLType, "InvZoom");
fInvInsetVar = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
- "InvInset");
+ kHalf2_GrSLType, "InvInset");
fBoundsVar = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
- "Bounds");
+ kHalf4_GrSLType, "Bounds");
const GrMagnifierEffect& zoom = args.fFp.cast<GrMagnifierEffect>();
fColorSpaceHelper.emitCode(uniformHandler, zoom.colorSpaceXform());
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
- fragBuilder->codeAppendf("\t\tfloat2 coord = %s;\n", coords2D.c_str());
- fragBuilder->codeAppendf("\t\tfloat2 zoom_coord = %s + %s * %s;\n",
+ fragBuilder->codeAppendf("\t\thighfloat2 coord = %s;\n", coords2D.c_str());
+ fragBuilder->codeAppendf("\t\thighfloat2 zoom_coord = %s + %s * %s;\n",
uniformHandler->getUniformCStr(fOffsetVar),
coords2D.c_str(),
uniformHandler->getUniformCStr(fInvZoomVar));
const char* bounds = uniformHandler->getUniformCStr(fBoundsVar);
- fragBuilder->codeAppendf("\t\tfloat2 delta = (coord - %s.xy) * %s.zw;\n", bounds, bounds);
- fragBuilder->codeAppendf("\t\tdelta = min(delta, float2(1.0, 1.0) - delta);\n");
+ fragBuilder->codeAppendf("\t\thighfloat2 delta = (coord - %s.xy) * %s.zw;\n", bounds, bounds);
+ fragBuilder->codeAppendf("\t\tdelta = min(delta, half2(1.0, 1.0) - delta);\n");
fragBuilder->codeAppendf("\t\tdelta = delta * %s;\n",
uniformHandler->getUniformCStr(fInvInsetVar));
- fragBuilder->codeAppend("\t\tfloat weight = 0.0;\n");
+ fragBuilder->codeAppend("\t\thalf weight = 0.0;\n");
fragBuilder->codeAppend("\t\tif (delta.s < 2.0 && delta.t < 2.0) {\n");
- fragBuilder->codeAppend("\t\t\tdelta = float2(2.0, 2.0) - delta;\n");
- fragBuilder->codeAppend("\t\t\tfloat dist = length(delta);\n");
+ fragBuilder->codeAppend("\t\t\tdelta = half2(2.0, 2.0) - delta;\n");
+ fragBuilder->codeAppend("\t\t\thalf dist = length(delta);\n");
fragBuilder->codeAppend("\t\t\tdist = max(2.0 - dist, 0.0);\n");
fragBuilder->codeAppend("\t\t\tweight = min(dist * dist, 1.0);\n");
fragBuilder->codeAppend("\t\t} else {\n");
- fragBuilder->codeAppend("\t\t\tfloat2 delta_squared = delta * delta;\n");
+ fragBuilder->codeAppend("\t\t\thighfloat2 delta_squared = delta * delta;\n");
fragBuilder->codeAppend("\t\t\tweight = min(min(delta_squared.x, delta_squared.y), 1.0);\n");
fragBuilder->codeAppend("\t\t}\n");
- fragBuilder->codeAppend("\t\tfloat2 mix_coord = mix(coord, zoom_coord, weight);\n");
- fragBuilder->codeAppend("\t\tfloat4 output_color = ");
- fragBuilder->appendTextureLookup(args.fTexSamplers[0], "mix_coord", kVec2f_GrSLType,
+ fragBuilder->codeAppend("\t\thighfloat2 mix_coord = mix(coord, zoom_coord, weight);\n");
+ fragBuilder->codeAppend("\t\thalf4 output_color = ");
+ fragBuilder->appendTextureLookup(args.fTexSamplers[0], "mix_coord", kHalf2_GrSLType,
&fColorSpaceHelper);
fragBuilder->codeAppend(";\n");
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index 5f59637..7666fba 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -212,13 +212,9 @@
const GrMorphologyEffect& me = args.fFp.cast<GrMorphologyEffect>();
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
- fPixelSizeUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
- "PixelSize");
+ fPixelSizeUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "PixelSize");
const char* pixelSizeInc = uniformHandler->getUniformCStr(fPixelSizeUni);
- fRangeUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
- "Range");
+ fRangeUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHighFloat2_GrSLType, "Range");
const char* range = uniformHandler->getUniformCStr(fRangeUni);
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
@@ -226,11 +222,11 @@
const char* func;
switch (me.type()) {
case GrMorphologyEffect::Type::kErode:
- fragBuilder->codeAppendf("\t\t%s = float4(1, 1, 1, 1);\n", args.fOutputColor);
+ fragBuilder->codeAppendf("\t\t%s = half4(1, 1, 1, 1);\n", args.fOutputColor);
func = "min";
break;
case GrMorphologyEffect::Type::kDilate:
- fragBuilder->codeAppendf("\t\t%s = float4(0, 0, 0, 0);\n", args.fOutputColor);
+ fragBuilder->codeAppendf("\t\t%s = half4(0, 0, 0, 0);\n", args.fOutputColor);
func = "max";
break;
default:
@@ -255,12 +251,12 @@
int width = me.width();
// float2 coord = coord2D;
- fragBuilder->codeAppendf("\t\tfloat2 coord = %s;\n", coords2D.c_str());
+ fragBuilder->codeAppendf("\t\thighfloat2 coord = %s;\n", coords2D.c_str());
// coord.x -= radius * pixelSize;
fragBuilder->codeAppendf("\t\tcoord.%s -= %d.0 * %s; \n", dir, me.radius(), pixelSizeInc);
if (me.useRange()) {
// highBound = min(highBound, coord.x + (width-1) * pixelSize);
- fragBuilder->codeAppendf("\t\tfloat highBound = min(%s.y, coord.%s + %f * %s);",
+ fragBuilder->codeAppendf("\t\thighfloat highBound = min(%s.y, coord.%s + %f * %s);",
range, dir, float(width - 1), pixelSizeInc);
// coord.x = max(lowBound, coord.x);
fragBuilder->codeAppendf("\t\tcoord.%s = max(%s.x, coord.%s);", dir, range, dir);
diff --git a/src/effects/SkOverdrawColorFilter.cpp b/src/effects/SkOverdrawColorFilter.cpp
index 8ca699e..be5a623 100644
--- a/src/effects/SkOverdrawColorFilter.cpp
+++ b/src/effects/SkOverdrawColorFilter.cpp
@@ -150,49 +150,49 @@
void GLOverdrawFragmentProcessor::emitCode(EmitArgs& args) {
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
if (nullptr == args.fInputColor) {
- fragBuilder->codeAppendf("%s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
- fColors[5].fRGBA[0],
- fColors[5].fRGBA[1],
- fColors[5].fRGBA[2],
- fColors[5].fRGBA[3]);
+ fragBuilder->codeAppendf("%s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
+ fColors[5].fRGBA[0],
+ fColors[5].fRGBA[1],
+ fColors[5].fRGBA[2],
+ fColors[5].fRGBA[3]);
} else {
- fragBuilder->codeAppendf("float alpha = 255.0 * %s.a;", args.fInputColor);
+ fragBuilder->codeAppendf("half alpha = 255.0 * %s.a;", args.fInputColor);
fragBuilder->codeAppendf("if (alpha < 0.5) {");
- fragBuilder->codeAppendf(" %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
- fColors[0].fRGBA[0],
- fColors[0].fRGBA[1],
- fColors[0].fRGBA[2],
- fColors[0].fRGBA[3]);
+ fragBuilder->codeAppendf(" %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
+ fColors[0].fRGBA[0],
+ fColors[0].fRGBA[1],
+ fColors[0].fRGBA[2],
+ fColors[0].fRGBA[3]);
fragBuilder->codeAppendf("} else if (alpha < 1.5) {");
- fragBuilder->codeAppendf(" %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
- fColors[1].fRGBA[0],
- fColors[1].fRGBA[1],
- fColors[1].fRGBA[2],
- fColors[1].fRGBA[3]);
+ fragBuilder->codeAppendf(" %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
+ fColors[1].fRGBA[0],
+ fColors[1].fRGBA[1],
+ fColors[1].fRGBA[2],
+ fColors[1].fRGBA[3]);
fragBuilder->codeAppendf("} else if (alpha < 2.5) {");
- fragBuilder->codeAppendf(" %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
- fColors[2].fRGBA[0],
- fColors[2].fRGBA[1],
- fColors[2].fRGBA[2],
- fColors[2].fRGBA[3]);
+ fragBuilder->codeAppendf(" %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
+ fColors[2].fRGBA[0],
+ fColors[2].fRGBA[1],
+ fColors[2].fRGBA[2],
+ fColors[2].fRGBA[3]);
fragBuilder->codeAppendf("} else if (alpha < 3.5) {");
- fragBuilder->codeAppendf(" %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
- fColors[3].fRGBA[0],
- fColors[3].fRGBA[1],
- fColors[3].fRGBA[2],
- fColors[3].fRGBA[3]);
+ fragBuilder->codeAppendf(" %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
+ fColors[3].fRGBA[0],
+ fColors[3].fRGBA[1],
+ fColors[3].fRGBA[2],
+ fColors[3].fRGBA[3]);
fragBuilder->codeAppendf("} else if (alpha < 4.5) {");
- fragBuilder->codeAppendf(" %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
- fColors[4].fRGBA[0],
- fColors[4].fRGBA[1],
- fColors[4].fRGBA[2],
- fColors[4].fRGBA[3]);
+ fragBuilder->codeAppendf(" %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
+ fColors[4].fRGBA[0],
+ fColors[4].fRGBA[1],
+ fColors[4].fRGBA[2],
+ fColors[4].fRGBA[3]);
fragBuilder->codeAppendf("} else {");
- fragBuilder->codeAppendf(" %s.rgba = float4(%f, %f, %f, %f);", args.fOutputColor,
- fColors[5].fRGBA[0],
- fColors[5].fRGBA[1],
- fColors[5].fRGBA[2],
- fColors[5].fRGBA[3]);
+ fragBuilder->codeAppendf(" %s.rgba = half4(%f, %f, %f, %f);", args.fOutputColor,
+ fColors[5].fRGBA[0],
+ fColors[5].fRGBA[1],
+ fColors[5].fRGBA[2],
+ fColors[5].fRGBA[3]);
fragBuilder->codeAppendf("}");
}
}
diff --git a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
index 2f045f1..b0e7ca3 100644
--- a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
+++ b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
@@ -241,7 +241,7 @@
// Positive distance is towards the center of the circle.
// Map all the cases to the lower right quadrant.
- fragBuilder->codeAppendf("float2 delta = abs(sk_FragCoord.xy - %s.%s);",
+ fragBuilder->codeAppendf("half2 delta = abs(sk_FragCoord.xy - %s.%s);",
posName, indices);
switch (mode) {
@@ -249,14 +249,14 @@
// When a shadow circle gets large we can have some precision issues if
// we do "length(delta)/radius". The scaleDist temporary cuts the
// delta vector down a bit before invoking length.
- fragBuilder->codeAppendf("float scaledDist = length(delta/%s);", radName);
+ fragBuilder->codeAppendf("half scaledDist = length(delta/%s);", radName);
fragBuilder->codeAppendf("%s = clamp((%s.%c/%s - scaledDist), 0.0, 1.0);",
outputName, sizesName, indices[0], radName);
break;
case kRect_Mode:
fragBuilder->codeAppendf(
- "float2 rectDist = float2(1.0 - clamp((%s.%c - delta.x)/%s, 0.0, 1.0),"
- "1.0 - clamp((%s.%c - delta.y)/%s, 0.0, 1.0));",
+ "half2 rectDist = half2(1.0 - clamp((%s.%c - delta.x)/%s, 0.0, 1.0),"
+ "1.0 - clamp((%s.%c - delta.y)/%s, 0.0, 1.0));",
sizesName, indices[0], radName,
sizesName, indices[1], radName);
fragBuilder->codeAppendf("%s = clamp(1.0 - length(rectDist), 0.0, 1.0);",
@@ -273,11 +273,11 @@
//----------------
// rect distance computation
- fragBuilder->codeAppendf("float xDist = (%s.%c - delta.x) / %s;",
+ fragBuilder->codeAppendf("half xDist = (%s.%c - delta.x) / %s;",
sizesName, indices[0], radName);
- fragBuilder->codeAppendf("float yDist = (%s.%c - delta.y) / %s;",
+ fragBuilder->codeAppendf("half yDist = (%s.%c - delta.y) / %s;",
sizesName, indices[1], radName);
- fragBuilder->codeAppend("float rectDist = clamp(min(xDist, yDist), 0.0, 1.0);");
+ fragBuilder->codeAppend("half rectDist = clamp(min(xDist, yDist), 0.0, 1.0);");
//----------------
// ice-cream-cone fractional distance computation
@@ -286,59 +286,59 @@
// compute the pointy end of the ice cream cone. If it smaller we just want to
// use the center of the corner's circle. When using the blurRadius the inset
// amount can't exceed the halfwidths of the RRect.
- fragBuilder->codeAppendf("float insetDist = min(max(%s, %s.%c),"
+ fragBuilder->codeAppendf("half insetDist = min(max(%s, %s.%c),"
"min(%s.%c, %s.%c));",
radName, radiiName, indices[0],
sizesName, indices[0], sizesName, indices[1]);
// "maxValue" is a correction term for if the blurRadius is larger than the
// size of the RRect. In that case we don't want to go all the way to black.
- fragBuilder->codeAppendf("float maxValue = insetDist/%s;", radName);
+ fragBuilder->codeAppendf("half maxValue = insetDist/%s;", radName);
- fragBuilder->codeAppendf("float2 coneBottom = float2(%s.%c - insetDist,"
- "%s.%c - insetDist);",
+ fragBuilder->codeAppendf("half2 coneBottom = half2(%s.%c - insetDist,"
+ "%s.%c - insetDist);",
sizesName, indices[0], sizesName, indices[1]);
- fragBuilder->codeAppendf("float2 cornerTop = float2(%s.%c - %s.%c, %s.%c) -"
+ fragBuilder->codeAppendf("half2 cornerTop = half2(%s.%c - %s.%c, %s.%c) -"
"coneBottom;",
sizesName, indices[0], radiiName, indices[0],
sizesName, indices[1]);
- fragBuilder->codeAppendf("float2 cornerRight = float2(%s.%c, %s.%c - %s.%c) -"
+ fragBuilder->codeAppendf("half2 cornerRight = half2(%s.%c, %s.%c - %s.%c) -"
"coneBottom;",
sizesName, indices[0],
sizesName, indices[1], radiiName, indices[1]);
- fragBuilder->codeAppend("float2 ptInConeSpace = delta - coneBottom;");
- fragBuilder->codeAppend("float distToPtInConeSpace = length(ptInConeSpace);");
+ fragBuilder->codeAppend("half2 ptInConeSpace = delta - coneBottom;");
+ fragBuilder->codeAppend("half distToPtInConeSpace = length(ptInConeSpace);");
- fragBuilder->codeAppend("float cross1 = ptInConeSpace.x * cornerTop.y -"
- "ptInConeSpace.y * cornerTop.x;");
- fragBuilder->codeAppend("float cross2 = -ptInConeSpace.x * cornerRight.y + "
- "ptInConeSpace.y * cornerRight.x;");
+ fragBuilder->codeAppend("half cross1 = ptInConeSpace.x * cornerTop.y -"
+ "ptInConeSpace.y * cornerTop.x;");
+ fragBuilder->codeAppend("half cross2 = -ptInConeSpace.x * cornerRight.y + "
+ "ptInConeSpace.y * cornerRight.x;");
- fragBuilder->codeAppend("float inCone = step(0.0, cross1) *"
- "step(0.0, cross2);");
+ fragBuilder->codeAppend("half inCone = step(0.0, cross1) *"
+ "step(0.0, cross2);");
- fragBuilder->codeAppendf("float2 cornerCenterInConeSpace = float2(insetDist -"
+ fragBuilder->codeAppendf("half2 cornerCenterInConeSpace = half2(insetDist -"
"%s.%c);",
radiiName, indices[0]);
- fragBuilder->codeAppend("float2 connectingVec = ptInConeSpace -"
+ fragBuilder->codeAppend("half2 connectingVec = ptInConeSpace -"
"cornerCenterInConeSpace;");
fragBuilder->codeAppend("ptInConeSpace = normalize(ptInConeSpace);");
// "a" (i.e., dot(ptInConeSpace, ptInConeSpace) should always be 1.0f since
// ptInConeSpace is now normalized
- fragBuilder->codeAppend("float b = 2.0 * dot(ptInConeSpace, connectingVec);");
- fragBuilder->codeAppendf("float c = dot(connectingVec, connectingVec) - "
+ fragBuilder->codeAppend("half b = 2.0 * dot(ptInConeSpace, connectingVec);");
+ fragBuilder->codeAppendf("half c = dot(connectingVec, connectingVec) - "
"%s.%c * %s.%c;",
radiiName, indices[0], radiiName, indices[0]);
- fragBuilder->codeAppend("float fourAC = 4*c;");
+ fragBuilder->codeAppend("half fourAC = 4*c;");
// This max prevents sqrt(-1) when outside the cone
- fragBuilder->codeAppend("float bSq = max(b*b, fourAC);");
+ fragBuilder->codeAppend("half bSq = max(b*b, fourAC);");
// lop off negative values that are outside the cone
- fragBuilder->codeAppend("float coneDist = "
+ fragBuilder->codeAppend("half coneDist = "
"max(0.0, 0.5 * (-b + sqrt(bSq - fourAC)));");
// make the coneDist a fraction of how far it is from the edge to the
// cone's base
@@ -358,42 +358,38 @@
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
const char* positionsUniName = nullptr;
- fPositionsUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ fPositionsUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
"Positions", &positionsUniName);
const char* sizesUniName = nullptr;
- fSizesUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
- "Sizes", &sizesUniName);
+ fSizesUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+ kDefault_GrSLPrecision, "Sizes", &sizesUniName);
const char* radiiUniName = nullptr;
if (fp.fFirstMode == kSimpleCircular_Mode || fp.fSecondMode == kSimpleCircular_Mode) {
- fRadiiUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ fRadiiUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
"Radii", &radiiUniName);
}
const char* radUniName = nullptr;
- fRadiusUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ fRadiusUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
"Radius", &radUniName);
- fragBuilder->codeAppend("float firstDist;");
+ fragBuilder->codeAppend("half firstDist;");
fragBuilder->codeAppend("{");
this->emitModeCode(fp.firstMode(), fragBuilder,
positionsUniName, sizesUniName, radiiUniName,
radUniName, "firstDist", "xy");
fragBuilder->codeAppend("}");
- fragBuilder->codeAppend("float secondDist;");
+ fragBuilder->codeAppend("half secondDist;");
fragBuilder->codeAppend("{");
this->emitModeCode(fp.secondMode(), fragBuilder,
positionsUniName, sizesUniName, radiiUniName,
radUniName, "secondDist", "zw");
fragBuilder->codeAppend("}");
- fragBuilder->codeAppend("float2 distVec = float2(1.0 - firstDist, 1.0 - secondDist);");
+ fragBuilder->codeAppend("half2 distVec = half2(1.0 - firstDist, 1.0 - secondDist);");
// Finally use the distance to apply the Gaussian edge
- fragBuilder->codeAppend("float factor = clamp(length(distVec), 0.0, 1.0);");
+ fragBuilder->codeAppend("half factor = clamp(length(distVec), 0.0, 1.0);");
fragBuilder->codeAppend("factor = exp(-factor * factor * 4.0) - 0.018;");
fragBuilder->codeAppendf("%s = factor*%s;",
args.fOutputColor, args.fInputColor);
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 2101bd6..cbfe3ab 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -396,8 +396,7 @@
void GLColorTableEffect::emitCode(EmitArgs& args) {
const char* yoffsets;
- fRGBAYValuesUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ fRGBAYValuesUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
"yoffsets", &yoffsets);
static const float kColorScaleFactor = 255.0f / 256.0f;
static const float kColorOffsetFactor = 1.0f / 512.0f;
@@ -405,14 +404,14 @@
if (nullptr == args.fInputColor) {
// the input color is solid white (all ones).
static const float kMaxValue = kColorScaleFactor + kColorOffsetFactor;
- fragBuilder->codeAppendf("\t\tfloat4 coord = float4(%f, %f, %f, %f);\n",
+ fragBuilder->codeAppendf("\t\thalf4 coord = half4(%f, %f, %f, %f);\n",
kMaxValue, kMaxValue, kMaxValue, kMaxValue);
} else {
- fragBuilder->codeAppendf("\t\tfloat nonZeroAlpha = max(%s.a, .0001);\n", args.fInputColor);
- fragBuilder->codeAppendf("\t\tfloat4 coord = float4(%s.rgb / nonZeroAlpha, nonZeroAlpha);\n",
+ fragBuilder->codeAppendf("\t\thalf nonZeroAlpha = max(%s.a, .0001);\n", args.fInputColor);
+ fragBuilder->codeAppendf("\t\thalf4 coord = half4(%s.rgb / nonZeroAlpha, nonZeroAlpha);\n",
args.fInputColor);
- fragBuilder->codeAppendf("\t\tcoord = coord * %f + float4(%f, %f, %f, %f);\n",
+ fragBuilder->codeAppendf("\t\tcoord = coord * %f + half4(%f, %f, %f, %f);\n",
kColorScaleFactor,
kColorOffsetFactor, kColorOffsetFactor,
kColorOffsetFactor, kColorOffsetFactor);
@@ -421,22 +420,22 @@
SkString coord;
fragBuilder->codeAppendf("\t\t%s.a = ", args.fOutputColor);
- coord.printf("float2(coord.a, %s.a)", yoffsets);
+ coord.printf("half2(coord.a, %s.a)", yoffsets);
fragBuilder->appendTextureLookup(args.fTexSamplers[0], coord.c_str());
fragBuilder->codeAppend(".a;\n");
fragBuilder->codeAppendf("\t\t%s.r = ", args.fOutputColor);
- coord.printf("float2(coord.r, %s.r)", yoffsets);
+ coord.printf("half2(coord.r, %s.r)", yoffsets);
fragBuilder->appendTextureLookup(args.fTexSamplers[0], coord.c_str());
fragBuilder->codeAppend(".a;\n");
fragBuilder->codeAppendf("\t\t%s.g = ", args.fOutputColor);
- coord.printf("float2(coord.g, %s.g)", yoffsets);
+ coord.printf("half2(coord.g, %s.g)", yoffsets);
fragBuilder->appendTextureLookup(args.fTexSamplers[0], coord.c_str());
fragBuilder->codeAppend(".a;\n");
fragBuilder->codeAppendf("\t\t%s.b = ", args.fOutputColor);
- coord.printf("float2(coord.b, %s.b)", yoffsets);
+ coord.printf("half2(coord.b, %s.b)", yoffsets);
fragBuilder->appendTextureLookup(args.fTexSamplers[0], coord.c_str());
fragBuilder->codeAppend(".a;\n");
diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp
index 659d333..58ae2a9 100644
--- a/src/gpu/GrDefaultGeoProcFactory.cpp
+++ b/src/gpu/GrDefaultGeoProcFactory.cpp
@@ -82,26 +82,26 @@
// Setup pass through color
if (gp.hasVertexColor()) {
- GrGLSLVertToFrag varying(kVec4f_GrSLType);
+ GrGLSLVertToFrag varying(kHalf4_GrSLType);
varyingHandler->addVarying("color", &varying);
// There are several optional steps to process the color. Start with the attribute:
- vertBuilder->codeAppendf("float4 color = %s;", gp.inColor()->fName);
+ vertBuilder->codeAppendf("half4 color = %s;", gp.inColor()->fName);
// Linearize
if (gp.linearizeColor()) {
SkString srgbFuncName;
static const GrShaderVar gSrgbArgs[] = {
- GrShaderVar("x", kFloat_GrSLType),
+ GrShaderVar("x", kHalf_GrSLType),
};
- vertBuilder->emitFunction(kFloat_GrSLType,
+ vertBuilder->emitFunction(kHalf_GrSLType,
"srgb_to_linear",
SK_ARRAY_COUNT(gSrgbArgs),
gSrgbArgs,
"return (x <= 0.04045) ? (x / 12.92) "
": pow((x + 0.055) / 1.055, 2.4);",
&srgbFuncName);
- vertBuilder->codeAppendf("color = float4(%s(%s.r), %s(%s.g), %s(%s.b), %s.a);",
+ vertBuilder->codeAppendf("color = half4(%s(%s.r), %s(%s.g), %s(%s.b), %s.a);",
srgbFuncName.c_str(), gp.inColor()->fName,
srgbFuncName.c_str(), gp.inColor()->fName,
srgbFuncName.c_str(), gp.inColor()->fName,
@@ -110,7 +110,7 @@
// For SkColor, do a red/blue swap and premul
if (gp.fFlags & kColorAttributeIsSkColor_GPFlag) {
- vertBuilder->codeAppend("color = float4(color.a * color.bgr, color.a);");
+ vertBuilder->codeAppend("color = half4(color.a * color.bgr, color.a);");
}
// Do color-correction to destination gamut
@@ -161,19 +161,18 @@
// Setup coverage as pass through
if (gp.hasVertexCoverage()) {
- fragBuilder->codeAppendf("float alpha = 1.0;");
+ fragBuilder->codeAppendf("half alpha = 1.0;");
varyingHandler->addPassThroughAttribute(gp.inCoverage(), "alpha");
- fragBuilder->codeAppendf("%s = float4(alpha);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(alpha);", args.fOutputCoverage);
} else if (gp.coverage() == 0xff) {
- fragBuilder->codeAppendf("%s = float4(1);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage);
} else {
const char* fragCoverage;
fCoverageUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf_GrSLType,
"Coverage",
&fragCoverage);
- fragBuilder->codeAppendf("%s = float4(%s);", args.fOutputCoverage, fragCoverage);
+ fragBuilder->codeAppendf("%s = half4(%s);", args.fOutputCoverage, fragCoverage);
}
}
diff --git a/src/gpu/GrFragmentProcessor.cpp b/src/gpu/GrFragmentProcessor.cpp
index 060cde5..ca49da8 100644
--- a/src/gpu/GrFragmentProcessor.cpp
+++ b/src/gpu/GrFragmentProcessor.cpp
@@ -177,7 +177,7 @@
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, args.fInputColor);
- fragBuilder->codeAppendf("float invAlpha = %s.a <= 0.0 ? 0.0 : 1.0 / %s.a;",
+ fragBuilder->codeAppendf("half invAlpha = %s.a <= 0.0 ? 0.0 : 1.0 / %s.a;",
args.fInputColor, args.fInputColor);
fragBuilder->codeAppendf("%s.rgb *= invAlpha;", args.fOutputColor);
}
@@ -387,8 +387,7 @@
void emitCode(EmitArgs& args) override {
const char* colorName;
fColorUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"Color", &colorName);
this->emitChild(0, colorName, args);
}
diff --git a/src/gpu/GrFragmentProcessor.h b/src/gpu/GrFragmentProcessor.h
index 8bf30d5..83d8edd 100644
--- a/src/gpu/GrFragmentProcessor.h
+++ b/src/gpu/GrFragmentProcessor.h
@@ -18,7 +18,7 @@
class GrShaderCaps;
class GrSwizzle;
-/** Provides custom fragment shader code. Fragment processors receive an input color (float4) and
+/** Provides custom fragment shader code. Fragment processors receive an input color (half4) and
produce an output color. They may reference textures and uniforms. They may use
GrCoordTransforms to receive a transformation of the local coordinates that map from local space
to the fragment being processed.
diff --git a/src/gpu/GrPathProcessor.cpp b/src/gpu/GrPathProcessor.cpp
index 42668bc..24326e9 100644
--- a/src/gpu/GrPathProcessor.cpp
+++ b/src/gpu/GrPathProcessor.cpp
@@ -37,14 +37,13 @@
// Setup uniform color
const char* stagedLocalVarName;
fColorUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"Color",
&stagedLocalVarName);
fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, stagedLocalVarName);
// setup constant solid coverage
- fragBuilder->codeAppendf("%s = float4(1);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage);
}
void emitTransforms(GrGLSLVaryingHandler* varyingHandler,
@@ -52,8 +51,8 @@
int i = 0;
while (const GrCoordTransform* coordTransform = transformHandler->nextCoordTransform()) {
GrSLType varyingType =
- coordTransform->getMatrix().hasPerspective() ? kVec3f_GrSLType
- : kVec2f_GrSLType;
+ coordTransform->getMatrix().hasPerspective() ? kHalf3_GrSLType
+ : kHalf2_GrSLType;
SkString strVaryingName;
strVaryingName.printf("TransformedCoord_%d", i);
@@ -89,9 +88,9 @@
}
fInstalledTransforms[t].fCurrentValue = m;
- SkASSERT(fInstalledTransforms[t].fType == kVec2f_GrSLType ||
- fInstalledTransforms[t].fType == kVec3f_GrSLType);
- unsigned components = fInstalledTransforms[t].fType == kVec2f_GrSLType ? 2 : 3;
+ SkASSERT(fInstalledTransforms[t].fType == kHalf2_GrSLType ||
+ fInstalledTransforms[t].fType == kHalf3_GrSLType);
+ unsigned components = fInstalledTransforms[t].fType == kHalf2_GrSLType ? 2 : 3;
pd.setPathFragmentInputTransform(fInstalledTransforms[t].fHandle, components, m);
++t;
}
diff --git a/src/gpu/GrShaderVar.cpp b/src/gpu/GrShaderVar.cpp
index e6d774c..d205907 100644
--- a/src/gpu/GrShaderVar.cpp
+++ b/src/gpu/GrShaderVar.cpp
@@ -81,7 +81,7 @@
}
void GrShaderVar::appendDecl(const GrShaderCaps* shaderCaps, SkString* out) const {
- SkASSERT(kDefault_GrSLPrecision == fPrecision || GrSLTypeAcceptsPrecision(fType));
+ SkASSERT(kDefault_GrSLPrecision == fPrecision || GrSLTypeTemporarilyAcceptsPrecision(fType));
SkString layout = fLayoutQualifier;
if (!fLayoutQualifier.isEmpty()) {
out->appendf("layout(%s) ", fLayoutQualifier.c_str());
diff --git a/src/gpu/GrShaderVar.h b/src/gpu/GrShaderVar.h
index 7f09f8c..5a379b9 100644
--- a/src/gpu/GrShaderVar.h
+++ b/src/gpu/GrShaderVar.h
@@ -37,13 +37,12 @@
};
/**
- * Defaults to a non-arry float with no precision specifier, type modifier, or layout qualifier.
+ * Defaults to a non-arry half with no type modifier or layout qualifier.
*/
GrShaderVar()
- : fType(kFloat_GrSLType)
+ : fType(kHalf_GrSLType)
, fTypeModifier(kNone_TypeModifier)
, fCount(kNonArray)
- , fPrecision(kDefault_GrSLPrecision)
, fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) {
}
@@ -116,7 +115,7 @@
const char* extraModifiers = nullptr,
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
SkASSERT(kVoid_GrSLType != type);
- SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
+ SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeTemporarilyAcceptsPrecision(type));
fType = type;
fTypeModifier = typeModifier;
fName = name;
@@ -140,7 +139,7 @@
const char* extraModifiers = nullptr,
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
SkASSERT(kVoid_GrSLType != type);
- SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
+ SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeTemporarilyAcceptsPrecision(type));
fType = type;
fTypeModifier = typeModifier;
fName = name;
@@ -165,7 +164,7 @@
const char* extraModifiers = nullptr,
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
SkASSERT(kVoid_GrSLType != type);
- SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
+ SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeTemporarilyAcceptsPrecision(type));
fType = type;
fTypeModifier = typeModifier;
fName = name;
@@ -190,7 +189,7 @@
const char* extraModifiers = nullptr,
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
SkASSERT(kVoid_GrSLType != type);
- SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
+ SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeTemporarilyAcceptsPrecision(type));
fType = type;
fTypeModifier = typeModifier;
fName = name;
diff --git a/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp b/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
index e4e59ff..d192ff7 100644
--- a/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
@@ -122,8 +122,8 @@
const TexelBufferHandle& pointsBuffer,
const char* rtAdjust, GrGPArgs* gpArgs) const {
v->codeAppendf("int packedoffset = %s.w;", proc.instanceAttrib());
- v->codeAppend ("highp float2 atlasoffset = float2((packedoffset<<16) >> 16, "
- "packedoffset >> 16);");
+ v->codeAppend ("highfloat2 atlasoffset = highfloat2((packedoffset<<16) >> 16, "
+ "packedoffset >> 16);");
this->onEmitVertexShader(proc, v, pointsBuffer, "atlasoffset", rtAdjust, gpArgs);
}
@@ -135,12 +135,10 @@
SkString emitVertexFn;
SkSTArray<2, GrShaderVar> emitArgs;
- const char* position = emitArgs.emplace_back("position", kVec2f_GrSLType,
- GrShaderVar::kNonArray,
- kHigh_GrSLPrecision).c_str();
- const char* coverage = emitArgs.emplace_back("coverage", kFloat_GrSLType,
- GrShaderVar::kNonArray,
- kHigh_GrSLPrecision).c_str();
+ const char* position = emitArgs.emplace_back("position", kHighFloat2_GrSLType,
+ GrShaderVar::kNonArray).c_str();
+ const char* coverage = emitArgs.emplace_back("coverage", kHighFloat_GrSLType,
+ GrShaderVar::kNonArray).c_str();
g->emitFunction(kVoid_GrSLType, "emitVertex", emitArgs.count(), emitArgs.begin(), [&]() {
SkString fnBody;
this->emitPerVertexGeometryCode(&fnBody, position, coverage, fGeomWind.c_str());
@@ -151,12 +149,12 @@
fnBody.appendf("%s = %s * %s;",
fFragCoverageTimesWind.gsOut(), coverage, fGeomWind.c_str());
}
- fnBody.append ("gl_Position = float4(position, 0, 1);");
+ fnBody.append ("gl_Position = highfloat4(position, 0, 1);");
fnBody.append ("EmitVertex();");
return fnBody;
}().c_str(), &emitVertexFn);
- g->codeAppendf("highp float2 bloat = %f * abs(%s.xz);", kAABloatRadius, rtAdjust);
+ g->codeAppendf("highfloat2 bloat = %f * abs(%s.xz);", kAABloatRadius, rtAdjust);
#ifdef SK_DEBUG
if (proc.debugVisualizations()) {
@@ -173,7 +171,7 @@
SkASSERT(numSides >= 3);
if (!insetPts) {
- g->codeAppendf("highp float2 centroidpt = %s * float%i(%f);",
+ g->codeAppendf("highfloat2 centroidpt = %s * highfloat%i(%f);",
polygonPts, numSides, 1.0 / numSides);
}
@@ -181,42 +179,42 @@
"nextidx = (%s + 1) %% %i;",
wedgeIdx, numSides - 1, numSides, wedgeIdx, numSides);
- g->codeAppendf("highp float2 self = %s[%s];"
- "highp int leftidx = %s > 0 ? previdx : nextidx;"
- "highp int rightidx = %s > 0 ? nextidx : previdx;",
+ g->codeAppendf("highfloat2 self = %s[%s];"
+ "int leftidx = %s > 0 ? previdx : nextidx;"
+ "int rightidx = %s > 0 ? nextidx : previdx;",
polygonPts, wedgeIdx, fGeomWind.c_str(), fGeomWind.c_str());
// Which quadrant does the vector from self -> right fall into?
- g->codeAppendf("highp float2 right = %s[rightidx];", polygonPts);
+ g->codeAppendf("highfloat2 right = %s[rightidx];", polygonPts);
if (3 == numSides) {
// TODO: evaluate perf gains.
- g->codeAppend ("highp float2 qsr = sign(right - self);");
+ g->codeAppend ("highfloat2 qsr = sign(right - self);");
} else {
SkASSERT(4 == numSides);
- g->codeAppendf("highp float2 diag = %s[(%s + 2) %% 4];", polygonPts, wedgeIdx);
- g->codeAppend ("highp float2 qsr = sign((right != self ? right : diag) - self);");
+ g->codeAppendf("highfloat2 diag = %s[(%s + 2) %% 4];", polygonPts, wedgeIdx);
+ g->codeAppend ("highfloat2 qsr = sign((right != self ? right : diag) - self);");
}
// Which quadrant does the vector from left -> self fall into?
- g->codeAppendf("highp float2 qls = sign(self - %s[leftidx]);", polygonPts);
+ g->codeAppendf("highfloat2 qls = sign(self - %s[leftidx]);", polygonPts);
// d2 just helps us reduce triangle counts with orthogonal, axis-aligned lines.
// TODO: evaluate perf gains.
const char* dr2 = "dr";
if (3 == numSides) {
// TODO: evaluate perf gains.
- g->codeAppend ("highp float2 dr = float2(qsr.y != 0 ? +qsr.y : +qsr.x, "
- "qsr.x != 0 ? -qsr.x : +qsr.y);");
- g->codeAppend ("highp float2 dr2 = float2(qsr.y != 0 ? +qsr.y : -qsr.x, "
- "qsr.x != 0 ? -qsr.x : -qsr.y);");
- g->codeAppend ("highp float2 dl = float2(qls.y != 0 ? +qls.y : +qls.x, "
- "qls.x != 0 ? -qls.x : +qls.y);");
+ g->codeAppend ("highfloat2 dr = highfloat2(qsr.y != 0 ? +qsr.y : +qsr.x, "
+ "qsr.x != 0 ? -qsr.x : +qsr.y);");
+ g->codeAppend ("highfloat2 dr2 = highfloat2(qsr.y != 0 ? +qsr.y : -qsr.x, "
+ "qsr.x != 0 ? -qsr.x : -qsr.y);");
+ g->codeAppend ("highfloat2 dl = highfloat2(qls.y != 0 ? +qls.y : +qls.x, "
+ "qls.x != 0 ? -qls.x : +qls.y);");
dr2 = "dr2";
} else {
- g->codeAppend ("highp float2 dr = float2(qsr.y != 0 ? +qsr.y : 1, "
- "qsr.x != 0 ? -qsr.x : 1);");
- g->codeAppend ("highp float2 dl = (qls == float2(0)) ? dr : "
- "float2(qls.y != 0 ? +qls.y : 1, qls.x != 0 ? -qls.x : 1);");
+ g->codeAppend ("highfloat2 dr = highfloat2(qsr.y != 0 ? +qsr.y : 1, "
+ "qsr.x != 0 ? -qsr.x : 1);");
+ g->codeAppend ("highfloat2 dl = (qls == highfloat2(0)) ? dr : "
+ "highfloat2(qls.y != 0 ? +qls.y : 1, qls.x != 0 ? -qls.x : 1);");
}
g->codeAppendf("bool2 dnotequal = notEqual(%s, dl);", dr2);
@@ -236,7 +234,7 @@
g->codeAppendf( "%s(self + bloat * dl, 1);", emitVertexFn);
g->codeAppend ("}");
g->codeAppend ("if (all(dnotequal)) {");
- g->codeAppendf( "%s(self + bloat * float2(-dl.y, dl.x), 1);", emitVertexFn);
+ g->codeAppendf( "%s(self + bloat * highfloat2(-dl.y, dl.x), 1);", emitVertexFn);
g->codeAppend ("}");
g->codeAppend ("EndPrimitive();");
@@ -247,18 +245,18 @@
const char* leftPt, const char* rightPt,
const char* distanceEquation) const {
if (!distanceEquation) {
- this->emitEdgeDistanceEquation(g, leftPt, rightPt, "highp float3 edge_distance_equation");
+ this->emitEdgeDistanceEquation(g, leftPt, rightPt, "highfloat3 edge_distance_equation");
distanceEquation = "edge_distance_equation";
}
// qlr is defined in emitEdgeDistanceEquation.
- g->codeAppendf("highp float2x2 endpts = float2x2(%s - bloat * qlr, %s + bloat * qlr);",
+ g->codeAppendf("highfloat2x2 endpts = highfloat2x2(%s - bloat * qlr, %s + bloat * qlr);",
leftPt, rightPt);
- g->codeAppendf("mediump float2 endpts_coverage = %s.xy * endpts + %s.z;",
+ g->codeAppendf("half2 endpts_coverage = %s.xy * endpts + %s.z;",
distanceEquation, distanceEquation);
// d1 is defined in emitEdgeDistanceEquation.
- g->codeAppend ("highp float2 d2 = d1;");
+ g->codeAppend ("highfloat2 d2 = d1;");
g->codeAppend ("bool aligned = qlr.x == 0 || qlr.y == 0;");
g->codeAppend ("if (aligned) {");
g->codeAppend ( "d1 -= qlr;");
@@ -287,25 +285,25 @@
const char* leftPt, const char* rightPt,
const char* outputDistanceEquation) const {
// Which quadrant does the vector from left -> right fall into?
- g->codeAppendf("highp float2 qlr = sign(%s - %s);", rightPt, leftPt);
- g->codeAppend ("highp float2 d1 = float2(qlr.y, -qlr.x);");
+ g->codeAppendf("highfloat2 qlr = sign(%s - %s);", rightPt, leftPt);
+ g->codeAppend ("highfloat2 d1 = highfloat2(qlr.y, -qlr.x);");
- g->codeAppendf("highp float2 n = float2(%s.y - %s.y, %s.x - %s.x);",
+ g->codeAppendf("highfloat2 n = highfloat2(%s.y - %s.y, %s.x - %s.x);",
rightPt, leftPt, leftPt, rightPt);
- g->codeAppendf("highp float2 kk = n * float2x2(%s + bloat * d1, %s - bloat * d1);",
+ g->codeAppendf("highfloat2 kk = n * highfloat2x2(%s + bloat * d1, %s - bloat * d1);",
leftPt, leftPt);
// Clamp for when n=0. wind=0 when n=0 so as long as we don't get Inf or NaN we are fine.
- g->codeAppendf("highp float scale = 1 / max(kk[0] - kk[1], 1e-30);");
+ g->codeAppendf("highfloat scale = 1 / max(kk[0] - kk[1], 1e-30);");
- g->codeAppendf("%s = float3(-n, kk[1]) * scale;", outputDistanceEquation);
+ g->codeAppendf("%s = half3(-n, kk[1]) * scale;", outputDistanceEquation);
}
int PrimitiveProcessor::emitCornerGeometry(GrGLSLGeometryBuilder* g, const char* emitVertexFn,
const char* pt) const {
- g->codeAppendf("%s(%s + float2(-bloat.x, -bloat.y), 1);", emitVertexFn, pt);
- g->codeAppendf("%s(%s + float2(-bloat.x, +bloat.y), 1);", emitVertexFn, pt);
- g->codeAppendf("%s(%s + float2(+bloat.x, -bloat.y), 1);", emitVertexFn, pt);
- g->codeAppendf("%s(%s + float2(+bloat.x, +bloat.y), 1);", emitVertexFn, pt);
+ g->codeAppendf("%s(%s + highfloat2(-bloat.x, -bloat.y), 1);", emitVertexFn, pt);
+ g->codeAppendf("%s(%s + highfloat2(-bloat.x, +bloat.y), 1);", emitVertexFn, pt);
+ g->codeAppendf("%s(%s + highfloat2(+bloat.x, -bloat.y), 1);", emitVertexFn, pt);
+ g->codeAppendf("%s(%s + highfloat2(+bloat.x, +bloat.y), 1);", emitVertexFn, pt);
g->codeAppend ("EndPrimitive();");
return 4;
@@ -321,17 +319,17 @@
f->codeAppendf("%s.a = %s;", outputColor, fFragCoverageTimesWind.fsIn());
break;
case CoverageType::kShader:
- f->codeAppendf("mediump float coverage = 0;");
+ f->codeAppendf("half coverage = 0;");
this->emitShaderCoverage(f, "coverage");
f->codeAppendf("%s.a = coverage * %s;", outputColor, fFragWind.fsIn());
break;
}
- f->codeAppendf("%s = float4(1);", outputCoverage);
+ f->codeAppendf("%s = half4(1);", outputCoverage);
#ifdef SK_DEBUG
if (proc.debugVisualizations()) {
- f->codeAppendf("%s = float4(-%s.a, %s.a, 0, 1);", outputColor, outputColor, outputColor);
+ f->codeAppendf("%s = half4(-%s.a, %s.a, 0, 1);", outputColor, outputColor, outputColor);
}
#endif
}
@@ -340,17 +338,17 @@
const char* samplesName) const {
// Standard DX11 sample locations.
#if defined(SK_BUILD_FOR_ANDROID) || defined(SK_BUILD_FOR_IOS)
- f->defineConstant("highp float2[8]", samplesName, "float2[8]("
- "float2(+1, -3)/16, float2(-1, +3)/16, float2(+5, +1)/16, float2(-3, -5)/16, "
- "float2(-5, +5)/16, float2(-7, -1)/16, float2(+3, +7)/16, float2(+7, -7)/16."
+ f->defineConstant("highfloat2[8]", samplesName, "highfloat2[8]("
+ "highfloat2(+1, -3)/16, highfloat2(-1, +3)/16, highfloat2(+5, +1)/16, highfloat2(-3, -5)/16, "
+ "highfloat2(-5, +5)/16, highfloat2(-7, -1)/16, highfloat2(+3, +7)/16, highfloat2(+7, -7)/16."
")");
return 8;
#else
- f->defineConstant("highp float2[16]", samplesName, "float2[16]("
- "float2(+1, +1)/16, float2(-1, -3)/16, float2(-3, +2)/16, float2(+4, -1)/16, "
- "float2(-5, -2)/16, float2(+2, +5)/16, float2(+5, +3)/16, float2(+3, -5)/16, "
- "float2(-2, +6)/16, float2( 0, -7)/16, float2(-4, -6)/16, float2(-6, +4)/16, "
- "float2(-8, 0)/16, float2(+7, -4)/16, float2(+6, +7)/16, float2(-7, -8)/16."
+ f->defineConstant("highfloat2[16]", samplesName, "highfloat2[16]("
+ "highfloat2(+1, +1)/16, highfloat2(-1, -3)/16, highfloat2(-3, +2)/16, highfloat2(+4, -1)/16, "
+ "highfloat2(-5, -2)/16, highfloat2(+2, +5)/16, highfloat2(+5, +3)/16, highfloat2(+3, -5)/16, "
+ "highfloat2(-2, +6)/16, highfloat2( 0, -7)/16, highfloat2(-4, -6)/16, highfloat2(-6, +4)/16, "
+ "highfloat2(-8, 0)/16, highfloat2(+7, -4)/16, highfloat2(+6, +7)/16, highfloat2(-7, -8)/16."
")");
return 16;
#endif
diff --git a/src/gpu/ccpr/GrCCPRCoverageProcessor.h b/src/gpu/ccpr/GrCCPRCoverageProcessor.h
index 198956a..ab6a3cb 100644
--- a/src/gpu/ccpr/GrCCPRCoverageProcessor.h
+++ b/src/gpu/ccpr/GrCCPRCoverageProcessor.h
@@ -138,9 +138,9 @@
PrimitiveProcessor(CoverageType coverageType)
: fCoverageType(coverageType)
- , fGeomWind("wind", kFloat_GrSLType, GrShaderVar::kNonArray, kLow_GrSLPrecision)
- , fFragWind(kFloat_GrSLType)
- , fFragCoverageTimesWind(kFloat_GrSLType) {}
+ , fGeomWind("wind", kHalf_GrSLType, GrShaderVar::kNonArray, kLow_GrSLPrecision)
+ , fFragWind(kHalf_GrSLType)
+ , fFragCoverageTimesWind(kHalf_GrSLType) {}
// Called before generating shader code. Subclass should add its custom varyings to the handler
// and update its corresponding internal member variables.
diff --git a/src/gpu/ccpr/GrCCPRCubicProcessor.cpp b/src/gpu/ccpr/GrCCPRCubicProcessor.cpp
index 5f6f759..161c1ed 100644
--- a/src/gpu/ccpr/GrCCPRCubicProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRCubicProcessor.cpp
@@ -27,7 +27,7 @@
v->codeAppendf("int4 indices = int4(%s.y, %s.x, %s.x + 1, %s.y + 1);",
proc.instanceAttrib(), proc.instanceAttrib(), proc.instanceAttrib(),
proc.instanceAttrib());
- v->codeAppend ("highp float4x2 bezierpts = float4x2(");
+ v->codeAppend ("highfloat4x2 bezierpts = highfloat4x2(");
v->appendTexelFetch(pointsBuffer, "indices[sk_VertexID]");
v->codeAppend (".xy, ");
v->appendTexelFetch(pointsBuffer, "indices[(sk_VertexID + 1) % 4]");
@@ -38,24 +38,24 @@
v->codeAppend (".xy);");
// Find the corner of the inset geometry that corresponds to this bezier vertex (bezierpts[0]).
- v->codeAppend ("highp float2x2 N = float2x2(bezierpts[3].y - bezierpts[0].y, "
- "bezierpts[0].x - bezierpts[3].x, "
- "bezierpts[1].y - bezierpts[0].y, "
- "bezierpts[0].x - bezierpts[1].x);");
- v->codeAppend ("highp float2x2 P = float2x2(bezierpts[3], bezierpts[1]);");
+ v->codeAppend ("highfloat2x2 N = highfloat2x2(bezierpts[3].y - bezierpts[0].y, "
+ "bezierpts[0].x - bezierpts[3].x, "
+ "bezierpts[1].y - bezierpts[0].y, "
+ "bezierpts[0].x - bezierpts[1].x);");
+ v->codeAppend ("highfloat2x2 P = highfloat2x2(bezierpts[3], bezierpts[1]);");
v->codeAppend ("if (abs(determinant(N)) < 2) {"); // Area of [pts[3], pts[0], pts[1]] < 1px.
// The inset corner doesn't exist because we are effectively colinear with
// both neighbor vertices. Just duplicate a neighbor's inset corner.
v->codeAppend ( "int smallidx = (dot(N[0], N[0]) > dot(N[1], N[1])) ? 1 : 0;");
- v->codeAppend ( "N[smallidx] = float2(bezierpts[2].y - bezierpts[3 - smallidx * 2].y, "
- "bezierpts[3 - smallidx * 2].x - bezierpts[2].x);");
+ v->codeAppend ( "N[smallidx] = highfloat2(bezierpts[2].y - bezierpts[3 - smallidx * 2].y, "
+ "bezierpts[3 - smallidx * 2].x - bezierpts[2].x);");
v->codeAppend ( "P[smallidx] = bezierpts[2];");
v->codeAppend ("}");
v->codeAppend ("N[0] *= sign(dot(N[0], P[1] - P[0]));");
v->codeAppend ("N[1] *= sign(dot(N[1], P[0] - P[1]));");
- v->codeAppendf("highp float2 K = float2(dot(N[0], P[0] + %f * sign(N[0])), "
- "dot(N[1], P[1] + %f * sign(N[1])));", inset, inset);
+ v->codeAppendf("highfloat2 K = highfloat2(dot(N[0], P[0] + %f * sign(N[0])), "
+ "dot(N[1], P[1] + %f * sign(N[1])));", inset, inset);
v->codeAppendf("%s.xy = K * inverse(N) + %s;", fInset.vsOut(), atlasOffset);
v->codeAppendf("%s.xy = %s.xy * %s.xz + %s.yw;",
fInset.vsOut(), fInset.vsOut(), rtAdjust, rtAdjust);
@@ -71,15 +71,15 @@
v->codeAppend ("[sk_VertexID % 2];");
// Emit the vertex position.
- v->codeAppendf("highp float2 self = bezierpts[0] + %s;", atlasOffset);
- gpArgs->fPositionVar.set(kVec2f_GrSLType, "self");
+ v->codeAppendf("highfloat2 self = bezierpts[0] + %s;", atlasOffset);
+ gpArgs->fPositionVar.set(kHighFloat2_GrSLType, "self");
}
void GrCCPRCubicProcessor::emitWind(GrGLSLGeometryBuilder* g, const char* rtAdjust,
const char* outputWind) const {
// We will define bezierpts in onEmitGeometryShader.
- g->codeAppend ("highp float area_times_2 = "
- "determinant(float3x3(1, bezierpts[0], "
+ g->codeAppend ("highfloat area_times_2 = "
+ "determinant(highfloat3x3(1, bezierpts[0], "
"1, bezierpts[2], "
"0, bezierpts[3] - bezierpts[1]));");
// Drop curves that are nearly flat. The KLM math becomes unstable in this case.
@@ -98,13 +98,13 @@
void GrCCPRCubicProcessor::onEmitGeometryShader(GrGLSLGeometryBuilder* g, const char* emitVertexFn,
const char* wind, const char* rtAdjust) const {
// Prepend bezierpts at the start of the shader.
- g->codePrependf("highp float4x2 bezierpts = float4x2(sk_in[0].gl_Position.xy, "
- "sk_in[1].gl_Position.xy, "
- "sk_in[2].gl_Position.xy, "
- "sk_in[3].gl_Position.xy);");
+ g->codePrependf("highfloat4x2 bezierpts = highfloat4x2(sk_in[0].gl_Position.xy, "
+ "sk_in[1].gl_Position.xy, "
+ "sk_in[2].gl_Position.xy, "
+ "sk_in[3].gl_Position.xy);");
// Evaluate the cubic at t=.5 for an approximate midpoint.
- g->codeAppendf("highp float2 midpoint = bezierpts * float4(.125, .375, .375, .125);");
+ g->codeAppendf("highfloat2 midpoint = bezierpts * highfloat4(.125, .375, .375, .125);");
// Finish finding the inset geometry we started in the vertex shader. The z component tells us
// how "sharp" an inset corner is. And the vertex shader already skips one corner if it is
@@ -112,9 +112,9 @@
// geometry is all empty (it should never be non-convex because the curve gets chopped into
// convex segments ahead of time).
g->codeAppendf("bool isempty = "
- "any(lessThan(float4(%s[0].z, %s[1].z, %s[2].z, %s[3].z) * %s, float4(2)));",
+ "any(lessThan(highfloat4(%s[0].z, %s[1].z, %s[2].z, %s[3].z) * %s, highfloat4(2)));",
fInset.gsIn(), fInset.gsIn(), fInset.gsIn(), fInset.gsIn(), wind);
- g->codeAppendf("highp float2 inset[4];");
+ g->codeAppendf("highfloat2 inset[4];");
g->codeAppend ("for (int i = 0; i < 4; ++i) {");
g->codeAppendf( "inset[i] = isempty ? midpoint : %s[i].xy;", fInset.gsIn());
g->codeAppend ("}");
@@ -124,30 +124,30 @@
// actually triangle with a vertex at the crossover point. If there are >1 backwards edges, the
// inset geometry doesn't exist (i.e. the bezier quadrilateral isn't large enough) and we
// degenerate to the midpoint.
- g->codeAppend ("lowp float backwards[4];");
- g->codeAppend ("lowp int numbackwards = 0;");
+ g->codeAppend ("half backwards[4];");
+ g->codeAppend ("short numbackwards = 0;");
g->codeAppend ("for (int i = 0; i < 4; ++i) {");
- g->codeAppend ( "lowp int j = (i + 1) % 4;");
- g->codeAppendf( "highp float2 inner = inset[j] - inset[i];");
- g->codeAppendf( "highp float2 outer = sk_in[j].gl_Position.xy - sk_in[i].gl_Position.xy;");
+ g->codeAppend ( "short j = (i + 1) % 4;");
+ g->codeAppendf( "highfloat2 inner = inset[j] - inset[i];");
+ g->codeAppendf( "highfloat2 outer = sk_in[j].gl_Position.xy - sk_in[i].gl_Position.xy;");
g->codeAppendf( "backwards[i] = sign(dot(outer, inner));");
g->codeAppendf( "numbackwards += backwards[i] < 0 ? 1 : 0;");
g->codeAppend ("}");
// Find the crossover point. If there actually isn't one, this math is meaningless and will get
// dropped on the floor later.
- g->codeAppend ("lowp int x = (backwards[0] != backwards[2]) ? 1 : 0;");
- g->codeAppend ("lowp int x3 = (x + 3) % 4;");
- g->codeAppend ("highp float2x2 X = float2x2(inset[x].y - inset[x+1].y, "
- "inset[x+1].x - inset[x].x, "
- "inset[x+2].y - inset[x3].y, "
- "inset[x3].x - inset[x+2].x);");
- g->codeAppend ("highp float2 KK = float2(dot(X[0], inset[x]), dot(X[1], inset[x+2]));");
- g->codeAppend ("highp float2 crossoverpoint = KK * inverse(X);");
+ g->codeAppend ("short x = (backwards[0] != backwards[2]) ? 1 : 0;");
+ g->codeAppend ("short x3 = (x + 3) % 4;");
+ g->codeAppend ("highfloat2x2 X = highfloat2x2(inset[x].y - inset[x+1].y, "
+ "inset[x+1].x - inset[x].x, "
+ "inset[x+2].y - inset[x3].y, "
+ "inset[x3].x - inset[x+2].x);");
+ g->codeAppend ("highfloat2 KK = highfloat2(dot(X[0], inset[x]), dot(X[1], inset[x+2]));");
+ g->codeAppend ("highfloat2 crossoverpoint = KK * inverse(X);");
// Determine what point backwards edges should collapse into. If there is one backwards edge,
// it should collapse to the crossover point. If >1, they should all collapse to the midpoint.
- g->codeAppend ("highp float2 collapsepoint = numbackwards == 1 ? crossoverpoint : midpoint;");
+ g->codeAppend ("highfloat2 collapsepoint = numbackwards == 1 ? crossoverpoint : midpoint;");
// Collapse backwards egdes to the "collapse" point.
g->codeAppend ("for (int i = 0; i < 4; ++i) {");
@@ -158,46 +158,46 @@
// Calculate the KLM matrix.
g->declareGlobal(fKLMMatrix);
- g->codeAppend ("highp float4 K, L, M;");
+ g->codeAppend ("highfloat4 K, L, M;");
if (Type::kSerpentine == fType) {
- g->codeAppend ("highp float2 l,m;");
- g->codeAppendf("l.ts = float2(%s[0], %s[1]);", fTS.gsIn(), fTS.gsIn());
- g->codeAppendf("m.ts = float2(%s[2], %s[3]);", fTS.gsIn(), fTS.gsIn());
- g->codeAppend ("K = float4(0, l.s * m.s, -l.t * m.s - m.t * l.s, l.t * m.t);");
- g->codeAppend ("L = float4(-1,3,-3,1) * l.ssst * l.sstt * l.sttt;");
- g->codeAppend ("M = float4(-1,3,-3,1) * m.ssst * m.sstt * m.sttt;");
+ g->codeAppend ("highfloat2 l,m;");
+ g->codeAppendf("l.ts = highfloat2(%s[0], %s[1]);", fTS.gsIn(), fTS.gsIn());
+ g->codeAppendf("m.ts = highfloat2(%s[2], %s[3]);", fTS.gsIn(), fTS.gsIn());
+ g->codeAppend ("K = highfloat4(0, l.s * m.s, -l.t * m.s - m.t * l.s, l.t * m.t);");
+ g->codeAppend ("L = highfloat4(-1,3,-3,1) * l.ssst * l.sstt * l.sttt;");
+ g->codeAppend ("M = highfloat4(-1,3,-3,1) * m.ssst * m.sstt * m.sttt;");
} else {
- g->codeAppend ("highp float2 d,e;");
- g->codeAppendf("d.ts = float2(%s[0], %s[1]);", fTS.gsIn(), fTS.gsIn());
- g->codeAppendf("e.ts = float2(%s[2], %s[3]);", fTS.gsIn(), fTS.gsIn());
- g->codeAppend ("highp float4 dxe = float4(d.s * e.s, d.s * e.t, d.t * e.s, d.t * e.t);");
- g->codeAppend ("K = float4(0, dxe.x, -dxe.y - dxe.z, dxe.w);");
- g->codeAppend ("L = float4(-1,1,-1,1) * d.sstt * (dxe.xyzw + float4(0, 2*dxe.zy, 0));");
- g->codeAppend ("M = float4(-1,1,-1,1) * e.sstt * (dxe.xzyw + float4(0, 2*dxe.yz, 0));");
+ g->codeAppend ("highfloat2 d,e;");
+ g->codeAppendf("d.ts = highfloat2(%s[0], %s[1]);", fTS.gsIn(), fTS.gsIn());
+ g->codeAppendf("e.ts = highfloat2(%s[2], %s[3]);", fTS.gsIn(), fTS.gsIn());
+ g->codeAppend ("highfloat4 dxe = highfloat4(d.s * e.s, d.s * e.t, d.t * e.s, d.t * e.t);");
+ g->codeAppend ("K = highfloat4(0, dxe.x, -dxe.y - dxe.z, dxe.w);");
+ g->codeAppend ("L = highfloat4(-1,1,-1,1) * d.sstt * (dxe.xyzw + highfloat4(0, 2*dxe.zy, 0));");
+ g->codeAppend ("M = highfloat4(-1,1,-1,1) * e.sstt * (dxe.xzyw + highfloat4(0, 2*dxe.yz, 0));");
}
- g->codeAppend ("highp float2x4 C = float4x4(-1, 3, -3, 1, "
- " 3, -6, 3, 0, "
- "-3, 3, 0, 0, "
- " 1, 0, 0, 0) * transpose(bezierpts);");
+ g->codeAppend ("highfloat2x4 C = highfloat4x4(-1, 3, -3, 1, "
+ " 3, -6, 3, 0, "
+ "-3, 3, 0, 0, "
+ " 1, 0, 0, 0) * transpose(bezierpts);");
- g->codeAppend ("highp float2 absdet = abs(C[0].xx * C[1].zy - C[1].xx * C[0].zy);");
+ g->codeAppend ("highfloat2 absdet = abs(C[0].xx * C[1].zy - C[1].xx * C[0].zy);");
g->codeAppend ("lowp int middlerow = absdet[0] > absdet[1] ? 2 : 1;");
- g->codeAppend ("highp float3x3 CI = inverse(float3x3(C[0][0], C[0][middlerow], C[0][3], "
- "C[1][0], C[1][middlerow], C[1][3], "
- " 0, 0, 1));");
- g->codeAppendf("%s = CI * float3x3(K[0], K[middlerow], K[3], "
- "L[0], L[middlerow], L[3], "
- "M[0], M[middlerow], M[3]);", fKLMMatrix.c_str());
+ g->codeAppend ("highfloat3x3 CI = inverse(highfloat3x3(C[0][0], C[0][middlerow], C[0][3], "
+ "C[1][0], C[1][middlerow], C[1][3], "
+ " 0, 0, 1));");
+ g->codeAppendf("%s = CI * highfloat3x3(K[0], K[middlerow], K[3], "
+ "L[0], L[middlerow], L[3], "
+ "M[0], M[middlerow], M[3]);", fKLMMatrix.c_str());
// Orient the KLM matrix so we fill the correct side of the curve.
- g->codeAppendf("lowp float2 orientation = sign(float3(midpoint, 1) * float2x3(%s[1], %s[2]));",
+ g->codeAppendf("half2 orientation = sign(half3(midpoint, 1) * half2x3(%s[1], %s[2]));",
fKLMMatrix.c_str(), fKLMMatrix.c_str());
- g->codeAppendf("%s *= float3x3(orientation[0] * orientation[1], 0, 0, "
- "0, orientation[0], 0, "
- "0, 0, orientation[1]);", fKLMMatrix.c_str());
+ g->codeAppendf("%s *= highfloat3x3(orientation[0] * orientation[1], 0, 0, "
+ "0, orientation[0], 0, "
+ "0, 0, orientation[1]);", fKLMMatrix.c_str());
g->declareGlobal(fKLMDerivatives);
g->codeAppendf("%s[0] = %s[0].xy * %s.xz;",
@@ -228,7 +228,7 @@
void GrCCPRCubicInsetProcessor::emitPerVertexGeometryCode(SkString* fnBody, const char* position,
const char* /*coverage*/,
const char* /*wind*/) const {
- fnBody->appendf("highp float3 klm = float3(%s, 1) * %s;", position, fKLMMatrix.c_str());
+ fnBody->appendf("highfloat3 klm = highfloat3(%s, 1) * %s;", position, fKLMMatrix.c_str());
fnBody->appendf("%s = klm;", fKLM.gsOut());
fnBody->appendf("%s[0] = 3 * klm[0] * %s[0];", fGradMatrix.gsOut(), fKLMDerivatives.c_str());
fnBody->appendf("%s[1] = -klm[1] * %s[2].xy - klm[2] * %s[1].xy;",
@@ -237,11 +237,11 @@
void GrCCPRCubicInsetProcessor::emitShaderCoverage(GrGLSLFragmentBuilder* f,
const char* outputCoverage) const {
- f->codeAppendf("highp float k = %s.x, l = %s.y, m = %s.z;",
+ f->codeAppendf("highfloat k = %s.x, l = %s.y, m = %s.z;",
fKLM.fsIn(), fKLM.fsIn(), fKLM.fsIn());
- f->codeAppend ("highp float f = k*k*k - l*m;");
- f->codeAppendf("highp float2 grad = %s * float2(k, 1);", fGradMatrix.fsIn());
- f->codeAppend ("highp float d = f * inversesqrt(dot(grad, grad));");
+ f->codeAppend ("highfloat f = k*k*k - l*m;");
+ f->codeAppendf("highfloat2 grad = %s * highfloat2(k, 1);", fGradMatrix.fsIn());
+ f->codeAppend ("highfloat d = f * inversesqrt(dot(grad, grad));");
f->codeAppendf("%s = clamp(0.5 - d, 0, 1);", outputCoverage);
}
@@ -251,8 +251,8 @@
// We defined bezierpts in onEmitGeometryShader.
g->declareGlobal(fEdgeDistanceEquation);
g->codeAppendf("int edgeidx0 = %s > 0 ? 3 : 0;", wind);
- g->codeAppendf("highp float2 edgept0 = bezierpts[edgeidx0];");
- g->codeAppendf("highp float2 edgept1 = bezierpts[3 - edgeidx0];");
+ g->codeAppendf("highfloat2 edgept0 = bezierpts[edgeidx0];");
+ g->codeAppendf("highfloat2 edgept1 = bezierpts[3 - edgeidx0];");
this->emitEdgeDistanceEquation(g, "edgept0", "edgept1", fEdgeDistanceEquation.c_str());
g->codeAppendf("%s.z += 0.5;", fEdgeDistanceEquation.c_str()); // outer = -.5, inner = .5
@@ -261,9 +261,10 @@
fEdgeDistanceDerivatives.c_str(), fEdgeDistanceEquation.c_str(), rtAdjust);
g->declareGlobal(fEdgeSpaceTransform);
- g->codeAppend ("highp float4 edgebbox = float4(min(bezierpts[0], bezierpts[3]) - bloat, "
- "max(bezierpts[0], bezierpts[3]) + bloat);");
- g->codeAppendf("%s.xy = 2 / float2(edgebbox.zw - edgebbox.xy);", fEdgeSpaceTransform.c_str());
+ g->codeAppend ("highfloat4 edgebbox = highfloat4(min(bezierpts[0], bezierpts[3]) - bloat, "
+ "max(bezierpts[0], bezierpts[3]) + bloat);");
+ g->codeAppendf("%s.xy = 2 / highfloat2(edgebbox.zw - edgebbox.xy);",
+ fEdgeSpaceTransform.c_str());
g->codeAppendf("%s.zw = -1 - %s.xy * edgebbox.xy;",
fEdgeSpaceTransform.c_str(), fEdgeSpaceTransform.c_str());
@@ -278,14 +279,14 @@
void GrCCPRCubicBorderProcessor::emitPerVertexGeometryCode(SkString* fnBody, const char* position,
const char* /*coverage*/,
const char* /*wind*/) const {
- fnBody->appendf("highp float3 klm = float3(%s, 1) * %s;", position, fKLMMatrix.c_str());
- fnBody->appendf("highp float d = dot(float3(%s, 1), %s);",
+ fnBody->appendf("highfloat3 klm = highfloat3(%s, 1) * %s;", position, fKLMMatrix.c_str());
+ fnBody->appendf("highfloat d = dot(highfloat3(%s, 1), %s);",
position, fEdgeDistanceEquation.c_str());
- fnBody->appendf("%s = float4(klm, d);", fKLMD.gsOut());
- fnBody->appendf("%s = float4(%s[0].x, %s[1].x, %s[2].x, %s.x);",
+ fnBody->appendf("%s = highfloat4(klm, d);", fKLMD.gsOut());
+ fnBody->appendf("%s = highfloat4(%s[0].x, %s[1].x, %s[2].x, %s.x);",
fdKLMDdx.gsOut(), fKLMDerivatives.c_str(), fKLMDerivatives.c_str(),
fKLMDerivatives.c_str(), fEdgeDistanceDerivatives.c_str());
- fnBody->appendf("%s = float4(%s[0].y, %s[1].y, %s[2].y, %s.y);",
+ fnBody->appendf("%s = highfloat4(%s[0].y, %s[1].y, %s[2].y, %s.y);",
fdKLMDdy.gsOut(), fKLMDerivatives.c_str(), fKLMDerivatives.c_str(),
fKLMDerivatives.c_str(), fEdgeDistanceDerivatives.c_str());
fnBody->appendf("%s = position * %s.xy + %s.zw;", fEdgeSpaceCoord.gsOut(),
@@ -303,21 +304,21 @@
// Along the shared edge, we start with distance-to-edge coverage, then subtract out the
// remaining pixel coverage that is still inside the shared edge, but outside the curve.
// Outside the shared edege, we just use standard msaa to count samples inside the curve.
- f->codeAppendf("bool use_edge = all(lessThan(abs(%s), float2(1)));", fEdgeSpaceCoord.fsIn());
+ f->codeAppendf("bool use_edge = all(lessThan(abs(%s), highfloat2(1)));", fEdgeSpaceCoord.fsIn());
f->codeAppendf("%s = (use_edge ? clamp(%s.w + 0.5, 0, 1) : 0) * %i;",
outputCoverage, fKLMD.fsIn(), sampleCount);
- f->codeAppendf("highp float2x4 grad_klmd = float2x4(%s, %s);", fdKLMDdx.fsIn(),
+ f->codeAppendf("highfloat2x4 grad_klmd = highfloat2x4(%s, %s);", fdKLMDdx.fsIn(),
fdKLMDdy.fsIn());
f->codeAppendf("for (int i = 0; i < %i; ++i) {", sampleCount);
- f->codeAppendf( "highp float4 klmd = grad_klmd * samples[i] + %s;", fKLMD.fsIn());
- f->codeAppend ( "lowp float f = klmd.y * klmd.z - klmd.x * klmd.x * klmd.x;");
+ f->codeAppendf( "highfloat4 klmd = grad_klmd * samples[i] + %s;", fKLMD.fsIn());
+ f->codeAppend ( "half f = klmd.y * klmd.z - klmd.x * klmd.x * klmd.x;");
// A sample is inside our cubic sub-section if it is inside the implicit AND L & M are both
// positive. This works because the sections get chopped at the K/L and K/M intersections.
- f->codeAppend ( "bool4 inside = greaterThan(float4(f,klmd.yzw), float4(0));");
- f->codeAppend ( "lowp float in_curve = all(inside.xyz) ? 1 : 0;");
- f->codeAppend ( "lowp float in_edge = inside.w ? 1 : 0;");
+ f->codeAppend ( "bool4 inside = greaterThan(highfloat4(f,klmd.yzw), highfloat4(0));");
+ f->codeAppend ( "half in_curve = all(inside.xyz) ? 1 : 0;");
+ f->codeAppend ( "half in_edge = inside.w ? 1 : 0;");
f->codeAppendf( "%s += use_edge ? in_edge * (in_curve - 1) : in_curve;", outputCoverage);
f->codeAppend ("}");
diff --git a/src/gpu/ccpr/GrCCPRCubicProcessor.h b/src/gpu/ccpr/GrCCPRCubicProcessor.h
index f31dad7..12a4ebc 100644
--- a/src/gpu/ccpr/GrCCPRCubicProcessor.h
+++ b/src/gpu/ccpr/GrCCPRCubicProcessor.h
@@ -46,11 +46,10 @@
GrCCPRCubicProcessor(Type type)
: INHERITED(CoverageType::kShader)
, fType(type)
- , fInset(kVec3f_GrSLType)
- , fTS(kFloat_GrSLType)
- , fKLMMatrix("klm_matrix", kMat33f_GrSLType, GrShaderVar::kNonArray,
- kHigh_GrSLPrecision)
- , fKLMDerivatives("klm_derivatives", kVec2f_GrSLType, 3, kHigh_GrSLPrecision) {}
+ , fInset(kHighFloat3_GrSLType)
+ , fTS(kHighFloat_GrSLType)
+ , fKLMMatrix("klm_matrix", kHighFloat3x3_GrSLType, GrShaderVar::kNonArray)
+ , fKLMDerivatives("klm_derivatives", kHighFloat2_GrSLType, 3) {}
void resetVaryings(GrGLSLVaryingHandler* varyingHandler) override {
varyingHandler->addVarying("insets", &fInset, kHigh_GrSLPrecision);
@@ -81,8 +80,8 @@
public:
GrCCPRCubicInsetProcessor(Type type)
: INHERITED(type)
- , fKLM(kVec3f_GrSLType)
- , fGradMatrix(kMat22f_GrSLType) {}
+ , fKLM(kHighFloat3_GrSLType)
+ , fGradMatrix(kHighFloat2x2_GrSLType) {}
void resetVaryings(GrGLSLVaryingHandler* varyingHandler) override {
this->INHERITED::resetVaryings(varyingHandler);
@@ -107,16 +106,16 @@
public:
GrCCPRCubicBorderProcessor(Type type)
: INHERITED(type)
- , fEdgeDistanceEquation("edge_distance_equation", kVec3f_GrSLType,
- GrShaderVar::kNonArray, kHigh_GrSLPrecision)
- , fEdgeDistanceDerivatives("edge_distance_derivatives", kVec2f_GrSLType,
- GrShaderVar::kNonArray, kHigh_GrSLPrecision)
- , fEdgeSpaceTransform("edge_space_transform", kVec4f_GrSLType, GrShaderVar::kNonArray,
- kHigh_GrSLPrecision)
- , fKLMD(kVec4f_GrSLType)
- , fdKLMDdx(kVec4f_GrSLType)
- , fdKLMDdy(kVec4f_GrSLType)
- , fEdgeSpaceCoord(kVec2f_GrSLType) {}
+ , fEdgeDistanceEquation("edge_distance_equation", kHighFloat3_GrSLType,
+ GrShaderVar::kNonArray)
+ , fEdgeDistanceDerivatives("edge_distance_derivatives", kHighFloat2_GrSLType,
+ GrShaderVar::kNonArray)
+ , fEdgeSpaceTransform("edge_space_transform", kHighFloat4_GrSLType,
+ GrShaderVar::kNonArray)
+ , fKLMD(kHighFloat4_GrSLType)
+ , fdKLMDdx(kHighFloat4_GrSLType)
+ , fdKLMDdy(kHighFloat4_GrSLType)
+ , fEdgeSpaceCoord(kHighFloat2_GrSLType) {}
void resetVaryings(GrGLSLVaryingHandler* varyingHandler) override {
this->INHERITED::resetVaryings(varyingHandler);
diff --git a/src/gpu/ccpr/GrCCPRPathProcessor.cpp b/src/gpu/ccpr/GrCCPRPathProcessor.cpp
index 1292553..203a0ec 100644
--- a/src/gpu/ccpr/GrCCPRPathProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRPathProcessor.cpp
@@ -120,12 +120,12 @@
const char* atlasAdjust;
fAtlasAdjustUniform = uniHandler->addUniform(
kVertex_GrShaderFlag,
- kVec2f_GrSLType, kHigh_GrSLPrecision, "atlas_adjust", &atlasAdjust);
+ kHighFloat2_GrSLType, "atlas_adjust", &atlasAdjust);
varyingHandler->emitAttributes(proc);
- GrGLSLVertToFrag texcoord(kVec2f_GrSLType);
- GrGLSLVertToFrag color(kVec4f_GrSLType);
+ GrGLSLVertToFrag texcoord(kHighFloat2_GrSLType);
+ GrGLSLVertToFrag color(kHalf4_GrSLType);
varyingHandler->addVarying("texcoord", &texcoord, kHigh_GrSLPrecision);
varyingHandler->addFlatPassThroughAttribute(&proc.getInstanceAttrib(InstanceAttribs::kColor),
args.fOutputColor, kLow_GrSLPrecision);
@@ -136,41 +136,41 @@
// Find the intersections of (bloated) devBounds and devBounds45 in order to come up with an
// octagon that circumscribes the (bloated) path. A vertex is the intersection of two lines:
// one edge from the path's bounding box and one edge from its 45-degree bounding box.
- v->codeAppendf("highp float2x2 N = float2x2(%s);", proc.getEdgeNormsAttrib().fName);
+ v->codeAppendf("highfloat2x2 N = highfloat2x2(%s);", proc.getEdgeNormsAttrib().fName);
// N[0] is the normal for the edge we are intersecting from the regular bounding box, pointing
// out of the octagon.
- v->codeAppendf("highp float2 refpt = (min(N[0].x, N[0].y) < 0) ? %s.xy : %s.zw;",
+ v->codeAppendf("highfloat2 refpt = (min(N[0].x, N[0].y) < 0) ? %s.xy : %s.zw;",
proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName,
proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName);
v->codeAppendf("refpt += N[0] * %f;", kAABloatRadius); // bloat for AA.
// N[1] is the normal for the edge we are intersecting from the 45-degree bounding box, pointing
// out of the octagon.
- v->codeAppendf("highp float2 refpt45 = (N[1].x < 0) ? %s.xy : %s.zw;",
+ v->codeAppendf("highfloat2 refpt45 = (N[1].x < 0) ? %s.xy : %s.zw;",
proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).fName,
proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).fName);
- v->codeAppendf("refpt45 *= float2x2(.5,.5,-.5,.5);"); // transform back to device space.
+ v->codeAppendf("refpt45 *= highfloat2x2(.5,.5,-.5,.5);"); // transform back to device space.
v->codeAppendf("refpt45 += N[1] * %f;", kAABloatRadius); // bloat for AA.
- v->codeAppend ("highp float2 K = float2(dot(N[0], refpt), dot(N[1], refpt45));");
- v->codeAppendf("highp float2 octocoord = K * inverse(N);");
+ v->codeAppend ("highfloat2 K = highfloat2(dot(N[0], refpt), dot(N[1], refpt45));");
+ v->codeAppendf("highfloat2 octocoord = K * inverse(N);");
- gpArgs->fPositionVar.set(kVec2f_GrSLType, "octocoord");
+ gpArgs->fPositionVar.set(kHighFloat2_GrSLType, "octocoord");
// Convert to atlas coordinates in order to do our texture lookup.
- v->codeAppendf("highp float2 atlascoord = octocoord + float2(%s);",
+ v->codeAppendf("highfloat2 atlascoord = octocoord + highfloat2(%s);",
proc.getInstanceAttrib(InstanceAttribs::kAtlasOffset).fName);
if (kTopLeft_GrSurfaceOrigin == proc.atlasProxy()->origin()) {
v->codeAppendf("%s = atlascoord * %s;", texcoord.vsOut(), atlasAdjust);
} else {
SkASSERT(kBottomLeft_GrSurfaceOrigin == proc.atlasProxy()->origin());
- v->codeAppendf("%s = float2(atlascoord.x * %s.x, 1 - atlascoord.y * %s.y);",
+ v->codeAppendf("%s = highfloat2(atlascoord.x * %s.x, 1 - atlascoord.y * %s.y);",
texcoord.vsOut(), atlasAdjust, atlasAdjust);
}
// Convert to (local) path cordinates.
- v->codeAppendf("highp float2 pathcoord = inverse(float2x2(%s)) * (octocoord - %s);",
+ v->codeAppendf("highfloat2 pathcoord = inverse(highfloat2x2(%s)) * (octocoord - %s);",
proc.getInstanceAttrib(InstanceAttribs::kViewMatrix).fName,
proc.getInstanceAttrib(InstanceAttribs::kViewTranslate).fName);
@@ -180,16 +180,16 @@
// Fragment shader.
GrGLSLPPFragmentBuilder* f = args.fFragBuilder;
- f->codeAppend ("mediump float coverage_count = ");
- f->appendTextureLookup(args.fTexSamplers[0], texcoord.fsIn(), kVec2f_GrSLType);
+ f->codeAppend ("half coverage_count = ");
+ f->appendTextureLookup(args.fTexSamplers[0], texcoord.fsIn(), kHighFloat2_GrSLType);
f->codeAppend (".a;");
if (SkPath::kWinding_FillType == proc.fillType()) {
- f->codeAppendf("%s = float4(min(abs(coverage_count), 1));", args.fOutputCoverage);
+ f->codeAppendf("%s = half4(min(abs(coverage_count), 1));", args.fOutputCoverage);
} else {
SkASSERT(SkPath::kEvenOdd_FillType == proc.fillType());
- f->codeAppend ("mediump float t = mod(abs(coverage_count), 2);");
- f->codeAppendf("%s = float4(1 - abs(t - 1));", args.fOutputCoverage);
+ f->codeAppend ("half t = mod(abs(coverage_count), 2);");
+ f->codeAppendf("%s = half4(1 - abs(t - 1));", args.fOutputCoverage);
}
}
diff --git a/src/gpu/ccpr/GrCCPRQuadraticProcessor.cpp b/src/gpu/ccpr/GrCCPRQuadraticProcessor.cpp
index ed5f0f3..25cc5e4 100644
--- a/src/gpu/ccpr/GrCCPRQuadraticProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRQuadraticProcessor.cpp
@@ -18,17 +18,17 @@
GrGPArgs* gpArgs) const {
v->codeAppendf("int3 indices = int3(%s.y, %s.x, %s.y + 1);",
proc.instanceAttrib(), proc.instanceAttrib(), proc.instanceAttrib());
- v->codeAppend ("highp float2 self = ");
+ v->codeAppend ("highfloat2 self = ");
v->appendTexelFetch(pointsBuffer, "indices[sk_VertexID]");
v->codeAppendf(".xy + %s;", atlasOffset);
- gpArgs->fPositionVar.set(kVec2f_GrSLType, "self");
+ gpArgs->fPositionVar.set(kHighFloat2_GrSLType, "self");
}
void GrCCPRQuadraticProcessor::emitWind(GrGLSLGeometryBuilder* g, const char* rtAdjust,
const char* outputWind) const {
// We will define bezierpts in onEmitGeometryShader.
- g->codeAppend ("highp float area_times_2 = "
- "determinant(float2x2(bezierpts[1] - bezierpts[0], "
+ g->codeAppend ("highfloat area_times_2 = "
+ "determinant(highfloat2x2(bezierpts[1] - bezierpts[0], "
"bezierpts[2] - bezierpts[0]));");
// Drop curves that are nearly flat, in favor of the higher quality triangle antialiasing.
g->codeAppendf("if (2 * abs(area_times_2) < length((bezierpts[2] - bezierpts[0]) * %s.zx)) {",
@@ -47,26 +47,26 @@
const char* emitVertexFn, const char* wind,
const char* rtAdjust) const {
// Prepend bezierpts at the start of the shader.
- g->codePrependf("highp float3x2 bezierpts = float3x2(sk_in[0].gl_Position.xy, "
- "sk_in[1].gl_Position.xy, "
- "sk_in[2].gl_Position.xy);");
+ g->codePrependf("highfloat3x2 bezierpts = highfloat3x2(sk_in[0].gl_Position.xy, "
+ "sk_in[1].gl_Position.xy, "
+ "sk_in[2].gl_Position.xy);");
g->declareGlobal(fCanonicalMatrix);
- g->codeAppendf("%s = float3x3(0.0, 0, 1, "
- "0.5, 0, 1, "
- "1.0, 1, 1) * "
- "inverse(float3x3(bezierpts[0], 1, "
- "bezierpts[1], 1, "
- "bezierpts[2], 1));",
+ g->codeAppendf("%s = highfloat3x3(0.0, 0, 1, "
+ "0.5, 0, 1, "
+ "1.0, 1, 1) * "
+ "inverse(highfloat3x3(bezierpts[0], 1, "
+ "bezierpts[1], 1, "
+ "bezierpts[2], 1));",
fCanonicalMatrix.c_str());
g->declareGlobal(fCanonicalDerivatives);
- g->codeAppendf("%s = float2x2(%s) * float2x2(%s.x, 0, 0, %s.z);",
+ g->codeAppendf("%s = highfloat2x2(%s) * highfloat2x2(%s.x, 0, 0, %s.z);",
fCanonicalDerivatives.c_str(), fCanonicalMatrix.c_str(), rtAdjust, rtAdjust);
g->declareGlobal(fEdgeDistanceEquation);
- g->codeAppendf("highp float2 edgept0 = bezierpts[%s > 0 ? 2 : 0];", wind);
- g->codeAppendf("highp float2 edgept1 = bezierpts[%s > 0 ? 0 : 2];", wind);
+ g->codeAppendf("highfloat2 edgept0 = bezierpts[%s > 0 ? 2 : 0];", wind);
+ g->codeAppendf("highfloat2 edgept1 = bezierpts[%s > 0 ? 0 : 2];", wind);
this->emitEdgeDistanceEquation(g, "edgept0", "edgept1", fEdgeDistanceEquation.c_str());
this->emitQuadraticGeometry(g, emitVertexFn, rtAdjust);
@@ -75,7 +75,7 @@
void GrCCPRQuadraticProcessor::emitPerVertexGeometryCode(SkString* fnBody, const char* position,
const char* /*coverage*/,
const char* /*wind*/) const {
- fnBody->appendf("%s.xy = (%s * float3(%s, 1)).xy;",
+ fnBody->appendf("%s.xy = (%s * highfloat3(%s, 1)).xy;",
fXYD.gsOut(), fCanonicalMatrix.c_str(), position);
fnBody->appendf("%s.z = dot(%s.xy, %s) + %s.z;",
fXYD.gsOut(), fEdgeDistanceEquation.c_str(), position,
@@ -88,18 +88,18 @@
const char* /*rtAdjust*/) const {
// Find the t value whose tangent is halfway between the tangents at the endpionts.
// (We defined bezierpts in onEmitGeometryShader.)
- g->codeAppend ("highp float2 tan0 = bezierpts[1] - bezierpts[0];");
- g->codeAppend ("highp float2 tan1 = bezierpts[2] - bezierpts[1];");
- g->codeAppend ("highp float2 midnorm = normalize(tan0) - normalize(tan1);");
- g->codeAppend ("highp float2 T = midnorm * float2x2(tan0 - tan1, tan0);");
- g->codeAppend ("highp float t = clamp(T.t / T.s, 0, 1);"); // T.s=0 is weeded out by this point.
+ g->codeAppend ("highfloat2 tan0 = bezierpts[1] - bezierpts[0];");
+ g->codeAppend ("highfloat2 tan1 = bezierpts[2] - bezierpts[1];");
+ g->codeAppend ("highfloat2 midnorm = normalize(tan0) - normalize(tan1);");
+ g->codeAppend ("highfloat2 T = midnorm * highfloat2x2(tan0 - tan1, tan0);");
+ g->codeAppend ("highfloat t = clamp(T.t / T.s, 0, 1);"); // T.s=0 is weeded out by this point.
// Clip the bezier triangle by the tangent at our new t value. This is a simple application for
// De Casteljau's algorithm.
- g->codeAppendf("highp float4x2 quadratic_hull = float4x2(bezierpts[0], "
- "bezierpts[0] + tan0 * t, "
- "bezierpts[1] + tan1 * t, "
- "bezierpts[2]);");
+ g->codeAppendf("highfloat4x2 quadratic_hull = highfloat4x2(bezierpts[0], "
+ "bezierpts[0] + tan0 * t, "
+ "bezierpts[1] + tan1 * t, "
+ "bezierpts[2]);");
int maxVerts = this->emitHullGeometry(g, emitVertexFn, "quadratic_hull", 4, "sk_InvocationID");
@@ -109,13 +109,13 @@
}
void GrCCPRQuadraticHullProcessor::onEmitPerVertexGeometryCode(SkString* fnBody) const {
- fnBody->appendf("%s = float2(2 * %s.x, -1) * %s;",
+ fnBody->appendf("%s = highfloat2(2 * %s.x, -1) * %s;",
fGradXY.gsOut(), fXYD.gsOut(), fCanonicalDerivatives.c_str());
}
void GrCCPRQuadraticHullProcessor::emitShaderCoverage(GrGLSLFragmentBuilder* f,
const char* outputCoverage) const {
- f->codeAppendf("highp float d = (%s.x * %s.x - %s.y) * inversesqrt(dot(%s, %s));",
+ f->codeAppendf("highfloat d = (%s.x * %s.x - %s.y) * inversesqrt(dot(%s, %s));",
fXYD.fsIn(), fXYD.fsIn(), fXYD.fsIn(), fGradXY.fsIn(), fGradXY.fsIn());
f->codeAppendf("%s = clamp(0.5 - d, 0, 1);", outputCoverage);
f->codeAppendf("%s += min(%s.z, 0);", outputCoverage, fXYD.fsIn()); // Flat closing edge.
@@ -128,7 +128,7 @@
g->codeAppendf("%s = %s.xy * %s.xz;",
fEdgeDistanceDerivatives.c_str(), fEdgeDistanceEquation.c_str(), rtAdjust);
- g->codeAppendf("highp float2 corner = bezierpts[sk_InvocationID * 2];");
+ g->codeAppendf("highfloat2 corner = bezierpts[sk_InvocationID * 2];");
int numVertices = this->emitCornerGeometry(g, emitVertexFn, "corner");
g->configure(GrGLSLGeometryBuilder::InputType::kTriangles,
@@ -136,35 +136,35 @@
}
void GrCCPRQuadraticCornerProcessor::onEmitPerVertexGeometryCode(SkString* fnBody) const {
- fnBody->appendf("%s = float3(%s[0].x, %s[0].y, %s.x);",
+ fnBody->appendf("%s = highfloat3(%s[0].x, %s[0].y, %s.x);",
fdXYDdx.gsOut(), fCanonicalDerivatives.c_str(), fCanonicalDerivatives.c_str(),
fEdgeDistanceDerivatives.c_str());
- fnBody->appendf("%s = float3(%s[1].x, %s[1].y, %s.y);",
+ fnBody->appendf("%s = highfloat3(%s[1].x, %s[1].y, %s.y);",
fdXYDdy.gsOut(), fCanonicalDerivatives.c_str(), fCanonicalDerivatives.c_str(),
fEdgeDistanceDerivatives.c_str());
}
void GrCCPRQuadraticCornerProcessor::emitShaderCoverage(GrGLSLFragmentBuilder* f,
const char* outputCoverage) const {
- f->codeAppendf("highp float x = %s.x, y = %s.y, d = %s.z;",
+ f->codeAppendf("highfloat x = %s.x, y = %s.y, d = %s.z;",
fXYD.fsIn(), fXYD.fsIn(), fXYD.fsIn());
- f->codeAppendf("highp float2x3 grad_xyd = float2x3(%s, %s);", fdXYDdx.fsIn(), fdXYDdy.fsIn());
+ f->codeAppendf("highfloat2x3 grad_xyd = highfloat2x3(%s, %s);", fdXYDdx.fsIn(), fdXYDdy.fsIn());
// Erase what the previous hull shader wrote. We don't worry about the two corners falling on
// the same pixel because those cases should have been weeded out by this point.
- f->codeAppend ("highp float f = x*x - y;");
- f->codeAppend ("highp float2 grad_f = float2(2*x, -1) * float2x2(grad_xyd);");
+ f->codeAppend ("highfloat f = x*x - y;");
+ f->codeAppend ("highfloat2 grad_f = highfloat2(2*x, -1) * highfloat2x2(grad_xyd);");
f->codeAppendf("%s = -(0.5 - f * inversesqrt(dot(grad_f, grad_f)));", outputCoverage);
f->codeAppendf("%s -= d;", outputCoverage);
// Use software msaa to approximate coverage at the corner pixels.
int sampleCount = this->defineSoftSampleLocations(f, "samples");
- f->codeAppendf("highp float3 xyd_center = float3(%s.xy, %s.z + 0.5);",
+ f->codeAppendf("highfloat3 xyd_center = highfloat3(%s.xy, %s.z + 0.5);",
fXYD.fsIn(), fXYD.fsIn());
f->codeAppendf("for (int i = 0; i < %i; ++i) {", sampleCount);
- f->codeAppend ( "highp float3 xyd = grad_xyd * samples[i] + xyd_center;");
- f->codeAppend ( "lowp float f = xyd.y - xyd.x * xyd.x;"); // f > 0 -> inside curve.
- f->codeAppendf( "%s += all(greaterThan(float2(f,xyd.z), float2(0))) ? %f : 0;",
+ f->codeAppend ( "highfloat3 xyd = grad_xyd * samples[i] + xyd_center;");
+ f->codeAppend ( "half f = xyd.y - xyd.x * xyd.x;"); // f > 0 -> inside curve.
+ f->codeAppendf( "%s += all(greaterThan(highfloat2(f,xyd.z), highfloat2(0))) ? %f : 0;",
outputCoverage, 1.0 / sampleCount);
f->codeAppendf("}");
}
diff --git a/src/gpu/ccpr/GrCCPRQuadraticProcessor.h b/src/gpu/ccpr/GrCCPRQuadraticProcessor.h
index 1eda255..5b8a854 100644
--- a/src/gpu/ccpr/GrCCPRQuadraticProcessor.h
+++ b/src/gpu/ccpr/GrCCPRQuadraticProcessor.h
@@ -24,13 +24,12 @@
public:
GrCCPRQuadraticProcessor()
: INHERITED(CoverageType::kShader)
- , fCanonicalMatrix("canonical_matrix", kMat33f_GrSLType, GrShaderVar::kNonArray,
- kHigh_GrSLPrecision)
- , fCanonicalDerivatives("canonical_derivatives", kMat22f_GrSLType,
- GrShaderVar::kNonArray, kHigh_GrSLPrecision)
- , fEdgeDistanceEquation("edge_distance_equation", kVec3f_GrSLType,
- GrShaderVar::kNonArray, kHigh_GrSLPrecision)
- , fXYD(kVec3f_GrSLType) {}
+ , fCanonicalMatrix("canonical_matrix", kHighFloat3x3_GrSLType, GrShaderVar::kNonArray)
+ , fCanonicalDerivatives("canonical_derivatives", kHighFloat2x2_GrSLType,
+ GrShaderVar::kNonArray)
+ , fEdgeDistanceEquation("edge_distance_equation", kHighFloat3_GrSLType,
+ GrShaderVar::kNonArray)
+ , fXYD(kHighFloat3_GrSLType) {}
void resetVaryings(GrGLSLVaryingHandler* varyingHandler) override {
varyingHandler->addVarying("xyd", &fXYD, kHigh_GrSLPrecision);
@@ -67,7 +66,7 @@
class GrCCPRQuadraticHullProcessor : public GrCCPRQuadraticProcessor {
public:
GrCCPRQuadraticHullProcessor()
- : fGradXY(kVec2f_GrSLType) {}
+ : fGradXY(kHighFloat2_GrSLType) {}
void resetVaryings(GrGLSLVaryingHandler* varyingHandler) override {
this->INHERITED::resetVaryings(varyingHandler);
@@ -91,10 +90,10 @@
class GrCCPRQuadraticCornerProcessor : public GrCCPRQuadraticProcessor {
public:
GrCCPRQuadraticCornerProcessor()
- : fEdgeDistanceDerivatives("edge_distance_derivatives", kVec2f_GrSLType,
- GrShaderVar::kNonArray, kHigh_GrSLPrecision)
- , fdXYDdx(kVec3f_GrSLType)
- , fdXYDdy(kVec3f_GrSLType) {}
+ : fEdgeDistanceDerivatives("edge_distance_derivatives", kHighFloat2_GrSLType,
+ GrShaderVar::kNonArray)
+ , fdXYDdx(kHighFloat3_GrSLType)
+ , fdXYDdy(kHighFloat3_GrSLType) {}
void resetVaryings(GrGLSLVaryingHandler* varyingHandler) override {
this->INHERITED::resetVaryings(varyingHandler);
diff --git a/src/gpu/ccpr/GrCCPRTriangleProcessor.cpp b/src/gpu/ccpr/GrCCPRTriangleProcessor.cpp
index bb2ad1b..ee25851 100644
--- a/src/gpu/ccpr/GrCCPRTriangleProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRTriangleProcessor.cpp
@@ -16,16 +16,16 @@
const TexelBufferHandle& pointsBuffer,
const char* atlasOffset, const char* rtAdjust,
GrGPArgs* gpArgs) const {
- v->codeAppend ("highp float2 self = ");
+ v->codeAppend ("highfloat2 self = ");
v->appendTexelFetch(pointsBuffer,
SkStringPrintf("%s[sk_VertexID]", proc.instanceAttrib()).c_str());
v->codeAppendf(".xy + %s;", atlasOffset);
- gpArgs->fPositionVar.set(kVec2f_GrSLType, "self");
+ gpArgs->fPositionVar.set(kHighFloat2_GrSLType, "self");
}
void GrCCPRTriangleProcessor::defineInputVertices(GrGLSLGeometryBuilder* g) const {
// Prepend in_vertices at the start of the shader.
- g->codePrependf("highp float3x2 in_vertices = float3x2(sk_in[0].gl_Position.xy, "
+ g->codePrependf("highfloat3x2 in_vertices = highfloat3x2(sk_in[0].gl_Position.xy, "
"sk_in[1].gl_Position.xy, "
"sk_in[2].gl_Position.xy);");
}
@@ -33,8 +33,8 @@
void GrCCPRTriangleProcessor::emitWind(GrGLSLGeometryBuilder* g, const char* /*rtAdjust*/,
const char* outputWind) const {
// We will define in_vertices in defineInputVertices.
- g->codeAppendf("%s = sign(determinant(float2x2(in_vertices[1] - in_vertices[0], "
- "in_vertices[2] - in_vertices[0])));",
+ g->codeAppendf("%s = sign(determinant(highfloat2x2(in_vertices[1] - in_vertices[0], "
+ "in_vertices[2] - in_vertices[0])));",
outputWind);
}
@@ -53,8 +53,8 @@
if (GeometryType::kHulls != fGeometryType) {
g->codeAppend ("int edgeidx0 = sk_InvocationID, "
"edgeidx1 = (edgeidx0 + 1) % 3;");
- g->codeAppendf("highp float2 edgept0 = in_vertices[%s > 0 ? edgeidx0 : edgeidx1];", wind);
- g->codeAppendf("highp float2 edgept1 = in_vertices[%s > 0 ? edgeidx1 : edgeidx0];", wind);
+ g->codeAppendf("highfloat2 edgept0 = in_vertices[%s > 0 ? edgeidx0 : edgeidx1];", wind);
+ g->codeAppendf("highfloat2 edgept1 = in_vertices[%s > 0 ? edgeidx1 : edgeidx0];", wind);
maxOutputVertices += this->emitEdgeGeometry(g, emitVertexFn, "edgept0", "edgept1");
}
@@ -73,15 +73,15 @@
this->INHERITED::onEmitVertexShader(proc, v, pointsBuffer, atlasOffset, rtAdjust, gpArgs);
// Fetch and transform the next point in the triangle.
- v->codeAppend ("highp float2 next = ");
+ v->codeAppend ("highfloat2 next = ");
v->appendTexelFetch(pointsBuffer,
SkStringPrintf("%s[(sk_VertexID+1) %% 3]", proc.instanceAttrib()).c_str());
v->codeAppendf(".xy + %s;", atlasOffset);
// Find the plane that gives distance from the [self -> next] edge, normalized to its AA
// bloat width.
- v->codeAppend ("highp float2 n = float2(next.y - self.y, self.x - next.x);");
- v->codeAppendf("highp float2 d = n * float2x2(self + %f * sign(n), "
+ v->codeAppend ("highfloat2 n = highfloat2(next.y - self.y, self.x - next.x);");
+ v->codeAppendf("highfloat2 d = n * highfloat2x2(self + %f * sign(n), "
"self - %f * sign(n));",
kAABloatRadius, kAABloatRadius);
@@ -98,7 +98,7 @@
const char* rtAdjust) const {
this->defineInputVertices(g);
- g->codeAppend ("highp float2 self = in_vertices[sk_InvocationID];");
+ g->codeAppend ("highfloat2 self = in_vertices[sk_InvocationID];");
int numVertices = this->emitCornerGeometry(g, emitVertexFn, "self");
g->configure(GrGLSLGeometryBuilder::InputType::kTriangles,
@@ -114,7 +114,7 @@
fNeighbors.gsOut(), fDevCoord.gsIn());
fnBody->appendf("%s.zw = %s[(sk_InvocationID + 2) %% 3];",
fNeighbors.gsOut(), fDevCoord.gsIn());
- fnBody->appendf("%s = float3x3(%s[(sk_InvocationID + 2) %% 3], "
+ fnBody->appendf("%s = highfloat3x3(%s[(sk_InvocationID + 2) %% 3], "
"%s[sk_InvocationID], "
"%s[(sk_InvocationID + 1) %% 3]) * %s;",
fEdgeDistances.gsOut(), fEdgeDistance.gsIn(), fEdgeDistance.gsIn(),
@@ -129,32 +129,28 @@
void GrCCPRTriangleCornerProcessor::emitShaderCoverage(GrGLSLFragmentBuilder* f,
const char* outputCoverage) const {
// FIXME: Adreno breaks if we don't put the frag coord in an intermediate highp variable.
- f->codeAppendf("highp float2 fragcoord = sk_FragCoord.xy;");
+ f->codeAppendf("highfloat2 fragcoord = sk_FragCoord.xy;");
// Approximate coverage by tracking where 4 horizontal lines enter and leave the triangle.
- GrShaderVar samples("samples", kVec4f_GrSLType, GrShaderVar::kNonArray,
- kHigh_GrSLPrecision);
+ GrShaderVar samples("samples", kHighFloat4_GrSLType, GrShaderVar::kNonArray);
f->declareGlobal(samples);
- f->codeAppendf("%s = fragcoord.y + float4(-0.375, -0.125, 0.125, 0.375);", samples.c_str());
+ f->codeAppendf("%s = fragcoord.y + highfloat4(-0.375, -0.125, 0.125, 0.375);", samples.c_str());
- GrShaderVar leftedge("leftedge", kVec4f_GrSLType, GrShaderVar::kNonArray,
- kHigh_GrSLPrecision);
+ GrShaderVar leftedge("leftedge", kHighFloat4_GrSLType, GrShaderVar::kNonArray);
f->declareGlobal(leftedge);
- f->codeAppendf("%s = float4(fragcoord.x - 0.5);", leftedge.c_str());
+ f->codeAppendf("%s = highfloat4(fragcoord.x - 0.5);", leftedge.c_str());
- GrShaderVar rightedge("rightedge", kVec4f_GrSLType, GrShaderVar::kNonArray,
- kHigh_GrSLPrecision);
+ GrShaderVar rightedge("rightedge", kHighFloat4_GrSLType, GrShaderVar::kNonArray);
f->declareGlobal(rightedge);
- f->codeAppendf("%s = float4(fragcoord.x + 0.5);", rightedge.c_str());
+ f->codeAppendf("%s = highfloat4(fragcoord.x + 0.5);", rightedge.c_str());
SkString sampleEdgeFn;
- GrShaderVar edgeArg("edge_distance", kVec3f_GrSLType, GrShaderVar::kNonArray,
- kHigh_GrSLPrecision);
+ GrShaderVar edgeArg("edge_distance", kHighFloat3_GrSLType, GrShaderVar::kNonArray);
f->emitFunction(kVoid_GrSLType, "sampleEdge", 1, &edgeArg, [&]() {
SkString b;
- b.appendf("highp float m = abs(%s.x) < 1e-3 ? 1e18 : -1 / %s.x;",
+ b.appendf("highfloat m = abs(%s.x) < 1e-3 ? 1e18 : -1 / %s.x;",
edgeArg.c_str(), edgeArg.c_str());
- b.appendf("highp float4 edge = m * (%s.y * samples + %s.z);",
+ b.appendf("highfloat4 edge = m * (%s.y * samples + %s.z);",
edgeArg.c_str(), edgeArg.c_str());
b.appendf("if (%s.x <= 1e-3 || (abs(%s.x) < 1e-3 && %s.y > 0)) {",
edgeArg.c_str(), edgeArg.c_str(), edgeArg.c_str());
@@ -166,10 +162,10 @@
}().c_str(), &sampleEdgeFn);
// See if the previous neighbor already handled this pixel.
- f->codeAppendf("if (all(lessThan(abs(fragcoord - %s.zw), float2(%f)))) {",
+ f->codeAppendf("if (all(lessThan(abs(fragcoord - %s.zw), highfloat2(%f)))) {",
fNeighbors.fsIn(), kAABloatRadius);
// Handle the case where all 3 corners defer to the previous neighbor.
- f->codeAppendf( "if (%s != 0 || !all(lessThan(abs(fragcoord - %s.xy), float2(%f)))) {",
+ f->codeAppendf( "if (%s != 0 || !all(lessThan(abs(fragcoord - %s.xy), highfloat2(%f)))) {",
fCornerIdx.fsIn(), fNeighbors.fsIn(), kAABloatRadius);
f->codeAppend ( "discard;");
f->codeAppend ( "}");
@@ -177,7 +173,7 @@
// Erase what the hull and two edges wrote at this corner in previous shaders (the two .5's
// for the edges and the -1 for the hull cancel each other out).
- f->codeAppendf("%s = dot(float3(fragcoord, 1) * float2x3(%s), float2(1));",
+ f->codeAppendf("%s = dot(highfloat3(fragcoord, 1) * highfloat2x3(%s), highfloat2(1));",
outputCoverage, fEdgeDistances.fsIn());
// Sample the two edges at this corner.
@@ -185,15 +181,15 @@
f->codeAppendf("%s(%s[1]);", sampleEdgeFn.c_str(), fEdgeDistances.fsIn());
// Handle the opposite edge if the next neighbor will defer to us.
- f->codeAppendf("if (all(lessThan(abs(fragcoord - %s.xy), float2(%f)))) {",
+ f->codeAppendf("if (all(lessThan(abs(fragcoord - %s.xy), highfloat2(%f)))) {",
fNeighbors.fsIn(), kAABloatRadius);
// Erase the coverage the opposite edge wrote to this corner.
- f->codeAppendf( "%s += dot(%s[2], float3(fragcoord, 1)) + 0.5;",
+ f->codeAppendf( "%s += dot(%s[2], highfloat3(fragcoord, 1)) + 0.5;",
outputCoverage, fEdgeDistances.fsIn());
// Sample the opposite edge.
f->codeAppendf( "%s(%s[2]);", sampleEdgeFn.c_str(), fEdgeDistances.fsIn());
f->codeAppend ("}");
- f->codeAppendf("highp float4 widths = max(%s - %s, 0);", rightedge.c_str(), leftedge.c_str());
- f->codeAppendf("%s += dot(widths, float4(0.25));", outputCoverage);
+ f->codeAppendf("highfloat4 widths = max(%s - %s, 0);", rightedge.c_str(), leftedge.c_str());
+ f->codeAppendf("%s += dot(widths, highfloat4(0.25));", outputCoverage);
}
diff --git a/src/gpu/ccpr/GrCCPRTriangleProcessor.h b/src/gpu/ccpr/GrCCPRTriangleProcessor.h
index 1e52d51..9ac7652 100644
--- a/src/gpu/ccpr/GrCCPRTriangleProcessor.h
+++ b/src/gpu/ccpr/GrCCPRTriangleProcessor.h
@@ -72,11 +72,11 @@
public:
GrCCPRTriangleCornerProcessor()
: INHERITED(CoverageType::kShader)
- , fEdgeDistance(kVec3f_GrSLType)
- , fDevCoord(kVec2f_GrSLType)
- , fNeighbors(kVec4f_GrSLType)
- , fEdgeDistances(kMat33f_GrSLType)
- , fCornerIdx(kInt_GrSLType) {}
+ , fEdgeDistance(kHighFloat3_GrSLType)
+ , fDevCoord(kHighFloat2_GrSLType)
+ , fNeighbors(kHighFloat4_GrSLType)
+ , fEdgeDistances(kHighFloat3x3_GrSLType)
+ , fCornerIdx(kShort_GrSLType) {}
void resetVaryings(GrGLSLVaryingHandler* varyingHandler) override {
this->INHERITED::resetVaryings(varyingHandler);
diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp
index aa9a509..5848888 100644
--- a/src/gpu/effects/GrBezierEffect.cpp
+++ b/src/gpu/effects/GrBezierEffect.cpp
@@ -77,7 +77,7 @@
// emit attributes
varyingHandler->emitAttributes(gp);
- GrGLSLVertToFrag v(kVec4f_GrSLType);
+ GrGLSLVertToFrag v(kHighFloat4_GrSLType);
varyingHandler->addVarying("ConicCoeffs", &v, kHigh_GrSLPrecision);
vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inConicCoeffs()->fName);
@@ -102,26 +102,18 @@
gp.localMatrix(),
args.fFPCoordTransformHandler);
- // TODO: this precision check should actually be a check on the number of bits
- // high and medium provide and the selection of the lowest level that suffices.
- // Additionally we should assert that the upstream code only lets us get here if
- // either high or medium provides the required number of bits.
- GrSLPrecision precision = kHigh_GrSLPrecision;
- const GrShaderCaps::PrecisionInfo& highP = args.fShaderCaps->getFloatShaderPrecisionInfo(
- kFragment_GrShaderType,
- kHigh_GrSLPrecision);
- if (!highP.supported()) {
- precision = kMedium_GrSLPrecision;
- }
+ // TODO: we should check on the number of bits float and half provide and use the smallest one
+ // that suffices. Additionally we should assert that the upstream code only lets us get here if
+ // either float or half provides the required number of bits.
- GrShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, precision);
- GrShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, precision);
- GrShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, precision);
- GrShaderVar dfdx("dfdx", kFloat_GrSLType, 0, precision);
- GrShaderVar dfdy("dfdy", kFloat_GrSLType, 0, precision);
- GrShaderVar gF("gF", kVec2f_GrSLType, 0, precision);
- GrShaderVar gFM("gFM", kFloat_GrSLType, 0, precision);
- GrShaderVar func("func", kFloat_GrSLType, 0, precision);
+ GrShaderVar edgeAlpha("edgeAlpha", kHighFloat_GrSLType, 0);
+ GrShaderVar dklmdx("dklmdx", kHighFloat3_GrSLType, 0);
+ GrShaderVar dklmdy("dklmdy", kHighFloat3_GrSLType, 0);
+ GrShaderVar dfdx("dfdx", kHighFloat_GrSLType, 0);
+ GrShaderVar dfdy("dfdy", kHighFloat_GrSLType, 0);
+ GrShaderVar gF("gF", kHighFloat2_GrSLType, 0);
+ GrShaderVar gFM("gFM", kHighFloat_GrSLType, 0);
+ GrShaderVar func("func", kHighFloat_GrSLType, 0);
fragBuilder->declAppend(edgeAlpha);
fragBuilder->declAppend(dklmdx);
@@ -146,7 +138,8 @@
v.fsIn(), dklmdy.c_str(),
v.fsIn(), dklmdy.c_str(),
v.fsIn(), dklmdy.c_str());
- fragBuilder->codeAppendf("%s = float2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str());
+ fragBuilder->codeAppendf("%s = highfloat2(%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 +168,8 @@
v.fsIn(), dklmdy.c_str(),
v.fsIn(), dklmdy.c_str(),
v.fsIn(), dklmdy.c_str());
- fragBuilder->codeAppendf("%s = float2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str());
+ fragBuilder->codeAppendf("%s = highfloat2(%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;",
@@ -191,7 +185,7 @@
case kFillBW_GrProcessorEdgeType: {
fragBuilder->codeAppendf("%s = %s.x * %s.x - %s.y * %s.z;",
edgeAlpha.c_str(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn());
- fragBuilder->codeAppendf("%s = float(%s < 0.0);",
+ fragBuilder->codeAppendf("%s = highfloat(%s < 0.0);",
edgeAlpha.c_str(), edgeAlpha.c_str());
break;
}
@@ -203,14 +197,13 @@
if (gp.coverageScale() != 0xff) {
const char* coverageScale;
fCoverageScaleUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType,
- kHigh_GrSLPrecision,
+ kHighFloat_GrSLType,
"Coverage",
&coverageScale);
- fragBuilder->codeAppendf("%s = float4(%s * %s);",
+ fragBuilder->codeAppendf("%s = half4(%s * %s);",
args.fOutputCoverage, coverageScale, edgeAlpha.c_str());
} else {
- fragBuilder->codeAppendf("%s = float4(%s);", args.fOutputCoverage, edgeAlpha.c_str());
+ fragBuilder->codeAppendf("%s = half4(%s);", args.fOutputCoverage, edgeAlpha.c_str());
}
}
@@ -338,7 +331,7 @@
// emit attributes
varyingHandler->emitAttributes(gp);
- GrGLSLVertToFrag v(kVec4f_GrSLType);
+ GrGLSLVertToFrag v(kHalf4_GrSLType);
varyingHandler->addVarying("HairQuadEdge", &v);
vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inHairQuadEdge()->fName);
@@ -363,13 +356,13 @@
gp.localMatrix(),
args.fFPCoordTransformHandler);
- fragBuilder->codeAppendf("float edgeAlpha;");
+ fragBuilder->codeAppendf("half edgeAlpha;");
switch (fEdgeType) {
case kHairlineAA_GrProcessorEdgeType: {
- 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,"
+ fragBuilder->codeAppendf("half2 duvdx = dFdx(%s.xy);", v.fsIn());
+ fragBuilder->codeAppendf("half2 duvdy = dFdy(%s.xy);", v.fsIn());
+ fragBuilder->codeAppendf("half2 gF = half2(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 +374,9 @@
break;
}
case kFillAA_GrProcessorEdgeType: {
- 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,"
+ fragBuilder->codeAppendf("half2 duvdx = dFdx(%s.xy);", v.fsIn());
+ fragBuilder->codeAppendf("half2 duvdy = dFdy(%s.xy);", v.fsIn());
+ fragBuilder->codeAppendf("half2 gF = half2(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);",
@@ -397,7 +390,7 @@
case kFillBW_GrProcessorEdgeType: {
fragBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);",
v.fsIn(), v.fsIn(), v.fsIn());
- fragBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);");
+ fragBuilder->codeAppend("edgeAlpha = half(edgeAlpha < 0.0);");
break;
}
default:
@@ -407,13 +400,13 @@
if (0xff != gp.coverageScale()) {
const char* coverageScale;
fCoverageScaleUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf_GrSLType,
"Coverage",
&coverageScale);
- fragBuilder->codeAppendf("%s = float4(%s * edgeAlpha);", args.fOutputCoverage, coverageScale);
+ fragBuilder->codeAppendf("%s = half4(%s * edgeAlpha);", args.fOutputCoverage,
+ coverageScale);
} else {
- fragBuilder->codeAppendf("%s = float4(edgeAlpha);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
}
}
@@ -561,25 +554,25 @@
// Setup KLM
const char* devkLMMatrixName;
- fDevKLMUniform = uniformHandler->addUniform(kVertex_GrShaderFlag, kMat33f_GrSLType,
- kHigh_GrSLPrecision, "KLM", &devkLMMatrixName);
- GrGLSLVertToFrag v(kVec3f_GrSLType);
+ fDevKLMUniform = uniformHandler->addUniform(kVertex_GrShaderFlag, kHighFloat3x3_GrSLType, "KLM",
+ &devkLMMatrixName);
+ GrGLSLVertToFrag v(kHighFloat3_GrSLType);
varyingHandler->addVarying("CubicCoeffs", &v, kHigh_GrSLPrecision);
- vertBuilder->codeAppendf("%s = %s * float3(%s, 1);",
+ vertBuilder->codeAppendf("%s = %s * highfloat3(%s, 1);",
v.vsOut(), devkLMMatrixName, gpArgs->fPositionVar.c_str());
- GrGLSLVertToFrag gradCoeffs(kVec4f_GrSLType);
+ GrGLSLVertToFrag gradCoeffs(kHighFloat4_GrSLType);
if (kFillAA_GrProcessorEdgeType == fEdgeType || kHairlineAA_GrProcessorEdgeType == fEdgeType) {
varyingHandler->addVarying("GradCoeffs", &gradCoeffs, kHigh_GrSLPrecision);
- vertBuilder->codeAppendf("highp float k = %s[0], l = %s[1], m = %s[2];",
+ vertBuilder->codeAppendf("highfloat k = %s[0], l = %s[1], m = %s[2];",
v.vsOut(), v.vsOut(), v.vsOut());
- 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]);",
+ vertBuilder->codeAppendf("highfloat2 gk = highfloat2(%s[0][0], %s[1][0]), "
+ "gl = highfloat2(%s[0][1], %s[1][1]), "
+ "gm = highfloat2(%s[0][2], %s[1][2]);",
devkLMMatrixName, devkLMMatrixName, devkLMMatrixName,
devkLMMatrixName, devkLMMatrixName, devkLMMatrixName);
- vertBuilder->codeAppendf("%s = float4(3 * k * gk, -m * gl - l * gm);",
+ vertBuilder->codeAppendf("%s = highfloat4(3 * k * gk, -m * gl - l * gm);",
gradCoeffs.vsOut());
}
@@ -592,9 +585,9 @@
args.fFPCoordTransformHandler);
- GrShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, kHigh_GrSLPrecision);
- GrShaderVar gF("gF", kVec2f_GrSLType, 0, kHigh_GrSLPrecision);
- GrShaderVar func("func", kFloat_GrSLType, 0, kHigh_GrSLPrecision);
+ GrShaderVar edgeAlpha("edgeAlpha", kHighFloat_GrSLType, 0);
+ GrShaderVar gF("gF", kHighFloat2_GrSLType, 0);
+ GrShaderVar func("func", kHighFloat_GrSLType, 0);
fragBuilder->declAppend(edgeAlpha);
fragBuilder->declAppend(gF);
@@ -638,7 +631,7 @@
fragBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;",
edgeAlpha.c_str(), v.fsIn(), v.fsIn(),
v.fsIn(), v.fsIn(), v.fsIn());
- fragBuilder->codeAppendf("%s = float(%s < 0.0);", edgeAlpha.c_str(), edgeAlpha.c_str());
+ fragBuilder->codeAppendf("%s = half(%s < 0.0);", edgeAlpha.c_str(), edgeAlpha.c_str());
break;
}
default:
@@ -646,7 +639,7 @@
}
- fragBuilder->codeAppendf("%s = float4(%s);", args.fOutputCoverage, edgeAlpha.c_str());
+ fragBuilder->codeAppendf("%s = highfloat4(%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 c8b302c..f14881c 100644
--- a/src/gpu/effects/GrBicubicEffect.cpp
+++ b/src/gpu/effects/GrBicubicEffect.cpp
@@ -42,8 +42,7 @@
const GrBicubicEffect& bicubicEffect = args.fFp.cast<GrBicubicEffect>();
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
- fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"ImageIncrement");
const char* imgInc = uniformHandler->getUniformCStr(fImageIncrementUni);
@@ -71,26 +70,26 @@
*
* This is GLSL, so the matrix is column-major (transposed from standard matrix notation).
*/
- fragBuilder->codeAppend("float4x4 kMitchellCoefficients = float4x4("
+ fragBuilder->codeAppend("half4x4 kMitchellCoefficients = half4x4("
" 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("float2 coord = %s - %s * float2(0.5);", coords2D.c_str(), imgInc);
+ fragBuilder->codeAppendf("highfloat2 coord = %s - %s * highfloat2(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("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];");
+ fragBuilder->codeAppend("highfloat2 f = fract(coord);");
+ fragBuilder->codeAppendf("coord = (coord - f + highfloat2(0.5)) * %s;", imgInc);
+ fragBuilder->codeAppend("half4 wx = kMitchellCoefficients * half4(1.0, f.x, f.x * f.x, f.x * f.x * f.x);");
+ fragBuilder->codeAppend("half4 wy = kMitchellCoefficients * half4(1.0, f.y, f.y * f.y, f.y * f.y * f.y);");
+ fragBuilder->codeAppend("half4 rowColors[4];");
for (int y = 0; y < 4; ++y) {
for (int x = 0; x < 4; ++x) {
SkString coord;
- coord.printf("coord + %s * float2(%d, %d)", imgInc, x - 1, y - 1);
+ coord.printf("coord + %s * highfloat2(%d, %d)", imgInc, x - 1, y - 1);
SkString sampleVar;
sampleVar.printf("rowColors[%d]", x);
fDomain.sampleTexture(fragBuilder,
@@ -102,7 +101,7 @@
args.fTexSamplers[0]);
}
fragBuilder->codeAppendf(
- "float4 s%d = wx.x * rowColors[0] + wx.y * rowColors[1] + wx.z * rowColors[2] + wx.w * rowColors[3];",
+ "half4 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 a934ff1..71be7e5 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.cpp
+++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp
@@ -34,7 +34,7 @@
SkDEBUGCODE(GrTexture* atlas = cte.textureSampler(0).peekTexture());
SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
- GrGLSLVertToFrag v(kVec2f_GrSLType);
+ GrGLSLVertToFrag v(kHighFloat2_GrSLType);
varyingHandler->addVarying("TextureCoords", &v, kHigh_GrSLPrecision);
vertBuilder->codeAppendf("%s = %s;", v.vsOut(),
cte.inTextureCoords()->fName);
@@ -65,12 +65,12 @@
fragBuilder->appendTextureLookupAndModulate(args.fOutputColor,
args.fTexSamplers[0],
v.fsIn(),
- kVec2f_GrSLType);
+ kHalf2_GrSLType);
fragBuilder->codeAppend(";");
- fragBuilder->codeAppendf("%s = float4(1);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage);
} else {
fragBuilder->codeAppendf("%s = ", args.fOutputCoverage);
- fragBuilder->appendTextureLookup(args.fTexSamplers[0], v.fsIn(), kVec2f_GrSLType);
+ fragBuilder->appendTextureLookup(args.fTexSamplers[0], v.fsIn(), kHalf2_GrSLType);
fragBuilder->codeAppend(";");
}
}
diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
index 1b5ea60..ff997cd 100644
--- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
@@ -25,12 +25,12 @@
args.fFp.cast<GrBlurredEdgeFragmentProcessor>();
(void)_outer;
fragBuilder->codeAppendf(
- "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 = "
- "float4(factor);\n",
- args.fInputColor ? args.fInputColor : "float4(1)", _outer.mode(),
- args.fOutputColor);
+ "half factor = half(1.0 - highfloat(%s.w));\n@switch (%d) {\n case 0:\n "
+ "factor = half(exp(highfloat(highfloat(-factor * factor) * 4.0)) - "
+ "0.017999999999999999);\n break;\n case 1:\n factor = "
+ "half(smoothstep(1.0, 0.0, highfloat(factor)));\n break;\n}\n%s = "
+ "half4(factor);\n",
+ args.fInputColor ? args.fInputColor : "half4(1)", _outer.mode(), args.fOutputColor);
}
private:
diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.fp b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.fp
index 3ff233a..fe5ffd5 100644
--- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.fp
+++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.fp
@@ -15,7 +15,7 @@
layout(key) in int mode;
void main() {
- float factor = 1.0 - sk_InColor.a;
+ half factor = 1.0 - sk_InColor.a;
@switch (mode) {
case 0: // kGaussian_Mode
factor = exp(-factor * factor * 4.0) - 0.018;
@@ -24,5 +24,5 @@
factor = smoothstep(1.0, 0.0, factor);
break;
}
- sk_OutColor = float4(factor);
+ sk_OutColor = half4(factor);
}
diff --git a/src/gpu/effects/GrCircleEffect.cpp b/src/gpu/effects/GrCircleEffect.cpp
index b764559..7b4a9f7 100644
--- a/src/gpu/effects/GrCircleEffect.cpp
+++ b/src/gpu/effects/GrCircleEffect.cpp
@@ -24,14 +24,15 @@
const GrCircleEffect& _outer = args.fFp.cast<GrCircleEffect>();
(void)_outer;
prevRadius = -1.0;
- fCircleVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType,
+ fCircleVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
kDefault_GrSLPrecision, "circle");
fragBuilder->codeAppendf(
- "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",
+ "half2 prevCenter;\nhalf prevRadius = %f;\nhalf d;\n@if (%d == 2 || %d == 3) {\n "
+ " d = (highfloat(length((%s.xy - half2(sk_FragCoord.xy)) * %s.w)) - 1.0) * "
+ "%s.z;\n} else {\n d = half((1.0 - highfloat(length((%s.xy - "
+ "half2(sk_FragCoord.xy)) * %s.w))) * highfloat(%s.z));\n}\n@if ((%d == 1 || %d == "
+ "3) || %d == 4) {\n d = half(clamp(highfloat(d), 0.0, 1.0));\n} else {\n d = "
+ "half(highfloat(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 +41,7 @@
args.fUniformHandler->getUniformCStr(fCircleVar),
args.fUniformHandler->getUniformCStr(fCircleVar), _outer.edgeType(),
_outer.edgeType(), _outer.edgeType(), args.fOutputColor,
- args.fInputColor ? args.fInputColor : "float4(1)");
+ args.fInputColor ? args.fInputColor : "half4(1)");
}
private:
diff --git a/src/gpu/effects/GrCircleEffect.fp b/src/gpu/effects/GrCircleEffect.fp
index 884112e..031b2ee 100644
--- a/src/gpu/effects/GrCircleEffect.fp
+++ b/src/gpu/effects/GrCircleEffect.fp
@@ -6,14 +6,14 @@
*/
layout(key) in int edgeType;
-in float2 center;
-in float radius;
+in half2 center;
+in half radius;
-float2 prevCenter;
-float prevRadius = -1;
+half2 prevCenter;
+half 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 float4 circle;
+uniform half4 circle;
@optimizationFlags { kCompatibleWithCoverageAsAlpha_OptimizationFlag }
@@ -36,7 +36,7 @@
// TODO: Right now the distance to circle caclulation is performed in a space normalized to the
// radius and then denormalized. This is to prevent overflow on devices that have a "real"
// mediump. It'd be nice to only do this on mediump devices.
- float d;
+ half d;
@if (edgeType == 2 /* kInverseFillBW_GrProcessorEdgeType */ ||
edgeType == 3 /* kInverseFillAA_GrProcessorEdgeType */) {
d = (length((circle.xy - sk_FragCoord.xy) * circle.w) - 1.0) * circle.z;
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index 2cf7919..668423d 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -20,17 +20,14 @@
const GrConfigConversionEffect& cce = args.fFp.cast<GrConfigConversionEffect>();
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
- // Use highp throughout the shader to avoid some precision issues on specific GPUs.
- fragBuilder->elevateDefaultPrecision(kHigh_GrSLPrecision);
-
if (nullptr == args.fInputColor) {
// could optimize this case, but we aren't for now.
- args.fInputColor = "float4(1)";
+ args.fInputColor = "half4(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("float4 color = floor(%s * 255.0 + 0.5) / 255.0;", args.fInputColor);
+ fragBuilder->codeAppendf("half4 color = floor(%s * 255.0 + 0.5) / 255.0;", args.fInputColor);
switch (cce.pmConversion()) {
case GrConfigConversionEffect::kToPremul_PMConversion:
@@ -40,7 +37,7 @@
case GrConfigConversionEffect::kToUnpremul_PMConversion:
fragBuilder->codeAppend(
- "color.rgb = color.a <= 0.0 ? float3(0,0,0) : floor(color.rgb / color.a * 255.0 + 0.5) / 255.0;");
+ "color.rgb = color.a <= 0.0 ? half3(0,0,0) : floor(color.rgb / color.a * 255.0 + 0.5) / 255.0;");
break;
default:
diff --git a/src/gpu/effects/GrConstColorProcessor.cpp b/src/gpu/effects/GrConstColorProcessor.cpp
index a8b328e..7051872 100644
--- a/src/gpu/effects/GrConstColorProcessor.cpp
+++ b/src/gpu/effects/GrConstColorProcessor.cpp
@@ -19,7 +19,7 @@
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
const char* colorUni;
fColorUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kMedium_GrSLPrecision,
+ kHalf4_GrSLType,
"constantColor",
&colorUni);
GrConstColorProcessor::InputMode mode = args.fFp.cast<GrConstColorProcessor>().inputMode();
diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp
index e61923c..97f4569 100644
--- a/src/gpu/effects/GrConvexPolyEffect.cpp
+++ b/src/gpu/effects/GrConvexPolyEffect.cpp
@@ -103,8 +103,7 @@
// The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
// respectively.
fRectUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"rect",
&rectName);
@@ -112,16 +111,16 @@
if (GrProcessorEdgeTypeIsAA(aare.getEdgeType())) {
// The amount of coverage removed in x and y by the edges is computed as a pair of negative
// numbers, xSub and ySub.
- fragBuilder->codeAppend("\t\tfloat xSub, ySub;\n");
+ fragBuilder->codeAppend("\t\thalf xSub, ySub;\n");
fragBuilder->codeAppendf("\t\txSub = min(sk_FragCoord.x - %s.x, 0.0);\n", rectName);
fragBuilder->codeAppendf("\t\txSub += min(%s.z - sk_FragCoord.x, 0.0);\n", rectName);
fragBuilder->codeAppendf("\t\tySub = min(sk_FragCoord.y - %s.y, 0.0);\n", rectName);
fragBuilder->codeAppendf("\t\tySub += min(%s.w - sk_FragCoord.y, 0.0);\n", rectName);
// Now compute coverage in x and y and multiply them to get the fraction of the pixel
// covered.
- fragBuilder->codeAppendf("\t\tfloat alpha = (1.0 + max(xSub, -1.0)) * (1.0 + max(ySub, -1.0));\n");
+ fragBuilder->codeAppendf("\t\thalf alpha = (1.0 + max(xSub, -1.0)) * (1.0 + max(ySub, -1.0));\n");
} else {
- fragBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n");
+ fragBuilder->codeAppendf("\t\thalf alpha = 1.0;\n");
fragBuilder->codeAppendf("\t\talpha *= (sk_FragCoord.x - %s.x) > -0.5 ? 1.0 : 0.0;\n",
rectName);
fragBuilder->codeAppendf("\t\talpha *= (%s.z - sk_FragCoord.x) > -0.5 ? 1.0 : 0.0;\n",
@@ -191,16 +190,15 @@
const char *edgeArrayName;
fEdgeUniform = args.fUniformHandler->addUniformArray(kFragment_GrShaderFlag,
- kVec3f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf3_GrSLType,
"edges",
cpe.getEdgeCount(),
&edgeArrayName);
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
- fragBuilder->codeAppend("\t\tfloat alpha = 1.0;\n");
- fragBuilder->codeAppend("\t\tfloat edge;\n");
+ fragBuilder->codeAppend("\t\thalf alpha = 1.0;\n");
+ fragBuilder->codeAppend("\t\thalf edge;\n");
for (int i = 0; i < cpe.getEdgeCount(); ++i) {
- fragBuilder->codeAppendf("\t\tedge = dot(%s[%d], float3(sk_FragCoord.x, sk_FragCoord.y, "
+ fragBuilder->codeAppendf("\t\tedge = dot(%s[%d], half3(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 2d66e1e..ab0d835 100644
--- a/src/gpu/effects/GrDisableColorXP.cpp
+++ b/src/gpu/effects/GrDisableColorXP.cpp
@@ -53,7 +53,7 @@
// 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 = float4(0);", args.fOutputPrimary);
+ fragBuilder->codeAppendf("%s = half4(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 8dd2fa6..d1d14c9 100644
--- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
@@ -45,8 +45,7 @@
// adjust based on gamma
const char* distanceAdjustUniName = nullptr;
// width, height, 1/(3*width)
- fDistanceAdjustUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ fDistanceAdjustUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
"DistanceAdjust", &distanceAdjustUniName);
#endif
@@ -70,8 +69,8 @@
args.fFPCoordTransformHandler);
// add varyings
- GrGLSLVertToFrag recipScale(kFloat_GrSLType);
- GrGLSLVertToFrag uv(kVec2f_GrSLType);
+ GrGLSLVertToFrag recipScale(kHalf2_GrSLType);
+ GrGLSLVertToFrag uv(kHighFloat2_GrSLType);
bool isUniformScale = (dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask) ==
kUniformScale_DistanceFieldEffectMask;
bool isSimilarity = SkToBool(dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag);
@@ -79,7 +78,7 @@
SkToBool(dfTexEffect.getFlags() & kGammaCorrect_DistanceFieldEffectFlag);
bool isAliased =
SkToBool(dfTexEffect.getFlags() & kAliased_DistanceFieldEffectFlag);
- varyingHandler->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision);
+ varyingHandler->addVarying("TextureCoords", &uv);
vertBuilder->codeAppendf("%s = %s;", uv.vsOut(), dfTexEffect.inTextureCoords()->fName);
// compute numbers to be hardcoded to convert texture coordinates from float to int
@@ -87,28 +86,28 @@
GrTexture* atlas = dfTexEffect.textureSampler(0).peekTexture();
SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
- GrGLSLVertToFrag st(kVec2f_GrSLType);
- varyingHandler->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
- vertBuilder->codeAppendf("%s = float2(%d, %d) * %s;", st.vsOut(),
+ GrGLSLVertToFrag st(kHighFloat2_GrSLType);
+ varyingHandler->addVarying("IntTextureCoords", &st);
+ vertBuilder->codeAppendf("%s = highfloat2(%d, %d) * %s;", st.vsOut(),
atlas->width(), atlas->height(),
dfTexEffect.inTextureCoords()->fName);
// Use highp to work around aliasing issues
- fragBuilder->codeAppendf("highp float2 uv = %s;\n", uv.fsIn());
+ fragBuilder->codeAppendf("highfloat2 uv = %s;\n", uv.fsIn());
- fragBuilder->codeAppend("\tfloat texColor = ");
+ fragBuilder->codeAppend("\thalf texColor = ");
fragBuilder->appendTextureLookup(args.fTexSamplers[0],
"uv",
- kVec2f_GrSLType);
+ kHighFloat2_GrSLType);
fragBuilder->codeAppend(".r;\n");
- fragBuilder->codeAppend("\tfloat distance = "
+ fragBuilder->codeAppend("\thalf distance = "
SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");");
#ifdef SK_GAMMA_APPLY_TO_A8
// adjust width based on gamma
fragBuilder->codeAppendf("distance -= %s;", distanceAdjustUniName);
#endif
- fragBuilder->codeAppend("float afwidth;");
+ fragBuilder->codeAppend("half afwidth;");
if (isUniformScale) {
// For uniform scale, we adjust for the effect of the transformation on the distance
// by using the length of the gradient of the t coordinate in the y direction.
@@ -131,29 +130,29 @@
// this gives us a smooth step across approximately one fragment
#ifdef SK_VULKAN
- fragBuilder->codeAppendf("float st_grad_len = length(dFdx(%s));", st.fsIn());
+ fragBuilder->codeAppendf("half st_grad_len = length(dFdx(%s));", st.fsIn());
#else
// We use the y gradient because there is a bug in the Mali 400 in the x direction.
- fragBuilder->codeAppendf("float st_grad_len = length(dFdy(%s));", st.fsIn());
+ fragBuilder->codeAppendf("half st_grad_len = length(dFdy(%s));", st.fsIn());
#endif
fragBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*st_grad_len);");
} else {
// 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("float2 dist_grad = float2(dFdx(distance), dFdy(distance));");
+ fragBuilder->codeAppend("half2 dist_grad = half2(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("half dg_len2 = dot(dist_grad, dist_grad);");
fragBuilder->codeAppend("if (dg_len2 < 0.0001) {");
- fragBuilder->codeAppend("dist_grad = float2(0.7071, 0.7071);");
+ fragBuilder->codeAppend("dist_grad = half2(0.7071, 0.7071);");
fragBuilder->codeAppend("} else {");
fragBuilder->codeAppend("dist_grad = dist_grad*inversesqrt(dg_len2);");
fragBuilder->codeAppend("}");
- 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->codeAppendf("half2 Jdx = dFdx(%s);", st.fsIn());
+ fragBuilder->codeAppendf("half2 Jdy = dFdy(%s);", st.fsIn());
+ fragBuilder->codeAppend("half2 grad = half2(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
@@ -161,18 +160,18 @@
}
if (isAliased) {
- fragBuilder->codeAppend("float val = distance > 0 ? 1.0 : 0.0;");
+ fragBuilder->codeAppend("half val = distance > 0 ? 1.0 : 0.0;");
} else if (isGammaCorrect) {
// The smoothstep falloff compensates for the non-linear sRGB response curve. If we are
// doing gamma-correct rendering (to an sRGB or F16 buffer), then we actually want
// distance mapped linearly to coverage, so use a linear step:
fragBuilder->codeAppend(
- "float val = clamp((distance + afwidth) / (2.0 * afwidth), 0.0, 1.0);");
+ "half val = clamp((distance + afwidth) / (2.0 * afwidth), 0.0, 1.0);");
} else {
- fragBuilder->codeAppend("float val = smoothstep(-afwidth, afwidth, distance);");
+ fragBuilder->codeAppend("half val = smoothstep(-afwidth, afwidth, distance);");
}
- fragBuilder->codeAppendf("%s = float4(val);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(val);", args.fOutputCoverage);
}
void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& proc,
@@ -323,7 +322,7 @@
// emit attributes
varyingHandler->emitAttributes(dfTexEffect);
- GrGLSLVertToFrag v(kVec2f_GrSLType);
+ GrGLSLVertToFrag v(kHighFloat2_GrSLType);
varyingHandler->addVarying("TextureCoords", &v, kHigh_GrSLPrecision);
// setup pass through color
@@ -347,23 +346,22 @@
args.fFPCoordTransformHandler);
const char* textureSizeUniName = nullptr;
- fTextureSizeUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fTextureSizeUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"TextureSize", &textureSizeUniName);
// Use highp to work around aliasing issues
- fragBuilder->codeAppendf("highp float2 uv = %s;", v.fsIn());
+ fragBuilder->codeAppendf("highfloat2 uv = %s;", v.fsIn());
- fragBuilder->codeAppend("float texColor = ");
+ fragBuilder->codeAppend("half texColor = ");
fragBuilder->appendTextureLookup(args.fTexSamplers[0],
"uv",
- kVec2f_GrSLType);
+ kHighFloat2_GrSLType);
fragBuilder->codeAppend(".r;");
- fragBuilder->codeAppend("float distance = "
+ fragBuilder->codeAppend("half distance = "
SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");");
- fragBuilder->codeAppendf("highp float2 st = uv*%s;", textureSizeUniName);
- fragBuilder->codeAppend("float afwidth;");
+ fragBuilder->codeAppendf("highfloat2 st = uv*%s;", textureSizeUniName);
+ fragBuilder->codeAppend("half afwidth;");
bool isUniformScale = (dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask) ==
kUniformScale_DistanceFieldEffectMask;
bool isSimilarity = SkToBool(dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag);
@@ -388,29 +386,29 @@
// this gives us a smooth step across approximately one fragment
#ifdef SK_VULKAN
- fragBuilder->codeAppend("float st_grad_len = length(dFdx(st));");
+ fragBuilder->codeAppend("half st_grad_len = length(dFdx(st));");
#else
// We use the y gradient because there is a bug in the Mali 400 in the x direction.
- fragBuilder->codeAppend("float st_grad_len = length(dFdy(st));");
+ fragBuilder->codeAppend("half st_grad_len = length(dFdy(st));");
#endif
fragBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*st_grad_len);");
} else {
// 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("float2 dist_grad = float2(dFdx(distance), dFdy(distance));");
+ fragBuilder->codeAppend("half2 dist_grad = half2(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("half dg_len2 = dot(dist_grad, dist_grad);");
fragBuilder->codeAppend("if (dg_len2 < 0.0001) {");
- fragBuilder->codeAppend("dist_grad = float2(0.7071, 0.7071);");
+ fragBuilder->codeAppend("dist_grad = half2(0.7071, 0.7071);");
fragBuilder->codeAppend("} else {");
fragBuilder->codeAppend("dist_grad = dist_grad*inversesqrt(dg_len2);");
fragBuilder->codeAppend("}");
- 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("half2 Jdx = dFdx(st);");
+ fragBuilder->codeAppend("half2 Jdy = dFdy(st);");
+ fragBuilder->codeAppend("half2 grad = half2(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
@@ -421,12 +419,12 @@
// mapped linearly to coverage, so use a linear step:
if (isGammaCorrect) {
fragBuilder->codeAppend(
- "float val = clamp((distance + afwidth) / (2.0 * afwidth), 0.0, 1.0);");
+ "half val = clamp((distance + afwidth) / (2.0 * afwidth), 0.0, 1.0);");
} else {
- fragBuilder->codeAppend("float val = smoothstep(-afwidth, afwidth, distance);");
+ fragBuilder->codeAppend("half val = smoothstep(-afwidth, afwidth, distance);");
}
- fragBuilder->codeAppendf("%s = float4(val);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(val);", args.fOutputCoverage);
}
void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& proc,
@@ -589,8 +587,7 @@
bool isSimilarity = SkToBool(dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag);
bool isGammaCorrect =
SkToBool(dfTexEffect.getFlags() & kGammaCorrect_DistanceFieldEffectFlag);
- GrGLSLVertToFrag recipScale(kFloat_GrSLType);
- GrGLSLVertToFrag uv(kVec2f_GrSLType);
+ GrGLSLVertToFrag uv(kHighFloat2_GrSLType);
varyingHandler->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision);
vertBuilder->codeAppendf("%s = %s;", uv.vsOut(), dfTexEffect.inTextureCoords()->fName);
@@ -599,9 +596,9 @@
GrTexture* atlas = dfTexEffect.textureSampler(0).peekTexture();
SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
- GrGLSLVertToFrag st(kVec2f_GrSLType);
+ GrGLSLVertToFrag st(kHighFloat2_GrSLType);
varyingHandler->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
- vertBuilder->codeAppendf("%s = float2(%d, %d) * %s;", st.vsOut(),
+ vertBuilder->codeAppendf("%s = highfloat2(%d, %d) * %s;", st.vsOut(),
atlas->width(), atlas->height(),
dfTexEffect.inTextureCoords()->fName);
@@ -609,69 +606,68 @@
// create LCD offset adjusted by inverse of transform
// Use highp to work around aliasing issues
- fragBuilder->codeAppendf("highp float2 uv = %s;\n", uv.fsIn());
+ fragBuilder->codeAppendf("highfloat2 uv = %s;\n", uv.fsIn());
SkScalar lcdDelta = 1.0f / (3.0f * atlas->width());
if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) {
- fragBuilder->codeAppendf("highp float delta = -%.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
+ fragBuilder->codeAppendf("highfloat delta = -%.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
} else {
- fragBuilder->codeAppendf("highp float delta = %.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
+ fragBuilder->codeAppendf("highfloat delta = %.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
}
if (isUniformScale) {
#ifdef SK_VULKAN
- fragBuilder->codeAppendf("float st_grad_len = abs(dFdx(%s.x));", st.fsIn());
+ fragBuilder->codeAppendf("half st_grad_len = abs(dFdx(%s.x));", st.fsIn());
#else
// 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());
+ fragBuilder->codeAppendf("half st_grad_len = abs(dFdy(%s.y));", st.fsIn());
#endif
- fragBuilder->codeAppend("float2 offset = float2(st_grad_len*delta, 0.0);");
+ fragBuilder->codeAppend("half2 offset = half2(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("float2 st_grad = dFdx(%s);", st.fsIn());
- fragBuilder->codeAppend("float2 offset = delta*st_grad;");
+ fragBuilder->codeAppendf("half2 st_grad = dFdx(%s);", st.fsIn());
+ fragBuilder->codeAppend("half2 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("float2 st_grad = dFdy(%s);", st.fsIn());
- fragBuilder->codeAppend("float2 offset = delta*float2(st_grad.y, -st_grad.x);");
+ fragBuilder->codeAppendf("half2 st_grad = dFdy(%s);", st.fsIn());
+ fragBuilder->codeAppend("half2 offset = delta*half2(st_grad.y, -st_grad.x);");
#endif
- fragBuilder->codeAppend("float st_grad_len = length(st_grad);");
+ fragBuilder->codeAppend("half st_grad_len = length(st_grad);");
} else {
- fragBuilder->codeAppendf("float2 st = %s;\n", st.fsIn());
+ fragBuilder->codeAppendf("half2 st = %s;\n", st.fsIn());
- fragBuilder->codeAppend("float2 Jdx = dFdx(st);");
- fragBuilder->codeAppend("float2 Jdy = dFdy(st);");
- fragBuilder->codeAppend("float2 offset = delta*Jdx;");
+ fragBuilder->codeAppend("half2 Jdx = dFdx(st);");
+ fragBuilder->codeAppend("half2 Jdy = dFdy(st);");
+ fragBuilder->codeAppend("half2 offset = delta*Jdx;");
}
// green is distance to uv center
- fragBuilder->codeAppend("\tfloat4 texColor = ");
- fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv", kVec2f_GrSLType);
+ fragBuilder->codeAppend("\thalf4 texColor = ");
+ fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv", kHighFloat2_GrSLType);
fragBuilder->codeAppend(";\n");
- fragBuilder->codeAppend("\tfloat3 distance;\n");
+ fragBuilder->codeAppend("\thalf3 distance;\n");
fragBuilder->codeAppend("\tdistance.y = texColor.r;\n");
// red is distance to left offset
- fragBuilder->codeAppend("\tfloat2 uv_adjusted = uv - offset;\n");
+ fragBuilder->codeAppend("\thighfloat2 uv_adjusted = uv - offset;\n");
fragBuilder->codeAppend("\ttexColor = ");
- fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv_adjusted", kVec2f_GrSLType);
+ fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv_adjusted", kHighFloat2_GrSLType);
fragBuilder->codeAppend(";\n");
fragBuilder->codeAppend("\tdistance.x = texColor.r;\n");
// blue is distance to right offset
fragBuilder->codeAppend("\tuv_adjusted = uv + offset;\n");
fragBuilder->codeAppend("\ttexColor = ");
- fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv_adjusted", kVec2f_GrSLType);
+ fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv_adjusted", kHighFloat2_GrSLType);
fragBuilder->codeAppend(";\n");
fragBuilder->codeAppend("\tdistance.z = texColor.r;\n");
fragBuilder->codeAppend("\tdistance = "
- "float3(" SK_DistanceFieldMultiplier ")*(distance - float3(" SK_DistanceFieldThreshold"));");
+ "half3(" SK_DistanceFieldMultiplier ")*(distance - half3(" SK_DistanceFieldThreshold"));");
// adjust width based on gamma
const char* distanceAdjustUniName = nullptr;
- fDistanceAdjustUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec3f_GrSLType, kDefault_GrSLPrecision,
+ fDistanceAdjustUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
"DistanceAdjust", &distanceAdjustUniName);
fragBuilder->codeAppendf("distance -= %s;", distanceAdjustUniName);
@@ -679,7 +675,7 @@
// for each color component. However, this is only important when using perspective
// transformations, and even then using a single factor seems like a reasonable
// trade-off between quality and speed.
- fragBuilder->codeAppend("float afwidth;");
+ fragBuilder->codeAppend("half afwidth;");
if (isSimilarity) {
// For similarity transform (uniform scale-only is a subset of this), we adjust for the
// effect of the transformation on the distance by using the length of the gradient of
@@ -692,16 +688,16 @@
// 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("float2 dist_grad = float2(dFdx(distance.r), dFdy(distance.r));");
+ fragBuilder->codeAppend("half2 dist_grad = half2(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("half dg_len2 = dot(dist_grad, dist_grad);");
fragBuilder->codeAppend("if (dg_len2 < 0.0001) {");
- fragBuilder->codeAppend("dist_grad = float2(0.7071, 0.7071);");
+ fragBuilder->codeAppend("dist_grad = half2(0.7071, 0.7071);");
fragBuilder->codeAppend("} else {");
fragBuilder->codeAppend("dist_grad = dist_grad*inversesqrt(dg_len2);");
fragBuilder->codeAppend("}");
- fragBuilder->codeAppend("float2 grad = float2(dist_grad.x*Jdx.x + dist_grad.y*Jdy.x,");
+ fragBuilder->codeAppend("half2 grad = half2(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 +709,11 @@
// mapped linearly to coverage, so use a linear step:
if (isGammaCorrect) {
fragBuilder->codeAppendf("%s = "
- "float4(clamp((distance + float3(afwidth)) / float3(2.0 * afwidth), 0.0, 1.0), 1.0);",
+ "half4(clamp((distance + half3(afwidth)) / half3(2.0 * afwidth), 0.0, 1.0), 1.0);",
args.fOutputCoverage);
} else {
fragBuilder->codeAppendf(
- "%s = float4(smoothstep(float3(-afwidth), float3(afwidth), distance), 1.0);",
+ "%s = half4(smoothstep(half3(-afwidth), half3(afwidth), distance), 1.0);",
args.fOutputCoverage);
}
}
diff --git a/src/gpu/effects/GrDitherEffect.cpp b/src/gpu/effects/GrDitherEffect.cpp
index d78af4e..6f5266e 100644
--- a/src/gpu/effects/GrDitherEffect.cpp
+++ b/src/gpu/effects/GrDitherEffect.cpp
@@ -24,21 +24,22 @@
const GrDitherEffect& _outer = args.fFp.cast<GrDitherEffect>();
(void)_outer;
fragBuilder->codeAppendf(
- "float value;\nfloat range;\n@switch (%d) {\n case 0:\n range = "
+ "half value;\nhalf range;\n@switch (%d) {\n case 0:\n range = "
"0.0039215686274509803;\n break;\n case 1:\n range = "
"0.015873015873015872;\n break;\n default:\n range = "
"0.066666666666666666;\n break;\n}\n@if (sk_Caps.integerSupport) {\n "
"uint x = uint(sk_FragCoord.x);\n uint y = uint(sk_FragCoord.y);\n uint m = "
"(((((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 float4 "
- "modValues = mod(sk_FragCoord.xyxy, float4(2.0, 2.0, 4.0, 4.0));\n float4 "
- "stepValues = step(modValues, float4(1.0, 1.0, 2.0, 2.0));\n value = "
- "dot(stepValues, float4(0.5, 0.25, 0.125, 0.0625)) - 0.46875;\n}\n%s = "
- "float4(clamp(%s.xyz + value * range, 0.0, %s.w), %s.w);\n",
+ "| (x & 4) >> 2;\n value = highfloat(highfloat(half(m)) / 64.0) - 0.4921875;\n} "
+ "else {\n half4 modValues = half4(mod(sk_FragCoord.xyxy, highfloat4(half4(2.0, "
+ "2.0, 4.0, 4.0))));\n half4 stepValues = half4(step(highfloat4(modValues), "
+ "highfloat4(half4(1.0, 1.0, 2.0, 2.0))));\n value = highfloat(dot(stepValues, "
+ "half4(0.5, 0.25, 0.125, 0.0625))) - 0.46875;\n}\n%s = "
+ "half4(clamp(highfloat3(%s.xyz + value * range), 0.0, highfloat(%s.w)), %s.w);\n",
_outer.rangeType(), args.fOutputColor,
- args.fInputColor ? args.fInputColor : "float4(1)",
- args.fInputColor ? args.fInputColor : "float4(1)",
- args.fInputColor ? args.fInputColor : "float4(1)");
+ args.fInputColor ? args.fInputColor : "half4(1)",
+ args.fInputColor ? args.fInputColor : "half4(1)",
+ args.fInputColor ? args.fInputColor : "half4(1)");
}
private:
diff --git a/src/gpu/effects/GrDitherEffect.fp b/src/gpu/effects/GrDitherEffect.fp
index fe641c6..f2d54cf 100644
--- a/src/gpu/effects/GrDitherEffect.fp
+++ b/src/gpu/effects/GrDitherEffect.fp
@@ -32,8 +32,8 @@
}
void main() {
- float value;
- float range;
+ half value;
+ half range;
@switch (rangeType) {
case 0:
range = 1.0 / 255.0;
@@ -53,17 +53,17 @@
uint m = (y & 1) << 5 | (x & 1) << 4 |
(y & 2) << 2 | (x & 2) << 1 |
(y & 4) >> 1 | (x & 4) >> 2;
- value = float(m) * 1.0 / 64.0 - 63.0 / 128.0;
+ value = half(m) * 1.0 / 64.0 - 63.0 / 128.0;
} else {
// Simulate the integer effect used above using step/mod. For speed, simulates a 4x4
// dither pattern rather than an 8x8 one.
- float4 modValues = mod(sk_FragCoord.xyxy, float4(2.0, 2.0, 4.0, 4.0));
- float4 stepValues = step(modValues, float4(1.0, 1.0, 2.0, 2.0));
- value = dot(stepValues, float4(8.0 / 16.0, 4.0 / 16.0, 2.0 / 16.0, 1.0 / 16.0)) - 15.0 / 32.0;
+ half4 modValues = mod(sk_FragCoord.xyxy, half4(2.0, 2.0, 4.0, 4.0));
+ half4 stepValues = step(modValues, half4(1.0, 1.0, 2.0, 2.0));
+ value = dot(stepValues, half4(8.0 / 16.0, 4.0 / 16.0, 2.0 / 16.0, 1.0 / 16.0)) - 15.0 / 32.0;
}
// 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 = float4(clamp(sk_InColor.rgb + value * range, 0, sk_InColor.a), sk_InColor.a);
+ sk_OutColor = half4(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 e9443a8..96beb45 100644
--- a/src/gpu/effects/GrEllipseEffect.cpp
+++ b/src/gpu/effects/GrEllipseEffect.cpp
@@ -23,35 +23,34 @@
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
const GrEllipseEffect& _outer = args.fFp.cast<GrEllipseEffect>();
(void)_outer;
- prevRadii = float2(-1.0);
+ prevRadii = half2(-1.0);
useScale = sk_Caps.floatPrecisionVaries;
- fEllipseVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType,
- kHigh_GrSLPrecision, "ellipse");
+ fEllipseVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHighFloat4_GrSLType,
+ kDefault_GrSLPrecision, "ellipse");
if (useScale) {
- fScaleVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec2f_GrSLType,
+ fScaleVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
kDefault_GrSLPrecision, "scale");
}
fragBuilder->codeAppendf(
- "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",
+ "half2 prevCenter;\nhalf2 prevRadii = half2(%f, %f);\nbool useScale = %s;\nhalf2 d "
+ "= half2(sk_FragCoord.xy - %s.xy);\n@if (useScale) {\n d *= %s.y;\n}\nhalf2 Z = "
+ "d * half2(%s.zw);\nhalf implicit = dot(Z, d) - 1.0;\nhalf grad_dot = 4.0 * dot(Z, "
+ "Z);\ngrad_dot = half(max(highfloat(grad_dot), 0.0001));\nhalf approx_dist = "
+ "highfloat(implicit) * inversesqrt(highfloat(grad_dot));\n@if (useScale) {\n "
+ "approx_dist *= %s.x;\n}\nhalf alpha;\n@switch (%d) {\n case 0:\n alpha "
+ "= half(highfloat(approx_dist) > 0.0 ? 0.0 : 1.0);\n break;\n case 1:\n "
+ " alpha = half(clamp(0.5 - highfloat(approx_dist), 0.0, 1.0));\n "
+ "break;\n case 2:\n alpha = half(highfloat(approx_dist) > 0.0 ? 1.0 : "
+ "0.0);\n break;\n case 3:\n alpha = half(clamp(0.5 + "
+ "highfloat(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)
- : "float2(0.0)",
+ fScaleVar.isValid() ? args.fUniformHandler->getUniformCStr(fScaleVar) : "half2(0)",
args.fUniformHandler->getUniformCStr(fEllipseVar),
- fScaleVar.isValid() ? args.fUniformHandler->getUniformCStr(fScaleVar)
- : "float2(0.0)",
+ fScaleVar.isValid() ? args.fUniformHandler->getUniformCStr(fScaleVar) : "half2(0)",
_outer.edgeType(), args.fOutputColor,
- args.fInputColor ? args.fInputColor : "float4(1)");
+ args.fInputColor ? args.fInputColor : "half4(1)");
}
private:
diff --git a/src/gpu/effects/GrEllipseEffect.fp b/src/gpu/effects/GrEllipseEffect.fp
index 85c4c96..3663d56 100644
--- a/src/gpu/effects/GrEllipseEffect.fp
+++ b/src/gpu/effects/GrEllipseEffect.fp
@@ -6,17 +6,17 @@
*/
layout(key) in int edgeType;
-in float2 center;
-in float2 radii;
+in half2 center;
+in half2 radii;
-float2 prevCenter;
-float2 prevRadii = float2(-1);
+half2 prevCenter;
+half2 prevRadii = half2(-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 float4 ellipse;
+// The last two terms can underflow with halfs, so we use floats.
+uniform highfloat4 ellipse;
bool useScale = sk_Caps.floatPrecisionVaries;
-layout(when=useScale) uniform float2 scale;
+layout(when=useScale) uniform half2 scale;
@optimizationFlags { kCompatibleWithCoverageAsAlpha_OptimizationFlag }
@@ -50,7 +50,7 @@
void main() {
// d is the offset to the ellipse center
- float2 d = sk_FragCoord.xy - ellipse.xy;
+ half2 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,19 +58,19 @@
@if (useScale) {
d *= scale.y;
}
- float2 Z = d * ellipse.zw;
+ half2 Z = d * ellipse.zw;
// implicit is the evaluation of (x/rx)^2 + (y/ry)^2 - 1.
- float implicit = dot(Z, d) - 1;
+ half implicit = dot(Z, d) - 1;
// grad_dot is the squared length of the gradient of the implicit.
- float grad_dot = 4 * dot(Z, Z);
+ half grad_dot = 4 * dot(Z, Z);
// Avoid calling inversesqrt on zero.
grad_dot = max(grad_dot, 1e-4);
- float approx_dist = implicit * inversesqrt(grad_dot);
+ half approx_dist = implicit * inversesqrt(grad_dot);
@if (useScale) {
approx_dist *= scale.x;
}
- float alpha;
+ half alpha;
@switch (edgeType) {
case 0 /* kFillBW_GrProcessorEdgeType */:
alpha = approx_dist > 0.0 ? 0.0 : 1.0;
diff --git a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
index 23b6178..dfbe17a 100644
--- a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
+++ b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
@@ -41,11 +41,11 @@
args.fFp.cast<GrGaussianConvolutionFragmentProcessor>();
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
- fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kVec2f_GrSLType,
- kDefault_GrSLPrecision, "ImageIncrement");
+ fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
+ "ImageIncrement");
if (ce.useBounds()) {
- fBoundsUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kVec2f_GrSLType,
- kDefault_GrSLPrecision, "Bounds");
+ fBoundsUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
+ "Bounds");
}
int width = ce.width();
@@ -53,19 +53,19 @@
int arrayCount = (width + 3) / 4;
SkASSERT(4 * arrayCount >= width);
- fKernelUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag, kVec4f_GrSLType,
- kDefault_GrSLPrecision, "Kernel", arrayCount);
+ fKernelUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag, kHalf4_GrSLType,
+ "Kernel", arrayCount);
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
- fragBuilder->codeAppendf("%s = float4(0, 0, 0, 0);", args.fOutputColor);
+ fragBuilder->codeAppendf("%s = half4(0, 0, 0, 0);", args.fOutputColor);
const GrShaderVar& kernel = uniformHandler->getUniformVariable(fKernelUni);
const char* imgInc = uniformHandler->getUniformCStr(fImageIncrementUni);
- fragBuilder->codeAppendf("float2 coord = %s - %d.0 * %s;", coords2D.c_str(), ce.radius(), imgInc);
- fragBuilder->codeAppend("float2 coordSampled = float2(0, 0);");
+ fragBuilder->codeAppendf("highfloat2 coord = %s - %d.0 * %s;", coords2D.c_str(), ce.radius(), imgInc);
+ fragBuilder->codeAppend("highfloat2 coordSampled = half2(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 9d9a03e..063f8f3 100644
--- a/src/gpu/effects/GrMatrixConvolutionEffect.cpp
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
@@ -47,20 +47,15 @@
SkASSERT(4 * arrayCount >= kWidth * kHeight);
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
- fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"ImageIncrement");
- fKernelUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ fKernelUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag, kHalf4_GrSLType,
"Kernel",
arrayCount);
- fKernelOffsetUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fKernelOffsetUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"KernelOffset");
- fGainUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision, "Gain");
- fBiasUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision, "Bias");
+ fGainUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "Gain");
+ fBiasUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "Bias");
const char* kernelOffset = uniformHandler->getUniformCStr(fKernelOffsetUni);
const char* imgInc = uniformHandler->getUniformCStr(fImageIncrementUni);
@@ -70,9 +65,9 @@
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
SkString coords2D = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
- 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;");
+ fragBuilder->codeAppend("half4 sum = half4(0, 0, 0, 0);");
+ fragBuilder->codeAppendf("highfloat2 coord = %s - %s * %s;", coords2D.c_str(), kernelOffset, imgInc);
+ fragBuilder->codeAppend("half4 c;");
const char* kVecSuffix[4] = { ".x", ".y", ".z", ".w" };
for (int y = 0; y < kHeight; y++) {
@@ -80,10 +75,10 @@
GrGLSLShaderBuilder::ShaderBlock block(fragBuilder);
int offset = y*kWidth + x;
- fragBuilder->codeAppendf("float k = %s[%d]%s;", kernel, offset / 4,
+ fragBuilder->codeAppendf("half k = %s[%d]%s;", kernel, offset / 4,
kVecSuffix[offset & 0x3]);
SkString coord;
- coord.printf("coord + float2(%d, %d) * %s", x, y, imgInc);
+ coord.printf("coord + half2(%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 b30746a..fee7f17 100644
--- a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp
+++ b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp
@@ -23,24 +23,21 @@
const char* srcCoeffsName = nullptr;
if (SkToBool(csxe.ops() & GrNonlinearColorSpaceXformEffect::kSrcTransfer_Op)) {
fSrcTransferFnUni = uniformHandler->addUniformArray(
- kFragment_GrShaderFlag, kFloat_GrSLType, kDefault_GrSLPrecision,
- "SrcTransferFn", GrNonlinearColorSpaceXformEffect::kNumTransferFnCoeffs,
- &srcCoeffsName);
+ kFragment_GrShaderFlag, kHalf_GrSLType, "SrcTransferFn",
+ GrNonlinearColorSpaceXformEffect::kNumTransferFnCoeffs, &srcCoeffsName);
}
const char* dstCoeffsName = nullptr;
if (SkToBool(csxe.ops() & GrNonlinearColorSpaceXformEffect::kDstTransfer_Op)) {
fDstTransferFnUni = uniformHandler->addUniformArray(
- kFragment_GrShaderFlag, kFloat_GrSLType, kDefault_GrSLPrecision,
- "DstTransferFn", GrNonlinearColorSpaceXformEffect::kNumTransferFnCoeffs,
- &dstCoeffsName);
+ kFragment_GrShaderFlag, kHalf_GrSLType, "DstTransferFn",
+ GrNonlinearColorSpaceXformEffect::kNumTransferFnCoeffs, &dstCoeffsName);
}
const char* gamutXformName = nullptr;
if (SkToBool(csxe.ops() & GrNonlinearColorSpaceXformEffect::kGamutXform_Op)) {
- fGamutXformUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kMat44f_GrSLType,
- kDefault_GrSLPrecision, "GamutXform",
- &gamutXformName);
+ fGamutXformUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4x4_GrSLType,
+ "GamutXform", &gamutXformName);
}
// Helper function to apply the src or dst transfer function to a single value
@@ -52,32 +49,32 @@
}
const char* fnName = i ? "dst_transfer_fn" : "src_transfer_fn";
static const GrShaderVar gTransferFnFuncArgs[] = {
- GrShaderVar("x", kFloat_GrSLType),
+ GrShaderVar("x", kHalf_GrSLType),
};
SkString transferFnBody;
// Temporaries to make evaluation line readable
- transferFnBody.printf("float A = %s[0];", coeffsName);
- transferFnBody.appendf("float B = %s[1];", coeffsName);
- transferFnBody.appendf("float C = %s[2];", coeffsName);
- transferFnBody.appendf("float D = %s[3];", coeffsName);
- transferFnBody.appendf("float E = %s[4];", coeffsName);
- transferFnBody.appendf("float F = %s[5];", coeffsName);
- transferFnBody.appendf("float G = %s[6];", coeffsName);
- transferFnBody.append("float s = sign(x);");
+ transferFnBody.printf("half A = %s[0];", coeffsName);
+ transferFnBody.appendf("half B = %s[1];", coeffsName);
+ transferFnBody.appendf("half C = %s[2];", coeffsName);
+ transferFnBody.appendf("half D = %s[3];", coeffsName);
+ transferFnBody.appendf("half E = %s[4];", coeffsName);
+ transferFnBody.appendf("half F = %s[5];", coeffsName);
+ transferFnBody.appendf("half G = %s[6];", coeffsName);
+ transferFnBody.append("half s = sign(x);");
transferFnBody.append("x = abs(x);");
transferFnBody.appendf("return s * ((x < D) ? (C * x) + F : pow(A * x + B, G) + E);");
- fragBuilder->emitFunction(kFloat_GrSLType, fnName, SK_ARRAY_COUNT(gTransferFnFuncArgs),
+ fragBuilder->emitFunction(kHalf_GrSLType, fnName, SK_ARRAY_COUNT(gTransferFnFuncArgs),
gTransferFnFuncArgs, transferFnBody.c_str(), &tfFuncNames[i]);
}
if (nullptr == args.fInputColor) {
- args.fInputColor = "float4(1)";
+ args.fInputColor = "half4(1)";
}
- fragBuilder->codeAppendf("float4 color = %s;", args.fInputColor);
+ fragBuilder->codeAppendf("half4 color = %s;", args.fInputColor);
// 1: Un-premultiply the input color (if necessary)
- fragBuilder->codeAppendf("float nonZeroAlpha = max(color.a, 0.00001);");
- fragBuilder->codeAppendf("color = float4(color.rgb / nonZeroAlpha, nonZeroAlpha);");
+ fragBuilder->codeAppendf("half nonZeroAlpha = max(color.a, 0.00001);");
+ fragBuilder->codeAppendf("color = half4(color.rgb / nonZeroAlpha, nonZeroAlpha);");
// 2: Apply src transfer function (to get to linear RGB)
if (srcCoeffsName) {
@@ -89,7 +86,7 @@
// 3: Apply gamut matrix
if (gamutXformName) {
fragBuilder->codeAppendf(
- "color.rgb = (%s * float4(color.rgb, 1.0)).rgb;", gamutXformName);
+ "color.rgb = (%s * half4(color.rgb, 1.0)).rgb;", gamutXformName);
}
// 4: Apply dst transfer fn
@@ -100,7 +97,7 @@
}
// 5: Premultiply again
- fragBuilder->codeAppendf("%s = float4(color.rgb * color.a, color.a);", args.fOutputColor);
+ fragBuilder->codeAppendf("%s = half4(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 658f190..e6c7bf9 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -440,7 +440,7 @@
SkASSERT(inColor);
switch (outputType) {
case BlendFormula::kNone_OutputType:
- fragBuilder->codeAppendf("%s = float4(0.0);", output);
+ fragBuilder->codeAppendf("%s = half4(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 @@
fragBuilder->codeAppendf("%s = (1.0 - %s.a) * %s;", output, inColor, inCoverage);
break;
case BlendFormula::kISCModulate_OutputType:
- fragBuilder->codeAppendf("%s = (float4(1.0) - %s) * %s;", output, inColor, inCoverage);
+ fragBuilder->codeAppendf("%s = (half4(1.0) - %s) * %s;", output, inColor, inCoverage);
break;
default:
SK_ABORT("Unsupported output type.");
@@ -629,8 +629,8 @@
private:
void emitOutputsForBlendState(const EmitArgs& args) override {
const char* alpha;
- fAlphaUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kFloat_GrSLType,
- kDefault_GrSLPrecision, "alpha", &alpha);
+ fAlphaUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+ "alpha", &alpha);
GrGLSLXPFragmentBuilder* fragBuilder = args.fXPFragBuilder;
// We want to force our primary output to be alpha * Coverage, where alpha is the alpha
// value of the src color. We know that there are no color stages (or we wouldn't have
diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index 6d47e58..7ad354c 100644
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -160,15 +160,11 @@
// edges correspond to components x, y, z, and w, respectively. When a side of the rrect has
// only rectangular corners, that side's value corresponds to the rect edge's value outset by
// half a pixel.
- fInnerRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
- "innerRect",
- &rectName);
+ fInnerRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+ "innerRect", &rectName);
// x is (r + .5) and y is 1/(r + .5)
- fRadiusPlusHalfUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
- "radiusPlusHalf",
- &radiusPlusHalfName);
+ fRadiusPlusHalfUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
+ "radiusPlusHalf", &radiusPlusHalfName);
// If we're on a device with a "real" mediump then the length calculation could overflow.
SkString clampedCircleDistance;
@@ -197,87 +193,87 @@
// alphas together.
switch (crre.getCircularCornerFlags()) {
case CircularRRectEffect::kAll_CornerFlags:
- 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());
+ fragBuilder->codeAppendf("half2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
+ fragBuilder->codeAppendf("half2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName);
+ fragBuilder->codeAppend("half2 dxy = max(max(dxy0, dxy1), 0.0);");
+ fragBuilder->codeAppendf("half alpha = %s;", clampedCircleDistance.c_str());
break;
case CircularRRectEffect::kTopLeft_CornerFlag:
- fragBuilder->codeAppendf("float2 dxy = max(%s.xy - sk_FragCoord.xy, 0.0);",
+ fragBuilder->codeAppendf("half2 dxy = max(%s.xy - sk_FragCoord.xy, 0.0);",
rectName);
- fragBuilder->codeAppendf("float rightAlpha = clamp(%s.z - sk_FragCoord.x, 0.0, 1.0);",
+ fragBuilder->codeAppendf("half rightAlpha = clamp(%s.z - sk_FragCoord.x, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float bottomAlpha = clamp(%s.w - sk_FragCoord.y, 0.0, 1.0);",
+ fragBuilder->codeAppendf("half bottomAlpha = clamp(%s.w - sk_FragCoord.y, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float alpha = bottomAlpha * rightAlpha * %s;",
+ fragBuilder->codeAppendf("half alpha = bottomAlpha * rightAlpha * %s;",
clampedCircleDistance.c_str());
break;
case CircularRRectEffect::kTopRight_CornerFlag:
- fragBuilder->codeAppendf("float2 dxy = max(float2(sk_FragCoord.x - %s.z, "
- "%s.y - sk_FragCoord.y), 0.0);",
+ fragBuilder->codeAppendf("half2 dxy = max(half2(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);",
+ fragBuilder->codeAppendf("half leftAlpha = clamp(sk_FragCoord.x - %s.x, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float bottomAlpha = clamp(%s.w - sk_FragCoord.y, 0.0, 1.0);",
+ fragBuilder->codeAppendf("half bottomAlpha = clamp(%s.w - sk_FragCoord.y, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float alpha = bottomAlpha * leftAlpha * %s;",
+ fragBuilder->codeAppendf("half alpha = bottomAlpha * leftAlpha * %s;",
clampedCircleDistance.c_str());
break;
case CircularRRectEffect::kBottomRight_CornerFlag:
- fragBuilder->codeAppendf("float2 dxy = max(sk_FragCoord.xy - %s.zw, 0.0);",
+ fragBuilder->codeAppendf("half2 dxy = max(sk_FragCoord.xy - %s.zw, 0.0);",
rectName);
- fragBuilder->codeAppendf("float leftAlpha = clamp(sk_FragCoord.x - %s.x, 0.0, 1.0);",
+ fragBuilder->codeAppendf("half leftAlpha = clamp(sk_FragCoord.x - %s.x, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float topAlpha = clamp(sk_FragCoord.y - %s.y, 0.0, 1.0);",
+ fragBuilder->codeAppendf("half topAlpha = clamp(sk_FragCoord.y - %s.y, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float alpha = topAlpha * leftAlpha * %s;",
+ fragBuilder->codeAppendf("half alpha = topAlpha * leftAlpha * %s;",
clampedCircleDistance.c_str());
break;
case CircularRRectEffect::kBottomLeft_CornerFlag:
- fragBuilder->codeAppendf("float2 dxy = max(float2(%s.x - sk_FragCoord.x, sk_FragCoord.y - "
+ fragBuilder->codeAppendf("half2 dxy = max(half2(%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);",
+ fragBuilder->codeAppendf("half rightAlpha = clamp(%s.z - sk_FragCoord.x, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float topAlpha = clamp(sk_FragCoord.y - %s.y, 0.0, 1.0);",
+ fragBuilder->codeAppendf("half topAlpha = clamp(sk_FragCoord.y - %s.y, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float alpha = topAlpha * rightAlpha * %s;",
+ fragBuilder->codeAppendf("half alpha = topAlpha * rightAlpha * %s;",
clampedCircleDistance.c_str());
break;
case CircularRRectEffect::kLeft_CornerFlags:
- fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
- fragBuilder->codeAppendf("float dy1 = sk_FragCoord.y - %s.w;", rectName);
- 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);",
+ fragBuilder->codeAppendf("half2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
+ fragBuilder->codeAppendf("half dy1 = sk_FragCoord.y - %s.w;", rectName);
+ fragBuilder->codeAppend("half2 dxy = max(half2(dxy0.x, max(dxy0.y, dy1)), 0.0);");
+ fragBuilder->codeAppendf("half rightAlpha = clamp(%s.z - sk_FragCoord.x, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float alpha = rightAlpha * %s;",
+ fragBuilder->codeAppendf("half alpha = rightAlpha * %s;",
clampedCircleDistance.c_str());
break;
case CircularRRectEffect::kTop_CornerFlags:
- fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
- fragBuilder->codeAppendf("float dx1 = sk_FragCoord.x - %s.z;", rectName);
- 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);",
+ fragBuilder->codeAppendf("half2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
+ fragBuilder->codeAppendf("half dx1 = sk_FragCoord.x - %s.z;", rectName);
+ fragBuilder->codeAppend("half2 dxy = max(half2(max(dxy0.x, dx1), dxy0.y), 0.0);");
+ fragBuilder->codeAppendf("half bottomAlpha = clamp(%s.w - sk_FragCoord.y, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float alpha = bottomAlpha * %s;",
+ fragBuilder->codeAppendf("half alpha = bottomAlpha * %s;",
clampedCircleDistance.c_str());
break;
case CircularRRectEffect::kRight_CornerFlags:
- fragBuilder->codeAppendf("float dy0 = %s.y - sk_FragCoord.y;", rectName);
- 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);",
+ fragBuilder->codeAppendf("half dy0 = %s.y - sk_FragCoord.y;", rectName);
+ fragBuilder->codeAppendf("half2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName);
+ fragBuilder->codeAppend("half2 dxy = max(half2(dxy1.x, max(dy0, dxy1.y)), 0.0);");
+ fragBuilder->codeAppendf("half leftAlpha = clamp(sk_FragCoord.x - %s.x, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float alpha = leftAlpha * %s;",
+ fragBuilder->codeAppendf("half alpha = leftAlpha * %s;",
clampedCircleDistance.c_str());
break;
case CircularRRectEffect::kBottom_CornerFlags:
- fragBuilder->codeAppendf("float dx0 = %s.x - sk_FragCoord.x;", rectName);
- 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);",
+ fragBuilder->codeAppendf("half dx0 = %s.x - sk_FragCoord.x;", rectName);
+ fragBuilder->codeAppendf("half2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName);
+ fragBuilder->codeAppend("half2 dxy = max(half2(max(dx0, dxy1.x), dxy1.y), 0.0);");
+ fragBuilder->codeAppendf("half topAlpha = clamp(sk_FragCoord.y - %s.y, 0.0, 1.0);",
rectName);
- fragBuilder->codeAppendf("float alpha = topAlpha * %s;",
+ fragBuilder->codeAppendf("half alpha = topAlpha * %s;",
clampedCircleDistance.c_str());
break;
}
@@ -514,10 +510,8 @@
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
const char *rectName;
// The inner rect is the rrect bounds inset by the x/y radii
- fInnerRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
- "innerRect",
- &rectName);
+ fInnerRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
+ "innerRect", &rectName);
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
// At each quarter-ellipse corner we compute a vector that is the offset of the fragment pos
@@ -532,17 +526,16 @@
// 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("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
- fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName);
+ fragBuilder->codeAppendf("half2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
+ fragBuilder->codeAppendf("half2 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
// radii uniform values are already in this normalized space.
const char* scaleName = nullptr;
if (args.fShaderCaps->floatPrecisionVaries()) {
- fScaleUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
- "scale", &scaleName);
+ fScaleUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType, "scale",
+ &scaleName);
}
// The uniforms with the inv squared radii are highp to prevent underflow.
@@ -550,34 +543,32 @@
case SkRRect::kSimple_Type: {
const char *invRadiiXYSqdName;
fInvRadiiSqdUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf2_GrSLType,
"invRadiiXY",
&invRadiiXYSqdName);
- fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
+ fragBuilder->codeAppend("half2 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("float2 Z = dxy * %s.xy;", invRadiiXYSqdName);
+ fragBuilder->codeAppendf("half2 Z = dxy * %s.xy;", invRadiiXYSqdName);
break;
}
case SkRRect::kNinePatch_Type: {
const char *invRadiiLTRBSqdName;
fInvRadiiSqdUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"invRadiiLTRB",
&invRadiiLTRBSqdName);
if (scaleName) {
fragBuilder->codeAppendf("dxy0 *= %s.y;", scaleName);
fragBuilder->codeAppendf("dxy1 *= %s.y;", scaleName);
}
- fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
+ fragBuilder->codeAppend("half2 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("float2 Z = max(max(dxy0 * %s.xy, dxy1 * %s.zw), 0.0);",
+ fragBuilder->codeAppendf("half2 Z = max(max(dxy0 * %s.xy, dxy1 * %s.zw), 0.0);",
invRadiiLTRBSqdName, invRadiiLTRBSqdName);
break;
@@ -586,20 +577,20 @@
SK_ABORT("RRect should always be simple or nine-patch.");
}
// implicit is the evaluation of (x/a)^2 + (y/b)^2 - 1.
- fragBuilder->codeAppend("float implicit = dot(Z, dxy) - 1.0;");
+ fragBuilder->codeAppend("half implicit = dot(Z, dxy) - 1.0;");
// grad_dot is the squared length of the gradient of the implicit.
- fragBuilder->codeAppend("float grad_dot = 4.0 * dot(Z, Z);");
+ fragBuilder->codeAppend("half grad_dot = 4.0 * dot(Z, Z);");
// avoid calling inversesqrt on zero.
fragBuilder->codeAppend("grad_dot = max(grad_dot, 1.0e-4);");
- fragBuilder->codeAppend("float approx_dist = implicit * inversesqrt(grad_dot);");
+ fragBuilder->codeAppend("half approx_dist = implicit * inversesqrt(grad_dot);");
if (scaleName) {
fragBuilder->codeAppendf("approx_dist *= %s.x;", scaleName);
}
if (kFillAA_GrProcessorEdgeType == erre.getEdgeType()) {
- fragBuilder->codeAppend("float alpha = clamp(0.5 - approx_dist, 0.0, 1.0);");
+ fragBuilder->codeAppend("half alpha = clamp(0.5 - approx_dist, 0.0, 1.0);");
} else {
- fragBuilder->codeAppend("float alpha = clamp(0.5 + approx_dist, 0.0, 1.0);");
+ fragBuilder->codeAppend("half alpha = clamp(0.5 + approx_dist, 0.0, 1.0);");
}
fragBuilder->codeAppendf("%s = %s * alpha;", args.fOutputColor, args.fInputColor);
diff --git a/src/gpu/effects/GrSRGBEffect.cpp b/src/gpu/effects/GrSRGBEffect.cpp
index f415a6c..0e56dfc 100644
--- a/src/gpu/effects/GrSRGBEffect.cpp
+++ b/src/gpu/effects/GrSRGBEffect.cpp
@@ -20,11 +20,11 @@
SkString srgbFuncName;
static const GrShaderVar gSrgbArgs[] = {
- GrShaderVar("x", kFloat_GrSLType),
+ GrShaderVar("x", kHalf_GrSLType),
};
switch (srgbe.mode()) {
case GrSRGBEffect::Mode::kLinearToSRGB:
- fragBuilder->emitFunction(kFloat_GrSLType,
+ fragBuilder->emitFunction(kHalf_GrSLType,
"linear_to_srgb",
SK_ARRAY_COUNT(gSrgbArgs),
gSrgbArgs,
@@ -33,7 +33,7 @@
&srgbFuncName);
break;
case GrSRGBEffect::Mode::kSRGBToLinear:
- fragBuilder->emitFunction(kFloat_GrSLType,
+ fragBuilder->emitFunction(kHalf_GrSLType,
"srgb_to_linear",
SK_ARRAY_COUNT(gSrgbArgs),
gSrgbArgs,
@@ -44,20 +44,20 @@
}
if (nullptr == args.fInputColor) {
- args.fInputColor = "float4(1)";
+ args.fInputColor = "half4(1)";
}
- fragBuilder->codeAppendf("float4 color = %s;", args.fInputColor);
+ fragBuilder->codeAppendf("half4 color = %s;", args.fInputColor);
if (srgbe.alpha() == GrSRGBEffect::Alpha::kPremul) {
- fragBuilder->codeAppendf("float nonZeroAlpha = max(color.a, 0.00001);");
- fragBuilder->codeAppendf("color = float4(color.rgb / nonZeroAlpha, color.a);");
+ fragBuilder->codeAppendf("half nonZeroAlpha = max(color.a, 0.00001);");
+ fragBuilder->codeAppendf("color = half4(color.rgb / nonZeroAlpha, color.a);");
}
- fragBuilder->codeAppendf("color = float4(%s(color.r), %s(color.g), %s(color.b), color.a);",
+ fragBuilder->codeAppendf("color = half4(%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 = float4(color.rgb, 1) * color.a;");
+ fragBuilder->codeAppendf("color = half4(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 297dd50..ca4c5db 100644
--- a/src/gpu/effects/GrShadowGeoProc.cpp
+++ b/src/gpu/effects/GrShadowGeoProc.cpp
@@ -26,7 +26,7 @@
// emit attributes
varyingHandler->emitAttributes(rsgp);
- fragBuilder->codeAppend("float4 shadowParams;");
+ fragBuilder->codeAppend("half4 shadowParams;");
varyingHandler->addPassThroughAttribute(rsgp.inShadowParams(), "shadowParams");
// setup pass through color
@@ -43,12 +43,12 @@
rsgp.inPosition()->fName,
args.fFPCoordTransformHandler);
- fragBuilder->codeAppend("float d = length(shadowParams.xy);");
- fragBuilder->codeAppend("float distance = shadowParams.z * (1.0 - d);");
+ fragBuilder->codeAppend("half d = length(shadowParams.xy);");
+ fragBuilder->codeAppend("half distance = shadowParams.z * (1.0 - d);");
- fragBuilder->codeAppend("float factor = 1.0 - clamp(distance, 0.0, shadowParams.w);");
+ fragBuilder->codeAppend("half factor = 1.0 - clamp(distance, 0.0, shadowParams.w);");
fragBuilder->codeAppend("factor = exp(-factor * factor * 4.0) - 0.018;");
- fragBuilder->codeAppendf("%s = float4(factor);",
+ fragBuilder->codeAppendf("%s = half4(factor);",
args.fOutputCoverage);
}
diff --git a/src/gpu/effects/GrSimpleTextureEffect.cpp b/src/gpu/effects/GrSimpleTextureEffect.cpp
index ed2734b..8f1b12f 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.cpp
+++ b/src/gpu/effects/GrSimpleTextureEffect.cpp
@@ -26,15 +26,15 @@
fColorSpaceHelper.emitCode(args.fUniformHandler, _outer.colorXform().get());
SkString sk_TransformedCoords2D_0 = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
fragBuilder->codeAppendf(
- "float4 _tmpVar1;%s = %s * %stexture(%s, %s).%s%s;\n", args.fOutputColor,
- args.fInputColor ? args.fInputColor : "float4(1)",
+ "half4 _tmpVar1;%s = %s * %stexture(%s, %s).%s%s;\n", args.fOutputColor,
+ args.fInputColor ? args.fInputColor : "half4(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(", float4(clamp((%s * float4(_tmpVar1.rgb, 1.0)).rgb, "
- "0.0, _tmpVar1.a), _tmpVar1.a))",
+ ? SkStringPrintf(", half4(clamp((%s * half4(_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 80824fe..91d91b8 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 float4x4 matrix;
+in half4x4 matrix;
@constructorParams {
GrSamplerParams samplerParams
diff --git a/src/gpu/effects/GrTextureDomain.cpp b/src/gpu/effects/GrTextureDomain.cpp
index 5101762..d2a3ba3 100644
--- a/src/gpu/effects/GrTextureDomain.cpp
+++ b/src/gpu/effects/GrTextureDomain.cpp
@@ -78,8 +78,7 @@
if (textureDomain.fIndex >= 0) {
uniName.appendS32(textureDomain.fIndex);
}
- fDomainUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ fDomainUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
uniName.c_str(), &name);
fDomainName = name;
}
@@ -88,7 +87,7 @@
case kIgnore_Mode: {
builder->codeAppendf("%s = ", outColor);
builder->appendTextureLookupAndModulate(inModulateColor, sampler, inCoords.c_str(),
- kVec2f_GrSLType, colorXformHelper);
+ kHighFloat2_GrSLType, colorXformHelper);
builder->codeAppend(";");
break;
}
@@ -99,7 +98,7 @@
builder->codeAppendf("%s = ", outColor);
builder->appendTextureLookupAndModulate(inModulateColor, sampler, clampedCoords.c_str(),
- kVec2f_GrSLType, colorXformHelper);
+ kHighFloat2_GrSLType, colorXformHelper);
builder->codeAppend(";");
break;
}
@@ -115,20 +114,20 @@
// 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("float4 outside = float4(0.0, 0.0, 0.0, 0.0);");
- builder->codeAppend("float4 inside = ");
+ builder->codeAppend("half4 outside = half4(0.0, 0.0, 0.0, 0.0);");
+ builder->codeAppend("half4 inside = ");
builder->appendTextureLookupAndModulate(inModulateColor, sampler, inCoords.c_str(),
- kVec2f_GrSLType, colorXformHelper);
+ kHighFloat2_GrSLType, colorXformHelper);
builder->codeAppend(";");
- builder->codeAppendf("highp float x = (%s).x;", inCoords.c_str());
- builder->codeAppendf("highp float y = (%s).y;", inCoords.c_str());
+ builder->codeAppendf("highfloat x = (%s).x;", inCoords.c_str());
+ builder->codeAppendf("highfloat y = (%s).y;", inCoords.c_str());
builder->codeAppendf("x = abs(2.0*(x - %s.x)/(%s.z - %s.x) - 1.0);",
domain, domain, domain);
builder->codeAppendf("y = abs(2.0*(y - %s.y)/(%s.w - %s.y) - 1.0);",
domain, domain, domain);
- builder->codeAppend("float blend = step(1.0, max(x, y));");
+ builder->codeAppend("half blend = step(1.0, max(x, y));");
builder->codeAppendf("%s = mix(inside, outside, blend);", outColor);
} else {
builder->codeAppend("bool4 outside;\n");
@@ -136,10 +135,10 @@
domain);
builder->codeAppendf("outside.zw = greaterThan(%s, %s.zw);", inCoords.c_str(),
domain);
- builder->codeAppendf("%s = any(outside) ? float4(0.0, 0.0, 0.0, 0.0) : ",
+ builder->codeAppendf("%s = any(outside) ? half4(0.0, 0.0, 0.0, 0.0) : ",
outColor);
builder->appendTextureLookupAndModulate(inModulateColor, sampler, inCoords.c_str(),
- kVec2f_GrSLType, colorXformHelper);
+ kHighFloat2_GrSLType, colorXformHelper);
builder->codeAppend(";");
}
break;
@@ -152,7 +151,7 @@
builder->codeAppendf("%s = ", outColor);
builder->appendTextureLookupAndModulate(inModulateColor, sampler, clampedCoords.c_str(),
- kVec2f_GrSLType, colorXformHelper);
+ kHighFloat2_GrSLType, colorXformHelper);
builder->codeAppend(";");
break;
}
@@ -379,11 +378,10 @@
args.fFp.cast<GrDeviceSpaceTextureDecalFragmentProcessor>();
const char* scaleAndTranslateName;
fScaleAndTranslateUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"scaleAndTranslate",
&scaleAndTranslateName);
- args.fFragBuilder->codeAppendf("float2 coords = sk_FragCoord.xy * %s.xy + %s.zw;",
+ args.fFragBuilder->codeAppendf("half2 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 0db7d2c..ce9f607 100644
--- a/src/gpu/effects/GrTextureDomain.h
+++ b/src/gpu/effects/GrTextureDomain.h
@@ -23,7 +23,7 @@
/**
* 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 float4 of zeros (decal mode). The domain is clipped to
+ * the edge of the domain or result in a half4 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,7 +98,7 @@
* Call this from GrGLSLFragmentProcessor::emitCode() to sample the texture W.R.T. the
* domain and mode.
*
- * @param outcolor name of float4 variable to hold the sampled color.
+ * @param outcolor name of half4 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
diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
index 3b9b44c..11dee67 100644
--- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
@@ -217,7 +217,7 @@
const char* inputColor = nullptr;
if (args.fInputColor) {
inputColor = "inputColor";
- fragBuilder->codeAppendf("float4 inputColor = float4(%s.rgb, 1.0);", args.fInputColor);
+ fragBuilder->codeAppendf("half4 inputColor = half4(%s.rgb, 1.0);", args.fInputColor);
}
// declare outputColor and emit the code for each of the two children
@@ -452,7 +452,7 @@
const char* inputColor = args.fInputColor;
// We don't try to optimize for this case at all
if (!inputColor) {
- fragBuilder->codeAppendf("const float4 ones = float4(1);");
+ fragBuilder->codeAppendf("const half4 ones = half4(1);");
inputColor = "ones";
}
diff --git a/src/gpu/effects/GrYUVEffect.cpp b/src/gpu/effects/GrYUVEffect.cpp
index 80e87c2..00e2652 100644
--- a/src/gpu/effects/GrYUVEffect.cpp
+++ b/src/gpu/effects/GrYUVEffect.cpp
@@ -110,10 +110,9 @@
const YUVtoRGBEffect& effect = args.fFp.cast<YUVtoRGBEffect>();
const char* colorSpaceMatrix = nullptr;
- fMatrixUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
- kMat44f_GrSLType, kDefault_GrSLPrecision,
+ fMatrixUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4x4_GrSLType,
"ColorSpaceMatrix", &colorSpaceMatrix);
- fragBuilder->codeAppendf("%s = float4(", args.fOutputColor);
+ fragBuilder->codeAppendf("%s = half4(", args.fOutputColor);
fragBuilder->appendTextureLookup(args.fTexSamplers[0],
args.fTransformedCoords[0].c_str(),
args.fTransformedCoords[0].getType());
@@ -275,24 +274,24 @@
case kYUV_OutputChannels:
fRGBToYUVUni = args.fUniformHandler->addUniformArray(
kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"RGBToYUV", 3, &uniName);
- 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);",
+ fragBuilder->codeAppendf("%s = half4(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);",
args.fOutputColor, uniName, uniName, uniName, uniName,
uniName, uniName);
break;
case kUV_OutputChannels:
fRGBToYUVUni = args.fUniformHandler->addUniformArray(
kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"RGBToUV", 2, &uniName);
- 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);",
+ fragBuilder->codeAppendf("%s = half4(dot(rgbColor.rgb, %s[0].rgb) + %s[0].a,"
+ "dot(rgbColor.rgb, %s[1].rgb) + %s[1].a,"
+ "0.0,"
+ "rgbColor.a);",
args.fOutputColor, uniName, uniName, uniName, uniName);
break;
case kY_OutputChannels:
@@ -300,9 +299,9 @@
case kV_OutputChannels:
fRGBToYUVUni = args.fUniformHandler->addUniform(
kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"RGBToYUorV", &uniName);
- fragBuilder->codeAppendf("%s = float4(dot(rgbColor.rgb, %s.rgb) + %s.a);\n",
+ fragBuilder->codeAppendf("%s = half4(dot(rgbColor.rgb, %s.rgb) + %s.a);\n",
args.fOutputColor, uniName, uniName);
break;
}
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index be5df4e..91faed5 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -3463,13 +3463,13 @@
}
const char* version = shaderCaps->versionDeclString();
- GrShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kIn_TypeModifier);
- GrShaderVar uTexCoordXform("u_texCoordXform", kVec4f_GrSLType,
+ GrShaderVar aVertex("a_vertex", kHalf2_GrSLType, GrShaderVar::kIn_TypeModifier);
+ GrShaderVar uTexCoordXform("u_texCoordXform", kHalf4_GrSLType,
GrShaderVar::kUniform_TypeModifier);
- GrShaderVar uPosXform("u_posXform", kVec4f_GrSLType, GrShaderVar::kUniform_TypeModifier);
+ GrShaderVar uPosXform("u_posXform", kHalf4_GrSLType, GrShaderVar::kUniform_TypeModifier);
GrShaderVar uTexture("u_texture", samplerType, GrShaderVar::kUniform_TypeModifier);
- GrShaderVar vTexCoord("v_texCoord", kVec2f_GrSLType, GrShaderVar::kOut_TypeModifier);
- GrShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
+ GrShaderVar vTexCoord("v_texCoord", kHalf2_GrSLType, GrShaderVar::kOut_TypeModifier);
+ GrShaderVar oFragColor("o_FragColor", kHalf4_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString vshaderTxt(version);
if (shaderCaps->noperspectiveInterpolationSupport()) {
@@ -3493,7 +3493,7 @@
"void main() {"
" v_texCoord = a_vertex.xy * u_texCoordXform.xy + u_texCoordXform.zw;"
" gl_Position.xy = a_vertex * u_posXform.xy + u_posXform.zw;"
- " gl_Position.zw = float2(0, 1);"
+ " gl_Position.zw = half2(0, 1);"
"}"
);
@@ -3507,8 +3507,6 @@
fshaderTxt.appendf("#extension %s : require\n",
shaderCaps->externalTextureExtensionString());
}
- GrGLSLAppendDefaultFloatPrecisionDeclaration(kMedium_GrSLPrecision, *shaderCaps,
- &fshaderTxt);
vTexCoord.setTypeModifier(GrShaderVar::kIn_TypeModifier);
vTexCoord.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";");
@@ -3572,19 +3570,19 @@
}
const char* version = shaderCaps->versionDeclString();
- GrShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kIn_TypeModifier);
- GrShaderVar uTexCoordXform("u_texCoordXform", kVec4f_GrSLType,
+ GrShaderVar aVertex("a_vertex", kHalf2_GrSLType, GrShaderVar::kIn_TypeModifier);
+ GrShaderVar uTexCoordXform("u_texCoordXform", kHalf4_GrSLType,
GrShaderVar::kUniform_TypeModifier);
GrShaderVar uTexture("u_texture", kTexture2DSampler_GrSLType,
GrShaderVar::kUniform_TypeModifier);
// We need 1, 2, or 4 texture coordinates (depending on parity of each dimension):
GrShaderVar vTexCoords[] = {
- GrShaderVar("v_texCoord0", kVec2f_GrSLType, GrShaderVar::kOut_TypeModifier),
- GrShaderVar("v_texCoord1", kVec2f_GrSLType, GrShaderVar::kOut_TypeModifier),
- GrShaderVar("v_texCoord2", kVec2f_GrSLType, GrShaderVar::kOut_TypeModifier),
- GrShaderVar("v_texCoord3", kVec2f_GrSLType, GrShaderVar::kOut_TypeModifier),
+ GrShaderVar("v_texCoord0", kHalf2_GrSLType, GrShaderVar::kOut_TypeModifier),
+ GrShaderVar("v_texCoord1", kHalf2_GrSLType, GrShaderVar::kOut_TypeModifier),
+ GrShaderVar("v_texCoord2", kHalf2_GrSLType, GrShaderVar::kOut_TypeModifier),
+ GrShaderVar("v_texCoord3", kHalf2_GrSLType, GrShaderVar::kOut_TypeModifier),
};
- GrShaderVar oFragColor("o_FragColor", kVec4f_GrSLType,GrShaderVar::kOut_TypeModifier);
+ GrShaderVar oFragColor("o_FragColor", kHalf4_GrSLType,GrShaderVar::kOut_TypeModifier);
SkString vshaderTxt(version);
if (shaderCaps->noperspectiveInterpolationSupport()) {
@@ -3609,27 +3607,27 @@
vshaderTxt.append(
"// Mipmap Program VS\n"
"void main() {"
- " gl_Position.xy = a_vertex * float2(2, 2) - float2(1, 1);"
- " gl_Position.zw = float2(0, 1);"
+ " gl_Position.xy = a_vertex * half2(2, 2) - half2(1, 1);"
+ " gl_Position.zw = half2(0, 1);"
);
// Insert texture coordinate computation:
if (oddWidth && oddHeight) {
vshaderTxt.append(
" v_texCoord0 = a_vertex.xy * u_texCoordXform.yw;"
- " v_texCoord1 = a_vertex.xy * u_texCoordXform.yw + float2(u_texCoordXform.x, 0);"
- " v_texCoord2 = a_vertex.xy * u_texCoordXform.yw + float2(0, u_texCoordXform.z);"
+ " v_texCoord1 = a_vertex.xy * u_texCoordXform.yw + half2(u_texCoordXform.x, 0);"
+ " v_texCoord2 = a_vertex.xy * u_texCoordXform.yw + half2(0, u_texCoordXform.z);"
" v_texCoord3 = a_vertex.xy * u_texCoordXform.yw + u_texCoordXform.xz;"
);
} else if (oddWidth) {
vshaderTxt.append(
- " v_texCoord0 = a_vertex.xy * float2(u_texCoordXform.y, 1);"
- " v_texCoord1 = a_vertex.xy * float2(u_texCoordXform.y, 1) + float2(u_texCoordXform.x, 0);"
+ " v_texCoord0 = a_vertex.xy * half2(u_texCoordXform.y, 1);"
+ " v_texCoord1 = a_vertex.xy * half2(u_texCoordXform.y, 1) + half2(u_texCoordXform.x, 0);"
);
} else if (oddHeight) {
vshaderTxt.append(
- " v_texCoord0 = a_vertex.xy * float2(1, u_texCoordXform.w);"
- " v_texCoord1 = a_vertex.xy * float2(1, u_texCoordXform.w) + float2(0, u_texCoordXform.z);"
+ " v_texCoord0 = a_vertex.xy * half2(1, u_texCoordXform.w);"
+ " v_texCoord1 = a_vertex.xy * half2(1, u_texCoordXform.w) + half2(0, u_texCoordXform.z);"
);
} else {
vshaderTxt.append(
@@ -3645,8 +3643,6 @@
fshaderTxt.appendf("#extension %s : require\n", extension);
}
}
- GrGLSLAppendDefaultFloatPrecisionDeclaration(kMedium_GrSLPrecision, *shaderCaps,
- &fshaderTxt);
for (int i = 0; i < numTaps; ++i) {
vTexCoords[i].setTypeModifier(GrShaderVar::kIn_TypeModifier);
vTexCoords[i].appendDecl(shaderCaps, &fshaderTxt);
@@ -3732,7 +3728,7 @@
return false;
}
- GrShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kIn_TypeModifier);
+ GrShaderVar aVertex("a_vertex", kHalf2_GrSLType, GrShaderVar::kIn_TypeModifier);
const char* version = this->caps()->shaderCaps()->versionDeclString();
SkString vshaderTxt(version);
@@ -3741,17 +3737,14 @@
vshaderTxt.append(
"// Stencil Clip Clear Program VS\n"
"void main() {"
- " gl_Position = float4(a_vertex.x, a_vertex.y, 0, 1);"
+ " gl_Position = highfloat4(a_vertex.x, a_vertex.y, 0, 1);"
"}");
SkString fshaderTxt(version);
- GrGLSLAppendDefaultFloatPrecisionDeclaration(kMedium_GrSLPrecision,
- *this->caps()->shaderCaps(),
- &fshaderTxt);
fshaderTxt.appendf(
"// Stencil Clip Clear Program FS\n"
"void main() {"
- " sk_FragColor = float4(0);"
+ " sk_FragColor = half4(0);"
"}");
const char* str;
diff --git a/src/gpu/gl/GrGLProgramDataManager.cpp b/src/gpu/gl/GrGLProgramDataManager.cpp
index 3414aba..a8e3a63 100644
--- a/src/gpu/gl/GrGLProgramDataManager.cpp
+++ b/src/gpu/gl/GrGLProgramDataManager.cpp
@@ -73,7 +73,7 @@
void GrGLProgramDataManager::set1i(UniformHandle u, int32_t i) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kInt_GrSLType);
+ SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
if (kUnusedUniform != uni.fLocation) {
GR_GL_CALL(fGpu->glInterface(), Uniform1i(uni.fLocation, i));
@@ -84,7 +84,7 @@
int arrayCount,
const int v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kInt_GrSLType);
+ SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
if (kUnusedUniform != uni.fLocation) {
@@ -94,7 +94,7 @@
void GrGLProgramDataManager::set1f(UniformHandle u, float v0) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kFloat_GrSLType);
+ SkASSERT(uni.fType == kHighFloat_GrSLType || uni.fType == kHalf_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
if (kUnusedUniform != uni.fLocation) {
GR_GL_CALL(fGpu->glInterface(), Uniform1f(uni.fLocation, v0));
@@ -105,7 +105,7 @@
int arrayCount,
const float v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kFloat_GrSLType);
+ SkASSERT(uni.fType == kHighFloat_GrSLType || uni.fType == kHalf_GrSLType);
SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
// This assert fires in some instances of the two-pt gradient for its VSParams.
@@ -119,7 +119,7 @@
void GrGLProgramDataManager::set2f(UniformHandle u, float v0, float v1) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec2f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
if (kUnusedUniform != uni.fLocation) {
GR_GL_CALL(fGpu->glInterface(), Uniform2f(uni.fLocation, v0, v1));
@@ -130,7 +130,7 @@
int arrayCount,
const float v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec2f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
if (kUnusedUniform != uni.fLocation) {
@@ -140,7 +140,7 @@
void GrGLProgramDataManager::set3f(UniformHandle u, float v0, float v1, float v2) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec3f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
if (kUnusedUniform != uni.fLocation) {
GR_GL_CALL(fGpu->glInterface(), Uniform3f(uni.fLocation, v0, v1, v2));
@@ -151,7 +151,7 @@
int arrayCount,
const float v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec3f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
if (kUnusedUniform != uni.fLocation) {
@@ -165,7 +165,7 @@
float v2,
float v3) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec4f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
if (kUnusedUniform != uni.fLocation) {
GR_GL_CALL(fGpu->glInterface(), Uniform4f(uni.fLocation, v0, v1, v2, v3));
@@ -176,7 +176,7 @@
int arrayCount,
const float v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec4f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
if (kUnusedUniform != uni.fLocation) {
@@ -214,7 +214,8 @@
int arrayCount,
const float matrices[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kMat22f_GrSLType + (N - 2));
+ SkASSERT(uni.fType == kHighFloat2x2_GrSLType + (N - 2) ||
+ uni.fType == kHalf2x2_GrSLType + (N - 2));
SkASSERT(arrayCount > 0);
ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
if (kUnusedUniform != uni.fLocation) {
@@ -246,8 +247,10 @@
SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
const PathProcVarying& fragmentInput = fPathProcVaryings[u.toIndex()];
- SkASSERT((components == 2 && fragmentInput.fType == kVec2f_GrSLType) ||
- (components == 3 && fragmentInput.fType == kVec3f_GrSLType));
+ SkASSERT((components == 2 && (fragmentInput.fType == kHighFloat2_GrSLType ||
+ fragmentInput.fType == kHalf2_GrSLType)) ||
+ (components == 3 && (fragmentInput.fType == kHighFloat3_GrSLType ||
+ fragmentInput.fType == kHalf3_GrSLType)));
fGpu->glPathRendering()->setProgramPathFragmentInputTransform(fProgramID,
fragmentInput.fLocation,
diff --git a/src/gpu/glsl/GrGLSL.cpp b/src/gpu/glsl/GrGLSL.cpp
index b580f0b..8f3ef31 100644
--- a/src/gpu/glsl/GrGLSL.cpp
+++ b/src/gpu/glsl/GrGLSL.cpp
@@ -25,23 +25,3 @@
}
return false;
}
-
-void GrGLSLAppendDefaultFloatPrecisionDeclaration(GrSLPrecision p,
- const GrShaderCaps& shaderCaps,
- SkString* out) {
- if (shaderCaps.usesPrecisionModifiers()) {
- switch (p) {
- case kHigh_GrSLPrecision:
- out->append("precision highp float;\n");
- break;
- case kMedium_GrSLPrecision:
- out->append("precision mediump float;\n");
- break;
- case kLow_GrSLPrecision:
- out->append("precision lowp float;\n");
- break;
- default:
- SK_ABORT("Unknown precision value.");
- }
- }
-}
diff --git a/src/gpu/glsl/GrGLSLBlend.cpp b/src/gpu/glsl/GrGLSLBlend.cpp
index 34df0df..254f481 100644
--- a/src/gpu/glsl/GrGLSLBlend.cpp
+++ b/src/gpu/glsl/GrGLSLBlend.cpp
@@ -50,7 +50,7 @@
fsBuilder->codeAppendf("%s.%c = %s.%c * (1.0 - %s.a);",
final, component, src, component, dst);
fsBuilder->codeAppend("} else {");
- fsBuilder->codeAppendf("float d = %s.a - %s.%c;", src, src, component);
+ fsBuilder->codeAppendf("half d = %s.a - %s.%c;", src, src, component);
fsBuilder->codeAppend("if (0.0 == d) {");
fsBuilder->codeAppendf("%s.%c = %s.a * %s.a + %s.%c * (1.0 - %s.a) + %s.%c * (1.0 - %s.a);",
final, component, src, dst, src, component, dst, dst, component,
@@ -84,7 +84,7 @@
fsBuilder->codeAppendf("%s.%c = %s.%c * (1.0 - %s.a);",
final, component, dst, component, src);
fsBuilder->codeAppend("} else {");
- fsBuilder->codeAppendf("float d = max(0.0, %s.a - (%s.a - %s.%c) * %s.a / (%s.%c %s));",
+ fsBuilder->codeAppendf("half d = max(0.0, %s.a - (%s.a - %s.%c) * %s.a / (%s.%c %s));",
dst, dst, dst, component, src, src, component, divisorGuard);
fsBuilder->codeAppendf("%s.%c = %s.a * d + %s.%c * (1.0 - %s.a) + %s.%c * (1.0 - %s.a);",
final, component, src, src, component, dst, dst, component, src);
@@ -114,11 +114,11 @@
// else if (4D < Da)
fsBuilder->codeAppendf("} else if (4.0 * %s.%c <= %s.a) {",
dst, component, dst);
- fsBuilder->codeAppendf("float DSqd = %s.%c * %s.%c;",
+ fsBuilder->codeAppendf("half DSqd = %s.%c * %s.%c;",
dst, component, dst, component);
- fsBuilder->codeAppendf("float DCub = DSqd * %s.%c;", dst, component);
- fsBuilder->codeAppendf("float DaSqd = %s.a * %s.a;", dst, dst);
- fsBuilder->codeAppendf("float DaCub = DaSqd * %s.a;", dst);
+ fsBuilder->codeAppendf("half DCub = DSqd * %s.%c;", dst, component);
+ fsBuilder->codeAppendf("half DaSqd = %s.a * %s.a;", dst, dst);
+ fsBuilder->codeAppendf("half DaCub = DaSqd * %s.a;", dst);
// (Da^3 (-S)+Da^2 (S-D (3 Sa-6 S-1))+12 Da D^2 (Sa-2 S)-16 D^3 (Sa-2 S))/Da^2
fsBuilder->codeAppendf("%s.%c ="
"(DaSqd*(%s.%c - %s.%c * (3.0*%s.a - 6.0*%s.%c - 1.0)) +"
@@ -144,10 +144,10 @@
// Emit a helper that gets the luminance of a color.
SkString getFunction;
GrShaderVar getLumArgs[] = {
- GrShaderVar("color", kVec3f_GrSLType),
+ GrShaderVar("color", kHalf3_GrSLType),
};
- SkString getLumBody("return dot(float3(0.3, 0.59, 0.11), color);");
- fsBuilder->emitFunction(kFloat_GrSLType,
+ SkString getLumBody("return dot(highfloat3(0.3, 0.59, 0.11), color);");
+ fsBuilder->emitFunction(kHalf_GrSLType,
"luminance",
SK_ARRAY_COUNT(getLumArgs), getLumArgs,
getLumBody.c_str(),
@@ -155,27 +155,27 @@
// Emit the set luminance function.
GrShaderVar setLumArgs[] = {
- GrShaderVar("hueSat", kVec3f_GrSLType),
- GrShaderVar("alpha", kFloat_GrSLType),
- GrShaderVar("lumColor", kVec3f_GrSLType),
+ GrShaderVar("hueSat", kHalf3_GrSLType),
+ GrShaderVar("alpha", kHalf_GrSLType),
+ GrShaderVar("lumColor", kHalf3_GrSLType),
};
SkString setLumBody;
- setLumBody.printf("float diff = %s(lumColor - hueSat);", getFunction.c_str());
- setLumBody.append("float3 outColor = hueSat + diff;");
- setLumBody.appendf("float outLum = %s(outColor);", getFunction.c_str());
- setLumBody.append("float minComp = min(min(outColor.r, outColor.g), outColor.b);"
- "float maxComp = max(max(outColor.r, outColor.g), outColor.b);"
+ setLumBody.printf("half diff = %s(lumColor - hueSat);", getFunction.c_str());
+ setLumBody.append("half3 outColor = hueSat + diff;");
+ setLumBody.appendf("half outLum = %s(outColor);", getFunction.c_str());
+ setLumBody.append("half minComp = min(min(outColor.r, outColor.g), outColor.b);"
+ "half maxComp = max(max(outColor.r, outColor.g), outColor.b);"
"if (minComp < 0.0 && outLum != minComp) {"
- "outColor = outLum + ((outColor - float3(outLum, outLum, outLum)) * outLum) /"
+ "outColor = outLum + ((outColor - half3(outLum, outLum, outLum)) * outLum) /"
"(outLum - minComp);"
"}"
"if (maxComp > alpha && maxComp != outLum) {"
"outColor = outLum +"
- "((outColor - float3(outLum, outLum, outLum)) * (alpha - outLum)) /"
+ "((outColor - half3(outLum, outLum, outLum)) * (alpha - outLum)) /"
"(maxComp - outLum);"
"}"
"return outColor;");
- fsBuilder->emitFunction(kVec3f_GrSLType,
+ fsBuilder->emitFunction(kHalf3_GrSLType,
"set_luminance",
SK_ARRAY_COUNT(setLumArgs), setLumArgs,
setLumBody.c_str(),
@@ -188,11 +188,11 @@
static void add_sat_function(GrGLSLFragmentBuilder* fsBuilder, SkString* setSatFunction) {
// Emit a helper that gets the saturation of a color
SkString getFunction;
- GrShaderVar getSatArgs[] = { GrShaderVar("color", kVec3f_GrSLType) };
+ GrShaderVar getSatArgs[] = { GrShaderVar("color", kHalf3_GrSLType) };
SkString getSatBody;
getSatBody.printf("return max(max(color.r, color.g), color.b) - "
"min(min(color.r, color.g), color.b);");
- fsBuilder->emitFunction(kFloat_GrSLType,
+ fsBuilder->emitFunction(kHalf_GrSLType,
"saturation",
SK_ARRAY_COUNT(getSatArgs), getSatArgs,
getSatBody.c_str(),
@@ -204,33 +204,33 @@
// adjusted min, mid, and max inputs, respectively.
SkString helperFunction;
GrShaderVar helperArgs[] = {
- GrShaderVar("minComp", kFloat_GrSLType),
- GrShaderVar("midComp", kFloat_GrSLType),
- GrShaderVar("maxComp", kFloat_GrSLType),
- GrShaderVar("sat", kFloat_GrSLType),
+ GrShaderVar("minComp", kHalf_GrSLType),
+ GrShaderVar("midComp", kHalf_GrSLType),
+ GrShaderVar("maxComp", kHalf_GrSLType),
+ GrShaderVar("sat", kHalf_GrSLType),
};
static const char kHelperBody[] = "if (minComp < maxComp) {"
- "float3 result;"
+ "half3 result;"
"result.r = 0.0;"
"result.g = sat * (midComp - minComp) / (maxComp - minComp);"
"result.b = sat;"
"return result;"
"} else {"
- "return float3(0, 0, 0);"
+ "return half3(0, 0, 0);"
"}";
- fsBuilder->emitFunction(kVec3f_GrSLType,
+ fsBuilder->emitFunction(kHalf3_GrSLType,
"set_saturation_helper",
SK_ARRAY_COUNT(helperArgs), helperArgs,
kHelperBody,
&helperFunction);
GrShaderVar setSatArgs[] = {
- GrShaderVar("hueLumColor", kVec3f_GrSLType),
- GrShaderVar("satColor", kVec3f_GrSLType),
+ GrShaderVar("hueLumColor", kHalf3_GrSLType),
+ GrShaderVar("satColor", kHalf3_GrSLType),
};
const char* helpFunc = helperFunction.c_str();
SkString setSatBody;
- setSatBody.appendf("float sat = %s(satColor);"
+ setSatBody.appendf("half sat = %s(satColor);"
"if (hueLumColor.r <= hueLumColor.g) {"
"if (hueLumColor.g <= hueLumColor.b) {"
"hueLumColor.rgb = %s(hueLumColor.r, hueLumColor.g, hueLumColor.b, sat);"
@@ -249,7 +249,7 @@
"return hueLumColor;",
getFunction.c_str(), helpFunc, helpFunc, helpFunc, helpFunc,
helpFunc, helpFunc);
- fsBuilder->emitFunction(kVec3f_GrSLType,
+ fsBuilder->emitFunction(kHalf3_GrSLType,
"set_saturation",
SK_ARRAY_COUNT(setSatArgs), setSatArgs,
setSatBody.c_str(),
@@ -330,7 +330,7 @@
SkString setSat, setLum;
add_sat_function(fsBuilder, &setSat);
add_lum_function(fsBuilder, &setLum);
- fsBuilder->codeAppendf("float4 dstSrcAlpha = %s * %s.a;",
+ fsBuilder->codeAppendf("half4 dstSrcAlpha = %s * %s.a;",
dstColor, srcColor);
fsBuilder->codeAppendf("%s.rgb = %s(%s(%s.rgb * %s.a, dstSrcAlpha.rgb),"
"dstSrcAlpha.a, dstSrcAlpha.rgb);",
@@ -345,7 +345,7 @@
SkString setSat, setLum;
add_sat_function(fsBuilder, &setSat);
add_lum_function(fsBuilder, &setLum);
- fsBuilder->codeAppendf("float4 dstSrcAlpha = %s * %s.a;",
+ fsBuilder->codeAppendf("half4 dstSrcAlpha = %s * %s.a;",
dstColor, srcColor);
fsBuilder->codeAppendf("%s.rgb = %s(%s(dstSrcAlpha.rgb, %s.rgb * %s.a),"
"dstSrcAlpha.a, dstSrcAlpha.rgb);",
@@ -359,7 +359,7 @@
// SetLum(S * Da, Sa* Da, D * Sa) + (1 - Sa) * D + (1 - Da) * S
SkString setLum;
add_lum_function(fsBuilder, &setLum);
- fsBuilder->codeAppendf("float4 srcDstAlpha = %s * %s.a;",
+ fsBuilder->codeAppendf("half4 srcDstAlpha = %s * %s.a;",
srcColor, dstColor);
fsBuilder->codeAppendf("%s.rgb = %s(srcDstAlpha.rgb, srcDstAlpha.a, %s.rgb * %s.a);",
outputColor, setLum.c_str(), dstColor, srcColor);
@@ -371,7 +371,7 @@
// SetLum(D * Sa, Sa* Da, S * Da) + (1 - Sa) * D + (1 - Da) * S
SkString setLum;
add_lum_function(fsBuilder, &setLum);
- fsBuilder->codeAppendf("float4 srcDstAlpha = %s * %s.a;",
+ fsBuilder->codeAppendf("half4 srcDstAlpha = %s * %s.a;",
srcColor, dstColor);
fsBuilder->codeAppendf("%s.rgb = %s(%s.rgb * %s.a, srcDstAlpha.a, srcDstAlpha.rgb);",
outputColor, setLum.c_str(), dstColor, srcColor);
@@ -406,13 +406,13 @@
fsBuilder->codeAppendf(" * %s", srcColorName);
break;
case SkBlendModeCoeff::kISC:
- fsBuilder->codeAppendf(" * (float4(1.0) - %s)", srcColorName);
+ fsBuilder->codeAppendf(" * (half4(1.0) - %s)", srcColorName);
break;
case SkBlendModeCoeff::kDC:
fsBuilder->codeAppendf(" * %s", dstColorName);
break;
case SkBlendModeCoeff::kIDC:
- fsBuilder->codeAppendf(" * (float4(1.0) - %s)", dstColorName);
+ fsBuilder->codeAppendf(" * (half4(1.0) - %s)", dstColorName);
break;
case SkBlendModeCoeff::kSA:
fsBuilder->codeAppendf(" * %s.a", srcColorName);
@@ -453,7 +453,7 @@
false);
// append dst blend
if(!append_porterduff_term(fsBuilder, dstCoeff, dstColor, srcColor, dstColor, didAppend)) {
- fsBuilder->codeAppend("float4(0, 0, 0, 0)");
+ fsBuilder->codeAppend("half4(0, 0, 0, 0)");
}
if (clamp) {
fsBuilder->codeAppend(", 0, 1);");
@@ -505,7 +505,7 @@
false);
// append dst blend
if(!append_porterduff_term(fsBuilder, dstCoeff, dstColor, srcColor, dstColor, didAppend)) {
- fsBuilder->codeAppend("float4(0, 0, 0, 0)");
+ fsBuilder->codeAppend("half4(0, 0, 0, 0)");
}
fsBuilder->codeAppend(";");
}
diff --git a/src/gpu/glsl/GrGLSLColorSpaceXformHelper.h b/src/gpu/glsl/GrGLSLColorSpaceXformHelper.h
index b4605ba..f9ac30b 100644
--- a/src/gpu/glsl/GrGLSLColorSpaceXformHelper.h
+++ b/src/gpu/glsl/GrGLSLColorSpaceXformHelper.h
@@ -24,8 +24,8 @@
uint32_t visibility = kFragment_GrShaderFlag) {
SkASSERT(uniformHandler);
if (colorSpaceXform) {
- fGamutXformVar = uniformHandler->addUniform(visibility, kMat44f_GrSLType,
- kDefault_GrSLPrecision, "ColorXform");
+ fGamutXformVar = uniformHandler->addUniform(visibility, kHalf4x4_GrSLType,
+ "ColorXform");
fValid = true;
}
}
diff --git a/src/gpu/glsl/GrGLSLFragmentProcessor.cpp b/src/gpu/glsl/GrGLSLFragmentProcessor.cpp
index 6f75c16..ac2de13 100644
--- a/src/gpu/glsl/GrGLSLFragmentProcessor.cpp
+++ b/src/gpu/glsl/GrGLSLFragmentProcessor.cpp
@@ -29,7 +29,7 @@
SkASSERT(outputColor);
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
outputColor->append(fragBuilder->getMangleString());
- fragBuilder->codeAppendf("float4 %s;", outputColor->c_str());
+ fragBuilder->codeAppendf("half4 %s;", outputColor->c_str());
this->internalEmitChild(childIndex, inputColor, outputColor->c_str(), args);
}
diff --git a/src/gpu/glsl/GrGLSLFragmentProcessor.h b/src/gpu/glsl/GrGLSLFragmentProcessor.h
index ed4b71f..68bd1f2 100644
--- a/src/gpu/glsl/GrGLSLFragmentProcessor.h
+++ b/src/gpu/glsl/GrGLSLFragmentProcessor.h
@@ -86,9 +86,9 @@
@param fp The processor that generated this program stage.
@param key The key that was computed by GenKey() from the generating
GrProcessor.
- @param outputColor A predefined float4 in the FS in which the stage should place its
+ @param outputColor A predefined half4 in the FS in which the stage should place its
output color (or coverage).
- @param inputColor A float4 that holds the input color to the stage in the FS. This may
+ @param inputColor A half4 that holds the input color to the stage in the FS. This may
be nullptr in which case the implied input is solid white (all
ones). TODO: Better system for communicating optimization info
(e.g. input color is solid white, trans black, known to be opaque,
@@ -152,7 +152,7 @@
}
inline void emitChild(int childIndex, SkString* outputColor, EmitArgs& parentArgs) {
- this->emitChild(childIndex, "float4(1.0)", outputColor, parentArgs);
+ this->emitChild(childIndex, "half4(1.0)", outputColor, parentArgs);
}
/** Will emit the code of a child proc in its own scope. Pass in the parent's EmitArgs and
@@ -167,7 +167,7 @@
EmitArgs& parentArgs);
inline void emitChild(int childIndex, EmitArgs& args) {
- this->emitChild(childIndex, "float4(1.0)", args);
+ this->emitChild(childIndex, "half4(1.0)", args);
}
/** Variation that uses the parent's output color variable to hold the child's output.*/
diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
index afbfa09..5dac06f 100644
--- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
@@ -85,8 +85,7 @@
, fCustomColorOutputIndex(-1)
, fHasSecondaryOutput(false)
, fUsedSampleOffsetArrays(0)
- , fHasInitializedSampleMask(false)
- , fDefaultPrecision(kMedium_GrSLPrecision) {
+ , fHasInitializedSampleMask(false) {
fSubstageIndices.push_back(0);
#ifdef SK_DEBUG
fUsedProcessorFeatures = GrProcessor::kNone_RequiredFeatures;
@@ -112,14 +111,14 @@
}
SkString GrGLSLFragmentShaderBuilder::ensureCoords2D(const GrShaderVar& coords) {
- if (kVec3f_GrSLType != coords.getType()) {
- SkASSERT(kVec2f_GrSLType == coords.getType());
+ if (kHighFloat3_GrSLType != coords.getType() && kHalf3_GrSLType != coords.getType()) {
+ SkASSERT(kHighFloat2_GrSLType == coords.getType() || kHalf2_GrSLType == coords.getType());
return coords.getName();
}
SkString coords2D;
coords2D.printf("%s_ensure2D", coords.c_str());
- this->codeAppendf("\tfloat2 %s = %s.xy / %s.z;", coords2D.c_str(), coords.c_str(),
+ this->codeAppendf("\thighfloat2 %s = %s.xy / %s.z;", coords2D.c_str(), coords.c_str(),
coords.c_str());
return coords2D;
}
@@ -175,10 +174,6 @@
fHasInitializedSampleMask = true;
}
-void GrGLSLFragmentShaderBuilder::elevateDefaultPrecision(GrSLPrecision precision) {
- fDefaultPrecision = SkTMax(fDefaultPrecision, precision);
-}
-
const char* GrGLSLFragmentShaderBuilder::dstColor() {
SkDEBUGCODE(fHasReadDstColor = true;)
@@ -199,7 +194,7 @@
fOutputs[fCustomColorOutputIndex].setTypeModifier(GrShaderVar::kInOut_TypeModifier);
fbFetchColorName = DeclaredColorOutputName();
// Set the dstColor to an intermediate variable so we don't override it with the output
- this->codeAppendf("float4 %s = %s;", kDstColorName, fbFetchColorName);
+ this->codeAppendf("half4 %s = %s;", kDstColorName, fbFetchColorName);
} else {
return fbFetchColorName;
}
@@ -228,7 +223,7 @@
if (!fHasCustomColorOutput) {
fHasCustomColorOutput = true;
fCustomColorOutputIndex = fOutputs.count();
- fOutputs.push_back().set(kVec4f_GrSLType, DeclaredColorOutputName(),
+ fOutputs.push_back().set(kHalf4_GrSLType, DeclaredColorOutputName(),
GrShaderVar::kOut_TypeModifier);
fProgramBuilder->finalizeFragmentOutputColor(fOutputs.back());
}
@@ -247,7 +242,7 @@
// output. The condition also co-incides with the condition in whici GLES SL 2.0
// requires the built-in gl_SecondaryFragColorEXT, where as 3.0 requires a custom output.
if (caps.mustDeclareFragmentShaderOutput()) {
- fOutputs.push_back().set(kVec4f_GrSLType, DeclaredSecondaryColorOutputName(),
+ fOutputs.push_back().set(kHalf4_GrSLType, DeclaredSecondaryColorOutputName(),
GrShaderVar::kOut_TypeModifier);
fProgramBuilder->finalizeFragmentSecondaryColor(fOutputs.back());
}
@@ -280,9 +275,6 @@
void GrGLSLFragmentShaderBuilder::onFinalize() {
fProgramBuilder->varyingHandler()->getFragDecls(&this->inputs(), &this->outputs());
- GrGLSLAppendDefaultFloatPrecisionDeclaration(fDefaultPrecision,
- *fProgramBuilder->shaderCaps(),
- &this->precisionQualifier());
if (fUsedSampleOffsetArrays & (1 << kSkiaDevice_Coordinates)) {
this->defineSampleOffsetArray(sample_offset_array_name(kSkiaDevice_Coordinates),
SkMatrix::MakeTrans(-0.5f, -0.5f));
@@ -305,9 +297,9 @@
SkSTArray<16, SkPoint, true> offsets;
offsets.push_back_n(specs.fEffectiveSampleCnt);
m.mapPoints(offsets.begin(), specs.fSampleLocations, specs.fEffectiveSampleCnt);
- this->definitions().appendf("const highp float2 %s[] = float2[](", name);
+ this->definitions().appendf("const highfloat2 %s[] = highfloat2[](", name);
for (int i = 0; i < specs.fEffectiveSampleCnt; ++i) {
- this->definitions().appendf("float2(%f, %f)", offsets[i].x(), offsets[i].y());
+ this->definitions().appendf("highfloat2(%f, %f)", offsets[i].x(), offsets[i].y());
this->definitions().append(i + 1 != specs.fEffectiveSampleCnt ? ", " : ");\n");
}
}
diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h
index 73fe51f..fa36f7b 100644
--- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h
+++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.h
@@ -40,7 +40,7 @@
/**
* This returns a variable name to access the 2D, perspective correct version of the coords in
- * the fragment shader. The passed in coordinates must either be of type kVec2f or kVec3f. If
+ * the fragment shader. The passed in coordinates must either be of type kHalf2 or kHalf3. If
* the coordinates are 3-dimensional, it a perspective divide into is emitted into the
* fragment shader (xy / z) to convert them to 2D.
*/
@@ -90,13 +90,6 @@
virtual void maskSampleCoverage(const char* mask, bool invert = false) = 0;
/**
- * Overrides the default precision for the entire fragment program. Processors that require
- * high precision input (eg from incoming texture samples) may use this. For calculations that
- * are limited to a single processor's code, it is better to annotate individual declarations.
- */
- virtual void elevateDefaultPrecision(GrSLPrecision) = 0;
-
- /**
* Fragment procs with child procs should call these functions before/after calling emitCode
* on a child proc.
*/
@@ -169,7 +162,6 @@
void appendOffsetToSample(const char* sampleIdx, Coordinates) override;
void maskSampleCoverage(const char* mask, bool invert = false) override;
void overrideSampleCoverage(const char* mask) override;
- void elevateDefaultPrecision(GrSLPrecision) override;
const SkString& getMangleString() const override { return fMangleString; }
void onBeforeChildProcEmitCode() override;
void onAfterChildProcEmitCode() override;
@@ -234,7 +226,6 @@
bool fHasSecondaryOutput;
uint8_t fUsedSampleOffsetArrays;
bool fHasInitializedSampleMask;
- GrSLPrecision fDefaultPrecision;
#ifdef SK_DEBUG
// some state to verify shaders and effects are consistent, this is reset between effects by
diff --git a/src/gpu/glsl/GrGLSLGeometryProcessor.cpp b/src/gpu/glsl/GrGLSLGeometryProcessor.cpp
index a390036..072d62c 100644
--- a/src/gpu/glsl/GrGLSLGeometryProcessor.cpp
+++ b/src/gpu/glsl/GrGLSLGeometryProcessor.cpp
@@ -18,7 +18,8 @@
GrGPArgs gpArgs;
this->onEmitCode(args, &gpArgs);
vBuilder->transformToNormalizedDeviceSpace(gpArgs.fPositionVar, args.fRTAdjustName);
- if (kVec2f_GrSLType == gpArgs.fPositionVar.getType()) {
+ if (kHighFloat2_GrSLType == gpArgs.fPositionVar.getType() ||
+ kHalf2_GrSLType == gpArgs.fPositionVar.getType()) {
args.fVaryingHandler->setNoPerspective();
}
}
@@ -39,32 +40,28 @@
uint32_t type = coordTransform->getMatrix().getType();
type |= localMatrix.getType();
- varyingType = SkToBool(SkMatrix::kPerspective_Mask & type) ? kVec3f_GrSLType :
- kVec2f_GrSLType;
- // Coord transforms are always handled at high precision
- const GrSLPrecision precision = kHigh_GrSLPrecision;
-
+ varyingType = SkToBool(SkMatrix::kPerspective_Mask & type) ? kHighFloat3_GrSLType :
+ kHighFloat2_GrSLType;
const char* uniName;
fInstalledTransforms.push_back().fHandle = uniformHandler->addUniform(kVertex_GrShaderFlag,
- kMat33f_GrSLType,
- precision,
+ kHighFloat3x3_GrSLType,
strUniName.c_str(),
&uniName).toIndex();
SkString strVaryingName;
strVaryingName.printf("TransformedCoords_%d", i);
GrGLSLVertToFrag v(varyingType);
- varyingHandler->addVarying(strVaryingName.c_str(), &v, precision);
+ varyingHandler->addVarying(strVaryingName.c_str(), &v, kHigh_GrSLPrecision);
- SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
+ SkASSERT(kHighFloat2_GrSLType == varyingType || kHighFloat3_GrSLType == varyingType);
handler->specifyCoordsForCurrCoordTransform(SkString(v.fsIn()), varyingType);
- if (kVec2f_GrSLType == varyingType) {
- vb->codeAppendf("%s = (%s * float3(%s, 1)).xy;", v.vsOut(), uniName, localCoords);
+ if (kHighFloat2_GrSLType == varyingType) {
+ vb->codeAppendf("%s = (%s * highfloat3(%s, 1)).xy;", v.vsOut(), uniName, localCoords);
} else {
- vb->codeAppendf("%s = %s * float3(%s, 1);", v.vsOut(), uniName, localCoords);
+ vb->codeAppendf("%s = %s * highfloat3(%s, 1);", v.vsOut(), uniName, localCoords);
}
++i;
}
@@ -88,8 +85,8 @@
void GrGLSLGeometryProcessor::writeOutputPosition(GrGLSLVertexBuilder* vertBuilder,
GrGPArgs* gpArgs,
const char* posName) {
- gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2");
- vertBuilder->codeAppendf("float2 %s = %s;", gpArgs->fPositionVar.c_str(), posName);
+ gpArgs->fPositionVar.set(kHighFloat2_GrSLType, "pos2");
+ vertBuilder->codeAppendf("highfloat2 %s = %s;", gpArgs->fPositionVar.c_str(), posName);
}
void GrGLSLGeometryProcessor::writeOutputPosition(GrGLSLVertexBuilder* vertBuilder,
@@ -99,21 +96,21 @@
const SkMatrix& mat,
UniformHandle* viewMatrixUniform) {
if (mat.isIdentity()) {
- gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2");
- vertBuilder->codeAppendf("float2 %s = %s;", gpArgs->fPositionVar.c_str(), posName);
+ gpArgs->fPositionVar.set(kHighFloat2_GrSLType, "pos2");
+ vertBuilder->codeAppendf("highfloat2 %s = %s;", gpArgs->fPositionVar.c_str(), posName);
} else {
const char* viewMatrixName;
*viewMatrixUniform = uniformHandler->addUniform(kVertex_GrShaderFlag,
- kMat33f_GrSLType, kHigh_GrSLPrecision,
+ kHighFloat3x3_GrSLType,
"uViewM",
&viewMatrixName);
if (!mat.hasPerspective()) {
- gpArgs->fPositionVar.set(kVec2f_GrSLType, "pos2");
- vertBuilder->codeAppendf("float2 %s = (%s * float3(%s, 1)).xy;",
+ gpArgs->fPositionVar.set(kHighFloat2_GrSLType, "pos2");
+ vertBuilder->codeAppendf("highfloat2 %s = (%s * highfloat3(%s, 1)).xy;",
gpArgs->fPositionVar.c_str(), viewMatrixName, posName);
} else {
- gpArgs->fPositionVar.set(kVec3f_GrSLType, "pos3");
- vertBuilder->codeAppendf("float3 %s = %s * float3(%s, 1);",
+ gpArgs->fPositionVar.set(kHighFloat3_GrSLType, "pos3");
+ vertBuilder->codeAppendf("highfloat3 %s = %s * highfloat3(%s, 1);",
gpArgs->fPositionVar.c_str(), viewMatrixName, posName);
}
}
diff --git a/src/gpu/glsl/GrGLSLPrimitiveProcessor.cpp b/src/gpu/glsl/GrGLSLPrimitiveProcessor.cpp
index d9d17e5..0cb7e4d 100644
--- a/src/gpu/glsl/GrGLSLPrimitiveProcessor.cpp
+++ b/src/gpu/glsl/GrGLSLPrimitiveProcessor.cpp
@@ -43,13 +43,12 @@
SkASSERT(colorUniform);
const char* stagedLocalVarName;
*colorUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"Color",
&stagedLocalVarName);
fragBuilder->codeAppendf("%s = %s;", outputName, stagedLocalVarName);
if (fragBuilder->getProgramBuilder()->shaderCaps()->mustObfuscateUniformColor()) {
- fragBuilder->codeAppendf("%s = max(%s, float4(0, 0, 0, 0));", outputName, outputName);
+ fragBuilder->codeAppendf("%s = max(%s, half4(0, 0, 0, 0));", outputName, outputName);
}
}
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.cpp b/src/gpu/glsl/GrGLSLProgramBuilder.cpp
index bb3dc4f..c4446ec 100644
--- a/src/gpu/glsl/GrGLSLProgramBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLProgramBuilder.cpp
@@ -82,8 +82,7 @@
rtAdjustVisibility |= kGeometry_GrShaderFlag;
}
fUniformHandles.fRTAdjustmentUni = this->uniformHandler()->addUniform(rtAdjustVisibility,
- kVec4f_GrSLType,
- kHigh_GrSLPrecision,
+ kHalf4_GrSLType,
"rtAdjustment");
const char* rtAdjustName =
this->uniformHandler()->getUniformCStr(fUniformHandles.fRTAdjustmentUni);
@@ -455,7 +454,7 @@
} else {
this->nameVariable(&outName, '\0', baseName);
}
- fFS.codeAppendf("float4 %s;", outName.c_str());
+ fFS.codeAppendf("half4 %s;", outName.c_str());
*output = outName;
}
@@ -468,7 +467,7 @@
GrGLSLUniformHandler* uniformHandler = this->uniformHandler();
fUniformHandles.fRTHeightUni =
uniformHandler->internalAddUniformArray(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ kHalf_GrSLType, kDefault_GrSLPrecision,
name, false, 0, nullptr);
}
diff --git a/src/gpu/glsl/GrGLSLShaderBuilder.cpp b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
index 8f7d23d..ee99a06 100644
--- a/src/gpu/glsl/GrGLSLShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
@@ -122,16 +122,16 @@
// re-insert the original alpha. The supplied srcColor is likely to be of the form
// "texture(...)", and we don't want to evaluate that twice, so wrap everything in a function.
static const GrShaderVar gColorGamutXformArgs[] = {
- GrShaderVar("color", kVec4f_GrSLType),
- GrShaderVar("xform", kMat44f_GrSLType),
+ GrShaderVar("color", kHalf4_GrSLType),
+ GrShaderVar("xform", kHalf4x4_GrSLType),
};
SkString functionBody;
// Gamut xform, clamp to destination gamut. We only support/have premultiplied textures, so we
// always just clamp to alpha.
- functionBody.append("\tcolor.rgb = clamp((xform * float4(color.rgb, 1.0)).rgb, 0.0, color.a);\n");
+ functionBody.append("\tcolor.rgb = clamp((xform * half4(color.rgb, 1.0)).rgb, 0.0, color.a);\n");
functionBody.append("\treturn color;");
SkString colorGamutXformFuncName;
- this->emitFunction(kVec4f_GrSLType,
+ this->emitFunction(kHalf4_GrSLType,
"colorGamutXform",
SK_ARRAY_COUNT(gColorGamutXformArgs),
gColorGamutXformArgs,
diff --git a/src/gpu/glsl/GrGLSLShaderBuilder.h b/src/gpu/glsl/GrGLSLShaderBuilder.h
index 4906c03..9ac6ab7 100644
--- a/src/gpu/glsl/GrGLSLShaderBuilder.h
+++ b/src/gpu/glsl/GrGLSLShaderBuilder.h
@@ -37,23 +37,23 @@
void appendTextureLookup(SkString* out,
SamplerHandle,
const char* coordName,
- GrSLType coordType = kVec2f_GrSLType) const;
+ GrSLType coordType = kHalf2_GrSLType) const;
/** Version of above that appends the result to the shader code instead.*/
void appendTextureLookup(SamplerHandle,
const char* coordName,
- GrSLType coordType = kVec2f_GrSLType,
+ GrSLType coordType = kHalf2_GrSLType,
GrGLSLColorSpaceXformHelper* colorXformHelper = nullptr);
/** Does the work of appendTextureLookup and modulates the result by modulation. The result is
- always a float4. modulation and the swizzle specified by SamplerHandle must both be
- float4 or float. If modulation is "" or nullptr it this function acts as though
+ always a half4. modulation and the swizzle specified by SamplerHandle must both be
+ half4 or half. If modulation is "" or nullptr it this function acts as though
appendTextureLookup were called. */
void appendTextureLookupAndModulate(const char* modulation,
SamplerHandle,
const char* coordName,
- GrSLType coordType = kVec2f_GrSLType,
+ GrSLType coordType = kHalf2_GrSLType,
GrGLSLColorSpaceXformHelper* colorXformHelper = nullptr);
/** Adds a helper function to facilitate color gamut transformation, and produces code that
diff --git a/src/gpu/glsl/GrGLSLUniformHandler.h b/src/gpu/glsl/GrGLSLUniformHandler.h
index cf80c3f..84bbfa1 100644
--- a/src/gpu/glsl/GrGLSLUniformHandler.h
+++ b/src/gpu/glsl/GrGLSLUniformHandler.h
@@ -38,6 +38,13 @@
return this->addUniformArray(visibility, type, precision, name, 0, outName);
}
+ UniformHandle addUniform(uint32_t visibility,
+ GrSLType type,
+ const char* name,
+ const char** outName = nullptr) {
+ return this->addUniform(visibility, type, kDefault_GrSLPrecision, name, outName);
+ }
+
UniformHandle addUniformArray(uint32_t visibility,
GrSLType type,
GrSLPrecision precision,
@@ -49,6 +56,16 @@
outName);
}
+ UniformHandle addUniformArray(uint32_t visibility,
+ GrSLType type,
+ const char* name,
+ int arrayCount,
+ const char** outName = nullptr) {
+ SkASSERT(!GrSLTypeIsCombinedSamplerType(type));
+ return this->internalAddUniformArray(visibility, type, kDefault_GrSLPrecision, name, true,
+ arrayCount, outName);
+ }
+
virtual const GrShaderVar& getUniformVariable(UniformHandle u) const = 0;
/**
diff --git a/src/gpu/glsl/GrGLSLVertexShaderBuilder.cpp b/src/gpu/glsl/GrGLSLVertexShaderBuilder.cpp
index e06ee2d..4e3b644 100644
--- a/src/gpu/glsl/GrGLSLVertexShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLVertexShaderBuilder.cpp
@@ -18,25 +18,25 @@
const char* rtAdjustName) {
// setup RT Uniform
if (this->getProgramBuilder()->desc()->header().fSnapVerticesToPixelCenters) {
- if (kVec3f_GrSLType == posVar.getType()) {
+ if (kHighFloat3_GrSLType == posVar.getType()) {
const char* p = posVar.c_str();
- this->codeAppendf("{float2 _posTmp = float2(%s.x/%s.z, %s.y/%s.z);", p, p, p, p);
+ this->codeAppendf("{highfloat2 _posTmp = highfloat2(%s.x/%s.z, %s.y/%s.z);", p, p, p, p);
} else {
- SkASSERT(kVec2f_GrSLType == posVar.getType());
- this->codeAppendf("{float2 _posTmp = %s;", posVar.c_str());
+ SkASSERT(kHighFloat2_GrSLType == posVar.getType());
+ this->codeAppendf("{highfloat2 _posTmp = %s;", posVar.c_str());
}
- this->codeAppendf("_posTmp = floor(_posTmp) + float2(0.5, 0.5);"
- "gl_Position = float4(_posTmp.x * %s.x + %s.y,"
+ this->codeAppendf("_posTmp = floor(_posTmp) + half2(0.5, 0.5);"
+ "gl_Position = highfloat4(_posTmp.x * %s.x + %s.y,"
"_posTmp.y * %s.z + %s.w, 0, 1);}",
rtAdjustName, rtAdjustName, rtAdjustName, rtAdjustName);
- } else if (kVec3f_GrSLType == posVar.getType()) {
- this->codeAppendf("gl_Position = float4(dot(%s.xz, %s.xy), dot(%s.yz, %s.zw), 0, %s.z);",
+ } else if (kHighFloat3_GrSLType == posVar.getType()) {
+ this->codeAppendf("gl_Position = highfloat4(dot(%s.xz, %s.xy), dot(%s.yz, %s.zw), 0, %s.z);",
posVar.c_str(), rtAdjustName,
posVar.c_str(), rtAdjustName,
posVar.c_str());
} else {
- SkASSERT(kVec2f_GrSLType == posVar.getType());
- this->codeAppendf("gl_Position = float4(%s.x * %s.x + %s.y, %s.y * %s.z + %s.w, 0, 1);",
+ SkASSERT(kHighFloat2_GrSLType == posVar.getType());
+ this->codeAppendf("gl_Position = highfloat4(%s.x * %s.x + %s.y, %s.y * %s.z + %s.w, 0, 1);",
posVar.c_str(), rtAdjustName, rtAdjustName,
posVar.c_str(), rtAdjustName, rtAdjustName);
}
diff --git a/src/gpu/glsl/GrGLSLXferProcessor.cpp b/src/gpu/glsl/GrGLSLXferProcessor.cpp
index 6c2c460..99862e2 100644
--- a/src/gpu/glsl/GrGLSLXferProcessor.cpp
+++ b/src/gpu/glsl/GrGLSLXferProcessor.cpp
@@ -52,7 +52,7 @@
// The discard here also helps for batching text draws together which need to read from
// a dst copy for blends. Though this only helps the case where the outer bounding boxes
// of each letter overlap and not two actually parts of the text.
- fragBuilder->codeAppendf("if (all(lessThanEqual(%s.rgb, float3(0)))) {"
+ fragBuilder->codeAppendf("if (all(lessThanEqual(%s.rgb, half3(0)))) {"
" discard;"
"}", args.fInputCoverage);
}
@@ -61,27 +61,25 @@
const char* dstCoordScaleName;
fDstTopLeftUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf2_GrSLType,
"DstTextureUpperLeft",
&dstTopLeftName);
fDstScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf2_GrSLType,
"DstTextureCoordScale",
&dstCoordScaleName);
fragBuilder->codeAppend("// Read color from copy of the destination.\n");
- fragBuilder->codeAppendf("float2 _dstTexCoord = (sk_FragCoord.xy - %s) * %s;",
+ fragBuilder->codeAppendf("half2 _dstTexCoord = (sk_FragCoord.xy - %s) * %s;",
dstTopLeftName, dstCoordScaleName);
if (flipY) {
fragBuilder->codeAppend("_dstTexCoord.y = 1.0 - _dstTexCoord.y;");
}
- fragBuilder->codeAppendf("float4 %s = ", dstColor);
+ fragBuilder->codeAppendf("half4 %s = ", dstColor);
fragBuilder->appendTextureLookup(args.fDstTextureSamplerHandle, "_dstTexCoord",
- kVec2f_GrSLType);
+ kHalf2_GrSLType);
fragBuilder->codeAppend(";");
} else {
needsLocalOutColor = args.fShaderCaps->requiresLocalOutputColorForFBFetch();
@@ -91,7 +89,7 @@
if (!needsLocalOutColor) {
outColor = args.fOutputPrimary;
} else {
- fragBuilder->codeAppendf("float4 %s;", outColor);
+ fragBuilder->codeAppendf("half4 %s;", outColor);
}
this->emitBlendCodeForDstRead(fragBuilder,
@@ -139,18 +137,18 @@
fragBuilder->codeAppendf("%s *= %s;", outColor, srcCoverage);
fragBuilder->codeAppendf("%s = %s;", outColorSecondary, srcCoverage);
} else {
- fragBuilder->codeAppendf("%s = float4(1.0);", outColorSecondary);
+ fragBuilder->codeAppendf("%s = half4(1.0);", outColorSecondary);
}
} else if (srcCoverage) {
if (proc.isLCD()) {
- fragBuilder->codeAppendf("float lerpRed = mix(%s.a, %s.a, %s.r);",
+ fragBuilder->codeAppendf("half lerpRed = mix(%s.a, %s.a, %s.r);",
dstColor, outColor, srcCoverage);
- fragBuilder->codeAppendf("float lerpBlue = mix(%s.a, %s.a, %s.g);",
+ fragBuilder->codeAppendf("half lerpBlue = mix(%s.a, %s.a, %s.g);",
dstColor, outColor, srcCoverage);
- fragBuilder->codeAppendf("float lerpGreen = mix(%s.a, %s.a, %s.b);",
+ fragBuilder->codeAppendf("half lerpGreen = mix(%s.a, %s.a, %s.b);",
dstColor, outColor, srcCoverage);
}
- fragBuilder->codeAppendf("%s = %s * %s + (float4(1.0) - %s) * %s;",
+ fragBuilder->codeAppendf("%s = %s * %s + (half4(1.0) - %s) * %s;",
outColor, srcCoverage, outColor, srcCoverage, dstColor);
if (proc.isLCD()) {
fragBuilder->codeAppendf("%s.a = max(max(lerpRed, lerpBlue), lerpGreen);", outColor);
diff --git a/src/gpu/instanced/InstanceProcessor.cpp b/src/gpu/instanced/InstanceProcessor.cpp
index ab68326..d26e466 100644
--- a/src/gpu/instanced/InstanceProcessor.cpp
+++ b/src/gpu/instanced/InstanceProcessor.cpp
@@ -105,32 +105,38 @@
void initParams(const TexelBufferHandle paramsBuffer) {
fParamsBuffer = paramsBuffer;
- fVertexBuilder->codeAppendf("highp int paramsIdx = int(%s & 0x%x);",
+ fVertexBuilder->codeAppendf("int paramsIdx = int(%s & 0x%x);",
this->attr(Attrib::kInstanceInfo),
kParamsIdx_InfoMask);
}
const char* attr(Attrib attr) const { return fInstProc.getAttrib((int)attr).fName; }
- void fetchNextParam(GrSLType type = kVec4f_GrSLType) const {
+ void fetchNextParam(GrSLType type = kHalf4_GrSLType) const {
SkASSERT(fParamsBuffer.isValid());
switch (type) {
- case kVec2f_GrSLType: // fall through
- case kVec3f_GrSLType: // fall through
- case kVec4f_GrSLType:
+ case kHighFloat2_GrSLType: // fall through
+ case kHighFloat3_GrSLType: // fall through
+ case kHighFloat4_GrSLType: // fall through
+ case kHalf2_GrSLType: // fall through
+ case kHalf3_GrSLType: // fall through
+ case kHalf4_GrSLType:
break;
default:
fVertexBuilder->codeAppendf("%s(", GrGLSLTypeString(type));
}
fVertexBuilder->appendTexelFetch(fParamsBuffer, "paramsIdx++");
switch (type) {
- case kVec2f_GrSLType:
+ case kHighFloat2_GrSLType: // fall through
+ case kHalf2_GrSLType:
fVertexBuilder->codeAppend(".xy");
break;
- case kVec3f_GrSLType:
+ case kHighFloat3_GrSLType: // fall through
+ case kHalf3_GrSLType:
fVertexBuilder->codeAppend(".xyz");
break;
- case kVec4f_GrSLType:
+ case kHighFloat4_GrSLType: // fall through
+ case kHalf4_GrSLType:
break;
default:
fVertexBuilder->codeAppend(")");
@@ -177,11 +183,11 @@
, fModifiesCoverage(false)
, fModifiesColor(false)
, fNeedsNeighborRadii(false)
- , fColor(kVec4f_GrSLType)
+ , fColor(kHalf4_GrSLType)
, fTriangleIsArc(kInt_GrSLType)
- , fArcCoords(kVec2f_GrSLType)
- , fInnerShapeCoords(kVec2f_GrSLType)
- , fInnerRRect(kVec4f_GrSLType)
+ , fArcCoords(kHalf2_GrSLType)
+ , fInnerShapeCoords(kHalf2_GrSLType)
+ , fInnerRRect(kHalf4_GrSLType)
, fModifiedShapeCoords(nullptr) {
if (fOpInfo.fShapeTypes & kRRect_ShapesMask) {
fModifiedShapeCoords = "adjustedShapeCoords";
@@ -232,16 +238,16 @@
}
if (!ip.opInfo().fHasPerspective) {
- v->codeAppendf("float2x3 shapeMatrix = float2x3(%s, %s);",
+ v->codeAppendf("half2x3 shapeMatrix = half2x3(%s, %s);",
inputs.attr(Attrib::kShapeMatrixX), inputs.attr(Attrib::kShapeMatrixY));
} else {
v->defineConstantf("int", "PERSPECTIVE_FLAG", "0x%x", kPerspective_InfoFlag);
- v->codeAppendf("float3x3 shapeMatrix = float3x3(%s, %s, float3(0, 0, 1));",
+ v->codeAppendf("half3x3 shapeMatrix = half3x3(%s, %s, half3(0, 0, 1));",
inputs.attr(Attrib::kShapeMatrixX), inputs.attr(Attrib::kShapeMatrixY));
v->codeAppendf("if (0 != (%s & uint(PERSPECTIVE_FLAG))) {",
inputs.attr(Attrib::kInstanceInfo));
v->codeAppend ( "shapeMatrix[2] = ");
- inputs.fetchNextParam(kVec3f_GrSLType);
+ inputs.fetchNextParam(kHalf3_GrSLType);
v->codeAppend ( ";");
v->codeAppend ("}");
}
@@ -303,16 +309,16 @@
inputs.attr(Attrib::kInstanceInfo));
}
// Here we take advantage of the fact that outerRect == localRect in recordDRRect.
- v->codeAppendf("float4 outer = %s;", inputs.attr(Attrib::kLocalRect));
- v->codeAppend ("float4 inner = ");
+ v->codeAppendf("half4 outer = %s;", inputs.attr(Attrib::kLocalRect));
+ v->codeAppend ("half4 inner = ");
inputs.fetchNextParam();
v->codeAppend (";");
// outer2Inner is a transform from shape coords to inner shape coords:
// e.g. innerShapeCoords = shapeCoords * outer2Inner.xy + outer2Inner.zw
- v->codeAppend ("float4 outer2Inner = float4(outer.zw - outer.xy, "
- "outer.xy + outer.zw - inner.xy - inner.zw) / "
- "(inner.zw - inner.xy).xyxy;");
- v->codeAppendf("float2 innerShapeCoords = %s * outer2Inner.xy + outer2Inner.zw;",
+ v->codeAppend ("half4 outer2Inner = half4(outer.zw - outer.xy, "
+ "outer.xy + outer.zw - inner.xy - inner.zw) / "
+ "(inner.zw - inner.xy).xyxy;");
+ v->codeAppendf("half2 innerShapeCoords = %s * outer2Inner.xy + outer2Inner.zw;",
backend->outShapeCoords());
backend->initInnerShape(varyingHandler, v);
@@ -372,8 +378,8 @@
const char* localCoords = nullptr;
if (ip.opInfo().fUsesLocalCoords) {
localCoords = "localCoords";
- v->codeAppendf("float2 t = 0.5 * (%s + float2(1));", backend->outShapeCoords());
- v->codeAppendf("float2 localCoords = (1.0 - t) * %s.xy + t * %s.zw;",
+ v->codeAppendf("half2 t = 0.5 * (%s + half2(1));", backend->outShapeCoords());
+ v->codeAppendf("half2 localCoords = (1.0 - t) * %s.xy + t * %s.zw;",
inputs.attr(Attrib::kLocalRect), inputs.attr(Attrib::kLocalRect));
}
if (ip.opInfo().fHasLocalMatrix && ip.opInfo().fHasParams) {
@@ -383,20 +389,20 @@
if (!ip.opInfo().fUsesLocalCoords) {
inputs.skipParams(2);
} else {
- v->codeAppendf( "float2x3 localMatrix;");
+ v->codeAppendf( "half2x3 localMatrix;");
v->codeAppend ( "localMatrix[0] = ");
- inputs.fetchNextParam(kVec3f_GrSLType);
+ inputs.fetchNextParam(kHalf3_GrSLType);
v->codeAppend ( ";");
v->codeAppend ( "localMatrix[1] = ");
- inputs.fetchNextParam(kVec3f_GrSLType);
+ inputs.fetchNextParam(kHalf3_GrSLType);
v->codeAppend ( ";");
- v->codeAppend ( "localCoords = (float3(localCoords, 1) * localMatrix).xy;");
+ v->codeAppend ( "localCoords = (half3(localCoords, 1) * localMatrix).xy;");
}
v->codeAppend("}");
}
- GrSLType positionType = ip.opInfo().fHasPerspective ? kVec3f_GrSLType : kVec2f_GrSLType;
- v->codeAppendf("%s deviceCoords = float3(%s, 1) * shapeMatrix;",
+ GrSLType positionType = ip.opInfo().fHasPerspective ? kHighFloat3_GrSLType : kHighFloat2_GrSLType;
+ v->codeAppendf("%s deviceCoords = highfloat3(%s, 1) * shapeMatrix;",
GrGLSLTypeString(positionType), backend->outShapeCoords());
gpArgs->fPositionVar.set(positionType, "deviceCoords");
@@ -409,7 +415,7 @@
void GLSLInstanceProcessor::Backend::init(GrGLSLVaryingHandler* varyingHandler,
GrGLSLVertexBuilder* v) {
if (fModifiedShapeCoords) {
- v->codeAppendf("float2 %s = %s;", fModifiedShapeCoords, fInputs.attr(Attrib::kShapeCoords));
+ v->codeAppendf("half2 %s = %s;", fModifiedShapeCoords, fInputs.attr(Attrib::kShapeCoords));
}
this->onInit(varyingHandler, v);
@@ -423,10 +429,10 @@
void GLSLInstanceProcessor::Backend::setupRRect(GrGLSLVertexBuilder* v, int* usedShapeDefinitions) {
v->codeAppendf("uint2 corner = uint2(uint(%s) & 1, (uint(%s) >> 1) & 1);",
fInputs.attr(Attrib::kVertexAttrs), fInputs.attr(Attrib::kVertexAttrs));
- v->codeAppend ("float2 cornerSign = float2(corner) * 2.0 - 1.0;");
- v->codeAppendf("float2 radii%s;", fNeedsNeighborRadii ? ", neighborRadii" : "");
- v->codeAppend ("float2x2 p = ");
- fInputs.fetchNextParam(kMat22f_GrSLType);
+ v->codeAppend ("half2 cornerSign = half2(corner) * 2.0 - 1.0;");
+ v->codeAppendf("half2 radii%s;", fNeedsNeighborRadii ? ", neighborRadii" : "");
+ v->codeAppend ("half2x2 p = ");
+ fInputs.fetchNextParam(kHalf2x2_GrSLType);
v->codeAppend (";");
uint8_t types = fOpInfo.fShapeTypes & kRRect_ShapesMask;
if (0 == (types & (types - 1))) {
@@ -467,11 +473,11 @@
this->adjustRRectVertices(v);
if (fArcCoords.vsOut()) {
- v->codeAppendf("%s = (cornerSign * %s + radii - float2(1)) / radii;",
+ v->codeAppendf("%s = (cornerSign * %s + radii - half2(1)) / radii;",
fArcCoords.vsOut(), fModifiedShapeCoords);
}
if (fTriangleIsArc.vsOut()) {
- v->codeAppendf("%s = int(all(equal(float2(1), abs(%s))));",
+ v->codeAppendf("%s = int(all(equal(half2(1), abs(%s))));",
fTriangleIsArc.vsOut(), fInputs.attr(Attrib::kShapeCoords));
}
@@ -486,9 +492,9 @@
}
void GLSLInstanceProcessor::Backend::setupNinePatchRadii(GrGLSLVertexBuilder* v) {
- v->codeAppend("radii = float2(p[0][corner.x], p[1][corner.y]);");
+ v->codeAppend("radii = half2(p[0][corner.x], p[1][corner.y]);");
if (fNeedsNeighborRadii) {
- v->codeAppend("neighborRadii = float2(p[0][1 - corner.x], p[1][1 - corner.y]);");
+ v->codeAppend("neighborRadii = half2(p[0][1 - corner.x], p[1][1 - corner.y]);");
}
}
@@ -507,12 +513,12 @@
* x2 x4
*
*/
- v->codeAppend("float2x2 p2 = ");
- fInputs.fetchNextParam(kMat22f_GrSLType);
+ v->codeAppend("half2x2 p2 = ");
+ fInputs.fetchNextParam(kHalf2x2_GrSLType);
v->codeAppend(";");
- v->codeAppend("radii = float2(p[corner.x][corner.y], p2[corner.y][corner.x]);");
+ v->codeAppend("radii = half2(p[corner.x][corner.y], p2[corner.y][corner.x]);");
if (fNeedsNeighborRadii) {
- v->codeAppend("neighborRadii = float2(p[1 - corner.x][corner.y], "
+ v->codeAppend("neighborRadii = half2(p[1 - corner.x][corner.y], "
"p2[1 - corner.y][corner.x]);");
}
}
@@ -540,10 +546,10 @@
}
void GLSLInstanceProcessor::Backend::setupInnerSimpleRRect(GrGLSLVertexBuilder* v) {
- v->codeAppend("float2x2 innerP = ");
- fInputs.fetchNextParam(kMat22f_GrSLType);
+ v->codeAppend("half2x2 innerP = ");
+ fInputs.fetchNextParam(kHalf2x2_GrSLType);
v->codeAppend(";");
- v->codeAppend("float2 innerRadii = innerP[0] * 2.0 / innerP[1];");
+ v->codeAppend("half2 innerRadii = innerP[0] * 2.0 / innerP[1];");
this->onSetupInnerSimpleRRect(v);
}
@@ -554,7 +560,7 @@
fModifiesColor ? outColor : nullptr);
if (outCoverage && !fModifiesCoverage) {
// Even though the subclass doesn't use coverage, we are expected to assign some value.
- f->codeAppendf("%s = float4(1);", outCoverage);
+ f->codeAppendf("%s = half4(1);", outCoverage);
}
if (!fModifiesColor) {
// The subclass didn't assign a value to the output color.
@@ -621,18 +627,18 @@
void GLSLInstanceProcessor::BackendNonAA::setupInnerRect(GrGLSLVertexBuilder* v) {
if (fInnerRRect.vsOut()) {
- v->codeAppendf("%s = float4(1);", fInnerRRect.vsOut());
+ v->codeAppendf("%s = half4(1);", fInnerRRect.vsOut());
}
}
void GLSLInstanceProcessor::BackendNonAA::setupInnerOval(GrGLSLVertexBuilder* v) {
if (fInnerRRect.vsOut()) {
- v->codeAppendf("%s = float4(0, 0, 1, 1);", fInnerRRect.vsOut());
+ v->codeAppendf("%s = half4(0, 0, 1, 1);", fInnerRRect.vsOut());
}
}
void GLSLInstanceProcessor::BackendNonAA::onSetupInnerSimpleRRect(GrGLSLVertexBuilder* v) {
- v->codeAppendf("%s = float4(1.0 - innerRadii, 1.0 / innerRadii);", fInnerRRect.vsOut());
+ v->codeAppendf("%s = half4(1.0 - innerRadii, 1.0 / innerRadii);", fInnerRRect.vsOut());
}
void GLSLInstanceProcessor::BackendNonAA::onEmitCode(GrGLSLVertexBuilder*,
@@ -643,11 +649,11 @@
if (!fOpInfo.fCannotDiscard) {
dropFragment = "discard";
} else if (fModifiesCoverage) {
- f->codeAppend ("lowp float covered = 1.0;");
+ f->codeAppend ("half covered = 1.0;");
dropFragment = "covered = 0.0";
} else if (fModifiesColor) {
- f->codeAppendf("lowp float4 color = %s;", fColor.fsIn());
- dropFragment = "color = float4(0)";
+ f->codeAppendf("half4 color = %s;", fColor.fsIn());
+ dropFragment = "color = half4(0)";
}
if (fTriangleIsArc.fsIn()) {
SkASSERT(dropFragment);
@@ -658,19 +664,19 @@
SkASSERT(dropFragment);
f->codeAppendf("// Inner shape.\n");
if (kRect_ShapeFlag == fOpInfo.fInnerShapeTypes) {
- f->codeAppendf("if (all(lessThanEqual(abs(%s), float2(1)))) %s;",
+ f->codeAppendf("if (all(lessThanEqual(abs(%s), half2(1)))) %s;",
fInnerShapeCoords.fsIn(), dropFragment);
} else if (kOval_ShapeFlag == fOpInfo.fInnerShapeTypes) {
f->codeAppendf("if ((dot(%s, %s) <= 1.0)) %s;",
fInnerShapeCoords.fsIn(), fInnerShapeCoords.fsIn(), dropFragment);
} else {
- f->codeAppendf("if (all(lessThan(abs(%s), float2(1)))) {", fInnerShapeCoords.fsIn());
- f->codeAppendf( "float2 distanceToArcEdge = abs(%s) - %s.xy;",
+ f->codeAppendf("if (all(lessThan(abs(%s), half2(1)))) {", fInnerShapeCoords.fsIn());
+ f->codeAppendf( "half2 distanceToArcEdge = abs(%s) - %s.xy;",
fInnerShapeCoords.fsIn(), fInnerRRect.fsIn());
- f->codeAppend ( "if (any(lessThan(distanceToArcEdge, float2(0)))) {");
+ f->codeAppend ( "if (any(lessThan(distanceToArcEdge, half2(0)))) {");
f->codeAppendf( "%s;", dropFragment);
f->codeAppend ( "} else {");
- f->codeAppendf( "float2 rrectCoords = distanceToArcEdge * %s.zw;",
+ f->codeAppendf( "half2 rrectCoords = distanceToArcEdge * %s.zw;",
fInnerRRect.fsIn());
f->codeAppend ( "if (dot(rrectCoords, rrectCoords) <= 1.0) {");
f->codeAppendf( "%s;", dropFragment);
@@ -680,7 +686,7 @@
}
}
if (fModifiesCoverage) {
- f->codeAppendf("%s = float4(covered);", outCoverage);
+ f->codeAppendf("%s = half4(covered);", outCoverage);
} else if (fModifiesColor) {
f->codeAppendf("%s = color;", outColor);
}
@@ -692,15 +698,15 @@
public:
BackendCoverage(OpInfo opInfo, const VertexInputs& inputs)
: INHERITED(opInfo, inputs)
- , fColorTimesRectCoverage(kVec4f_GrSLType)
- , fRectCoverage(kFloat_GrSLType)
- , fEllipseCoords(kVec2f_GrSLType)
- , fEllipseName(kVec2f_GrSLType)
- , fBloatedRadius(kFloat_GrSLType)
- , fDistanceToInnerEdge(kVec2f_GrSLType)
- , fInnerShapeBloatedHalfSize(kVec2f_GrSLType)
- , fInnerEllipseCoords(kVec2f_GrSLType)
- , fInnerEllipseName(kVec2f_GrSLType) {
+ , fColorTimesRectCoverage(kHalf4_GrSLType)
+ , fRectCoverage(kHalf_GrSLType)
+ , fEllipseCoords(kHalf2_GrSLType)
+ , fEllipseName(kHalf2_GrSLType)
+ , fBloatedRadius(kHalf_GrSLType)
+ , fDistanceToInnerEdge(kHalf2_GrSLType)
+ , fInnerShapeBloatedHalfSize(kHalf2_GrSLType)
+ , fInnerEllipseCoords(kHalf2_GrSLType)
+ , fInnerEllipseName(kHalf2_GrSLType) {
fShapeIsCircle = !fOpInfo.fNonSquare && !(fOpInfo.fShapeTypes & kRRect_ShapesMask);
fTweakAlphaForCoverage = !fOpInfo.fCannotTweakAlphaForCoverage && !fOpInfo.fInnerShapeTypes;
fModifiesCoverage = !fTweakAlphaForCoverage;
@@ -747,10 +753,10 @@
void GLSLInstanceProcessor::BackendCoverage::onInit(GrGLSLVaryingHandler* varyingHandler,
GrGLSLVertexBuilder* v) {
- v->codeAppend ("float2x2 shapeTransposeMatrix = transpose(float2x2(shapeMatrix));");
- v->codeAppend ("float2 shapeHalfSize = float2(length(shapeTransposeMatrix[0]), "
+ v->codeAppend ("half2x2 shapeTransposeMatrix = transpose(half2x2(shapeMatrix));");
+ v->codeAppend ("half2 shapeHalfSize = half2(length(shapeTransposeMatrix[0]), "
"length(shapeTransposeMatrix[1]));");
- v->codeAppend ("float2 bloat = 0.5 / shapeHalfSize;");
+ v->codeAppend ("half2 bloat = 0.5 / shapeHalfSize;");
v->codeAppendf("bloatedShapeCoords = %s * (1.0 + bloat);", fInputs.attr(Attrib::kShapeCoords));
if (kOval_ShapeFlag != fOpInfo.fShapeTypes) {
@@ -763,7 +769,7 @@
} else {
varyingHandler->addVarying("rectCoverage", &fRectCoverage, kLow_GrSLPrecision);
}
- v->codeAppend("float rectCoverage = 0.0;");
+ v->codeAppend("half rectCoverage = 0.0;");
}
if (kRect_ShapeFlag != fOpInfo.fShapeTypes) {
varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc, kLow_GrSLPrecision);
@@ -779,18 +785,18 @@
void GLSLInstanceProcessor::BackendCoverage::setupRect(GrGLSLVertexBuilder* v) {
// Make the border one pixel wide. Inner vs outer is indicated by coordAttrs.
- v->codeAppendf("float2 rectBloat = (%s != 0) ? bloat : -bloat;",
+ v->codeAppendf("half2 rectBloat = (%s != 0) ? bloat : -bloat;",
fInputs.attr(Attrib::kVertexAttrs));
// Here we use the absolute value, because when the rect is thinner than a pixel, this makes it
// mark the spot where pixel center is within half a pixel of the *opposite* edge. This,
// combined with the "maxCoverage" logic below gives us mathematically correct coverage even for
// subpixel rectangles.
- v->codeAppendf("bloatedShapeCoords = %s * abs(float2(1.0 + rectBloat));",
+ v->codeAppendf("bloatedShapeCoords = %s * abs(half2(1.0 + rectBloat));",
fInputs.attr(Attrib::kShapeCoords));
// Determine coverage at the vertex. Coverage naturally ramps from 0 to 1 unless the rect is
// narrower than a pixel.
- v->codeAppend ("float maxCoverage = 4.0 * min(0.5, shapeHalfSize.x) *"
+ v->codeAppend ("half maxCoverage = 4.0 * min(0.5, shapeHalfSize.x) *"
"min(0.5, shapeHalfSize.y);");
v->codeAppendf("rectCoverage = (%s != 0) ? 0.0 : maxCoverage;",
fInputs.attr(Attrib::kVertexAttrs));
@@ -802,9 +808,9 @@
void GLSLInstanceProcessor::BackendCoverage::setupOval(GrGLSLVertexBuilder* v) {
// Offset the inner and outer octagons by one pixel. Inner vs outer is indicated by coordAttrs.
- v->codeAppendf("float2 ovalBloat = (%s != 0) ? bloat : -bloat;",
+ v->codeAppendf("half2 ovalBloat = (%s != 0) ? bloat : -bloat;",
fInputs.attr(Attrib::kVertexAttrs));
- v->codeAppendf("bloatedShapeCoords = %s * max(float2(1.0 + ovalBloat), float2(0));",
+ v->codeAppendf("bloatedShapeCoords = %s * max(half2(1.0 + ovalBloat), half2(0));",
fInputs.attr(Attrib::kShapeCoords));
v->codeAppendf("%s = bloatedShapeCoords * shapeHalfSize;", fEllipseCoords.vsOut());
if (fEllipseName.vsOut()) {
@@ -827,8 +833,8 @@
// We try to let the AA borders line up with the arc edges on their particular side, but we
// can't allow them to get closer than one half pixel to the edge or they might overlap with
// their neighboring border.
- v->codeAppend("float2 innerEdge = max(1.0 - bloat, float2(0));");
- v->codeAppend ("float2 borderEdge = cornerSign * clamp(1.0 - radii, -innerEdge, innerEdge);");
+ v->codeAppend("half2 innerEdge = max(1.0 - bloat, half2(0));");
+ v->codeAppend ("half2 borderEdge = cornerSign * clamp(1.0 - radii, -innerEdge, innerEdge);");
// 0.5 is a special value that indicates this vertex is an arc edge.
v->codeAppendf("if (abs(%s.x) == 0.5)"
"bloatedShapeCoords.x = borderEdge.x;", fInputs.attr(Attrib::kShapeCoords));
@@ -851,7 +857,7 @@
// interior edge of the border will necessarily clamp, and we need to match the AA behavior of
// the arc segments (i.e. distance from bloated edge only; ignoring the fact that the pixel
// actully has less coverage because it's not completely inside the opposite edge.)
- v->codeAppend("float2 d = shapeHalfSize + 0.5 - abs(bloatedShapeCoords) * shapeHalfSize;");
+ v->codeAppend("half2 d = shapeHalfSize + 0.5 - abs(bloatedShapeCoords) * shapeHalfSize;");
v->codeAppend("rectCoverage = min(d.x, d.y);");
SkASSERT(!fShapeIsCircle);
@@ -859,8 +865,8 @@
// smooth transition from flat edge to arc, we don't allow the radii to be smaller than one half
// pixel. (We don't worry about the transition on the opposite side when a radius is so large
// that the border clamped on that side.)
- v->codeAppendf("float2 clampedRadii = max(radii, bloat);");
- v->codeAppendf("%s = (cornerSign * bloatedShapeCoords + clampedRadii - float2(1)) * "
+ v->codeAppendf("half2 clampedRadii = max(radii, bloat);");
+ v->codeAppendf("%s = (cornerSign * bloatedShapeCoords + clampedRadii - half2(1)) * "
"shapeHalfSize;", fEllipseCoords.vsOut());
v->codeAppendf("%s = 1.0 / (clampedRadii * clampedRadii * shapeHalfSize * shapeHalfSize);",
fEllipseName.vsOut());
@@ -868,7 +874,7 @@
void GLSLInstanceProcessor::BackendCoverage::onInitInnerShape(GrGLSLVaryingHandler* varyingHandler,
GrGLSLVertexBuilder* v) {
- v->codeAppend("float2 innerShapeHalfSize = shapeHalfSize / outer2Inner.xy;");
+ v->codeAppend("half2 innerShapeHalfSize = shapeHalfSize / outer2Inner.xy;");
if (kOval_ShapeFlag == fOpInfo.fInnerShapeTypes) {
varyingHandler->addVarying("innerEllipseCoords", &fInnerEllipseCoords,
@@ -906,7 +912,7 @@
v->codeAppendf("%s = innerShapeCoords * innerShapeHalfSize;", fInnerEllipseCoords.vsOut());
}
if (fInnerRRect.vsOut()) {
- v->codeAppendf("%s = float4(0, 0, innerShapeHalfSize);", fInnerRRect.vsOut());
+ v->codeAppendf("%s = half4(0, 0, innerShapeHalfSize);", fInnerRRect.vsOut());
}
}
@@ -916,7 +922,7 @@
v->codeAppendf("%s = 1.0 / (innerRadii * innerRadii * innerShapeHalfSize * "
"innerShapeHalfSize);",
fInnerEllipseName.vsOut());
- v->codeAppendf("%s = float4(1.0 - innerRadii, innerShapeHalfSize);", fInnerRRect.vsOut());
+ v->codeAppendf("%s = half4(1.0 - innerRadii, innerShapeHalfSize);", fInnerRRect.vsOut());
}
void GLSLInstanceProcessor::BackendCoverage::onEmitCode(GrGLSLVertexBuilder* v,
@@ -933,7 +939,7 @@
v->codeAppendf("%s = rectCoverage;", fRectCoverage.vsOut());
}
- SkString coverage("lowp float coverage");
+ SkString coverage("half coverage");
if (fOpInfo.fInnerShapeTypes || (!fTweakAlphaForCoverage && fTriangleIsArc.fsIn())) {
f->codeAppendf("%s;", coverage.c_str());
coverage = "coverage";
@@ -960,7 +966,7 @@
if (fOpInfo.fInnerShapeTypes) {
f->codeAppendf("// Inner shape.\n");
- SkString innerCoverageDecl("lowp float innerCoverage");
+ SkString innerCoverageDecl("half innerCoverage");
if (kOval_ShapeFlag == fOpInfo.fInnerShapeTypes) {
this->emitArc(f, fInnerEllipseCoords.fsIn(), fInnerEllipseName.fsIn(),
true /*ellipseCoordsNeedClamp*/, true /*ellipseCoordsMayBeNegative*/,
@@ -974,12 +980,12 @@
this->emitInnerRect(f, innerCoverageDecl.c_str());
} else {
f->codeAppendf("%s = 0.0;", innerCoverageDecl.c_str());
- f->codeAppendf("mediump float2 distanceToArcEdge = abs(%s) - %s.xy;",
+ f->codeAppendf("half2 distanceToArcEdge = abs(%s) - %s.xy;",
fInnerShapeCoords.fsIn(), fInnerRRect.fsIn());
- f->codeAppend ("if (any(lessThan(distanceToArcEdge, float2(1e-5)))) {");
+ f->codeAppend ("if (any(lessThan(distanceToArcEdge, half2(1e-5)))) {");
this->emitInnerRect(f, "innerCoverage");
f->codeAppend ("} else {");
- f->codeAppendf( "mediump float2 ellipseCoords = distanceToArcEdge * %s.zw;",
+ f->codeAppendf( "half2 ellipseCoords = distanceToArcEdge * %s.zw;",
fInnerRRect.fsIn());
this->emitArc(f, "ellipseCoords", fInnerEllipseName.fsIn(),
false /*ellipseCoordsNeedClamp*/,
@@ -987,9 +993,9 @@
f->codeAppend ("}");
}
}
- f->codeAppendf("%s = float4(max(coverage - innerCoverage, 0.0));", outCoverage);
+ f->codeAppendf("%s = half4(max(coverage - innerCoverage, 0.0));", outCoverage);
} else if (!fTweakAlphaForCoverage) {
- f->codeAppendf("%s = float4(coverage);", outCoverage);
+ f->codeAppendf("%s = half4(coverage);", outCoverage);
}
}
@@ -1012,7 +1018,7 @@
const char* outCoverage) {
// TODO: circleCoords = max(circleCoords, 0) if we decide to do this optimization on rrects.
SkASSERT(!(kRRect_ShapesMask & fOpInfo.fShapeTypes));
- f->codeAppendf("mediump float distanceToEdge = %s - length(%s);",
+ f->codeAppendf("half distanceToEdge = %s - length(%s);",
fBloatedRadius.fsIn(), fEllipseCoords.fsIn());
f->codeAppendf("%s = clamp(distanceToEdge, 0.0, 1.0);", outCoverage);
}
@@ -1029,27 +1035,27 @@
// - To restrict the arcs of rounded rects to their positive quadrants.
// - To avoid inversesqrt(0) in the ellipse formula.
if (ellipseCoordsMayBeNegative) {
- f->codeAppendf("mediump float2 ellipseClampedCoords = max(abs(%s), float2(1e-4));",
+ f->codeAppendf("half2 ellipseClampedCoords = max(abs(%s), half2(1e-4));",
ellipseCoords);
} else {
- f->codeAppendf("mediump float2 ellipseClampedCoords = max(%s, float2(1e-4));",
+ f->codeAppendf("half2 ellipseClampedCoords = max(%s, half2(1e-4));",
ellipseCoords);
}
ellipseCoords = "ellipseClampedCoords";
}
// ellipseCoords are in pixel space and ellipseName is 1 / rx^2, 1 / ry^2.
- f->codeAppendf("highp float2 Z = %s * %s;", ellipseCoords, ellipseName);
+ f->codeAppendf("highfloat2 Z = %s * %s;", ellipseCoords, ellipseName);
// implicit is the evaluation of (x/rx)^2 + (y/ry)^2 - 1.
- f->codeAppendf("highp float implicit = dot(Z, %s) - 1.0;", ellipseCoords);
+ f->codeAppendf("highfloat implicit = dot(Z, %s) - 1.0;", ellipseCoords);
// gradDot is the squared length of the gradient of the implicit.
- f->codeAppendf("highp float gradDot = 4.0 * dot(Z, Z);");
- f->codeAppend ("mediump float approxDist = implicit * inversesqrt(gradDot);");
+ f->codeAppendf("highfloat gradDot = 4.0 * dot(Z, Z);");
+ f->codeAppend ("half approxDist = implicit * inversesqrt(gradDot);");
f->codeAppendf("%s = clamp(0.5 - approxDist, 0.0, 1.0);", outCoverage);
}
void GLSLInstanceProcessor::BackendCoverage::emitInnerRect(GrGLSLPPFragmentBuilder* f,
const char* outCoverage) {
- f->codeAppendf("lowp float2 c = %s - abs(%s);",
+ f->codeAppendf("half2 c = %s - abs(%s);",
fInnerShapeBloatedHalfSize.fsIn(), fDistanceToInnerEdge.fsIn());
f->codeAppendf("%s = clamp(min(c.x, c.y), 0.0, 1.0);", outCoverage);
}
@@ -1061,15 +1067,15 @@
BackendMultisample(OpInfo opInfo, const VertexInputs& inputs, int effectiveSampleCnt)
: INHERITED(opInfo, inputs)
, fEffectiveSampleCnt(effectiveSampleCnt)
- , fShapeCoords(kVec2f_GrSLType)
- , fShapeInverseMatrix(kMat22f_GrSLType)
- , fFragShapeHalfSpan(kVec2f_GrSLType)
- , fArcTest(kVec2f_GrSLType)
- , fArcInverseMatrix(kMat22f_GrSLType)
- , fFragArcHalfSpan(kVec2f_GrSLType)
+ , fShapeCoords(kHalf2_GrSLType)
+ , fShapeInverseMatrix(kHalf2x2_GrSLType)
+ , fFragShapeHalfSpan(kHalf2_GrSLType)
+ , fArcTest(kHalf2_GrSLType)
+ , fArcInverseMatrix(kHalf2x2_GrSLType)
+ , fFragArcHalfSpan(kHalf2_GrSLType)
, fEarlyAccept(kInt_GrSLType)
- , fInnerShapeInverseMatrix(kMat22f_GrSLType)
- , fFragInnerShapeHalfSpan(kVec2f_GrSLType) {
+ , fInnerShapeInverseMatrix(kHalf2x2_GrSLType)
+ , fFragInnerShapeHalfSpan(kHalf2_GrSLType) {
fRectTrianglesMaySplit = fOpInfo.fHasPerspective;
fNeedsNeighborRadii = this->isMixedSampled() && !fOpInfo.fHasPerspective;
}
@@ -1177,9 +1183,9 @@
}
}
if (!fOpInfo.fHasPerspective) {
- v->codeAppend("float2x2 shapeInverseMatrix = inverse(float2x2(shapeMatrix));");
- v->codeAppend("float2 fragShapeSpan = abs(float4(shapeInverseMatrix).xz) + "
- "abs(float4(shapeInverseMatrix).yw);");
+ v->codeAppend("half2x2 shapeInverseMatrix = inverse(half2x2(shapeMatrix));");
+ v->codeAppend("half2 fragShapeSpan = abs(half4(shapeInverseMatrix).xz) + "
+ "abs(half4(shapeInverseMatrix).yw);");
}
}
@@ -1195,7 +1201,7 @@
}
if (fArcTest.vsOut()) {
// Pick a value that is not > 0.
- v->codeAppendf("%s = float2(0);", fArcTest.vsOut());
+ v->codeAppendf("%s = highfloat2(0);", fArcTest.vsOut());
}
if (fTriangleIsArc.vsOut()) {
v->codeAppendf("%s = 0;", fTriangleIsArc.vsOut());
@@ -1208,8 +1214,8 @@
void GLSLInstanceProcessor::BackendMultisample::setupOval(GrGLSLVertexBuilder* v) {
v->codeAppendf("%s = abs(%s);", fArcCoords.vsOut(), this->outShapeCoords());
if (fArcInverseMatrix.vsOut()) {
- v->codeAppendf("float2 s = sign(%s);", this->outShapeCoords());
- v->codeAppendf("%s = shapeInverseMatrix * float2x2(s.x, 0, 0 , s.y);",
+ v->codeAppendf("half2 s = sign(%s);", this->outShapeCoords());
+ v->codeAppendf("%s = shapeInverseMatrix * half2x2(s.x, 0, 0 , s.y);",
fArcInverseMatrix.vsOut());
}
if (fFragArcHalfSpan.vsOut()) {
@@ -1217,7 +1223,7 @@
}
if (fArcTest.vsOut()) {
// Pick a value that is > 0.
- v->codeAppendf("%s = float2(1);", fArcTest.vsOut());
+ v->codeAppendf("%s = half2(1);", fArcTest.vsOut());
}
if (fTriangleIsArc.vsOut()) {
if (!this->isMixedSampled()) {
@@ -1243,13 +1249,13 @@
// For the mixed samples algorithm it's best to bloat the corner triangles a bit so that
// more of the pixels that cross into the arc region are completely inside the shared edges.
// We also snap to a regular rect if the radii shrink smaller than a pixel.
- v->codeAppend ("float2 midpt = 0.5 * (neighborRadii - radii);");
- v->codeAppend ("float2 cornerSize = any(lessThan(radii, fragShapeSpan)) ? "
- "float2(0) : min(radii + 0.5 * fragShapeSpan, 1.0 - midpt);");
+ v->codeAppend ("half2 midpt = 0.5 * (neighborRadii - radii);");
+ v->codeAppend ("half2 cornerSize = any(lessThan(radii, fragShapeSpan)) ? "
+ "half2(0) : min(radii + 0.5 * fragShapeSpan, 1.0 - midpt);");
} else {
// TODO: We could still bloat the corner triangle in the perspective case; we would just
// need to find the screen-space derivative of shape coords at this particular point.
- v->codeAppend ("float2 cornerSize = any(lessThan(radii, float2(1e-3))) ? float2(0) : radii;");
+ v->codeAppend ("half2 cornerSize = any(lessThan(radii, half2(1e-3))) ? half2(0) : radii;");
}
v->codeAppendf("if (abs(%s.x) == 0.5)"
@@ -1271,12 +1277,12 @@
v->codeAppendf("%s = 0.5 * fragShapeSpan;", fFragShapeHalfSpan.vsOut());
}
if (fArcInverseMatrix.vsOut()) {
- v->codeAppend ("float2 s = cornerSign / radii;");
- v->codeAppendf("%s = shapeInverseMatrix * float2x2(s.x, 0, 0, s.y);",
+ v->codeAppend ("half2 s = cornerSign / radii;");
+ v->codeAppendf("%s = shapeInverseMatrix * half2x2(s.x, 0, 0, s.y);",
fArcInverseMatrix.vsOut());
}
if (fFragArcHalfSpan.vsOut()) {
- v->codeAppendf("%s = 0.5 * (abs(float4(%s).xz) + abs(float4(%s).yw));",
+ v->codeAppendf("%s = 0.5 * (abs(half4(%s).xz) + abs(half4(%s).yw));",
fFragArcHalfSpan.vsOut(), fArcInverseMatrix.vsOut(),
fArcInverseMatrix.vsOut());
}
@@ -1285,8 +1291,8 @@
// edges of a fan triangle to a point within that triangle. fArcTest is used to check if a
// fragment is too close to either shared edge, in which case we point sample the shape as a
// rect at that point in order to guarantee the mixed samples discard logic works correctly.
- v->codeAppendf("%s = (cornerSize == float2(0)) ? float2(0) : "
- "cornerSign * %s * float2x2(1, cornerSize.x - 1.0, cornerSize.y - 1.0, 1);",
+ v->codeAppendf("%s = (cornerSize == half2(0)) ? half2(0) : "
+ "cornerSign * %s * half2x2(1, cornerSize.x - 1.0, cornerSize.y - 1.0, 1);",
fArcTest.vsOut(), fModifiedShapeCoords);
if (!fOpInfo.fHasPerspective) {
// Shift the point at which distances to edges are measured from the center of the pixel
@@ -1299,7 +1305,7 @@
}
if (fEarlyAccept.vsOut()) {
SkASSERT(this->isMixedSampled());
- v->codeAppendf("%s = all(equal(float2(1), abs(%s))) ? 0 : SAMPLE_MASK_ALL;",
+ v->codeAppendf("%s = all(equal(half2(1), abs(%s))) ? 0 : SAMPLE_MASK_ALL;",
fEarlyAccept.vsOut(), fInputs.attr(Attrib::kShapeCoords));
}
}
@@ -1315,7 +1321,7 @@
if (!fOpInfo.fHasPerspective) {
varyingHandler->addFlatVarying("innerShapeInverseMatrix", &fInnerShapeInverseMatrix,
kHigh_GrSLPrecision);
- v->codeAppendf("%s = shapeInverseMatrix * float2x2(outer2Inner.x, 0, 0, outer2Inner.y);",
+ v->codeAppendf("%s = shapeInverseMatrix * highfloat2x2(outer2Inner.x, 0, 0, outer2Inner.y);",
fInnerShapeInverseMatrix.vsOut());
varyingHandler->addFlatVarying("fragInnerShapeHalfSpan", &fFragInnerShapeHalfSpan,
kHigh_GrSLPrecision);
@@ -1329,14 +1335,14 @@
// The fragment shader will generalize every inner shape as a round rect. Since this one
// is a rect, we simply emit bogus parameters for the round rect (negative radii) that
// ensure the fragment shader always takes the "sample as rect" codepath.
- v->codeAppendf("%s = float4(2.0 * (inner.zw - inner.xy) / (outer.zw - outer.xy), float2(0));",
+ v->codeAppendf("%s = half4(2.0 * (inner.zw - inner.xy) / (outer.zw - outer.xy), half2(0));",
fInnerRRect.vsOut());
}
}
void GLSLInstanceProcessor::BackendMultisample::setupInnerOval(GrGLSLVertexBuilder* v) {
if (fInnerRRect.vsOut()) {
- v->codeAppendf("%s = float4(0, 0, 1, 1);", fInnerRRect.vsOut());
+ v->codeAppendf("%s = half4(0, 0, 1, 1);", fInnerRRect.vsOut());
}
}
@@ -1345,9 +1351,9 @@
if (fFragInnerShapeHalfSpan.vsOut()) {
v->codeAppendf("innerRadii = max(innerRadii, 2e-1 * %s);", fFragInnerShapeHalfSpan.vsOut());
} else {
- v->codeAppend ("innerRadii = max(innerRadii, float2(1e-4));");
+ v->codeAppend ("innerRadii = max(innerRadii, half2(1e-4));");
}
- v->codeAppendf("%s = float4(1.0 - innerRadii, 1.0 / innerRadii);", fInnerRRect.vsOut());
+ v->codeAppendf("%s = half4(1.0 - innerRadii, 1.0 / innerRadii);", fInnerRRect.vsOut());
}
void GLSLInstanceProcessor::BackendMultisample::onEmitCode(GrGLSLVertexBuilder*,
@@ -1360,8 +1366,8 @@
}
if (kRect_ShapeFlag != (fOpInfo.fShapeTypes | fOpInfo.fInnerShapeTypes)) {
- GrShaderVar x("x", kVec2f_GrSLType, GrShaderVar::kNonArray, kHigh_GrSLPrecision);
- f->emitFunction(kFloat_GrSLType, "square", 1, &x, "return dot(x, x);", &fSquareFun);
+ GrShaderVar x("x", kHighFloat2_GrSLType, GrShaderVar::kNonArray);
+ f->emitFunction(kHalf_GrSLType, "square", 1, &x, "return dot(x, x);", &fSquareFun);
}
EmitShapeCoords shapeCoords;
@@ -1383,7 +1389,7 @@
if (fOpInfo.fHasPerspective && fOpInfo.fInnerShapeTypes) {
// This determines if the fragment should consider the inner shape in its sample mask.
// We take the derivative early in case discards may occur before we get to the inner shape.
- f->codeAppendf("highp float2 fragInnerShapeApproxHalfSpan = 0.5 * fwidth(%s);",
+ f->codeAppendf("highfloat2 fragInnerShapeApproxHalfSpan = 0.5 * fwidth(%s);",
fInnerShapeCoords.fsIn());
}
@@ -1400,7 +1406,7 @@
if (arcTest && fOpInfo.fHasPerspective) {
// The non-perspective version accounts for fwidth() in the vertex shader.
// We make sure to take the derivative here, before a neighbor pixel may early accept.
- f->codeAppendf("highp float2 arcTest = %s - 0.5 * fwidth(%s);",
+ f->codeAppendf("highfloat2 arcTest = %s - 0.5 * fwidth(%s);",
fArcTest.fsIn(), fArcTest.fsIn());
arcTest = "arcTest";
}
@@ -1411,7 +1417,7 @@
if (arcTest) {
// At this point, if the sample mask is all set it means we are inside an arc triangle.
f->codeAppendf("if (gl_SampleMaskIn[0] == SAMPLE_MASK_ALL || "
- "all(greaterThan(%s, float2(0)))) {", arcTest);
+ "all(greaterThan(%s, highfloat2(0)))) {", arcTest);
this->emitArc(f, arcCoords, false, clampArcCoords, opts);
f->codeAppend ("} else {");
this->emitRect(f, shapeCoords, opts);
@@ -1484,10 +1490,10 @@
}
f->codeAppend ("int rectMask = 0;");
f->codeAppend ("for (int i = 0; i < SAMPLE_COUNT; i++) {");
- f->codeAppend ( "highp float2 pt = ");
+ f->codeAppend ( "highfloat2 pt = ");
this->interpolateAtSample(f, *coords.fVarying, "i", coords.fInverseMatrix);
f->codeAppend ( ";");
- f->codeAppend ( "if (all(lessThan(abs(pt), float2(1)))) rectMask |= (1 << i);");
+ f->codeAppend ( "if (all(lessThan(abs(pt), highfloat2(1)))) rectMask |= (1 << i);");
f->codeAppend ("}");
this->acceptCoverageMask(f, "rectMask", opts);
if (coords.fFragHalfSpan) {
@@ -1503,7 +1509,7 @@
SkString absArcCoords;
absArcCoords.printf(coordsMayBeNegative ? "abs(%s)" : "%s", coords.fVarying->fsIn());
if (clampCoords) {
- f->codeAppendf("if (%s(max(%s + %s, float2(0))) < 1.0) {",
+ f->codeAppendf("if (%s(max(%s + %s, half2(0))) < 1.0) {",
fSquareFun.c_str(), absArcCoords.c_str(), coords.fFragHalfSpan);
} else {
f->codeAppendf("if (%s(%s + %s) < 1.0) {",
@@ -1511,7 +1517,7 @@
}
// The entire pixel is inside the arc.
this->acceptOrRejectWholeFragment(f, true, opts);
- f->codeAppendf("} else if (%s(max(%s - %s, float2(0))) >= 1.0) {",
+ f->codeAppendf("} else if (%s(max(%s - %s, half2(0))) >= 1.0) {",
fSquareFun.c_str(), absArcCoords.c_str(), coords.fFragHalfSpan);
// The entire pixel is outside the arc.
this->acceptOrRejectWholeFragment(f, false, opts);
@@ -1519,12 +1525,12 @@
}
f->codeAppend ( "int arcMask = 0;");
f->codeAppend ( "for (int i = 0; i < SAMPLE_COUNT; i++) {");
- f->codeAppend ( "highp float2 pt = ");
+ f->codeAppend ( "highfloat2 pt = ");
this->interpolateAtSample(f, *coords.fVarying, "i", coords.fInverseMatrix);
f->codeAppend ( ";");
if (clampCoords) {
SkASSERT(!coordsMayBeNegative);
- f->codeAppend ( "pt = max(pt, float2(0));");
+ f->codeAppend ( "pt = max(pt, highfloat2(0));");
}
f->codeAppendf( "if (%s(pt) < 1.0) arcMask |= (1 << i);", fSquareFun.c_str());
f->codeAppend ( "}");
@@ -1538,31 +1544,31 @@
const EmitShapeCoords& coords,
const char* rrect,
const EmitShapeOpts& opts) {
- f->codeAppendf("highp float2 distanceToArcEdge = abs(%s) - %s.xy;", coords.fVarying->fsIn(),
+ f->codeAppendf("highfloat2 distanceToArcEdge = abs(%s) - %s.xy;", coords.fVarying->fsIn(),
rrect);
- f->codeAppend ("if (any(lessThan(distanceToArcEdge, float2(0)))) {");
+ f->codeAppend ("if (any(lessThan(distanceToArcEdge, highfloat2(0)))) {");
this->emitRect(f, coords, opts);
f->codeAppend ("} else {");
if (coords.fInverseMatrix && coords.fFragHalfSpan) {
- f->codeAppendf("highp float2 rrectCoords = distanceToArcEdge * %s.zw;", rrect);
- f->codeAppendf("highp float2 fragRRectHalfSpan = %s * %s.zw;", coords.fFragHalfSpan, rrect);
+ f->codeAppendf("highfloat2 rrectCoords = distanceToArcEdge * %s.zw;", rrect);
+ f->codeAppendf("highfloat2 fragRRectHalfSpan = %s * %s.zw;", coords.fFragHalfSpan, rrect);
f->codeAppendf("if (%s(rrectCoords + fragRRectHalfSpan) <= 1.0) {", fSquareFun.c_str());
// The entire pixel is inside the round rect.
this->acceptOrRejectWholeFragment(f, true, opts);
- f->codeAppendf("} else if (%s(max(rrectCoords - fragRRectHalfSpan, float2(0))) >= 1.0) {",
+ f->codeAppendf("} else if (%s(max(rrectCoords - fragRRectHalfSpan, highfloat2(0))) >= 1.0) {",
fSquareFun.c_str());
// The entire pixel is outside the round rect.
this->acceptOrRejectWholeFragment(f, false, opts);
f->codeAppend ("} else {");
- f->codeAppendf( "highp float2 s = %s.zw * sign(%s);", rrect, coords.fVarying->fsIn());
- f->codeAppendf( "highp float2x2 innerRRectInverseMatrix = %s * "
- "float2x2(s.x, 0, 0, s.y);", coords.fInverseMatrix);
+ f->codeAppendf( "highfloat2 s = %s.zw * sign(%s);", rrect, coords.fVarying->fsIn());
+ f->codeAppendf( "highfloat2x2 innerRRectInverseMatrix = %s * "
+ "highfloat2x2(s.x, 0, 0, s.y);", coords.fInverseMatrix);
f->codeAppend ( "highp int rrectMask = 0;");
f->codeAppend ( "for (int i = 0; i < SAMPLE_COUNT; i++) {");
- f->codeAppend ( "highp float2 pt = rrectCoords + ");
+ f->codeAppend ( "highfloat2 pt = rrectCoords + ");
f->appendOffsetToSample("i", GrGLSLFPFragmentBuilder::kSkiaDevice_Coordinates);
f->codeAppend ( "* innerRRectInverseMatrix;");
- f->codeAppendf( "if (%s(max(pt, float2(0))) < 1.0) rrectMask |= (1 << i);",
+ f->codeAppendf( "if (%s(max(pt, highfloat2(0))) < 1.0) rrectMask |= (1 << i);",
fSquareFun.c_str());
f->codeAppend ( "}");
this->acceptCoverageMask(f, "rrectMask", opts);
@@ -1570,10 +1576,10 @@
} else {
f->codeAppend ("int rrectMask = 0;");
f->codeAppend ("for (int i = 0; i < SAMPLE_COUNT; i++) {");
- f->codeAppend ( "highp float2 shapePt = ");
+ f->codeAppend ( "highfloat2 shapePt = ");
this->interpolateAtSample(f, *coords.fVarying, "i", nullptr);
f->codeAppend ( ";");
- f->codeAppendf( "highp float2 rrectPt = max(abs(shapePt) - %s.xy, float2(0)) * %s.zw;",
+ f->codeAppendf( "highfloat2 rrectPt = max(abs(shapePt) - %s.xy, highfloat2(0)) * %s.zw;",
rrect, rrect);
f->codeAppendf( "if (%s(rrectPt) < 1.0) rrectMask |= (1 << i);", fSquareFun.c_str());
f->codeAppend ("}");
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 425dbae..66cf3ff 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -564,7 +564,7 @@
// emit attributes
varyingHandler->emitAttributes(qe);
- GrGLSLVertToFrag v(kVec4f_GrSLType);
+ GrGLSLVertToFrag v(kHalf4_GrSLType);
varyingHandler->addVarying("QuadEdge", &v);
vertBuilder->codeAppendf("%s = %s;", v.vsOut(), qe.fInQuadEdge->fName);
@@ -585,17 +585,17 @@
qe.fLocalMatrix,
args.fFPCoordTransformHandler);
- fragBuilder->codeAppendf("float edgeAlpha;");
+ fragBuilder->codeAppendf("half edgeAlpha;");
// keep the derivative instructions outside the conditional
- fragBuilder->codeAppendf("float2 duvdx = dFdx(%s.xy);", v.fsIn());
- fragBuilder->codeAppendf("float2 duvdy = dFdy(%s.xy);", v.fsIn());
+ fragBuilder->codeAppendf("half2 duvdx = dFdx(%s.xy);", v.fsIn());
+ fragBuilder->codeAppendf("half2 duvdy = dFdy(%s.xy);", v.fsIn());
fragBuilder->codeAppendf("if (%s.z > 0.0 && %s.w > 0.0) {", v.fsIn(), v.fsIn());
// today we know z and w are in device space. We could use derivatives
fragBuilder->codeAppendf("edgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);", v.fsIn(),
v.fsIn());
fragBuilder->codeAppendf ("} else {");
- fragBuilder->codeAppendf("float2 gF = float2(2.0*%s.x*duvdx.x - duvdx.y,"
+ fragBuilder->codeAppendf("half2 gF = half2(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);", v.fsIn(), v.fsIn(),
@@ -603,7 +603,7 @@
fragBuilder->codeAppendf("edgeAlpha = "
"clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);}");
- fragBuilder->codeAppendf("%s = float4(edgeAlpha);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
}
static inline void GenKey(const GrGeometryProcessor& gp,
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 14c15cb..17ada15 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -882,12 +882,12 @@
varyingHandler->emitAttributes(dce);
// XY are dashPos, Z is dashInterval
- GrGLSLVertToFrag dashParams(kVec3f_GrSLType);
+ GrGLSLVertToFrag dashParams(kHalf3_GrSLType);
varyingHandler->addVarying("DashParam", &dashParams);
vertBuilder->codeAppendf("%s = %s;", dashParams.vsOut(), dce.inDashParams()->fName);
// x refers to circle radius - 0.5, y refers to cicle's center x coord
- GrGLSLVertToFrag circleParams(kVec2f_GrSLType);
+ GrGLSLVertToFrag circleParams(kHalf2_GrSLType);
varyingHandler->addVarying("CircleParams", &circleParams);
vertBuilder->codeAppendf("%s = %s;", circleParams.vsOut(), dce.inCircleParams()->fName);
@@ -908,21 +908,21 @@
args.fFPCoordTransformHandler);
// transforms all points so that we can compare them to our test circle
- fragBuilder->codeAppendf("float xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
+ fragBuilder->codeAppendf("half xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
dashParams.fsIn(), dashParams.fsIn(), dashParams.fsIn(),
dashParams.fsIn());
- fragBuilder->codeAppendf("float2 fragPosShifted = float2(xShifted, %s.y);", dashParams.fsIn());
- fragBuilder->codeAppendf("float2 center = float2(%s.y, 0.0);", circleParams.fsIn());
- fragBuilder->codeAppend("float dist = length(center - fragPosShifted);");
+ fragBuilder->codeAppendf("half2 fragPosShifted = half2(xShifted, %s.y);", dashParams.fsIn());
+ fragBuilder->codeAppendf("half2 center = half2(%s.y, 0.0);", circleParams.fsIn());
+ fragBuilder->codeAppend("half dist = length(center - fragPosShifted);");
if (dce.aaMode() != AAMode::kNone) {
- fragBuilder->codeAppendf("float diff = dist - %s.x;", circleParams.fsIn());
+ fragBuilder->codeAppendf("half diff = dist - %s.x;", circleParams.fsIn());
fragBuilder->codeAppend("diff = 1.0 - diff;");
- fragBuilder->codeAppend("float alpha = clamp(diff, 0.0, 1.0);");
+ fragBuilder->codeAppend("half alpha = clamp(diff, 0.0, 1.0);");
} else {
- fragBuilder->codeAppendf("float alpha = 1.0;");
+ fragBuilder->codeAppendf("half alpha = 1.0;");
fragBuilder->codeAppendf("alpha *= dist < %s.x + 0.5 ? 1.0 : 0.0;", circleParams.fsIn());
}
- fragBuilder->codeAppendf("%s = float4(alpha);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(alpha);", args.fOutputCoverage);
}
void GLDashingCircleEffect::setData(const GrGLSLProgramDataManager& pdman,
@@ -1085,13 +1085,13 @@
varyingHandler->emitAttributes(de);
// XY refers to dashPos, Z is the dash interval length
- GrGLSLVertToFrag inDashParams(kVec3f_GrSLType);
+ GrGLSLVertToFrag inDashParams(kHighFloat3_GrSLType);
varyingHandler->addVarying("DashParams", &inDashParams, GrSLPrecision::kHigh_GrSLPrecision);
vertBuilder->codeAppendf("%s = %s;", inDashParams.vsOut(), de.inDashParams()->fName);
// The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
// respectively.
- GrGLSLVertToFrag inRectParams(kVec4f_GrSLType);
+ GrGLSLVertToFrag inRectParams(kHighFloat4_GrSLType);
varyingHandler->addVarying("RectParams", &inRectParams, GrSLPrecision::kHigh_GrSLPrecision);
vertBuilder->codeAppendf("%s = %s;", inRectParams.vsOut(), de.inRectParams()->fName);
@@ -1112,14 +1112,14 @@
args.fFPCoordTransformHandler);
// transforms all points so that we can compare them to our test rect
- fragBuilder->codeAppendf("float xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
+ fragBuilder->codeAppendf("half xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
inDashParams.fsIn(), inDashParams.fsIn(), inDashParams.fsIn(),
inDashParams.fsIn());
- fragBuilder->codeAppendf("float2 fragPosShifted = float2(xShifted, %s.y);", inDashParams.fsIn());
+ fragBuilder->codeAppendf("half2 fragPosShifted = half2(xShifted, %s.y);", inDashParams.fsIn());
if (de.aaMode() == AAMode::kCoverage) {
// The amount of coverage removed in x and y by the edges is computed as a pair of negative
// numbers, xSub and ySub.
- fragBuilder->codeAppend("float xSub, ySub;");
+ fragBuilder->codeAppend("half xSub, ySub;");
fragBuilder->codeAppendf("xSub = min(fragPosShifted.x - %s.x, 0.0);", inRectParams.fsIn());
fragBuilder->codeAppendf("xSub += min(%s.z - fragPosShifted.x, 0.0);", inRectParams.fsIn());
fragBuilder->codeAppendf("ySub = min(fragPosShifted.y - %s.y, 0.0);", inRectParams.fsIn());
@@ -1127,24 +1127,24 @@
// Now compute coverage in x and y and multiply them to get the fraction of the pixel
// covered.
fragBuilder->codeAppendf(
- "float alpha = (1.0 + max(xSub, -1.0)) * (1.0 + max(ySub, -1.0));");
+ "half alpha = (1.0 + max(xSub, -1.0)) * (1.0 + max(ySub, -1.0));");
} else if (de.aaMode() == AAMode::kCoverageWithMSAA) {
// For MSAA, we don't modulate the alpha by the Y distance, since MSAA coverage will handle
// AA on the the top and bottom edges. The shader is only responsible for intra-dash alpha.
- fragBuilder->codeAppend("float xSub;");
+ fragBuilder->codeAppend("half xSub;");
fragBuilder->codeAppendf("xSub = min(fragPosShifted.x - %s.x, 0.0);", inRectParams.fsIn());
fragBuilder->codeAppendf("xSub += min(%s.z - fragPosShifted.x, 0.0);", inRectParams.fsIn());
// Now compute coverage in x to get the fraction of the pixel covered.
- fragBuilder->codeAppendf("float alpha = (1.0 + max(xSub, -1.0));");
+ fragBuilder->codeAppendf("half alpha = (1.0 + max(xSub, -1.0));");
} else {
// Assuming the bounding geometry is tight so no need to check y values
- fragBuilder->codeAppendf("float alpha = 1.0;");
+ fragBuilder->codeAppendf("half alpha = 1.0;");
fragBuilder->codeAppendf("alpha *= (fragPosShifted.x - %s.x) > -0.5 ? 1.0 : 0.0;",
inRectParams.fsIn());
fragBuilder->codeAppendf("alpha *= (%s.z - fragPosShifted.x) >= -0.5 ? 1.0 : 0.0;",
inRectParams.fsIn());
}
- fragBuilder->codeAppendf("%s = float4(alpha);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(alpha);", args.fOutputCoverage);
}
void GLDashingLineEffect::setData(const GrGLSLProgramDataManager& pdman,
diff --git a/src/gpu/ops/GrMSAAPathRenderer.cpp b/src/gpu/ops/GrMSAAPathRenderer.cpp
index ef19367..16ff097 100644
--- a/src/gpu/ops/GrMSAAPathRenderer.cpp
+++ b/src/gpu/ops/GrMSAAPathRenderer.cpp
@@ -140,7 +140,7 @@
varyingHandler->emitAttributes(qp);
varyingHandler->addPassThroughAttribute(qp.inColor(), args.fOutputColor);
- GrGLSLVertToFrag uv(kVec2f_GrSLType);
+ GrGLSLVertToFrag uv(kHighFloat2_GrSLType);
varyingHandler->addVarying("uv", &uv, kHigh_GrSLPrecision);
vsBuilder->codeAppendf("%s = %s;", uv.vsOut(), qp.inUV()->fName);
@@ -156,7 +156,7 @@
GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
fsBuilder->codeAppendf("if (%s.x * %s.x >= %s.y) discard;", uv.fsIn(), uv.fsIn(),
uv.fsIn());
- fsBuilder->codeAppendf("%s = float4(1.0);", args.fOutputCoverage);
+ fsBuilder->codeAppendf("%s = half4(1.0);", args.fOutputCoverage);
}
static inline void GenKey(const GrGeometryProcessor& gp,
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index 5677bce..363c73f 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -119,21 +119,21 @@
// emit attributes
varyingHandler->emitAttributes(cgp);
- fragBuilder->codeAppend("highp float4 circleEdge;");
+ fragBuilder->codeAppend("highfloat4 circleEdge;");
varyingHandler->addPassThroughAttribute(cgp.fInCircleEdge, "circleEdge",
kHigh_GrSLPrecision);
if (cgp.fInClipPlane) {
- fragBuilder->codeAppend("float3 clipPlane;");
+ fragBuilder->codeAppend("half3 clipPlane;");
varyingHandler->addPassThroughAttribute(cgp.fInClipPlane, "clipPlane");
}
if (cgp.fInIsectPlane) {
SkASSERT(cgp.fInClipPlane);
- fragBuilder->codeAppend("float3 isectPlane;");
+ fragBuilder->codeAppend("half3 isectPlane;");
varyingHandler->addPassThroughAttribute(cgp.fInIsectPlane, "isectPlane");
}
if (cgp.fInUnionPlane) {
SkASSERT(cgp.fInClipPlane);
- fragBuilder->codeAppend("float3 unionPlane;");
+ fragBuilder->codeAppend("half3 unionPlane;");
varyingHandler->addPassThroughAttribute(cgp.fInUnionPlane, "unionPlane");
}
@@ -152,19 +152,19 @@
cgp.fLocalMatrix,
args.fFPCoordTransformHandler);
- fragBuilder->codeAppend("highp float d = length(circleEdge.xy);");
- fragBuilder->codeAppend("float distanceToOuterEdge = circleEdge.z * (1.0 - d);");
- fragBuilder->codeAppend("float edgeAlpha = clamp(distanceToOuterEdge, 0.0, 1.0);");
+ fragBuilder->codeAppend("highfloat d = length(circleEdge.xy);");
+ fragBuilder->codeAppend("half distanceToOuterEdge = circleEdge.z * (1.0 - d);");
+ fragBuilder->codeAppend("half edgeAlpha = clamp(distanceToOuterEdge, 0.0, 1.0);");
if (cgp.fStroke) {
fragBuilder->codeAppend(
- "float distanceToInnerEdge = circleEdge.z * (d - circleEdge.w);");
- fragBuilder->codeAppend("float innerAlpha = clamp(distanceToInnerEdge, 0.0, 1.0);");
+ "half distanceToInnerEdge = circleEdge.z * (d - circleEdge.w);");
+ fragBuilder->codeAppend("half innerAlpha = clamp(distanceToInnerEdge, 0.0, 1.0);");
fragBuilder->codeAppend("edgeAlpha *= innerAlpha;");
}
if (cgp.fInClipPlane) {
fragBuilder->codeAppend(
- "float clip = clamp(circleEdge.z * dot(circleEdge.xy, clipPlane.xy) + "
+ "half clip = clamp(circleEdge.z * dot(circleEdge.xy, clipPlane.xy) + "
"clipPlane.z, 0.0, 1.0);");
if (cgp.fInIsectPlane) {
fragBuilder->codeAppend(
@@ -178,7 +178,7 @@
}
fragBuilder->codeAppend("edgeAlpha *= clip;");
}
- fragBuilder->codeAppendf("%s = float4(edgeAlpha);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
}
static void GenKey(const GrGeometryProcessor& gp,
@@ -275,12 +275,12 @@
// emit attributes
varyingHandler->emitAttributes(egp);
- GrGLSLVertToFrag ellipseOffsets(kVec2f_GrSLType);
+ GrGLSLVertToFrag ellipseOffsets(kHalf2_GrSLType);
varyingHandler->addVarying("EllipseOffsets", &ellipseOffsets);
vertBuilder->codeAppendf("%s = %s;", ellipseOffsets.vsOut(),
egp.fInEllipseOffset->fName);
- GrGLSLVertToFrag ellipseRadii(kVec4f_GrSLType);
+ GrGLSLVertToFrag ellipseRadii(kHalf4_GrSLType);
varyingHandler->addVarying("EllipseRadii", &ellipseRadii);
vertBuilder->codeAppendf("%s = %s;", ellipseRadii.vsOut(), egp.fInEllipseRadii->fName);
@@ -301,16 +301,16 @@
args.fFPCoordTransformHandler);
// for outer curve
- fragBuilder->codeAppendf("float2 scaledOffset = %s*%s.xy;", ellipseOffsets.fsIn(),
+ fragBuilder->codeAppendf("half2 scaledOffset = %s*%s.xy;", ellipseOffsets.fsIn(),
ellipseRadii.fsIn());
- fragBuilder->codeAppend("float test = dot(scaledOffset, scaledOffset) - 1.0;");
- fragBuilder->codeAppendf("float2 grad = 2.0*scaledOffset*%s.xy;", ellipseRadii.fsIn());
- fragBuilder->codeAppend("float grad_dot = dot(grad, grad);");
+ fragBuilder->codeAppend("half test = dot(scaledOffset, scaledOffset) - 1.0;");
+ fragBuilder->codeAppendf("half2 grad = 2.0*scaledOffset*%s.xy;", ellipseRadii.fsIn());
+ fragBuilder->codeAppend("half grad_dot = dot(grad, grad);");
// avoid calling inversesqrt on zero.
fragBuilder->codeAppend("grad_dot = max(grad_dot, 1.0e-4);");
- fragBuilder->codeAppend("float invlen = inversesqrt(grad_dot);");
- fragBuilder->codeAppend("float edgeAlpha = clamp(0.5-test*invlen, 0.0, 1.0);");
+ fragBuilder->codeAppend("half invlen = inversesqrt(grad_dot);");
+ fragBuilder->codeAppend("half edgeAlpha = clamp(0.5-test*invlen, 0.0, 1.0);");
// for inner curve
if (egp.fStroke) {
@@ -322,7 +322,7 @@
fragBuilder->codeAppend("edgeAlpha *= clamp(0.5+test*invlen, 0.0, 1.0);");
}
- fragBuilder->codeAppendf("%s = float4(edgeAlpha);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
}
static void GenKey(const GrGeometryProcessor& gp,
@@ -417,11 +417,11 @@
// emit attributes
varyingHandler->emitAttributes(diegp);
- GrGLSLVertToFrag offsets0(kVec2f_GrSLType);
+ GrGLSLVertToFrag offsets0(kHalf2_GrSLType);
varyingHandler->addVarying("EllipseOffsets0", &offsets0);
vertBuilder->codeAppendf("%s = %s;", offsets0.vsOut(), diegp.fInEllipseOffsets0->fName);
- GrGLSLVertToFrag offsets1(kVec2f_GrSLType);
+ GrGLSLVertToFrag offsets1(kHalf2_GrSLType);
varyingHandler->addVarying("EllipseOffsets1", &offsets1);
vertBuilder->codeAppendf("%s = %s;", offsets1.vsOut(), diegp.fInEllipseOffsets1->fName);
@@ -445,25 +445,25 @@
args.fFPCoordTransformHandler);
// for outer curve
- fragBuilder->codeAppendf("float2 scaledOffset = %s.xy;", offsets0.fsIn());
- fragBuilder->codeAppend("float test = dot(scaledOffset, scaledOffset) - 1.0;");
- fragBuilder->codeAppendf("float2 duvdx = dFdx(%s);", offsets0.fsIn());
- fragBuilder->codeAppendf("float2 duvdy = dFdy(%s);", offsets0.fsIn());
+ fragBuilder->codeAppendf("half2 scaledOffset = %s.xy;", offsets0.fsIn());
+ fragBuilder->codeAppend("half test = dot(scaledOffset, scaledOffset) - 1.0;");
+ fragBuilder->codeAppendf("half2 duvdx = dFdx(%s);", offsets0.fsIn());
+ fragBuilder->codeAppendf("half2 duvdy = dFdy(%s);", offsets0.fsIn());
fragBuilder->codeAppendf(
- "float2 grad = float2(2.0*%s.x*duvdx.x + 2.0*%s.y*duvdx.y,"
- " 2.0*%s.x*duvdy.x + 2.0*%s.y*duvdy.y);",
+ "half2 grad = half2(2.0*%s.x*duvdx.x + 2.0*%s.y*duvdx.y,"
+ " 2.0*%s.x*duvdy.x + 2.0*%s.y*duvdy.y);",
offsets0.fsIn(), offsets0.fsIn(), offsets0.fsIn(), offsets0.fsIn());
- fragBuilder->codeAppend("float grad_dot = dot(grad, grad);");
+ fragBuilder->codeAppend("half grad_dot = dot(grad, grad);");
// avoid calling inversesqrt on zero.
fragBuilder->codeAppend("grad_dot = max(grad_dot, 1.0e-4);");
- fragBuilder->codeAppend("float invlen = inversesqrt(grad_dot);");
+ fragBuilder->codeAppend("half invlen = inversesqrt(grad_dot);");
if (DIEllipseStyle::kHairline == diegp.fStyle) {
// can probably do this with one step
- fragBuilder->codeAppend("float edgeAlpha = clamp(1.0-test*invlen, 0.0, 1.0);");
+ fragBuilder->codeAppend("half edgeAlpha = clamp(1.0-test*invlen, 0.0, 1.0);");
fragBuilder->codeAppend("edgeAlpha *= clamp(1.0+test*invlen, 0.0, 1.0);");
} else {
- fragBuilder->codeAppend("float edgeAlpha = clamp(0.5-test*invlen, 0.0, 1.0);");
+ fragBuilder->codeAppend("half edgeAlpha = clamp(0.5-test*invlen, 0.0, 1.0);");
}
// for inner curve
@@ -473,14 +473,14 @@
fragBuilder->codeAppendf("duvdx = dFdx(%s);", offsets1.fsIn());
fragBuilder->codeAppendf("duvdy = dFdy(%s);", offsets1.fsIn());
fragBuilder->codeAppendf(
- "grad = float2(2.0*%s.x*duvdx.x + 2.0*%s.y*duvdx.y,"
- " 2.0*%s.x*duvdy.x + 2.0*%s.y*duvdy.y);",
+ "grad = half2(2.0*%s.x*duvdx.x + 2.0*%s.y*duvdx.y,"
+ " 2.0*%s.x*duvdy.x + 2.0*%s.y*duvdy.y);",
offsets1.fsIn(), offsets1.fsIn(), offsets1.fsIn(), offsets1.fsIn());
fragBuilder->codeAppend("invlen = inversesqrt(dot(grad, grad));");
fragBuilder->codeAppend("edgeAlpha *= clamp(0.5+test*invlen, 0.0, 1.0);");
}
- fragBuilder->codeAppendf("%s = float4(edgeAlpha);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
}
static void GenKey(const GrGeometryProcessor& gp,
diff --git a/src/gpu/vk/GrVkCopyManager.cpp b/src/gpu/vk/GrVkCopyManager.cpp
index 040d742..11ee129 100644
--- a/src/gpu/vk/GrVkCopyManager.cpp
+++ b/src/gpu/vk/GrVkCopyManager.cpp
@@ -44,17 +44,17 @@
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(set = 0, binding = 0) uniform vertexUniformBuffer {"
- "mediump float4 uPosXform;"
- "mediump float4 uTexCoordXform;"
+ "half4 uPosXform;"
+ "half4 uTexCoordXform;"
"};"
- "layout(location = 0) in highp float2 inPosition;"
- "layout(location = 1) out mediump float2 vTexCoord;"
+ "layout(location = 0) in highfloat2 inPosition;"
+ "layout(location = 1) out half2 vTexCoord;"
"// Copy Program VS\n"
"void main() {"
"vTexCoord = inPosition * uTexCoordXform.xy + uTexCoordXform.zw;"
"gl_Position.xy = inPosition * uPosXform.xy + uPosXform.zw;"
- "gl_Position.zw = float2(0, 1);"
+ "gl_Position.zw = half2(0, 1);"
"}"
);
@@ -63,11 +63,9 @@
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
- "precision mediump float;"
-
- "layout(set = 1, binding = 0) uniform mediump sampler2D uTextureSampler;"
- "layout(location = 1) in mediump float2 vTexCoord;"
- "layout(location = 0, index = 0) out mediump float4 fsColorOut;"
+ "layout(set = 1, binding = 0) uniform sampler2D uTextureSampler;"
+ "layout(location = 1) in half2 vTexCoord;"
+ "layout(location = 0, index = 0) out half4 fsColorOut;"
"// Copy Program FS\n"
"void main() {"
diff --git a/src/gpu/vk/GrVkPipelineStateDataManager.cpp b/src/gpu/vk/GrVkPipelineStateDataManager.cpp
index ee0b6a7..378ec0f 100644
--- a/src/gpu/vk/GrVkPipelineStateDataManager.cpp
+++ b/src/gpu/vk/GrVkPipelineStateDataManager.cpp
@@ -59,7 +59,7 @@
void GrVkPipelineStateDataManager::set1i(UniformHandle u, int32_t i) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kInt_GrSLType);
+ SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
void* buffer = this->getBufferPtrAndMarkDirty(uni);
memcpy(buffer, &i, sizeof(int32_t));
@@ -69,7 +69,7 @@
int arrayCount,
const int32_t v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kInt_GrSLType);
+ SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
SkASSERT(arrayCount > 0);
SkASSERT(arrayCount <= uni.fArrayCount ||
(1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
@@ -85,7 +85,7 @@
void GrVkPipelineStateDataManager::set1f(UniformHandle u, float v0) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kFloat_GrSLType);
+ SkASSERT(uni.fType == kHighFloat_GrSLType || uni.fType == kHalf_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
void* buffer = this->getBufferPtrAndMarkDirty(uni);
SkASSERT(sizeof(float) == 4);
@@ -96,7 +96,7 @@
int arrayCount,
const float v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kFloat_GrSLType);
+ SkASSERT(uni.fType == kHighFloat_GrSLType || uni.fType == kHalf_GrSLType);
SkASSERT(arrayCount > 0);
SkASSERT(arrayCount <= uni.fArrayCount ||
(1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
@@ -112,7 +112,7 @@
void GrVkPipelineStateDataManager::set2f(UniformHandle u, float v0, float v1) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec2f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
void* buffer = this->getBufferPtrAndMarkDirty(uni);
SkASSERT(sizeof(float) == 4);
@@ -124,7 +124,7 @@
int arrayCount,
const float v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec2f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
SkASSERT(arrayCount > 0);
SkASSERT(arrayCount <= uni.fArrayCount ||
(1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
@@ -140,7 +140,7 @@
void GrVkPipelineStateDataManager::set3f(UniformHandle u, float v0, float v1, float v2) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec3f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
void* buffer = this->getBufferPtrAndMarkDirty(uni);
SkASSERT(sizeof(float) == 4);
@@ -152,7 +152,7 @@
int arrayCount,
const float v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec3f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
SkASSERT(arrayCount > 0);
SkASSERT(arrayCount <= uni.fArrayCount ||
(1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
@@ -172,7 +172,7 @@
float v2,
float v3) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec4f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
void* buffer = this->getBufferPtrAndMarkDirty(uni);
SkASSERT(sizeof(float) == 4);
@@ -184,7 +184,7 @@
int arrayCount,
const float v[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kVec4f_GrSLType);
+ SkASSERT(uni.fType == kHighFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
SkASSERT(arrayCount > 0);
SkASSERT(arrayCount <= uni.fArrayCount ||
(1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
@@ -230,7 +230,8 @@
int arrayCount,
const float matrices[]) const {
const Uniform& uni = fUniforms[u.toIndex()];
- SkASSERT(uni.fType == kMat22f_GrSLType + (N - 2));
+ SkASSERT(uni.fType == kHighFloat2x2_GrSLType + (N - 2) ||
+ uni.fType == kHalf2x2_GrSLType + (N - 2));
SkASSERT(arrayCount > 0);
SkASSERT(arrayCount <= uni.fArrayCount ||
(1 == arrayCount && GrShaderVar::kNonArray == uni.fArrayCount));
diff --git a/src/gpu/vk/GrVkUniformHandler.cpp b/src/gpu/vk/GrVkUniformHandler.cpp
index be746cd..6a38506 100644
--- a/src/gpu/vk/GrVkUniformHandler.cpp
+++ b/src/gpu/vk/GrVkUniformHandler.cpp
@@ -16,29 +16,38 @@
// aligned to 16 bytes (i.e. has mask of 0xF).
uint32_t grsltype_to_alignment_mask(GrSLType type) {
switch(type) {
+ case kShort_GrSLType: // fall through
case kInt_GrSLType:
return 0x3;
+ case kUShort_GrSLType: // fall through
case kUint_GrSLType:
return 0x3;
- case kFloat_GrSLType:
+ case kHalf_GrSLType: // fall through
+ case kHighFloat_GrSLType:
return 0x3;
- case kVec2f_GrSLType:
+ case kHalf2_GrSLType: // fall through
+ case kHighFloat2_GrSLType:
return 0x7;
- case kVec3f_GrSLType:
+ case kHalf3_GrSLType: // fall through
+ case kHighFloat3_GrSLType:
return 0xF;
- case kVec4f_GrSLType:
+ case kHalf4_GrSLType: // fall through
+ case kHighFloat4_GrSLType:
return 0xF;
- case kVec2i_GrSLType:
+ case kInt2_GrSLType:
return 0x7;
- case kVec3i_GrSLType:
+ case kInt3_GrSLType:
return 0xF;
- case kVec4i_GrSLType:
+ case kInt4_GrSLType:
return 0xF;
- case kMat22f_GrSLType:
+ case kHalf2x2_GrSLType: // fall through
+ case kHighFloat2x2_GrSLType:
return 0x7;
- case kMat33f_GrSLType:
+ case kHalf3x3_GrSLType: // fall through
+ case kHighFloat3x3_GrSLType:
return 0xF;
- case kMat44f_GrSLType:
+ case kHalf4x4_GrSLType: // fall through
+ case kHighFloat4x4_GrSLType:
return 0xF;
// This query is only valid for certain types.
@@ -64,30 +73,39 @@
so a float2x2 takes up 8 floats. */
static inline uint32_t grsltype_to_vk_size(GrSLType type) {
switch(type) {
+ case kShort_GrSLType: // fall through
case kInt_GrSLType:
return sizeof(int32_t);
+ case kUShort_GrSLType: // fall through
case kUint_GrSLType:
return sizeof(int32_t);
- case kFloat_GrSLType:
+ case kHalf_GrSLType: // fall through
+ case kHighFloat_GrSLType:
return sizeof(float);
- case kVec2f_GrSLType:
+ case kHalf2_GrSLType: // fall through
+ case kHighFloat2_GrSLType:
return 2 * sizeof(float);
- case kVec3f_GrSLType:
+ case kHalf3_GrSLType: // fall through
+ case kHighFloat3_GrSLType:
return 3 * sizeof(float);
- case kVec4f_GrSLType:
+ case kHalf4_GrSLType: // fall through
+ case kHighFloat4_GrSLType:
return 4 * sizeof(float);
- case kVec2i_GrSLType:
+ case kInt2_GrSLType:
return 2 * sizeof(int32_t);
- case kVec3i_GrSLType:
+ case kInt3_GrSLType:
return 3 * sizeof(int32_t);
- case kVec4i_GrSLType:
+ case kInt4_GrSLType:
return 4 * sizeof(int32_t);
- case kMat22f_GrSLType:
+ case kHalf2x2_GrSLType: // fall through
+ case kHighFloat2x2_GrSLType:
//TODO: this will be 4 * szof(float) on std430.
return 8 * sizeof(float);
- case kMat33f_GrSLType:
+ case kHalf3x3_GrSLType: // fall through
+ case kHighFloat3x3_GrSLType:
return 12 * sizeof(float);
- case kMat44f_GrSLType:
+ case kHalf4x4_GrSLType: // fall through
+ case kHighFloat4x4_GrSLType:
return 16 * sizeof(float);
// This query is only valid for certain types.
@@ -118,7 +136,7 @@
int arrayCount) {
uint32_t alignmentMask = grsltype_to_alignment_mask(type);
// We want to use the std140 layout here, so we must make arrays align to 16 bytes.
- if (arrayCount || type == kMat22f_GrSLType) {
+ if (arrayCount || type == kHighFloat2x2_GrSLType) {
alignmentMask = 0xF;
}
uint32_t offsetDiff = *currentOffset & alignmentMask;
diff --git a/src/gpu/vk/GrVkVaryingHandler.cpp b/src/gpu/vk/GrVkVaryingHandler.cpp
index 8e43b76..5232399 100644
--- a/src/gpu/vk/GrVkVaryingHandler.cpp
+++ b/src/gpu/vk/GrVkVaryingHandler.cpp
@@ -13,25 +13,32 @@
switch(type) {
case kVoid_GrSLType:
return 0;
- case kFloat_GrSLType:
+ case kHighFloat_GrSLType: // fall through
+ case kHalf_GrSLType:
return 1;
- case kVec2f_GrSLType:
+ case kHighFloat2_GrSLType: // fall through
+ case kHalf2_GrSLType:
return 1;
- case kVec3f_GrSLType:
+ case kHighFloat3_GrSLType:
+ case kHalf3_GrSLType:
return 1;
- case kVec4f_GrSLType:
+ case kHighFloat4_GrSLType:
+ case kHalf4_GrSLType:
return 1;
- case kVec2i_GrSLType:
+ case kInt2_GrSLType:
return 1;
- case kVec3i_GrSLType:
+ case kInt3_GrSLType:
return 1;
- case kVec4i_GrSLType:
+ case kInt4_GrSLType:
return 1;
- case kMat22f_GrSLType:
+ case kHighFloat2x2_GrSLType:
+ case kHalf2x2_GrSLType:
return 2;
- case kMat33f_GrSLType:
+ case kHighFloat3x3_GrSLType:
+ case kHalf3x3_GrSLType:
return 3;
- case kMat44f_GrSLType:
+ case kHighFloat4x4_GrSLType:
+ case kHalf4x4_GrSLType:
return 4;
case kTexture2DSampler_GrSLType:
return 0;
@@ -45,9 +52,11 @@
return 0;
case kBool_GrSLType:
return 1;
- case kInt_GrSLType:
+ case kInt_GrSLType: // fall through
+ case kShort_GrSLType:
return 1;
case kUint_GrSLType:
+ case kUShort_GrSLType: // fall through
return 1;
case kTexture2D_GrSLType:
return 0;
diff --git a/src/shaders/SkPerlinNoiseShader.cpp b/src/shaders/SkPerlinNoiseShader.cpp
index cc9a569..9ef4169 100644
--- a/src/shaders/SkPerlinNoiseShader.cpp
+++ b/src/shaders/SkPerlinNoiseShader.cpp
@@ -816,15 +816,13 @@
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
SkString vCoords = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
- fBaseFrequencyUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fBaseFrequencyUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"baseFrequency");
const char* baseFrequencyUni = uniformHandler->getUniformCStr(fBaseFrequencyUni);
const char* stitchDataUni = nullptr;
if (pne.stitchTiles()) {
- fStitchDataUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fStitchDataUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"stitchData");
stitchDataUni = uniformHandler->getUniformCStr(fStitchDataUni);
}
@@ -849,29 +847,29 @@
const char* inc8bit = "0.00390625"; // 1.0 / 256.0
// This is the math to convert the two 16bit integer packed into rgba 8 bit input into a
// [-1,1] vector and perform a dot product between that vector and the provided vector.
- const char* dotLattice = "dot(((%s.ga + %s.rb * float2(%s)) * float2(2.0) - float2(1.0)), %s);";
+ const char* dotLattice = "dot(((%s.ga + %s.rb * half2(%s)) * half2(2.0) - half2(1.0)), %s);";
// Add noise function
static const GrShaderVar gPerlinNoiseArgs[] = {
- GrShaderVar(chanCoord, kFloat_GrSLType),
- GrShaderVar(noiseVec, kVec2f_GrSLType)
+ GrShaderVar(chanCoord, kHalf_GrSLType),
+ GrShaderVar(noiseVec, kHalf2_GrSLType)
};
static const GrShaderVar gPerlinNoiseStitchArgs[] = {
- GrShaderVar(chanCoord, kFloat_GrSLType),
- GrShaderVar(noiseVec, kVec2f_GrSLType),
- GrShaderVar(stitchData, kVec2f_GrSLType)
+ GrShaderVar(chanCoord, kHalf_GrSLType),
+ GrShaderVar(noiseVec, kHalf2_GrSLType),
+ GrShaderVar(stitchData, kHalf2_GrSLType)
};
SkString noiseCode;
- noiseCode.appendf("\tfloat4 %s;\n", floorVal);
+ noiseCode.appendf("\thalf4 %s;\n", floorVal);
noiseCode.appendf("\t%s.xy = floor(%s);\n", floorVal, noiseVec);
- noiseCode.appendf("\t%s.zw = %s.xy + float2(1.0);\n", floorVal, floorVal);
- noiseCode.appendf("\tfloat2 %s = fract(%s);\n", fractVal, noiseVec);
+ noiseCode.appendf("\t%s.zw = %s.xy + half2(1.0);\n", floorVal, floorVal);
+ noiseCode.appendf("\thalf2 %s = fract(%s);\n", fractVal, noiseVec);
// smooth curve : t * t * (3 - 2 * t)
- noiseCode.appendf("\n\tfloat2 %s = %s * %s * (float2(3.0) - float2(2.0) * %s);",
+ noiseCode.appendf("\n\thalf2 %s = %s * %s * (half2(3.0) - half2(2.0) * %s);",
noiseSmooth, fractVal, fractVal, fractVal);
// Adjust frequencies if we're stitching tiles
@@ -887,28 +885,28 @@
}
// Get texture coordinates and normalize
- noiseCode.appendf("\n\t%s = fract(floor(mod(%s, 256.0)) / float4(256.0));\n",
+ noiseCode.appendf("\n\t%s = fract(floor(mod(%s, 256.0)) / half4(256.0));\n",
floorVal, floorVal);
// Get permutation for x
{
SkString xCoords("");
- xCoords.appendf("float2(%s.x, 0.5)", floorVal);
+ xCoords.appendf("half2(%s.x, 0.5)", floorVal);
- noiseCode.appendf("\n\tfloat2 %s;\n\t%s.x = ", latticeIdx, latticeIdx);
+ noiseCode.appendf("\n\thalf2 %s;\n\t%s.x = ", latticeIdx, latticeIdx);
fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[0], xCoords.c_str(),
- kVec2f_GrSLType);
+ kHalf2_GrSLType);
noiseCode.append(".r;");
}
// Get permutation for x + 1
{
SkString xCoords("");
- xCoords.appendf("float2(%s.z, 0.5)", floorVal);
+ xCoords.appendf("half2(%s.z, 0.5)", floorVal);
noiseCode.appendf("\n\t%s.y = ", latticeIdx);
fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[0], xCoords.c_str(),
- kVec2f_GrSLType);
+ kHalf2_GrSLType);
noiseCode.append(".r;");
}
@@ -919,21 +917,21 @@
// (or 0.484368 here). The following rounding operation prevents these precision issues from
// affecting the result of the noise by making sure that we only have multiples of 1/255.
// (Note that 1/255 is about 0.003921569, which is the value used here).
- noiseCode.appendf("\n\t%s = floor(%s * float2(255.0) + float2(0.5)) * float2(0.003921569);",
+ noiseCode.appendf("\n\t%s = floor(%s * half2(255.0) + half2(0.5)) * half2(0.003921569);",
latticeIdx, latticeIdx);
#endif
// Get (x,y) coordinates with the permutated x
- noiseCode.appendf("\n\tfloat4 %s = fract(%s.xyxy + %s.yyww);", bcoords, latticeIdx, floorVal);
+ noiseCode.appendf("\n\thalf4 %s = fract(%s.xyxy + %s.yyww);", bcoords, latticeIdx, floorVal);
- noiseCode.appendf("\n\n\tfloat2 %s;", uv);
+ noiseCode.appendf("\n\n\thalf2 %s;", uv);
// Compute u, at offset (0,0)
{
SkString latticeCoords("");
- latticeCoords.appendf("float2(%s.x, %s)", bcoords, chanCoord);
- noiseCode.appendf("\n\tfloat4 %s = ", lattice);
+ latticeCoords.appendf("half2(%s.x, %s)", bcoords, chanCoord);
+ noiseCode.appendf("\n\thalf4 %s = ", lattice);
fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[1], latticeCoords.c_str(),
- kVec2f_GrSLType);
+ kHalf2_GrSLType);
noiseCode.appendf(".bgra;\n\t%s.x = ", uv);
noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
}
@@ -942,26 +940,26 @@
// Compute v, at offset (-1,0)
{
SkString latticeCoords("");
- latticeCoords.appendf("float2(%s.y, %s)", bcoords, chanCoord);
+ latticeCoords.appendf("half2(%s.y, %s)", bcoords, chanCoord);
noiseCode.append("\n\tlattice = ");
fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[1], latticeCoords.c_str(),
- kVec2f_GrSLType);
+ kHalf2_GrSLType);
noiseCode.appendf(".bgra;\n\t%s.y = ", uv);
noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
}
// Compute 'a' as a linear interpolation of 'u' and 'v'
- noiseCode.appendf("\n\tfloat2 %s;", ab);
+ noiseCode.appendf("\n\thalf2 %s;", ab);
noiseCode.appendf("\n\t%s.x = mix(%s.x, %s.y, %s.x);", ab, uv, uv, noiseSmooth);
noiseCode.appendf("\n\t%s.y -= 1.0;", fractVal);
// Compute v, at offset (-1,-1)
{
SkString latticeCoords("");
- latticeCoords.appendf("float2(%s.w, %s)", bcoords, chanCoord);
+ latticeCoords.appendf("half2(%s.w, %s)", bcoords, chanCoord);
noiseCode.append("\n\tlattice = ");
fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[1], latticeCoords.c_str(),
- kVec2f_GrSLType);
+ kHalf2_GrSLType);
noiseCode.appendf(".bgra;\n\t%s.y = ", uv);
noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
}
@@ -970,10 +968,10 @@
// Compute u, at offset (0,-1)
{
SkString latticeCoords("");
- latticeCoords.appendf("float2(%s.z, %s)", bcoords, chanCoord);
+ latticeCoords.appendf("half2(%s.z, %s)", bcoords, chanCoord);
noiseCode.append("\n\tlattice = ");
fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[1], latticeCoords.c_str(),
- kVec2f_GrSLType);
+ kHalf2_GrSLType);
noiseCode.appendf(".bgra;\n\t%s.x = ", uv);
noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
}
@@ -985,28 +983,28 @@
SkString noiseFuncName;
if (pne.stitchTiles()) {
- fragBuilder->emitFunction(kFloat_GrSLType,
+ fragBuilder->emitFunction(kHalf_GrSLType,
"perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseStitchArgs),
gPerlinNoiseStitchArgs, noiseCode.c_str(), &noiseFuncName);
} else {
- fragBuilder->emitFunction(kFloat_GrSLType,
+ fragBuilder->emitFunction(kHalf_GrSLType,
"perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseArgs),
gPerlinNoiseArgs, noiseCode.c_str(), &noiseFuncName);
}
// There are rounding errors if the floor operation is not performed here
- fragBuilder->codeAppendf("\n\t\tfloat2 %s = floor(%s.xy) * %s;",
+ fragBuilder->codeAppendf("\n\t\thalf2 %s = floor(%s.xy) * %s;",
noiseVec, vCoords.c_str(), baseFrequencyUni);
// Clear the color accumulator
- fragBuilder->codeAppendf("\n\t\t%s = float4(0.0);", args.fOutputColor);
+ fragBuilder->codeAppendf("\n\t\t%s = half4(0.0);", args.fOutputColor);
if (pne.stitchTiles()) {
// Set up TurbulenceInitial stitch values.
- fragBuilder->codeAppendf("\n\t\tfloat2 %s = %s;", stitchData, stitchDataUni);
+ fragBuilder->codeAppendf("\n\t\thalf2 %s = %s;", stitchData, stitchDataUni);
}
- fragBuilder->codeAppendf("\n\t\tfloat %s = 1.0;", ratio);
+ fragBuilder->codeAppendf("\n\t\thalf %s = 1.0;", ratio);
// Loop over all octaves
fragBuilder->codeAppendf("for (int octave = 0; octave < %d; ++octave) {", pne.numOctaves());
@@ -1017,7 +1015,7 @@
}
if (pne.stitchTiles()) {
fragBuilder->codeAppendf(
- "float4(\n\t\t\t\t%s(%s, %s, %s),\n\t\t\t\t%s(%s, %s, %s),"
+ "half4(\n\t\t\t\t%s(%s, %s, %s),\n\t\t\t\t%s(%s, %s, %s),"
"\n\t\t\t\t%s(%s, %s, %s),\n\t\t\t\t%s(%s, %s, %s))",
noiseFuncName.c_str(), chanCoordR, noiseVec, stitchData,
noiseFuncName.c_str(), chanCoordG, noiseVec, stitchData,
@@ -1025,7 +1023,7 @@
noiseFuncName.c_str(), chanCoordA, noiseVec, stitchData);
} else {
fragBuilder->codeAppendf(
- "float4(\n\t\t\t\t%s(%s, %s),\n\t\t\t\t%s(%s, %s),"
+ "half4(\n\t\t\t\t%s(%s, %s),\n\t\t\t\t%s(%s, %s),"
"\n\t\t\t\t%s(%s, %s),\n\t\t\t\t%s(%s, %s))",
noiseFuncName.c_str(), chanCoordR, noiseVec,
noiseFuncName.c_str(), chanCoordG, noiseVec,
@@ -1037,18 +1035,18 @@
}
fragBuilder->codeAppendf(" * %s;", ratio);
- fragBuilder->codeAppendf("\n\t\t\t%s *= float2(2.0);", noiseVec);
+ fragBuilder->codeAppendf("\n\t\t\t%s *= half2(2.0);", noiseVec);
fragBuilder->codeAppendf("\n\t\t\t%s *= 0.5;", ratio);
if (pne.stitchTiles()) {
- fragBuilder->codeAppendf("\n\t\t\t%s *= float2(2.0);", stitchData);
+ fragBuilder->codeAppendf("\n\t\t\t%s *= half2(2.0);", stitchData);
}
fragBuilder->codeAppend("\n\t\t}"); // end of the for loop on octaves
if (pne.type() == SkPerlinNoiseShaderImpl::kFractalNoise_Type) {
// The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult) + 1) / 2
// by fractalNoise and (turbulenceFunctionResult) by turbulence.
- fragBuilder->codeAppendf("\n\t\t%s = %s * float4(0.5) + float4(0.5);",
+ fragBuilder->codeAppendf("\n\t\t%s = %s * half4(0.5) + half4(0.5);",
args.fOutputColor,args.fOutputColor);
}
@@ -1056,7 +1054,7 @@
fragBuilder->codeAppendf("\n\t\t%s = clamp(%s, 0.0, 1.0);", args.fOutputColor, args.fOutputColor);
// Pre-multiply the result
- fragBuilder->codeAppendf("\n\t\t%s = float4(%s.rgb * %s.aaa, %s.a);\n",
+ fragBuilder->codeAppendf("\n\t\t%s = half4(%s.rgb * %s.aaa, %s.a);\n",
args.fOutputColor, args.fOutputColor,
args.fOutputColor, args.fOutputColor);
}
@@ -1235,133 +1233,130 @@
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
SkString vCoords = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
- fBaseFrequencyUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fBaseFrequencyUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"baseFrequency");
const char* baseFrequencyUni = uniformHandler->getUniformCStr(fBaseFrequencyUni);
- fZUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
- "z");
+ fZUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "z");
const char* zUni = uniformHandler->getUniformCStr(fZUni);
// fade function
static const GrShaderVar fadeArgs[] = {
- GrShaderVar("t", kVec3f_GrSLType)
+ GrShaderVar("t", kHalf3_GrSLType)
};
SkString fadeFuncName;
- fragBuilder->emitFunction(kVec3f_GrSLType, "fade", SK_ARRAY_COUNT(fadeArgs),
+ fragBuilder->emitFunction(kHalf3_GrSLType, "fade", SK_ARRAY_COUNT(fadeArgs),
fadeArgs,
"return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);",
&fadeFuncName);
// perm function
static const GrShaderVar permArgs[] = {
- GrShaderVar("x", kFloat_GrSLType)
+ GrShaderVar("x", kHalf_GrSLType)
};
SkString permFuncName;
SkString permCode("return ");
// FIXME even though I'm creating these textures with kRepeat_TileMode, they're clamped. Not
// sure why. Using fract() (here and the next texture lookup) as a workaround.
- fragBuilder->appendTextureLookup(&permCode, args.fTexSamplers[0], "float2(fract(x / 256.0), 0.0)",
- kVec2f_GrSLType);
+ fragBuilder->appendTextureLookup(&permCode, args.fTexSamplers[0], "highfloat2(fract(x / 256.0), 0.0)",
+ kHalf2_GrSLType);
permCode.append(".r * 255.0;");
- fragBuilder->emitFunction(kFloat_GrSLType, "perm", SK_ARRAY_COUNT(permArgs), permArgs,
+ fragBuilder->emitFunction(kHalf_GrSLType, "perm", SK_ARRAY_COUNT(permArgs), permArgs,
permCode.c_str(), &permFuncName);
// grad function
static const GrShaderVar gradArgs[] = {
- GrShaderVar("x", kFloat_GrSLType),
- GrShaderVar("p", kVec3f_GrSLType)
+ GrShaderVar("x", kHalf_GrSLType),
+ GrShaderVar("p", kHalf3_GrSLType)
};
SkString gradFuncName;
SkString gradCode("return dot(");
- fragBuilder->appendTextureLookup(&gradCode, args.fTexSamplers[1], "float2(fract(x / 16.0), 0.0)",
- kVec2f_GrSLType);
- gradCode.append(".rgb * 255.0 - float3(1.0), p);");
- fragBuilder->emitFunction(kFloat_GrSLType, "grad", SK_ARRAY_COUNT(gradArgs), gradArgs,
+ fragBuilder->appendTextureLookup(&gradCode, args.fTexSamplers[1], "highfloat2(fract(x / 16.0), 0.0)",
+ kHalf2_GrSLType);
+ gradCode.append(".rgb * 255.0 - highfloat3(1.0), p);");
+ fragBuilder->emitFunction(kHalf_GrSLType, "grad", SK_ARRAY_COUNT(gradArgs), gradArgs,
gradCode.c_str(), &gradFuncName);
// lerp function
static const GrShaderVar lerpArgs[] = {
- GrShaderVar("a", kFloat_GrSLType),
- GrShaderVar("b", kFloat_GrSLType),
- GrShaderVar("w", kFloat_GrSLType)
+ GrShaderVar("a", kHalf_GrSLType),
+ GrShaderVar("b", kHalf_GrSLType),
+ GrShaderVar("w", kHalf_GrSLType)
};
SkString lerpFuncName;
- fragBuilder->emitFunction(kFloat_GrSLType, "lerp", SK_ARRAY_COUNT(lerpArgs), lerpArgs,
+ fragBuilder->emitFunction(kHalf_GrSLType, "lerp", SK_ARRAY_COUNT(lerpArgs), lerpArgs,
"return a + w * (b - a);", &lerpFuncName);
// noise function
static const GrShaderVar noiseArgs[] = {
- GrShaderVar("p", kVec3f_GrSLType),
+ GrShaderVar("p", kHalf3_GrSLType),
};
SkString noiseFuncName;
SkString noiseCode;
- noiseCode.append("float3 P = mod(floor(p), 256.0);");
+ noiseCode.append("half3 P = mod(floor(p), 256.0);");
noiseCode.append("p -= floor(p);");
- noiseCode.appendf("float3 f = %s(p);", fadeFuncName.c_str());
- noiseCode.appendf("float A = %s(P.x) + P.y;", permFuncName.c_str());
- noiseCode.appendf("float AA = %s(A) + P.z;", permFuncName.c_str());
- noiseCode.appendf("float AB = %s(A + 1.0) + P.z;", permFuncName.c_str());
- noiseCode.appendf("float B = %s(P.x + 1.0) + P.y;", permFuncName.c_str());
- noiseCode.appendf("float BA = %s(B) + P.z;", permFuncName.c_str());
- noiseCode.appendf("float BB = %s(B + 1.0) + P.z;", permFuncName.c_str());
- noiseCode.appendf("float result = %s(", lerpFuncName.c_str());
+ noiseCode.appendf("half3 f = %s(p);", fadeFuncName.c_str());
+ noiseCode.appendf("half A = %s(P.x) + P.y;", permFuncName.c_str());
+ noiseCode.appendf("half AA = %s(A) + P.z;", permFuncName.c_str());
+ noiseCode.appendf("half AB = %s(A + 1.0) + P.z;", permFuncName.c_str());
+ noiseCode.appendf("half B = %s(P.x + 1.0) + P.y;", permFuncName.c_str());
+ noiseCode.appendf("half BA = %s(B) + P.z;", permFuncName.c_str());
+ noiseCode.appendf("half BB = %s(B + 1.0) + P.z;", permFuncName.c_str());
+ noiseCode.appendf("half result = %s(", lerpFuncName.c_str());
noiseCode.appendf("%s(%s(%s(%s(AA), p),", lerpFuncName.c_str(), lerpFuncName.c_str(),
gradFuncName.c_str(), permFuncName.c_str());
- noiseCode.appendf("%s(%s(BA), p + float3(-1.0, 0.0, 0.0)), f.x),", gradFuncName.c_str(),
+ noiseCode.appendf("%s(%s(BA), p + half3(-1.0, 0.0, 0.0)), f.x),", gradFuncName.c_str(),
permFuncName.c_str());
- noiseCode.appendf("%s(%s(%s(AB), p + float3(0.0, -1.0, 0.0)),", lerpFuncName.c_str(),
+ noiseCode.appendf("%s(%s(%s(AB), p + half3(0.0, -1.0, 0.0)),", lerpFuncName.c_str(),
gradFuncName.c_str(), permFuncName.c_str());
- noiseCode.appendf("%s(%s(BB), p + float3(-1.0, -1.0, 0.0)), f.x), f.y),",
+ noiseCode.appendf("%s(%s(BB), p + half3(-1.0, -1.0, 0.0)), f.x), f.y),",
gradFuncName.c_str(), permFuncName.c_str());
- noiseCode.appendf("%s(%s(%s(%s(AA + 1.0), p + float3(0.0, 0.0, -1.0)),",
+ noiseCode.appendf("%s(%s(%s(%s(AA + 1.0), p + half3(0.0, 0.0, -1.0)),",
lerpFuncName.c_str(), lerpFuncName.c_str(), gradFuncName.c_str(),
permFuncName.c_str());
- noiseCode.appendf("%s(%s(BA + 1.0), p + float3(-1.0, 0.0, -1.0)), f.x),",
+ noiseCode.appendf("%s(%s(BA + 1.0), p + half3(-1.0, 0.0, -1.0)), f.x),",
gradFuncName.c_str(), permFuncName.c_str());
- noiseCode.appendf("%s(%s(%s(AB + 1.0), p + float3(0.0, -1.0, -1.0)),",
+ noiseCode.appendf("%s(%s(%s(AB + 1.0), p + half3(0.0, -1.0, -1.0)),",
lerpFuncName.c_str(), gradFuncName.c_str(), permFuncName.c_str());
- noiseCode.appendf("%s(%s(BB + 1.0), p + float3(-1.0, -1.0, -1.0)), f.x), f.y), f.z);",
+ noiseCode.appendf("%s(%s(BB + 1.0), p + half3(-1.0, -1.0, -1.0)), f.x), f.y), f.z);",
gradFuncName.c_str(), permFuncName.c_str());
noiseCode.append("return result;");
- fragBuilder->emitFunction(kFloat_GrSLType, "noise", SK_ARRAY_COUNT(noiseArgs), noiseArgs,
+ fragBuilder->emitFunction(kHalf_GrSLType, "noise", SK_ARRAY_COUNT(noiseArgs), noiseArgs,
noiseCode.c_str(), &noiseFuncName);
// noiseOctaves function
static const GrShaderVar noiseOctavesArgs[] = {
- GrShaderVar("p", kVec3f_GrSLType)
+ GrShaderVar("p", kHalf3_GrSLType)
};
SkString noiseOctavesFuncName;
SkString noiseOctavesCode;
- noiseOctavesCode.append("float result = 0.0;");
- noiseOctavesCode.append("float ratio = 1.0;");
- noiseOctavesCode.appendf("for (float i = 0.0; i < %d; i++) {", pne.octaves());
+ noiseOctavesCode.append("half result = 0.0;");
+ noiseOctavesCode.append("half ratio = 1.0;");
+ noiseOctavesCode.appendf("for (half i = 0.0; i < %d; i++) {", pne.octaves());
noiseOctavesCode.appendf("result += %s(p) / ratio;", noiseFuncName.c_str());
noiseOctavesCode.append("p *= 2.0;");
noiseOctavesCode.append("ratio *= 2.0;");
noiseOctavesCode.append("}");
noiseOctavesCode.append("return (result + 1.0) / 2.0;");
- fragBuilder->emitFunction(kFloat_GrSLType, "noiseOctaves", SK_ARRAY_COUNT(noiseOctavesArgs),
+ fragBuilder->emitFunction(kHalf_GrSLType, "noiseOctaves", SK_ARRAY_COUNT(noiseOctavesArgs),
noiseOctavesArgs, noiseOctavesCode.c_str(), &noiseOctavesFuncName);
- fragBuilder->codeAppendf("float2 coords = %s * %s;", vCoords.c_str(), baseFrequencyUni);
- fragBuilder->codeAppendf("float r = %s(float3(coords, %s));", noiseOctavesFuncName.c_str(),
+ fragBuilder->codeAppendf("half2 coords = %s * %s;", vCoords.c_str(), baseFrequencyUni);
+ fragBuilder->codeAppendf("half r = %s(half3(coords, %s));", noiseOctavesFuncName.c_str(),
zUni);
- fragBuilder->codeAppendf("float g = %s(float3(coords, %s + 0000.0));",
+ fragBuilder->codeAppendf("half g = %s(half3(coords, %s + 0000.0));",
noiseOctavesFuncName.c_str(), zUni);
- fragBuilder->codeAppendf("float b = %s(float3(coords, %s + 0000.0));",
+ fragBuilder->codeAppendf("half b = %s(half3(coords, %s + 0000.0));",
noiseOctavesFuncName.c_str(), zUni);
- fragBuilder->codeAppendf("float a = %s(float3(coords, %s + 0000.0));",
+ fragBuilder->codeAppendf("half a = %s(half3(coords, %s + 0000.0));",
noiseOctavesFuncName.c_str(), zUni);
- fragBuilder->codeAppendf("%s = float4(r, g, b, a);", args.fOutputColor);
+ fragBuilder->codeAppendf("%s = half4(r, g, b, a);", args.fOutputColor);
// Clamp values
fragBuilder->codeAppendf("%s = clamp(%s, 0.0, 1.0);", args.fOutputColor, args.fOutputColor);
// Pre-multiply the result
- fragBuilder->codeAppendf("\n\t\t%s = float4(%s.rgb * %s.aaa, %s.a);\n",
+ fragBuilder->codeAppendf("\n\t\t%s = half4(%s.rgb * %s.aaa, %s.a);\n",
args.fOutputColor, args.fOutputColor,
args.fOutputColor, args.fOutputColor);
}
diff --git a/src/shaders/gradients/SkGradientShader.cpp b/src/shaders/gradients/SkGradientShader.cpp
index 1b24ef9..ea3affb 100644
--- a/src/shaders/gradients/SkGradientShader.cpp
+++ b/src/shaders/gradients/SkGradientShader.cpp
@@ -1361,17 +1361,15 @@
const GrGradientEffect& ge) {
if (int colorCount = color_type_to_color_count(ge.getColorType())) {
fColorsUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag,
- kVec4f_GrSLType,
- kDefault_GrSLPrecision,
+ kHalf4_GrSLType,
"Colors",
colorCount);
if (ge.fColorType == kSingleHardStop_ColorType) {
- fHardStopT = uniformHandler->addUniform(kFragment_GrShaderFlag, kFloat_GrSLType,
- kDefault_GrSLPrecision, "HardStopT");
+ fHardStopT = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
+ "HardStopT");
}
} else {
- fFSYUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ fFSYUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
"GradientYCoordFS");
}
}
@@ -1554,14 +1552,14 @@
// First, apply tiling rules.
switch (ge.fTileMode) {
case SkShader::kClamp_TileMode:
- fragBuilder->codeAppendf("float clamp_t = clamp(%s, 0.0, 1.0);", t);
+ fragBuilder->codeAppendf("half clamp_t = clamp(%s, 0.0, 1.0);", t);
break;
case SkShader::kRepeat_TileMode:
- fragBuilder->codeAppendf("float clamp_t = fract(%s);", t);
+ fragBuilder->codeAppendf("half clamp_t = fract(%s);", t);
break;
case SkShader::kMirror_TileMode:
- fragBuilder->codeAppendf("float t_1 = %s - 1.0;", t);
- fragBuilder->codeAppendf("float clamp_t = abs(t_1 - 2.0 * floor(t_1 * 0.5) - 1.0);");
+ fragBuilder->codeAppendf("half t_1 = %s - 1.0;", t);
+ fragBuilder->codeAppendf("half clamp_t = abs(t_1 - 2.0 * floor(t_1 * 0.5) - 1.0);");
break;
}
@@ -1571,8 +1569,8 @@
case kSingleHardStop_ColorType: {
const char* stopT = uniformHandler->getUniformCStr(fHardStopT);
- fragBuilder->codeAppend ("float4 start, end;");
- fragBuilder->codeAppend ("float relative_t;");
+ fragBuilder->codeAppend ("half4 start, end;");
+ fragBuilder->codeAppend ("half relative_t;");
fragBuilder->codeAppendf("if (clamp_t < %s) {", stopT);
fragBuilder->codeAppendf(" start = %s[0];", colors);
fragBuilder->codeAppendf(" end = %s[1];", colors);
@@ -1582,13 +1580,13 @@
fragBuilder->codeAppendf(" end = %s[3];", colors);
fragBuilder->codeAppendf(" relative_t = (clamp_t - %s) / (1 - %s);", stopT, stopT);
fragBuilder->codeAppend ("}");
- fragBuilder->codeAppend ("float4 colorTemp = mix(start, end, relative_t);");
+ fragBuilder->codeAppend ("half4 colorTemp = mix(start, end, relative_t);");
break;
}
case kHardStopLeftEdged_ColorType: {
- fragBuilder->codeAppendf("float4 colorTemp = mix(%s[1], %s[2], clamp_t);", colors,
+ fragBuilder->codeAppendf("half4 colorTemp = mix(%s[1], %s[2], clamp_t);", colors,
colors);
if (SkShader::kClamp_TileMode == ge.fTileMode) {
fragBuilder->codeAppendf("if (%s < 0.0) {", t);
@@ -1600,7 +1598,7 @@
}
case kHardStopRightEdged_ColorType: {
- fragBuilder->codeAppendf("float4 colorTemp = mix(%s[0], %s[1], clamp_t);", colors,
+ fragBuilder->codeAppendf("half4 colorTemp = mix(%s[0], %s[1], clamp_t);", colors,
colors);
if (SkShader::kClamp_TileMode == ge.fTileMode) {
fragBuilder->codeAppendf("if (%s > 1.0) {", t);
@@ -1612,15 +1610,15 @@
}
case kTwo_ColorType: {
- fragBuilder->codeAppendf("float4 colorTemp = mix(%s[0], %s[1], clamp_t);",
+ fragBuilder->codeAppendf("half4 colorTemp = mix(%s[0], %s[1], clamp_t);",
colors, colors);
break;
}
case kThree_ColorType: {
- fragBuilder->codeAppendf("float oneMinus2t = 1.0 - (2.0 * clamp_t);");
- fragBuilder->codeAppendf("float4 colorTemp = clamp(oneMinus2t, 0.0, 1.0) * %s[0];",
+ fragBuilder->codeAppendf("half oneMinus2t = 1.0 - (2.0 * clamp_t);");
+ fragBuilder->codeAppendf("half4 colorTemp = clamp(oneMinus2t, 0.0, 1.0) * %s[0];",
colors);
fragBuilder->codeAppendf("colorTemp += (1.0 - min(abs(oneMinus2t), 1.0)) * %s[1];",
colors);
@@ -1668,10 +1666,10 @@
const char* fsyuni = uniformHandler->getUniformCStr(fFSYUni);
- fragBuilder->codeAppendf("float2 coord = float2(%s, %s);", gradientTValue, fsyuni);
+ fragBuilder->codeAppendf("half2 coord = half2(%s, %s);", gradientTValue, fsyuni);
fragBuilder->codeAppendf("%s = ", outputColor);
fragBuilder->appendTextureLookupAndModulate(inputColor, texSamplers[0], "coord",
- kVec2f_GrSLType, &fColorSpaceHelper);
+ kHighFloat2_GrSLType, &fColorSpaceHelper);
fragBuilder->codeAppend(";");
}
diff --git a/src/shaders/gradients/SkSweepGradient.cpp b/src/shaders/gradients/SkSweepGradient.cpp
index 87b82fd..0e2b785a 100644
--- a/src/shaders/gradients/SkSweepGradient.cpp
+++ b/src/shaders/gradients/SkSweepGradient.cpp
@@ -198,8 +198,8 @@
const GrSweepGradient& ge = args.fFp.cast<GrSweepGradient>();
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
this->emitUniforms(uniformHandler, ge);
- fTBiasScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kVec2f_GrSLType,
- kDefault_GrSLPrecision, "SweepFSParams");
+ fTBiasScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
+ "SweepFSParams");
const char* tBiasScaleV = uniformHandler->getUniformCStr(fTBiasScaleUni);
const SkString coords2D = args.fFragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
diff --git a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp
index caada92..126a82a 100644
--- a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp
+++ b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp
@@ -235,8 +235,7 @@
const Edge2PtConicalEffect& ge = args.fFp.cast<Edge2PtConicalEffect>();
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
this->emitUniforms(uniformHandler, ge);
- fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec3f_GrSLType, kDefault_GrSLPrecision,
+ fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
"Conical2FSParams");
SkString cName("c");
@@ -255,8 +254,8 @@
const char* coords2D;
SkString bVar;
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
- if (kVec3f_GrSLType == args.fTransformedCoords[0].getType()) {
- fragBuilder->codeAppendf("\tfloat3 interpolants = float3(%s.xy / %s.z, %s.x / %s.z);\n",
+ if (kHalf3_GrSLType == args.fTransformedCoords[0].getType()) {
+ fragBuilder->codeAppendf("\thalf3 interpolants = half3(%s.xy / %s.z, %s.x / %s.z);\n",
args.fTransformedCoords[0].c_str(),
args.fTransformedCoords[0].c_str(),
args.fTransformedCoords[1].c_str(),
@@ -270,14 +269,14 @@
// output will default to transparent black (we simply won't write anything
// else to it if invalid, instead of discarding or returning prematurely)
- fragBuilder->codeAppendf("\t%s = float4(0.0,0.0,0.0,0.0);\n", args.fOutputColor);
+ fragBuilder->codeAppendf("\t%s = half4(0.0,0.0,0.0,0.0);\n", args.fOutputColor);
// c = (x^2)+(y^2) - params[1]
- fragBuilder->codeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
+ fragBuilder->codeAppendf("\thalf %s = dot(%s, %s) - %s;\n",
cName.c_str(), coords2D, coords2D, p1.c_str());
// linear case: t = -c/b
- fragBuilder->codeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(),
+ fragBuilder->codeAppendf("\thalf %s = -(%s / %s);\n", tName.c_str(),
cName.c_str(), bVar.c_str());
// if r(t) > 0, then t will be the x coordinate
@@ -525,8 +524,7 @@
const FocalOutside2PtConicalEffect& ge = args.fFp.cast<FocalOutside2PtConicalEffect>();
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
this->emitUniforms(uniformHandler, ge);
- fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"Conical2FSParams");
SkString tName("t");
SkString p0; // focalX
@@ -544,19 +542,19 @@
// output will default to transparent black (we simply won't write anything
// else to it if invalid, instead of discarding or returning prematurely)
- fragBuilder->codeAppendf("\t%s = float4(0.0,0.0,0.0,0.0);\n", args.fOutputColor);
+ fragBuilder->codeAppendf("\t%s = half4(0.0,0.0,0.0,0.0);\n", args.fOutputColor);
- fragBuilder->codeAppendf("\tfloat xs = %s.x * %s.x;\n", coords2D, coords2D);
- fragBuilder->codeAppendf("\tfloat ys = %s.y * %s.y;\n", coords2D, coords2D);
- fragBuilder->codeAppendf("\tfloat d = xs + %s * ys;\n", p1.c_str());
+ fragBuilder->codeAppendf("\thalf xs = %s.x * %s.x;\n", coords2D, coords2D);
+ fragBuilder->codeAppendf("\thalf ys = %s.y * %s.y;\n", coords2D, coords2D);
+ fragBuilder->codeAppendf("\thalf d = xs + %s * ys;\n", p1.c_str());
// Must check to see if we flipped the circle order (to make sure start radius < end radius)
// If so we must also flip sign on sqrt
if (!fIsFlipped) {
- fragBuilder->codeAppendf("\tfloat %s = %s.x * %s + sqrt(d);\n", tName.c_str(),
+ fragBuilder->codeAppendf("\thalf %s = %s.x * %s + sqrt(d);\n", tName.c_str(),
coords2D, p0.c_str());
} else {
- fragBuilder->codeAppendf("\tfloat %s = %s.x * %s - sqrt(d);\n", tName.c_str(),
+ fragBuilder->codeAppendf("\thalf %s = %s.x * %s - sqrt(d);\n", tName.c_str(),
coords2D, p0.c_str());
}
@@ -734,8 +732,7 @@
const FocalInside2PtConicalEffect& ge = args.fFp.cast<FocalInside2PtConicalEffect>();
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
this->emitUniforms(uniformHandler, ge);
- fFocalUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType, kDefault_GrSLPrecision,
+ fFocalUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType,
"Conical2FSParams");
SkString tName("t");
@@ -749,7 +746,7 @@
const char* coords2D = coords2DString.c_str();
// t = p.x * focalX + length(p)
- fragBuilder->codeAppendf("\tfloat %s = %s.x * %s + length(%s);\n", tName.c_str(),
+ fragBuilder->codeAppendf("\thalf %s = %s.x * %s + length(%s);\n", tName.c_str(),
coords2D, focal.c_str(), coords2D);
this->emitColor(fragBuilder,
@@ -993,11 +990,9 @@
const CircleInside2PtConicalEffect& ge = args.fFp.cast<CircleInside2PtConicalEffect>();
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
this->emitUniforms(uniformHandler, ge);
- fCenterUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fCenterUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"Conical2FSCenter");
- fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec3f_GrSLType, kDefault_GrSLPrecision,
+ fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf3_GrSLType,
"Conical2FSParams");
SkString tName("t");
@@ -1020,10 +1015,10 @@
// C = 1 / A
// d = dot(e, p) + B
// t = d +/- sqrt(d^2 - A * dot(p, p) + C)
- fragBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D);
- fragBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(),
+ fragBuilder->codeAppendf("\thalf pDotp = dot(%s, %s);\n", coords2D, coords2D);
+ fragBuilder->codeAppendf("\thalf d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(),
params.c_str());
- fragBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\n",
+ fragBuilder->codeAppendf("\thalf %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\n",
tName.c_str(), params.c_str(), params.c_str());
this->emitColor(fragBuilder,
@@ -1241,11 +1236,9 @@
const CircleOutside2PtConicalEffect& ge = args.fFp.cast<CircleOutside2PtConicalEffect>();
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
this->emitUniforms(uniformHandler, ge);
- fCenterUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
+ fCenterUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
"Conical2FSCenter");
- fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
+ fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType,
"Conical2FSParams");
SkString tName("t");
@@ -1262,7 +1255,7 @@
// output will default to transparent black (we simply won't write anything
// else to it if invalid, instead of discarding or returning prematurely)
- fragBuilder->codeAppendf("\t%s = float4(0.0,0.0,0.0,0.0);\n", args.fOutputColor);
+ fragBuilder->codeAppendf("\t%s = half4(0.0,0.0,0.0,0.0);\n", args.fOutputColor);
// p = coords2D
// e = center end
@@ -1273,18 +1266,18 @@
// d = dot(e, p) + B
// t = d +/- sqrt(d^2 - A * dot(p, p) + C)
- fragBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D);
- fragBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(),
+ fragBuilder->codeAppendf("\thalf pDotp = dot(%s, %s);\n", coords2D, coords2D);
+ fragBuilder->codeAppendf("\thalf d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(),
params.c_str());
- fragBuilder->codeAppendf("\tfloat deter = d * d - %s.x * pDotp + %s.z;\n", params.c_str(),
+ fragBuilder->codeAppendf("\thalf deter = d * d - %s.x * pDotp + %s.z;\n", params.c_str(),
params.c_str());
// Must check to see if we flipped the circle order (to make sure start radius < end radius)
// If so we must also flip sign on sqrt
if (!fIsFlipped) {
- fragBuilder->codeAppendf("\tfloat %s = d + sqrt(deter);\n", tName.c_str());
+ fragBuilder->codeAppendf("\thalf %s = d + sqrt(deter);\n", tName.c_str());
} else {
- fragBuilder->codeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str());
+ fragBuilder->codeAppendf("\thalf %s = d - sqrt(deter);\n", tName.c_str());
}
fragBuilder->codeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n",
diff --git a/src/sksl/SkSLCPP.h b/src/sksl/SkSLCPP.h
index 642f7c6..808e832 100644
--- a/src/sksl/SkSLCPP.h
+++ b/src/sksl/SkSLCPP.h
@@ -22,4 +22,6 @@
inline SkPoint float2(float x, float y) { return SkPoint::Make(x, y); }
+#define half2 float2
+
#endif
diff --git a/src/sksl/SkSLCPPCodeGenerator.cpp b/src/sksl/SkSLCPPCodeGenerator.cpp
index 17bcf0d..eda2512 100644
--- a/src/sksl/SkSLCPPCodeGenerator.cpp
+++ b/src/sksl/SkSLCPPCodeGenerator.cpp
@@ -51,16 +51,14 @@
void CPPCodeGenerator::writeHeader() {
}
-void CPPCodeGenerator::writePrecisionModifier() {
+bool CPPCodeGenerator::usesPrecisionModifiers() const {
+ return false;
}
-void CPPCodeGenerator::writeType(const Type& type) {
- if (type.kind() == Type::kStruct_Kind) {
- INHERITED::writeType(type);
- } else {
- this->write(type.name());
- }
+String CPPCodeGenerator::getTypeName(const Type& type) {
+ return type.name();
}
+
void CPPCodeGenerator::writeBinaryExpression(const BinaryExpression& b,
Precedence parentPrecedence) {
if (b.fOperator == Token::PERCENT) {
@@ -117,20 +115,13 @@
INHERITED::writeIndexExpression(i);
}
-static const char* default_value(const Type& type) {
- const char* name = type.name().c_str();
- if (!strcmp(name, "float")) {
- return "0.0";
- } else if (!strcmp(name, "float2")) {
- return "float2(0.0)";
- } else if (!strcmp(name, "float3")) {
- return "float30.0)";
- } else if (!strcmp(name, "float4")) {
- return "float4(0.0)";
- } else if (!strcmp(name, "floatt4x4") || !strcmp(name, "colorSpaceXform")) {
- return "float4x4(1.0)";
+static String default_value(const Type& type) {
+ switch (type.kind()) {
+ case Type::kScalar_Kind: return "0";
+ case Type::kVector_Kind: return type.fName + "(0)";
+ case Type::kMatrix_Kind: return type.fName + "(1)";
+ default: ABORT("unsupported default_value type\n");
}
- ABORT("unsupported default_value type\n");
}
static bool is_private(const Variable& var) {
@@ -141,7 +132,7 @@
}
void CPPCodeGenerator::writeRuntimeValue(const Type& type, const String& cppCode) {
- if (type == *fContext.fFloat_Type) {
+ if (type.isFloat()) {
this->write("%f");
fFormatArgs.push_back(cppCode);
} else if (type == *fContext.fInt_Type) {
@@ -150,8 +141,8 @@
} else if (type == *fContext.fBool_Type) {
this->write("%s");
fFormatArgs.push_back("(" + cppCode + " ? \"true\" : \"false\")");
- } else if (type == *fContext.fFloat2_Type) {
- this->write("float2(%f, %f)");
+ } else if (type == *fContext.fFloat2_Type || type == *fContext.fHalf2_Type) {
+ this->write(type.fName + "(%f, %f)");
fFormatArgs.push_back(cppCode + ".fX");
fFormatArgs.push_back(cppCode + ".fY");
} else {
@@ -189,7 +180,7 @@
switch (ref.fVariable.fModifiers.fLayout.fBuiltin) {
case SK_INCOLOR_BUILTIN:
this->write("%s");
- fFormatArgs.push_back(String("args.fInputColor ? args.fInputColor : \"float4(1)\""));
+ fFormatArgs.push_back(String("args.fInputColor ? args.fInputColor : \"half4(1)\""));
break;
case SK_OUTCOLOR_BUILTIN:
this->write("%s");
@@ -211,7 +202,7 @@
var = String::printf("fColorSpaceHelper.isValid() ? "
"args.fUniformHandler->getUniformCStr("
"fColorSpaceHelper.gamutXformUniform()) : \"%s\"",
- default_value(ref.fVariable.fType));
+ default_value(ref.fVariable.fType).c_str());
} else {
var = String::printf("args.fUniformHandler->getUniformCStr(%sVar)",
HCodeGenerator::FieldName(name.c_str()).c_str());
@@ -221,7 +212,7 @@
code = String::printf("%sVar.isValid() ? %s : \"%s\"",
HCodeGenerator::FieldName(name.c_str()).c_str(),
var.c_str(),
- default_value(ref.fVariable.fType));
+ default_value(ref.fVariable.fType).c_str());
} else {
code = var;
}
@@ -253,7 +244,7 @@
void CPPCodeGenerator::writeFunctionCall(const FunctionCall& c) {
if (c.fFunction.fBuiltin && c.fFunction.fName == "COLORSPACE") {
String tmpVar = "_tmpVar" + to_string(++fVarCount);
- fFunctionHeader += "float4 " + tmpVar + ";";
+ fFunctionHeader += "half4 " + tmpVar + ";";
ASSERT(c.fArguments.size() == 2);
this->write("%s");
fFormatArgs.push_back("fColorSpaceHelper.isValid() ? \"(" + tmpVar + " = \" : \"\"");
@@ -262,7 +253,7 @@
String xform("args.fUniformHandler->getUniformCStr(fColorSpaceHelper.gamutXformUniform())");
this->write("%s");
fFormatArgs.push_back("fColorSpaceHelper.isValid() ? SkStringPrintf(\", "
- "float4(clamp((%s * float4(" + tmpVar + ".rgb, 1.0)).rgb, 0.0, " +
+ "half4(clamp((%s * half4(" + tmpVar + ".rgb, 1.0)).rgb, 0.0, " +
tmpVar + ".a), " + tmpVar + ".a))\", " + xform + ").c_str() : \"\"");
return;
}
@@ -349,14 +340,22 @@
}
const char* type;
if (var.fType == *fContext.fFloat_Type) {
- type = "kFloat_GrSLType";
+ type = "kHighFloat_GrSLType";
+ } else if (var.fType == *fContext.fHalf_Type) {
+ type = "kHalf_GrSLType";
} else if (var.fType == *fContext.fFloat2_Type) {
- type = "kVec2f_GrSLType";
+ type = "kHighFloat2_GrSLType";
+ } else if (var.fType == *fContext.fHalf2_Type) {
+ type = "kHalf2_GrSLType";
} else if (var.fType == *fContext.fFloat4_Type) {
- type = "kVec4f_GrSLType";
+ type = "kHighFloat4_GrSLType";
+ } else if (var.fType == *fContext.fHalf4_Type) {
+ type = "kHalf4_GrSLType";
} else if (var.fType == *fContext.fFloat4x4_Type ||
var.fType == *fContext.fColorSpaceXform_Type) {
- type = "kMat44f_GrSLType";
+ type = "kHighFloat4x4_GrSLType";
+ } else if (var.fType == *fContext.fHalf4x4_Type) {
+ type = "kHalf4x4_GrSLType";
} else {
ABORT("unsupported uniform type: %s %s;\n", var.fType.name().c_str(), var.fName.c_str());
}
@@ -454,11 +453,12 @@
this->writef(" {\n");
}
const char* name = u->fName.c_str();
- if (u->fType == *fContext.fFloat4_Type) {
+ if (u->fType == *fContext.fFloat4_Type || u->fType == *fContext.fHalf4_Type) {
this->writef(" const SkRect %sValue = _outer.%s();\n"
" %s.set4fv(%sVar, 1, (float*) &%sValue);\n",
name, name, pdman, HCodeGenerator::FieldName(name).c_str(), name);
- } else if (u->fType == *fContext.fFloat4x4_Type) {
+ } else if (u->fType == *fContext.fFloat4x4_Type ||
+ u->fType == *fContext.fHalf4x4_Type) {
this->writef(" float %sValue[16];\n"
" _outer.%s().asColMajorf(%sValue);\n"
" %s.setMatrix4f(%sVar, %sValue);\n",
diff --git a/src/sksl/SkSLCPPCodeGenerator.h b/src/sksl/SkSLCPPCodeGenerator.h
index 27b434a..6727b9c 100644
--- a/src/sksl/SkSLCPPCodeGenerator.h
+++ b/src/sksl/SkSLCPPCodeGenerator.h
@@ -31,9 +31,9 @@
void writeHeader() override;
- void writePrecisionModifier() override;
+ bool usesPrecisionModifiers() const override;
- void writeType(const Type& type) override;
+ String getTypeName(const Type& type) override;
void writeBinaryExpression(const BinaryExpression& b, Precedence parentPrecedence) override;
diff --git a/src/sksl/SkSLCompiler.cpp b/src/sksl/SkSLCompiler.cpp
index 4ea956c..af1c4b7 100644
--- a/src/sksl/SkSLCompiler.cpp
+++ b/src/sksl/SkSLCompiler.cpp
@@ -197,9 +197,8 @@
*fContext.fSkArgs_Type, Variable::kGlobal_Storage);
fIRGenerator->fSymbolTable->add(skArgsName, std::unique_ptr<Symbol>(skArgs));
- Modifiers::Flag ignored1;
- std::vector<std::unique_ptr<ProgramElement>> ignored2;
- fIRGenerator->convertProgram(String(SKSL_INCLUDE), *fTypes, &ignored1, &ignored2);
+ std::vector<std::unique_ptr<ProgramElement>> ignored;
+ fIRGenerator->convertProgram(String(SKSL_INCLUDE), *fTypes, &ignored);
fIRGenerator->fSymbolTable->markAllFunctionsBuiltin();
ASSERT(!fErrorCount);
}
@@ -1132,24 +1131,22 @@
fErrorCount = 0;
fIRGenerator->start(&settings);
std::vector<std::unique_ptr<ProgramElement>> elements;
- Modifiers::Flag ignored;
switch (kind) {
case Program::kVertex_Kind:
- fIRGenerator->convertProgram(String(SKSL_VERT_INCLUDE), *fTypes, &ignored, &elements);
+ fIRGenerator->convertProgram(String(SKSL_VERT_INCLUDE), *fTypes, &elements);
break;
case Program::kFragment_Kind:
- fIRGenerator->convertProgram(String(SKSL_FRAG_INCLUDE), *fTypes, &ignored, &elements);
+ fIRGenerator->convertProgram(String(SKSL_FRAG_INCLUDE), *fTypes, &elements);
break;
case Program::kGeometry_Kind:
- fIRGenerator->convertProgram(String(SKSL_GEOM_INCLUDE), *fTypes, &ignored, &elements);
+ fIRGenerator->convertProgram(String(SKSL_GEOM_INCLUDE), *fTypes, &elements);
break;
case Program::kFragmentProcessor_Kind:
- fIRGenerator->convertProgram(String(SKSL_FP_INCLUDE), *fTypes, &ignored, &elements);
+ fIRGenerator->convertProgram(String(SKSL_FP_INCLUDE), *fTypes, &elements);
break;
}
fIRGenerator->fSymbolTable->markAllFunctionsBuiltin();
- Modifiers::Flag defaultPrecision;
- fIRGenerator->convertProgram(text, *fTypes, &defaultPrecision, &elements);
+ fIRGenerator->convertProgram(text, *fTypes, &elements);
if (!fErrorCount) {
for (auto& element : elements) {
if (element->fKind == ProgramElement::kFunction_Kind) {
@@ -1157,7 +1154,7 @@
}
}
}
- auto result = std::unique_ptr<Program>(new Program(kind, settings, defaultPrecision, &fContext,
+ auto result = std::unique_ptr<Program>(new Program(kind, settings, &fContext,
std::move(elements),
fIRGenerator->fSymbolTable,
fIRGenerator->fInputs));
diff --git a/src/sksl/SkSLContext.h b/src/sksl/SkSLContext.h
index b132cec..fbd5146 100644
--- a/src/sksl/SkSLContext.h
+++ b/src/sksl/SkSLContext.h
@@ -21,47 +21,47 @@
Context()
: fInvalid_Type(new Type(String("<INVALID>")))
, fVoid_Type(new Type(String("void")))
- , fDouble_Type(new Type(String("double"), Type::kFloat_NumberKind))
+ , fDouble_Type(new Type(String("double"), Type::kFloat_NumberKind, 4))
, fDouble2_Type(new Type(String("double2"), *fDouble_Type, 2))
, fDouble3_Type(new Type(String("double3"), *fDouble_Type, 3))
, fDouble4_Type(new Type(String("double4"), *fDouble_Type, 4))
- , fFloat_Type(new Type(String("float"), Type::kFloat_NumberKind))
- , fFloat2_Type(new Type(String("float2"), *fFloat_Type, 2))
- , fFloat3_Type(new Type(String("float3"), *fFloat_Type, 3))
- , fFloat4_Type(new Type(String("float4"), *fFloat_Type, 4))
- , fHalf_Type(new Type(String("half"), Type::kFloat_NumberKind))
+ , fFloat_Type(new Type(String("highfloat"), Type::kFloat_NumberKind, 3))
+ , fFloat2_Type(new Type(String("highfloat2"), *fFloat_Type, 2))
+ , fFloat3_Type(new Type(String("highfloat3"), *fFloat_Type, 3))
+ , fFloat4_Type(new Type(String("highfloat4"), *fFloat_Type, 4))
+ , fHalf_Type(new Type(String("half"), Type::kFloat_NumberKind, 2))
, fHalf2_Type(new Type(String("half2"), *fHalf_Type, 2))
, fHalf3_Type(new Type(String("half3"), *fHalf_Type, 3))
, fHalf4_Type(new Type(String("half4"), *fHalf_Type, 4))
- , fUInt_Type(new Type(String("uint"), Type::kUnsigned_NumberKind))
+ , fUInt_Type(new Type(String("uint"), Type::kUnsigned_NumberKind, 1))
, fUInt2_Type(new Type(String("uint2"), *fUInt_Type, 2))
, fUInt3_Type(new Type(String("uint3"), *fUInt_Type, 3))
, fUInt4_Type(new Type(String("uint4"), *fUInt_Type, 4))
- , fInt_Type(new Type(String("int"), Type::kSigned_NumberKind))
+ , fInt_Type(new Type(String("int"), Type::kSigned_NumberKind, 1))
, fInt2_Type(new Type(String("int2"), *fInt_Type, 2))
, fInt3_Type(new Type(String("int3"), *fInt_Type, 3))
, fInt4_Type(new Type(String("int4"), *fInt_Type, 4))
- , fUShort_Type(new Type(String("ushort"), Type::kUnsigned_NumberKind))
+ , fUShort_Type(new Type(String("ushort"), Type::kUnsigned_NumberKind, 0))
, fUShort2_Type(new Type(String("ushort2"), *fUShort_Type, 2))
, fUShort3_Type(new Type(String("ushort3"), *fUShort_Type, 3))
, fUShort4_Type(new Type(String("ushort4"), *fUShort_Type, 4))
- , fShort_Type(new Type(String("short"), Type::kSigned_NumberKind))
+ , fShort_Type(new Type(String("short"), Type::kSigned_NumberKind, 0))
, fShort2_Type(new Type(String("short2"), *fShort_Type, 2))
, fShort3_Type(new Type(String("short3"), *fShort_Type, 3))
, fShort4_Type(new Type(String("short4"), *fShort_Type, 4))
- , fBool_Type(new Type(String("bool"), Type::kNonnumeric_NumberKind))
+ , fBool_Type(new Type(String("bool"), Type::kNonnumeric_NumberKind, -1))
, fBool2_Type(new Type(String("bool2"), *fBool_Type, 2))
, fBool3_Type(new Type(String("bool3"), *fBool_Type, 3))
, fBool4_Type(new Type(String("bool4"), *fBool_Type, 4))
- , fFloat2x2_Type(new Type(String("float2x2"), *fFloat_Type, 2, 2))
- , fFloat2x3_Type(new Type(String("float2x3"), *fFloat_Type, 2, 3))
- , fFloat2x4_Type(new Type(String("float2x4"), *fFloat_Type, 2, 4))
- , fFloat3x2_Type(new Type(String("float3x2"), *fFloat_Type, 3, 2))
- , fFloat3x3_Type(new Type(String("float3x3"), *fFloat_Type, 3, 3))
- , fFloat3x4_Type(new Type(String("float3x4"), *fFloat_Type, 3, 4))
- , fFloat4x2_Type(new Type(String("float4x2"), *fFloat_Type, 4, 2))
- , fFloat4x3_Type(new Type(String("float4x3"), *fFloat_Type, 4, 3))
- , fFloat4x4_Type(new Type(String("float4x4"), *fFloat_Type, 4, 4))
+ , fFloat2x2_Type(new Type(String("highfloat2x2"), *fFloat_Type, 2, 2))
+ , fFloat2x3_Type(new Type(String("highfloat2x3"), *fFloat_Type, 2, 3))
+ , fFloat2x4_Type(new Type(String("highfloat2x4"), *fFloat_Type, 2, 4))
+ , fFloat3x2_Type(new Type(String("highfloat3x2"), *fFloat_Type, 3, 2))
+ , fFloat3x3_Type(new Type(String("highfloat3x3"), *fFloat_Type, 3, 3))
+ , fFloat3x4_Type(new Type(String("highfloat3x4"), *fFloat_Type, 3, 4))
+ , fFloat4x2_Type(new Type(String("highfloat4x2"), *fFloat_Type, 4, 2))
+ , fFloat4x3_Type(new Type(String("highfloat4x3"), *fFloat_Type, 4, 3))
+ , fFloat4x4_Type(new Type(String("highfloat4x4"), *fFloat_Type, 4, 4))
, fHalf2x2_Type(new Type(String("half2x2"), *fHalf_Type, 2, 2))
, fHalf2x3_Type(new Type(String("half2x3"), *fHalf_Type, 2, 3))
, fHalf2x4_Type(new Type(String("half2x4"), *fHalf_Type, 2, 4))
diff --git a/src/sksl/SkSLGLSLCodeGenerator.cpp b/src/sksl/SkSLGLSLCodeGenerator.cpp
index 64527a0..4168dc1 100644
--- a/src/sksl/SkSLGLSLCodeGenerator.cpp
+++ b/src/sksl/SkSLGLSLCodeGenerator.cpp
@@ -54,6 +54,87 @@
this->writeLine("#extension " + ext.fName + " : enable");
}
+bool GLSLCodeGenerator::usesPrecisionModifiers() const {
+ return fProgram.fSettings.fCaps->usesPrecisionModifiers();
+}
+
+String GLSLCodeGenerator::getTypeName(const Type& type) {
+ switch (type.kind()) {
+ case Type::kVector_Kind: {
+ Type component = type.componentType();
+ String result;
+ if (component == *fContext.fFloat_Type || component == *fContext.fHalf_Type) {
+ result = "vec";
+ }
+ else if (component == *fContext.fDouble_Type) {
+ result = "dvec";
+ }
+ else if (component == *fContext.fInt_Type || component == *fContext.fShort_Type) {
+ result = "ivec";
+ }
+ else if (component == *fContext.fUInt_Type || component == *fContext.fUShort_Type) {
+ result = "uvec";
+ }
+ else if (component == *fContext.fBool_Type) {
+ result = "bvec";
+ }
+ else {
+ ABORT("unsupported vector type");
+ }
+ result += to_string(type.columns());
+ return result;
+ }
+ case Type::kMatrix_Kind: {
+ String result;
+ Type component = type.componentType();
+ if (component == *fContext.fFloat_Type || component == *fContext.fHalf_Type) {
+ result = "mat";
+ }
+ else if (component == *fContext.fDouble_Type) {
+ result = "dmat";
+ }
+ else {
+ ABORT("unsupported matrix type");
+ }
+ result += to_string(type.columns());
+ if (type.columns() != type.rows()) {
+ result += "x";
+ result += to_string(type.rows());
+ }
+ return result;
+ }
+ case Type::kArray_Kind: {
+ String result = this->getTypeName(type.componentType()) + "[";
+ if (type.columns() != -1) {
+ result += to_string(type.columns());
+ }
+ result += "]";
+ return result;
+ }
+ case Type::kScalar_Kind: {
+ if (type == *fContext.fHalf_Type) {
+ return "float";
+ }
+ else if (type == *fContext.fShort_Type) {
+ return "int";
+ }
+ else if (type == *fContext.fUShort_Type) {
+ return "uint";
+ }
+ else if (type == *fContext.fFloat_Type) {
+ // FIXME: temporary, this goes away when highfloat is renamed back to float
+ return "float";
+ }
+ else {
+ return type.name();
+ }
+ break;
+ }
+ default:
+ return type.name();
+ }
+}
+
void GLSLCodeGenerator::writeType(const Type& type) {
if (type.kind() == Type::kStruct_Kind) {
for (const Type* search : fWrittenStructs) {
@@ -76,75 +157,7 @@
fIndentation--;
this->write("}");
} else {
- switch (type.kind()) {
- case Type::kVector_Kind: {
- Type component = type.componentType();
- if (component == *fContext.fFloat_Type || component == *fContext.fHalf_Type) {
- this->write("vec");
- }
- else if (component == *fContext.fDouble_Type) {
- this->write("dvec");
- }
- else if (component == *fContext.fInt_Type || component == *fContext.fShort_Type) {
- this->write("ivec");
- }
- else if (component == *fContext.fUInt_Type || component == *fContext.fUShort_Type) {
- this->write("uvec");
- }
- else if (component == *fContext.fBool_Type) {
- this->write("bvec");
- }
- else {
- ABORT("unsupported vector type");
- }
- this->write(to_string(type.columns()));
- break;
- }
- case Type::kMatrix_Kind: {
- Type component = type.componentType();
- if (component == *fContext.fFloat_Type || component == *fContext.fHalf_Type) {
- this->write("mat");
- }
- else if (component == *fContext.fDouble_Type) {
- this->write("dmat");
- }
- else {
- ABORT("unsupported matrix type");
- }
- this->write(to_string(type.columns()));
- if (type.columns() != type.rows()) {
- this->write("x");
- this->write(to_string(type.rows()));
- }
- break;
- }
- case Type::kArray_Kind: {
- this->writeType(type.componentType());
- this->write("[");
- if (type.columns() != -1) {
- this->write(to_string(type.columns()));
- }
- this->write("]");
- break;
- }
- case Type::kScalar_Kind: {
- if (type == *fContext.fHalf_Type) {
- this->write("float");
- }
- else if (type == *fContext.fShort_Type) {
- this->write("int");
- }
- else if (type == *fContext.fUShort_Type) {
- this->write("uint");
- }
- else {
- this->write(type.name());
- }
- break;
- }
- default:
- this->write(type.name());
- }
+ this->write(this->getTypeName(type));
}
}
@@ -157,7 +170,7 @@
this->writeBoolLiteral((BoolLiteral&) expr);
break;
case Expression::kConstructor_Kind:
- this->writeConstructor((Constructor&) expr);
+ this->writeConstructor((Constructor&) expr, parentPrecedence);
break;
case Expression::kIntLiteral_Kind:
this->writeIntLiteral((IntLiteral&) expr);
@@ -210,8 +223,10 @@
ASSERT(!fProgram.fSettings.fCaps->canUseMinAndAbsTogether());
String tmpVar1 = "minAbsHackVar" + to_string(fVarCount++);
String tmpVar2 = "minAbsHackVar" + to_string(fVarCount++);
- this->fFunctionHeader += " " + absExpr.fType.name() + " " + tmpVar1 + ";\n";
- this->fFunctionHeader += " " + otherExpr.fType.name() + " " + tmpVar2 + ";\n";
+ this->fFunctionHeader += String(" ") + this->getTypePrecision(absExpr.fType) +
+ this->getTypeName(absExpr.fType) + " " + tmpVar1 + ";\n";
+ this->fFunctionHeader += String(" ") + this->getTypePrecision(otherExpr.fType) +
+ this->getTypeName(otherExpr.fType) + " " + tmpVar2 + ";\n";
this->write("((" + tmpVar1 + " = ");
this->writeExpression(absExpr, kTopLevel_Precedence);
this->write(") < (" + tmpVar2 + " = ");
@@ -339,7 +354,15 @@
this->write(")");
}
-void GLSLCodeGenerator::writeConstructor(const Constructor& c) {
+void GLSLCodeGenerator::writeConstructor(const Constructor& c, Precedence parentPrecedence) {
+ if (c.fArguments.size() == 1 &&
+ this->getTypeName(c.fType) == this->getTypeName(c.fArguments[0]->fType)) {
+ // in cases like half(float), they're different types as far as SkSL is concerned but the
+ // same type as far as GLSL is concerned. We avoid a redundant float(float) by just writing
+ // out the inner expression here.
+ this->writeExpression(*c.fArguments[0], parentPrecedence);
+ return;
+ }
this->writeType(c.fType);
this->write("(");
const char* separator = "";
@@ -376,16 +399,14 @@
// depending on the surrounding code, accessing .xy with a uniform involved can
// do the same thing. Copying gl_FragCoord.xy into a temp float2beforehand
// (and only accessing .xy) seems to "fix" things.
- const char* precision = fProgram.fSettings.fCaps->usesPrecisionModifiers() ? "highp "
- : "";
+ const char* precision = usesPrecisionModifiers() ? "highp " : "";
fHeader.writeText("uniform ");
fHeader.writeText(precision);
fHeader.writeText("float " SKSL_RTHEIGHT_NAME ";\n");
fSetupFragPositionGlobal = true;
}
if (!fSetupFragPositionLocal) {
- const char* precision = fProgram.fSettings.fCaps->usesPrecisionModifiers() ? "highp "
- : "";
+ const char* precision = usesPrecisionModifiers() ? "highp " : "";
fFunctionHeader += precision;
fFunctionHeader += " vec2 _sktmpCoord = gl_FragCoord.xy;\n";
fFunctionHeader += precision;
@@ -570,6 +591,7 @@
}
void GLSLCodeGenerator::writeFunction(const FunctionDefinition& f) {
+ this->writeTypePrecision(f.fDeclaration.fReturnType);
this->writeType(f.fDeclaration.fReturnType);
this->write(" " + f.fDeclaration.fName + "(");
const char* separator = "";
@@ -583,6 +605,7 @@
sizes.push_back(type->columns());
type = &type->componentType();
}
+ this->writeTypePrecision(*type);
this->writeType(*type);
this->write(" " + param->fName);
for (int s : sizes) {
@@ -661,7 +684,7 @@
if (modifiers.fFlags & Modifiers::kConst_Flag) {
this->write("const ");
}
- if (fProgram.fSettings.fCaps->usesPrecisionModifiers()) {
+ if (usesPrecisionModifiers()) {
if (modifiers.fFlags & Modifiers::kLowp_Flag) {
this->write("lowp ");
}
@@ -711,23 +734,31 @@
this->writeExpression(value, kTopLevel_Precedence);
}
-void GLSLCodeGenerator::writeTypePrecision(const Type& type) {
- if (fProgram.fSettings.fCaps->usesPrecisionModifiers()) {
+const char* GLSLCodeGenerator::getTypePrecision(const Type& type) {
+ if (usesPrecisionModifiers()) {
switch (type.kind()) {
case Type::kScalar_Kind:
if (type == *fContext.fHalf_Type || type == *fContext.fShort_Type ||
type == *fContext.fUShort_Type) {
- this->write("mediump ");
+ return "mediump ";
}
- break;
+ if (type == *fContext.fFloat_Type || type == *fContext.fInt_Type ||
+ type == *fContext.fUInt_Type) {
+ return "highp ";
+ }
+ return "";
case Type::kVector_Kind: // fall through
case Type::kMatrix_Kind:
- this->writeTypePrecision(type.componentType());
- break;
+ return this->getTypePrecision(type.componentType());
default:
break;
}
}
+ return "";
+}
+
+void GLSLCodeGenerator::writeTypePrecision(const Type& type) {
+ this->write(this->getTypePrecision(type));
}
void GLSLCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, bool global) {
@@ -921,27 +952,6 @@
}
}
-void GLSLCodeGenerator::writePrecisionModifier() {
- if (fProgram.fSettings.fCaps->usesPrecisionModifiers()) {
- this->write("precision ");
- switch (fProgram.fDefaultPrecision) {
- case Modifiers::kLowp_Flag:
- this->write("lowp");
- break;
- case Modifiers::kMediump_Flag:
- this->write("mediump");
- break;
- case Modifiers::kHighp_Flag:
- this->write("highp");
- break;
- default:
- ASSERT(false);
- this->write("<error>");
- }
- this->writeLine(" float;");
- }
-}
-
void GLSLCodeGenerator::writeProgramElement(const ProgramElement& e) {
switch (e.fKind) {
case ProgramElement::kExtension_Kind:
@@ -957,7 +967,7 @@
} else if (builtin == SK_FRAGCOLOR_BUILTIN &&
fProgram.fSettings.fCaps->mustDeclareFragmentShaderOutput()) {
this->write("out ");
- if (fProgram.fSettings.fCaps->usesPrecisionModifiers()) {
+ if (usesPrecisionModifiers()) {
this->write("mediump ");
}
this->writeLine("vec4 sk_FragColor;");
@@ -988,7 +998,6 @@
this->writeHeader();
StringStream body;
fOut = &body;
- this->writePrecisionModifier();
for (const auto& e : fProgram.fElements) {
this->writeProgramElement(*e);
}
diff --git a/src/sksl/SkSLGLSLCodeGenerator.h b/src/sksl/SkSLGLSLCodeGenerator.h
index e10299a..c377d29 100644
--- a/src/sksl/SkSLGLSLCodeGenerator.h
+++ b/src/sksl/SkSLGLSLCodeGenerator.h
@@ -94,9 +94,11 @@
virtual void writeHeader();
- virtual void writePrecisionModifier();
+ virtual bool usesPrecisionModifiers() const;
- virtual void writeType(const Type& type);
+ virtual String getTypeName(const Type& type);
+
+ void writeType(const Type& type);
void writeExtension(const Extension& ext);
@@ -116,6 +118,8 @@
virtual void writeVarInitializer(const Variable& var, const Expression& value);
+ const char* getTypePrecision(const Type& type);
+
void writeTypePrecision(const Type& type);
void writeVarDeclarations(const VarDeclarations& decl, bool global);
@@ -132,7 +136,7 @@
virtual void writeFunctionCall(const FunctionCall& c);
- void writeConstructor(const Constructor& c);
+ void writeConstructor(const Constructor& c, Precedence parentPrecedence);
void writeFieldAccess(const FieldAccess& f);
diff --git a/src/sksl/SkSLHCodeGenerator.cpp b/src/sksl/SkSLHCodeGenerator.cpp
index 50d2428..b38e6c0 100644
--- a/src/sksl/SkSLHCodeGenerator.cpp
+++ b/src/sksl/SkSLHCodeGenerator.cpp
@@ -23,13 +23,15 @@
, fSectionAndParameterHelper(*program, *errors) {}
String HCodeGenerator::ParameterType(const Type& type) {
- if (type.fName == "float2") {
+ if (type.fName == "highfloat" || type.fName == "half") {
+ return "float";
+ } else if (type.fName == "highfloat2" || type.fName == "half2") {
return "SkPoint";
- } else if (type.fName == "int4") {
+ } else if (type.fName == "int4" || type.fName == "short4") {
return "SkIRect";
- } else if (type.fName == "float4") {
+ } else if (type.fName == "highfloat4" || type.fName == "half4") {
return "SkRect";
- } else if (type.fName == "float4x4") {
+ } else if (type.fName == "highfloat4x4" || type.fName == "half4x4") {
return "SkMatrix44";
} else if (type.kind() == Type::kSampler_Kind) {
return "sk_sp<GrTextureProxy>";
diff --git a/src/sksl/SkSLIRGenerator.cpp b/src/sksl/SkSLIRGenerator.cpp
index a46a931..50f5809 100644
--- a/src/sksl/SkSLIRGenerator.cpp
+++ b/src/sksl/SkSLIRGenerator.cpp
@@ -17,7 +17,6 @@
#include "ast/SkSLASTFloatLiteral.h"
#include "ast/SkSLASTIndexSuffix.h"
#include "ast/SkSLASTIntLiteral.h"
-#include "ast/SkSLASTPrecision.h"
#include "ir/SkSLBinaryExpression.h"
#include "ir/SkSLBoolLiteral.h"
#include "ir/SkSLBreakStatement.h"
@@ -981,8 +980,15 @@
*outResultType = context.fBool_Type.get();
return left.canCoerceTo(*context.fBool_Type) &&
right.canCoerceTo(*context.fBool_Type);
- case Token::STAR: // fall through
case Token::STAREQ:
+ if (left.kind() == Type::kScalar_Kind) {
+ *outLeftType = &left;
+ *outRightType = &left;
+ *outResultType = &left;
+ return right.canCoerceTo(left);
+ }
+ // fall through
+ case Token::STAR:
if (is_matrix_multiply(left, right)) {
// determine final component type
if (determine_binary_type(context, Token::STAR, left.componentType(),
@@ -1022,12 +1028,22 @@
isLogical = false;
validMatrixOrVectorOp = true;
break;
+ case Token::PLUSEQ:
+ case Token::MINUSEQ:
+ case Token::SLASHEQ:
+ case Token::PERCENTEQ:
+ case Token::SHLEQ:
+ case Token::SHREQ:
+ if (left.kind() == Type::kScalar_Kind) {
+ *outLeftType = &left;
+ *outRightType = &left;
+ *outResultType = &left;
+ return right.canCoerceTo(left);
+ }
+ // fall through
case Token::PLUS: // fall through
- case Token::PLUSEQ: // fall through
case Token::MINUS: // fall through
- case Token::MINUSEQ: // fall through
case Token::SLASH: // fall through
- case Token::SLASHEQ: // fall through
isLogical = false;
validMatrixOrVectorOp = true;
break;
@@ -1041,9 +1057,23 @@
validMatrixOrVectorOp = false;
}
bool isVectorOrMatrix = left.kind() == Type::kVector_Kind || left.kind() == Type::kMatrix_Kind;
- // FIXME: incorrect for shift
- if (right.canCoerceTo(left) && (left.kind() == Type::kScalar_Kind ||
- (isVectorOrMatrix && validMatrixOrVectorOp))) {
+ if (left.kind() == Type::kScalar_Kind && right.kind() == Type::kScalar_Kind &&
+ right.canCoerceTo(left)) {
+ if (left.priority() > right.priority()) {
+ *outLeftType = &left;
+ *outRightType = &left;
+ } else {
+ *outLeftType = &right;
+ *outRightType = &right;
+ }
+ if (isLogical) {
+ *outResultType = context.fBool_Type.get();
+ } else {
+ *outResultType = &left;
+ }
+ return true;
+ }
+ if (right.canCoerceTo(left) && isVectorOrMatrix && validMatrixOrVectorOp) {
*outLeftType = &left;
*outRightType = &left;
if (isLogical) {
@@ -1480,18 +1510,17 @@
to_string((uint64_t) args.size()) + ")");
return nullptr;
}
- if (type.isFloat() && args[0]->fType.isFloat()) {
+ if (type == args[0]->fType) {
return std::move(args[0]);
}
- if (type.isSigned() && args[0]->fType.isSigned()) {
- return std::move(args[0]);
- }
- if (type.isUnsigned() && args[0]->fType.isUnsigned()) {
- return std::move(args[0]);
+ if (type.isFloat() && args.size() == 1 && args[0]->fKind == Expression::kFloatLiteral_Kind) {
+ double value = ((FloatLiteral&) *args[0]).fValue;
+ return std::unique_ptr<Expression>(new FloatLiteral(fContext, position, value, &type));
}
if (type.isFloat() && args.size() == 1 && args[0]->fKind == Expression::kIntLiteral_Kind) {
int64_t value = ((IntLiteral&) *args[0]).fValue;
- return std::unique_ptr<Expression>(new FloatLiteral(fContext, position, (double) value));
+ return std::unique_ptr<Expression>(new FloatLiteral(fContext, position, (double) value,
+ &type));
}
if (args[0]->fKind == Expression::kIntLiteral_Kind && (type == *fContext.fInt_Type ||
type == *fContext.fUInt_Type)) {
@@ -1948,14 +1977,12 @@
void IRGenerator::convertProgram(String text,
SymbolTable& types,
- Modifiers::Flag* defaultPrecision,
std::vector<std::unique_ptr<ProgramElement>>* out) {
Parser parser(text, types, fErrors);
std::vector<std::unique_ptr<ASTDeclaration>> parsed = parser.file();
if (fErrors.errorCount()) {
return;
}
- *defaultPrecision = Modifiers::kHighp_Flag;
for (size_t i = 0; i < parsed.size(); i++) {
ASTDeclaration& decl = *parsed[i];
switch (decl.fKind) {
@@ -2002,10 +2029,6 @@
}
break;
}
- case ASTDeclaration::kPrecision_Kind: {
- *defaultPrecision = ((ASTPrecision&) decl).fPrecision;
- break;
- }
default:
ABORT("unsupported declaration: %s\n", decl.description().c_str());
}
diff --git a/src/sksl/SkSLIRGenerator.h b/src/sksl/SkSLIRGenerator.h
index 0a1bae4..949dc24 100644
--- a/src/sksl/SkSLIRGenerator.h
+++ b/src/sksl/SkSLIRGenerator.h
@@ -63,7 +63,6 @@
void convertProgram(String text,
SymbolTable& types,
- Modifiers::Flag* defaultPrecision,
std::vector<std::unique_ptr<ProgramElement>>* result);
/**
diff --git a/src/sksl/SkSLParser.cpp b/src/sksl/SkSLParser.cpp
index f712b34..dd044cd 100644
--- a/src/sksl/SkSLParser.cpp
+++ b/src/sksl/SkSLParser.cpp
@@ -49,7 +49,6 @@
#include "ast/SkSLASTIntLiteral.h"
#include "ast/SkSLASTModifiersDeclaration.h"
#include "ast/SkSLASTParameter.h"
-#include "ast/SkSLASTPrecision.h"
#include "ast/SkSLASTPrefixExpression.h"
#include "ast/SkSLASTReturnStatement.h"
#include "ast/SkSLASTSection.h"
@@ -109,20 +108,13 @@
layoutlex_destroy(fLayoutScanner);
}
-/* (precision | directive | section | declaration)* END_OF_FILE */
+/* (directive | section | declaration)* END_OF_FILE */
std::vector<std::unique_ptr<ASTDeclaration>> Parser::file() {
std::vector<std::unique_ptr<ASTDeclaration>> result;
for (;;) {
switch (this->peek().fKind) {
case Token::END_OF_FILE:
return result;
- case Token::PRECISION: {
- std::unique_ptr<ASTDeclaration> precision = this->precision();
- if (precision) {
- result.push_back(std::move(precision));
- }
- break;
- }
case Token::DIRECTIVE: {
std::unique_ptr<ASTDeclaration> decl = this->directive();
if (decl) {
@@ -238,36 +230,6 @@
return nullptr != fTypes[name];
}
-/* PRECISION (LOWP | MEDIUMP | HIGHP) type SEMICOLON */
-std::unique_ptr<ASTDeclaration> Parser::precision() {
- if (!this->expect(Token::PRECISION, "'precision'")) {
- return nullptr;
- }
- Modifiers::Flag result;
- Token p = this->nextToken();
- switch (p.fKind) {
- case Token::LOWP:
- result = Modifiers::kLowp_Flag;
- break;
- case Token::MEDIUMP:
- result = Modifiers::kMediump_Flag;
- break;
- case Token::HIGHP:
- result = Modifiers::kHighp_Flag;
- break;
- default:
- this->error(p.fPosition, "expected 'lowp', 'mediump', or 'highp', but found '" +
- p.fText + "'");
- return nullptr;
- }
- // FIXME handle the type
- if (!this->type()) {
- return nullptr;
- }
- this->expect(Token::SEMICOLON, "';'");
- return std::unique_ptr<ASTDeclaration>(new ASTPrecision(p.fPosition, result));
-}
-
/* DIRECTIVE(#version) INT_LITERAL ("es" | "compatibility")? |
DIRECTIVE(#extension) IDENTIFIER COLON IDENTIFIER */
std::unique_ptr<ASTDeclaration> Parser::directive() {
diff --git a/src/sksl/SkSLSPIRVCodeGenerator.cpp b/src/sksl/SkSLSPIRVCodeGenerator.cpp
index d367df9..de29d15 100644
--- a/src/sksl/SkSLSPIRVCodeGenerator.cpp
+++ b/src/sksl/SkSLSPIRVCodeGenerator.cpp
@@ -156,21 +156,22 @@
if (type.kind() == Type::kVector_Kind) {
return is_float(context, type.componentType());
}
- return type == *context.fFloat_Type || type == *context.fDouble_Type;
+ return type == *context.fFloat_Type || type == *context.fHalf_Type ||
+ type == *context.fDouble_Type;
}
static bool is_signed(const Context& context, const Type& type) {
if (type.kind() == Type::kVector_Kind) {
return is_signed(context, type.componentType());
}
- return type == *context.fInt_Type;
+ return type == *context.fInt_Type || type == *context.fShort_Type;
}
static bool is_unsigned(const Context& context, const Type& type) {
if (type.kind() == Type::kVector_Kind) {
return is_unsigned(context, type.componentType());
}
- return type == *context.fUInt_Type;
+ return type == *context.fUInt_Type || type == *context.fUShort_Type;
}
static bool is_bool(const Context& context, const Type& type) {
@@ -1041,11 +1042,36 @@
}
}
+Type SPIRVCodeGenerator::getActualType(const Type& type) {
+ if (type == *fContext.fHalf_Type) {
+ return *fContext.fFloat_Type;
+ }
+ if (type == *fContext.fShort_Type) {
+ return *fContext.fInt_Type;
+ }
+ if (type == *fContext.fUShort_Type) {
+ return *fContext.fUInt_Type;
+ }
+ if (type.kind() == Type::kMatrix_Kind || type.kind() == Type::kVector_Kind) {
+ if (type.componentType() == *fContext.fHalf_Type) {
+ return fContext.fFloat_Type->toCompound(fContext, type.columns(), type.rows());
+ }
+ if (type.componentType() == *fContext.fShort_Type) {
+ return fContext.fInt_Type->toCompound(fContext, type.columns(), type.rows());
+ }
+ if (type.componentType() == *fContext.fUShort_Type) {
+ return fContext.fUInt_Type->toCompound(fContext, type.columns(), type.rows());
+ }
+ }
+ return type;
+}
+
SpvId SPIRVCodeGenerator::getType(const Type& type) {
return this->getType(type, fDefaultLayout);
}
-SpvId SPIRVCodeGenerator::getType(const Type& type, const MemoryLayout& layout) {
+SpvId SPIRVCodeGenerator::getType(const Type& rawType, const MemoryLayout& layout) {
+ Type type = this->getActualType(rawType);
String key = type.name() + to_string((int) layout.fStd);
auto entry = fTypeMap.find(key);
if (entry == fTypeMap.end()) {
@@ -1199,8 +1225,9 @@
return this->getPointerType(type, fDefaultLayout, storageClass);
}
-SpvId SPIRVCodeGenerator::getPointerType(const Type& type, const MemoryLayout& layout,
+SpvId SPIRVCodeGenerator::getPointerType(const Type& rawType, const MemoryLayout& layout,
SpvStorageClass_ storageClass) {
+ Type type = this->getActualType(rawType);
String key = type.description() + "*" + to_string(layout.fStd) + to_string(storageClass);
auto entry = fTypeMap.find(key);
if (entry == fTypeMap.end()) {
@@ -1511,55 +1538,53 @@
}
SpvId SPIRVCodeGenerator::writeFloatConstructor(const Constructor& c, OutputStream& out) {
- ASSERT(c.fType == *fContext.fFloat_Type);
+ ASSERT(c.fType.isFloat());
ASSERT(c.fArguments.size() == 1);
ASSERT(c.fArguments[0]->fType.isNumber());
SpvId result = this->nextId();
SpvId parameter = this->writeExpression(*c.fArguments[0], out);
- if (c.fArguments[0]->fType == *fContext.fInt_Type) {
+ if (c.fArguments[0]->fType.isSigned()) {
this->writeInstruction(SpvOpConvertSToF, this->getType(c.fType), result, parameter,
out);
- } else if (c.fArguments[0]->fType == *fContext.fUInt_Type) {
+ } else {
+ ASSERT(c.fArguments[0]->fType.isUnsigned());
this->writeInstruction(SpvOpConvertUToF, this->getType(c.fType), result, parameter,
out);
- } else if (c.fArguments[0]->fType == *fContext.fFloat_Type) {
- return parameter;
}
return result;
}
SpvId SPIRVCodeGenerator::writeIntConstructor(const Constructor& c, OutputStream& out) {
- ASSERT(c.fType == *fContext.fInt_Type);
+ ASSERT(c.fType.isSigned());
ASSERT(c.fArguments.size() == 1);
ASSERT(c.fArguments[0]->fType.isNumber());
SpvId result = this->nextId();
SpvId parameter = this->writeExpression(*c.fArguments[0], out);
- if (c.fArguments[0]->fType == *fContext.fFloat_Type) {
+ if (c.fArguments[0]->fType.isFloat()) {
this->writeInstruction(SpvOpConvertFToS, this->getType(c.fType), result, parameter,
out);
- } else if (c.fArguments[0]->fType == *fContext.fUInt_Type) {
+ }
+ else {
+ ASSERT(c.fArguments[0]->fType.isUnsigned());
this->writeInstruction(SpvOpBitcast, this->getType(c.fType), result, parameter,
out);
- } else if (c.fArguments[0]->fType == *fContext.fInt_Type) {
- return parameter;
}
return result;
}
SpvId SPIRVCodeGenerator::writeUIntConstructor(const Constructor& c, OutputStream& out) {
- ASSERT(c.fType == *fContext.fUInt_Type);
+ ASSERT(c.fType.isUnsigned());
ASSERT(c.fArguments.size() == 1);
ASSERT(c.fArguments[0]->fType.isNumber());
SpvId result = this->nextId();
SpvId parameter = this->writeExpression(*c.fArguments[0], out);
- if (c.fArguments[0]->fType == *fContext.fFloat_Type) {
+ if (c.fArguments[0]->fType.isFloat()) {
this->writeInstruction(SpvOpConvertFToU, this->getType(c.fType), result, parameter,
out);
- } else if (c.fArguments[0]->fType == *fContext.fInt_Type) {
+ } else {
+ ASSERT(c.fArguments[0]->fType.isSigned());
this->writeInstruction(SpvOpBitcast, this->getType(c.fType), result, parameter,
out);
- } else if (c.fArguments[0]->fType == *fContext.fUInt_Type) {
- return parameter;
}
return result;
}
@@ -1794,11 +1819,15 @@
}
SpvId SPIRVCodeGenerator::writeConstructor(const Constructor& c, OutputStream& out) {
- if (c.fType == *fContext.fFloat_Type) {
+ if (c.fArguments.size() == 1 &&
+ this->getActualType(c.fType) == this->getActualType(c.fArguments[0]->fType)) {
+ return this->writeExpression(*c.fArguments[0], out);
+ }
+ if (c.fType == *fContext.fFloat_Type || c.fType == *fContext.fHalf_Type) {
return this->writeFloatConstructor(c, out);
- } else if (c.fType == *fContext.fInt_Type) {
+ } else if (c.fType == *fContext.fInt_Type || c.fType == *fContext.fShort_Type) {
return this->writeIntConstructor(c, out);
- } else if (c.fType == *fContext.fUInt_Type) {
+ } else if (c.fType == *fContext.fUInt_Type || c.fType == *fContext.fUShort_Type) {
return this->writeUIntConstructor(c, out);
}
switch (c.fType.kind()) {
@@ -2264,11 +2293,12 @@
if (b.fOperator == Token::COMMA) {
return rhs;
}
+ Type tmp("<invalid>");
// component type we are operating on: float, int, uint
const Type* operandType;
// IR allows mismatched types in expressions (e.g. float2* float), but they need special handling
// in SPIR-V
- if (b.fLeft->fType != b.fRight->fType) {
+ if (this->getActualType(b.fLeft->fType) != this->getActualType(b.fRight->fType)) {
if (b.fLeft->fType.kind() == Type::kVector_Kind &&
b.fRight->fType.isNumber()) {
// promote number to vector
@@ -2332,8 +2362,9 @@
ABORT("unsupported binary expression: %s", b.description().c_str());
}
} else {
- operandType = &b.fLeft->fType;
- ASSERT(*operandType == b.fRight->fType);
+ tmp = this->getActualType(b.fLeft->fType);
+ operandType = &tmp;
+ ASSERT(*operandType == this->getActualType(b.fRight->fType));
}
switch (b.fOperator) {
case Token::EQEQ: {
@@ -2712,7 +2743,7 @@
}
SpvId SPIRVCodeGenerator::writeFloatLiteral(const FloatLiteral& f) {
- if (f.fType == *fContext.fFloat_Type) {
+ if (f.fType == *fContext.fFloat_Type || f.fType == *fContext.fHalf_Type) {
float value = (float) f.fValue;
auto entry = fFloatConstants.find(value);
if (entry == fFloatConstants.end()) {
diff --git a/src/sksl/SkSLSPIRVCodeGenerator.h b/src/sksl/SkSLSPIRVCodeGenerator.h
index a532c9a..b12dc3e 100644
--- a/src/sksl/SkSLSPIRVCodeGenerator.h
+++ b/src/sksl/SkSLSPIRVCodeGenerator.h
@@ -98,6 +98,8 @@
SpvId nextId();
+ Type getActualType(const Type& type);
+
SpvId getType(const Type& type);
SpvId getType(const Type& type, const MemoryLayout& layout);
diff --git a/src/sksl/ast/SkSLASTPrecision.h b/src/sksl/ast/SkSLASTPrecision.h
deleted file mode 100644
index 4b50ed3..0000000
--- a/src/sksl/ast/SkSLASTPrecision.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SKSL_ASTPRECISION
-#define SKSL_ASTPRECISION
-
-#include "SkSLASTDeclaration.h"
-#include "../ir/SkSLModifiers.h"
-
-namespace SkSL {
-
-/**
- * Represents a precision declaration (e.g. 'precision mediump float;').
- */
-struct ASTPrecision : public ASTDeclaration {
- // FIXME handle the type
- ASTPrecision(Position position, Modifiers::Flag precision)
- : INHERITED(position, kPrecision_Kind)
- , fPrecision(precision) {}
-
- String description() const {
- switch (fPrecision) {
- case Modifiers::kLowp_Flag: return String("precision lowp float;");
- case Modifiers::kMediump_Flag: return String("precision mediump float;");
- case Modifiers::kHighp_Flag: return String("precision highp float;");
- default:
- ASSERT(false);
- return String("<error>");
- }
- ASSERT(false);
- return String("<error>");
- }
-
- const Modifiers::Flag fPrecision;
-
- typedef ASTDeclaration INHERITED;
-};
-
-} // namespace
-
-#endif
diff --git a/src/sksl/ir/SkSLConstructor.h b/src/sksl/ir/SkSLConstructor.h
index beed0f7..8f963e6 100644
--- a/src/sksl/ir/SkSLConstructor.h
+++ b/src/sksl/ir/SkSLConstructor.h
@@ -33,13 +33,15 @@
std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator,
const DefinitionMap& definitions) override {
if (fArguments.size() == 1 && fArguments[0]->fKind == Expression::kIntLiteral_Kind) {
- if (fType == *irGenerator.fContext.fFloat_Type) {
+ if (fType == *irGenerator.fContext.fFloat_Type ||
+ fType == *irGenerator.fContext.fHalf_Type) {
// promote float(1) to 1.0
int64_t intValue = ((IntLiteral&) *fArguments[0]).fValue;
return std::unique_ptr<Expression>(new FloatLiteral(irGenerator.fContext,
fPosition,
intValue));
- } else if (fType == *irGenerator.fContext.fUInt_Type) {
+ } else if (fType == *irGenerator.fContext.fUInt_Type ||
+ fType == *irGenerator.fContext.fUShort_Type) {
// promote uint(1) to 1u
int64_t intValue = ((IntLiteral&) *fArguments[0]).fValue;
return std::unique_ptr<Expression>(new IntLiteral(irGenerator.fContext,
diff --git a/src/sksl/ir/SkSLIRNode.h b/src/sksl/ir/SkSLIRNode.h
index 139be32..c03339e 100644
--- a/src/sksl/ir/SkSLIRNode.h
+++ b/src/sksl/ir/SkSLIRNode.h
@@ -24,7 +24,7 @@
virtual String description() const = 0;
- const Position fPosition;
+ Position fPosition;
};
} // namespace
diff --git a/src/sksl/ir/SkSLIndexExpression.h b/src/sksl/ir/SkSLIndexExpression.h
index c305365..58e3163 100644
--- a/src/sksl/ir/SkSLIndexExpression.h
+++ b/src/sksl/ir/SkSLIndexExpression.h
@@ -26,8 +26,15 @@
case 4: return *context.fFloat4_Type;
default: ASSERT(false);
}
+ } else if (type.componentType() == *context.fHalf_Type) {
+ switch (type.rows()) {
+ case 2: return *context.fHalf2_Type;
+ case 3: return *context.fHalf3_Type;
+ case 4: return *context.fHalf4_Type;
+ default: ASSERT(false);
+ }
} else {
- ASSERT(type.componentType() == *context.fDouble_Type);
+ ASSERT(type.componentType() == *context.fDouble_Type);
switch (type.rows()) {
case 2: return *context.fDouble2_Type;
case 3: return *context.fDouble3_Type;
diff --git a/src/sksl/ir/SkSLProgram.h b/src/sksl/ir/SkSLProgram.h
index a3eeaa3..0714083 100644
--- a/src/sksl/ir/SkSLProgram.h
+++ b/src/sksl/ir/SkSLProgram.h
@@ -104,14 +104,12 @@
Program(Kind kind,
Settings settings,
- Modifiers::Flag defaultPrecision,
Context* context,
std::vector<std::unique_ptr<ProgramElement>> elements,
std::shared_ptr<SymbolTable> symbols,
Inputs inputs)
: fKind(kind)
, fSettings(settings)
- , fDefaultPrecision(defaultPrecision)
, fContext(context)
, fSymbols(symbols)
, fElements(std::move(elements))
@@ -119,8 +117,6 @@
Kind fKind;
Settings fSettings;
- // FIXME handle different types; currently it assumes this is for floats
- Modifiers::Flag fDefaultPrecision;
Context* fContext;
// it's important to keep fElements defined after (and thus destroyed before) fSymbols,
// because destroying elements can modify reference counts in symbols
diff --git a/src/sksl/ir/SkSLSwizzle.h b/src/sksl/ir/SkSLSwizzle.h
index 9d7ca37..cb1343c 100644
--- a/src/sksl/ir/SkSLSwizzle.h
+++ b/src/sksl/ir/SkSLSwizzle.h
@@ -32,6 +32,12 @@
case 3: return *context.fFloat3_Type;
case 4: return *context.fFloat4_Type;
}
+ } else if (base == *context.fHalf_Type) {
+ switch (count) {
+ case 2: return *context.fHalf2_Type;
+ case 3: return *context.fHalf3_Type;
+ case 4: return *context.fHalf4_Type;
+ }
} else if (base == *context.fDouble_Type) {
switch (count) {
case 2: return *context.fDouble2_Type;
@@ -44,12 +50,24 @@
case 3: return *context.fInt3_Type;
case 4: return *context.fInt4_Type;
}
+ } else if (base == *context.fShort_Type) {
+ switch (count) {
+ case 2: return *context.fShort2_Type;
+ case 3: return *context.fShort3_Type;
+ case 4: return *context.fShort4_Type;
+ }
} else if (base == *context.fUInt_Type) {
switch (count) {
case 2: return *context.fUInt2_Type;
case 3: return *context.fUInt3_Type;
case 4: return *context.fUInt4_Type;
}
+ } else if (base == *context.fUShort_Type) {
+ switch (count) {
+ case 2: return *context.fUShort2_Type;
+ case 3: return *context.fUShort3_Type;
+ case 4: return *context.fUShort4_Type;
+ }
} else if (base == *context.fBool_Type) {
switch (count) {
case 2: return *context.fBool2_Type;
diff --git a/src/sksl/ir/SkSLSymbol.h b/src/sksl/ir/SkSLSymbol.h
index e883ea7..14e93a9 100644
--- a/src/sksl/ir/SkSLSymbol.h
+++ b/src/sksl/ir/SkSLSymbol.h
@@ -29,8 +29,8 @@
, fKind(kind)
, fName(std::move(name)) {}
- const Kind fKind;
- const String fName;
+ Kind fKind;
+ String fName;
typedef IRNode INHERITED;
};
diff --git a/src/sksl/ir/SkSLType.cpp b/src/sksl/ir/SkSLType.cpp
index 1fdc9bb..19bc58e 100644
--- a/src/sksl/ir/SkSLType.cpp
+++ b/src/sksl/ir/SkSLType.cpp
@@ -80,6 +80,38 @@
}
default: ABORT("unsupported row count (%d)", rows);
}
+ } else if (*this == *context.fHalf_Type) {
+ switch (rows) {
+ case 1:
+ switch (columns) {
+ case 2: return *context.fHalf2_Type;
+ case 3: return *context.fHalf3_Type;
+ case 4: return *context.fHalf4_Type;
+ default: ABORT("unsupported vector column count (%d)", columns);
+ }
+ case 2:
+ switch (columns) {
+ case 2: return *context.fHalf2x2_Type;
+ case 3: return *context.fHalf3x2_Type;
+ case 4: return *context.fHalf4x2_Type;
+ default: ABORT("unsupported matrix column count (%d)", columns);
+ }
+ case 3:
+ switch (columns) {
+ case 2: return *context.fHalf2x3_Type;
+ case 3: return *context.fHalf3x3_Type;
+ case 4: return *context.fHalf4x3_Type;
+ default: ABORT("unsupported matrix column count (%d)", columns);
+ }
+ case 4:
+ switch (columns) {
+ case 2: return *context.fHalf2x4_Type;
+ case 3: return *context.fHalf3x4_Type;
+ case 4: return *context.fHalf4x4_Type;
+ default: ABORT("unsupported matrix column count (%d)", columns);
+ }
+ default: ABORT("unsupported row count (%d)", rows);
+ }
} else if (*this == *context.fDouble_Type) {
switch (rows) {
case 1:
@@ -123,6 +155,17 @@
}
default: ABORT("unsupported row count (%d)", rows);
}
+ } else if (*this == *context.fShort_Type) {
+ switch (rows) {
+ case 1:
+ switch (columns) {
+ case 2: return *context.fShort2_Type;
+ case 3: return *context.fShort3_Type;
+ case 4: return *context.fShort4_Type;
+ default: ABORT("unsupported vector column count (%d)", columns);
+ }
+ default: ABORT("unsupported row count (%d)", rows);
+ }
} else if (*this == *context.fUInt_Type) {
switch (rows) {
case 1:
@@ -134,6 +177,17 @@
}
default: ABORT("unsupported row count (%d)", rows);
}
+ } else if (*this == *context.fUShort_Type) {
+ switch (rows) {
+ case 1:
+ switch (columns) {
+ case 2: return *context.fUShort2_Type;
+ case 3: return *context.fUShort3_Type;
+ case 4: return *context.fUShort4_Type;
+ default: ABORT("unsupported vector column count (%d)", columns);
+ }
+ default: ABORT("unsupported row count (%d)", rows);
+ }
} else if (*this == *context.fBool_Type) {
switch (rows) {
case 1:
diff --git a/src/sksl/ir/SkSLType.h b/src/sksl/ir/SkSLType.h
index 6ea4c56..d7220f1 100644
--- a/src/sksl/ir/SkSLType.h
+++ b/src/sksl/ir/SkSLType.h
@@ -81,18 +81,20 @@
, fFields(std::move(fields)) {}
// Create a scalar type.
- Type(String name, NumberKind numberKind)
+ Type(String name, NumberKind numberKind, int priority)
: INHERITED(Position(), kType_Kind, std::move(name))
, fTypeKind(kScalar_Kind)
, fNumberKind(numberKind)
+ , fPriority(priority)
, fColumns(1)
, fRows(1) {}
// Create a scalar type which can be coerced to the listed types.
- Type(String name, NumberKind numberKind, std::vector<const Type*> coercibleTypes)
+ Type(String name, NumberKind numberKind, int priority, std::vector<const Type*> coercibleTypes)
: INHERITED(Position(), kType_Kind, std::move(name))
, fTypeKind(kScalar_Kind)
, fNumberKind(numberKind)
+ , fPriority(priority)
, fCoercibleTypes(std::move(coercibleTypes))
, fColumns(1)
, fRows(1) {}
@@ -192,6 +194,14 @@
}
/**
+ * Returns the "priority" of a number type, in order of double > float > half > int > short.
+ * When operating on two number types, the result is the higher-priority type.
+ */
+ int priority() const {
+ return fPriority;
+ }
+
+ /**
* Returns true if an instance of this type can be freely coerced (implicitly converted) to
* another type.
*/
@@ -283,19 +293,20 @@
private:
typedef Symbol INHERITED;
- const Kind fTypeKind;
+ Kind fTypeKind;
// always kNonnumeric_NumberKind for non-scalar values
- const NumberKind fNumberKind;
+ NumberKind fNumberKind;
+ int fPriority = -1;
const Type* fComponentType = nullptr;
- const std::vector<const Type*> fCoercibleTypes;
- const int fColumns = -1;
- const int fRows = -1;
- const std::vector<Field> fFields;
- const SpvDim_ fDimensions = SpvDim1D;
- const bool fIsDepth = false;
- const bool fIsArrayed = false;
- const bool fIsMultisampled = false;
- const bool fIsSampled = false;
+ std::vector<const Type*> fCoercibleTypes;
+ int fColumns = -1;
+ int fRows = -1;
+ std::vector<Field> fFields;
+ SpvDim_ fDimensions = SpvDim1D;
+ bool fIsDepth = false;
+ bool fIsArrayed = false;
+ bool fIsMultisampled = false;
+ bool fIsSampled = false;
};
} // namespace
diff --git a/src/sksl/sksl.include b/src/sksl/sksl.include
index 7b738d5..aab9930 100644
--- a/src/sksl/sksl.include
+++ b/src/sksl/sksl.include
@@ -43,14 +43,14 @@
//$genDType ceil($genDType x);
$genType fract($genType x);
//$genDType fract($genDType x);
-$genType mod($genType x, float y);
+$genType mod($genType x, highfloat y);
$genType mod($genType x, $genType y);
//$genDType mod($genDType x, double y);
//$genDType mod($genDType x, $genDType y);
$genType modf($genType x, out $genType i);
//$genDType modf($genDType x, out $genDType i);
$genType min($genType x, $genType y);
-$genType min($genType x, float y);
+$genType min($genType x, highfloat y);
//$genDType min($genDType x, $genDType y);
//$genDType min($genDType x, double y);
$genIType min($genIType x, $genIType y);
@@ -58,7 +58,7 @@
//$genUType min($genUType x, $genUType y);
//$genUType min($genUType x, uint y);
$genType max($genType x, $genType y);
-$genType max($genType x, float y);
+$genType max($genType x, highfloat y);
//$genDType max($genDType x, $genDType y);
//$genDType max($genDType x, double y);
$genIType max($genIType x, $genIType y);
@@ -66,7 +66,7 @@
//$genUType max($genUType x, $genUType y);
//$genUType max($genUType x, uint y);
$genType clamp($genType x, $genType minVal, $genType maxVal);
-$genType clamp($genType x, float minVal, float maxVal);
+$genType clamp($genType x, highfloat minVal, highfloat maxVal);
//$genDType clamp($genDType x, $genDType minVal, $genDType maxVal);
//$genDType clamp($genDType x, double minVal, double maxVal);
$genIType clamp($genIType x, $genIType minVal, $genIType maxVal);
@@ -74,7 +74,7 @@
//$genUType clamp($genUType x, $genUType minVal, $genUType maxVal);
//$genUType clamp($genUType x, uint minVal, uint maxVal);
$genType mix($genType x, $genType y, $genType a);
-$genType mix($genType x, $genType y, float a);
+$genType mix($genType x, $genType y, highfloat a);
//$genDType mix($genDType x, $genDType y, $genDType a);
//$genDType mix($genDType x, $genDType y, double a);
$genType mix($genType x, $genType y, $genBType a);
@@ -83,21 +83,21 @@
//$genUType mix($genUType x, $genUType y, $genBType a);
$genBType mix($genBType x, $genBType y, $genBType a);
$genType step($genType edge, $genType x);
-$genType step(float edge, $genType x);
+$genType step(highfloat edge, $genType x);
//$genDType step($genDType edge, $genDType x);
//$genDType step(double edge, $genDType x);
$genType smoothstep($genType edge0, $genType edge1, $genType x);
-$genType smoothstep(float edge0, float edge1, $genType x);
+$genType smoothstep(highfloat edge0, highfloat edge1, $genType x);
//$genDType smoothstep($genDType edge0, $genDType edge1, $genDType x);
//$genDType smoothstep(double edge0, double edge1, $genDType x);
$genBType isnan($genType x);
$genBType isnan($genDType x);
$genBType isinf($genType x);
$genBType isinf($genDType x);
-$genIType floatBitsToInt($genType value);
-//$genUType floatBitsToUint($genType value);
-$genType intBitsToFloat($genIType value);
-$genType uintBitsToFloat($genUType value);
+$genIType highfloatBitsToInt($genType value);
+//$genUType highfloatBitsToUint($genType value);
+$genType intBitsTohighfloat($genIType value);
+$genType uintBitsTohighfloat($genUType value);
$genType fma($genType a, $genType b, $genType c);
$genHType fma($genHType a, $genHType b, $genHType c);
$genDType fma($genDType a, $genDType b, $genDType c);
@@ -106,68 +106,68 @@
//$genDType frexp($genDType x, out $genIType exp);
$genType ldexp($genType x, in $genIType exp);
//$genDType ldexp($genDType x, in $genIType exp);
-uint packUnorm2x16(float2 v);
-uint packSnorm2x16(float2 v);
-uint packUnorm4x8(float4 v);
-uint packSnorm4x8(float4 v);
-float2 unpackUnorm2x16(uint p);
-float2 unpackSnorm2x16(uint p);
-float4 unpackUnorm4x8(uint p);
-float4 unpackSnorm4x8(uint p);
+uint packUnorm2x16(highfloat2 v);
+uint packSnorm2x16(highfloat2 v);
+uint packUnorm4x8(highfloat4 v);
+uint packSnorm4x8(highfloat4 v);
+highfloat2 unpackUnorm2x16(uint p);
+highfloat2 unpackSnorm2x16(uint p);
+highfloat4 unpackUnorm4x8(uint p);
+highfloat4 unpackSnorm4x8(uint p);
//double packDouble2x32(uint2 v);
uint2 unpackDouble2x32(double v);
-uint packHalf2x16(float2 v);
-float2 unpackHalf2x16(uint v);
-float length($genType x);
+uint packHalf2x16(highfloat2 v);
+highfloat2 unpackHalf2x16(uint v);
+highfloat length($genType x);
half length($genHType x);
double length($genDType x);
-float distance($genType p0, $genType p1);
+highfloat distance($genType p0, $genType p1);
half distance($genHType p0, $genHType p1);
double distance($genDType p0, $genDType p1);
-float dot($genType x, $genType y);
+highfloat dot($genType x, $genType y);
half dot($genHType x, $genHType y);
double dot($genDType x, $genDType y);
-float3 cross(float3 x, float3 y);
+highfloat3 cross(highfloat3 x, highfloat3 y);
half3 cross(half3 x, half3 y);
double3 cross(double3 x, double3 y);
$genType normalize($genType x);
$genHType normalize($genHType x);
$genDType normalize($genDType x);
-float4 ftransform();
+highfloat4 ftransform();
$genType faceforward($genType N, $genType I, $genType Nref);
$genHType faceforward($genHType N, $genHType I, $genHType Nref);
$genDType faceforward($genDType N, $genDType I, $genDType Nref);
$genType reflect($genType I, $genType N);
$genHType reflect($genHType I, $genHType N);
$genDType reflect($genDType I, $genDType N);
-$genType refract($genType I, $genType N, float eta);
-$genHType refract($genHType I, $genHType N, float eta);
-$genDType refract($genDType I, $genDType N, float eta);
+$genType refract($genType I, $genType N, highfloat eta);
+$genHType refract($genHType I, $genHType N, highfloat eta);
+$genDType refract($genDType I, $genDType N, highfloat eta);
$mat matrixCompMult($mat x, $mat y);
-float2x2 outerProduct(float2 c, float2 r);
-float3x3 outerProduct(float3 c, float3 r);
-float4x3 outerProduct(float4 c, float4 r);
-float2x3 outerProduct(float3 c, float2 r);
-float3x2 outerProduct(float2 c, float3 r);
-float2x4 outerProduct(float4 c, float2 r);
-float4x2 outerProduct(float2 c, float4 r);
-float3x4 outerProduct(float4 c, float3 r);
-float4x3 outerProduct(float3 c, float4 r);
-float2x2 transpose(float2x2 m);
-float3x3 transpose(float3x3 m);
-float4x4 transpose(float4x4 m);
-float2x3 transpose(float3x2 m);
-float3x2 transpose(float2x3 m);
-float2x4 transpose(float4x2 m);
-float4x2 transpose(float2x4 m);
-float3x4 transpose(float4x3 m);
-float4x3 transpose(float3x4 m);
-float determinant(float2x2 m);
-float determinant(float3x3 m);
-float determinant(float4x4 m);
-float2x2 inverse(float2x2 m);
-float3x3 inverse(float3x3 m);
-float4x4 inverse(float4x4 m);
+highfloat2x2 outerProduct(highfloat2 c, highfloat2 r);
+highfloat3x3 outerProduct(highfloat3 c, highfloat3 r);
+highfloat4x3 outerProduct(highfloat4 c, highfloat4 r);
+highfloat2x3 outerProduct(highfloat3 c, highfloat2 r);
+highfloat3x2 outerProduct(highfloat2 c, highfloat3 r);
+highfloat2x4 outerProduct(highfloat4 c, highfloat2 r);
+highfloat4x2 outerProduct(highfloat2 c, highfloat4 r);
+highfloat3x4 outerProduct(highfloat4 c, highfloat3 r);
+highfloat4x3 outerProduct(highfloat3 c, highfloat4 r);
+highfloat2x2 transpose(highfloat2x2 m);
+highfloat3x3 transpose(highfloat3x3 m);
+highfloat4x4 transpose(highfloat4x4 m);
+highfloat2x3 transpose(highfloat3x2 m);
+highfloat3x2 transpose(highfloat2x3 m);
+highfloat2x4 transpose(highfloat4x2 m);
+highfloat4x2 transpose(highfloat2x4 m);
+highfloat3x4 transpose(highfloat4x3 m);
+highfloat4x3 transpose(highfloat3x4 m);
+highfloat determinant(highfloat2x2 m);
+highfloat determinant(highfloat3x3 m);
+highfloat determinant(highfloat4x4 m);
+highfloat2x2 inverse(highfloat2x2 m);
+highfloat3x3 inverse(highfloat3x3 m);
+highfloat4x4 inverse(highfloat4x4 m);
$bvec lessThan($vec x, $vec y);
$bvec lessThan($hvec x, $hvec y);
$bvec lessThan($dvec x, $dvec y);
@@ -254,19 +254,19 @@
int textureSize($gsamplerBuffer sampler);
int2 textureSize($gsampler2DMS sampler);
int3 textureSize($gsampler2DMSArray sampler);
-float2 textureQueryLod($gsampler1D sampler, float P);
-float2 textureQueryLod($gsampler2D sampler, float2 P);
-float2 textureQueryLod($gsampler3D sampler, float3 P);
-float2 textureQueryLod($gsamplerCube sampler, float3 P);
-float2 textureQueryLod($gsampler1DArray sampler, float P);
-float2 textureQueryLod($gsampler2DArray sampler, float2 P);
-float2 textureQueryLod($gsamplerCubeArray sampler, float3 P);
-float2 textureQueryLod(sampler1DShadow sampler, float P);
-float2 textureQueryLod(sampler2DShadow sampler, float2 P);
-float2 textureQueryLod(samplerCubeShadow sampler, float3 P);
-float2 textureQueryLod(sampler1DArrayShadow sampler, float P);
-float2 textureQueryLod(sampler2DArrayShadow sampler, float2 P);
-float2 textureQueryLod(samplerCubeArrayShadow sampler, float3 P);
+highfloat2 textureQueryLod($gsampler1D sampler, highfloat P);
+highfloat2 textureQueryLod($gsampler2D sampler, highfloat2 P);
+highfloat2 textureQueryLod($gsampler3D sampler, highfloat3 P);
+highfloat2 textureQueryLod($gsamplerCube sampler, highfloat3 P);
+highfloat2 textureQueryLod($gsampler1DArray sampler, highfloat P);
+highfloat2 textureQueryLod($gsampler2DArray sampler, highfloat2 P);
+highfloat2 textureQueryLod($gsamplerCubeArray sampler, highfloat3 P);
+highfloat2 textureQueryLod(sampler1DShadow sampler, highfloat P);
+highfloat2 textureQueryLod(sampler2DShadow sampler, highfloat2 P);
+highfloat2 textureQueryLod(samplerCubeShadow sampler, highfloat3 P);
+highfloat2 textureQueryLod(sampler1DArrayShadow sampler, highfloat P);
+highfloat2 textureQueryLod(sampler2DArrayShadow sampler, highfloat2 P);
+highfloat2 textureQueryLod(samplerCubeArrayShadow sampler, highfloat3 P);
int textureQueryLevels($gsampler1D sampler);
int textureQueryLevels($gsampler2D sampler);
int textureQueryLevels($gsampler3D sampler);
@@ -282,50 +282,50 @@
int textureQueryLevels(samplerCubeArrayShadow sampler);
*/
-$gfloat4 texture($gsampler1D sampler, float P);
-$gfloat4 texture($gsampler1D sampler, float P, float bias);
-$gfloat4 texture($gsampler2D sampler, float2 P);
+half4 texture($gsampler1D sampler, highfloat P);
+half4 texture($gsampler1D sampler, highfloat P, highfloat bias);
+half4 texture($gsampler2D sampler, highfloat2 P);
// The above currently only expand to handle the float/fixed case. So we also declare this integer
// version of texture().
-int4 texture(isampler2D sampler, float2 P);
-float4 texture(samplerExternalOES sampler, float2 P, float bias);
-float4 texture(samplerExternalOES sampler, float2 P);
+int4 texture(isampler2D sampler, highfloat2 P);
+half4 texture(samplerExternalOES sampler, highfloat2 P, highfloat bias);
+half4 texture(samplerExternalOES sampler, highfloat2 P);
/*
-$gfloat4 texture($gsampler2D sampler, float2 P, float bias);
-$gfloat4 texture($gsampler3D sampler, float3 P);
-$gfloat4 texture($gsampler3D sampler, float3 P, float bias);
-$gfloat4 texture($gsamplerCube sampler, float3 P);
-$gfloat4 texture($gsamplerCube sampler, float3 P, float bias);
-float texture(sampler1DShadow sampler, float3 P);
-float texture(sampler1DShadow sampler, float3 P, float bias);
-float texture(sampler2DShadow sampler, float3 P);
-float texture(sampler2DShadow sampler, float3 P, float bias);
-float texture(samplerCubeShadow sampler, float4 P);
-float texture(samplerCubeShadow sampler, float4 P, float bias);
-$gfloat4 texture($gsampler1DArray sampler, float2 P);
-$gfloat4 texture($gsampler1DArray sampler, float2 P, float bias);
-$gfloat4 texture($gsampler2DArray sampler, float3 P);
-$gfloat4 texture($gsampler2DArray sampler, float3 P, float bias);
-$gfloat4 texture($gsamplerCubeArray sampler, float4 P);
-$gfloat4 texture($gsamplerCubeArray sampler, float4 P, float bias);
-float texture(sampler1DArrayShadow sampler, float3 P);
-float texture(sampler1DArrayShadow sampler, float3 P, float bias);
-float texture(sampler2DArrayShadow sampler, float4 P);
+$gfloat4 texture($gsampler2D sampler, highfloat2 P, highfloat bias);
+$gfloat4 texture($gsampler3D sampler, highfloat3 P);
+$gfloat4 texture($gsampler3D sampler, highfloat3 P, highfloat bias);
+$gfloat4 texture($gsamplerCube sampler, highfloat3 P);
+$gfloat4 texture($gsamplerCube sampler, highfloat3 P, highfloat bias);
+highfloat texture(sampler1DShadow sampler, highfloat3 P);
+highfloat texture(sampler1DShadow sampler, highfloat3 P, highfloat bias);
+highfloat texture(sampler2DShadow sampler, highfloat3 P);
+highfloat texture(sampler2DShadow sampler, highfloat3 P, highfloat bias);
+highfloat texture(samplerCubeShadow sampler, highfloat4 P);
+highfloat texture(samplerCubeShadow sampler, highfloat4 P, highfloat bias);
+$gfloat4 texture($gsampler1DArray sampler, highfloat2 P);
+$gfloat4 texture($gsampler1DArray sampler, highfloat2 P, highfloat bias);
+$gfloat4 texture($gsampler2DArray sampler, highfloat3 P);
+$gfloat4 texture($gsampler2DArray sampler, highfloat3 P, highfloat bias);
+$gfloat4 texture($gsamplerCubeArray sampler, highfloat4 P);
+$gfloat4 texture($gsamplerCubeArray sampler, highfloat4 P, highfloat bias);
+highfloat texture(sampler1DArrayShadow sampler, highfloat3 P);
+highfloat texture(sampler1DArrayShadow sampler, highfloat3 P, highfloat bias);
+highfloat texture(sampler2DArrayShadow sampler, highfloat4 P);
*/
-$gfloat4 texture($gsampler2DRect sampler, float2 P);
-$gfloat4 texture($gsampler2DRect sampler, float3 P);
+half4 texture($gsampler2DRect sampler, highfloat2 P);
+half4 texture($gsampler2DRect sampler, highfloat3 P);
/*
-float texture(sampler2DRectShadow sampler, float3 P);
-float texture($gsamplerCubeArrayShadow sampler, float4 P, float compare);
+highfloat texture(sampler2DRectShadow sampler, highfloat3 P);
+highfloat texture($gsamplerCubeArrayShadow sampler, highfloat4 P, highfloat compare);
*/
// Currently we do not support the generic types of loading subpassInput so we have some explicit
// versions that we currently use
-float4 subpassLoad(subpassInput subpass);
-float4 subpassLoad(subpassInputMS subpass, int sample);
+highfloat4 subpassLoad(subpassInput subpass);
+highfloat4 subpassLoad(subpassInputMS subpass, int sample);
/*
$gfloat4subpassLoad(gsubpassInput subpass);
$gfloat4subpassLoad(gsubpassInputMS subpass, int sample);
@@ -336,50 +336,50 @@
STRINGIFY(
-$gfloat4 texture($gsampler1D sampler, float2 P);
-$gfloat4 texture($gsampler1D sampler, float2 P, float bias);
-$gfloat4 texture($gsampler2D sampler, float3 P);
-$gfloat4 texture($gsampler2D sampler, float3 P, float bias);
+half4 texture($gsampler1D sampler, highfloat2 P);
+half4 texture($gsampler1D sampler, highfloat2 P, highfloat bias);
+half4 texture($gsampler2D sampler, highfloat3 P);
+half4 texture($gsampler2D sampler, highfloat3 P, highfloat bias);
/*
-$gfloat4 textureProj($gsampler3D sampler, float4 P);
-$gfloat4 textureProj($gsampler3D sampler, float4 P, float bias);
-float textureProj(sampler1DShadow sampler, float4 P);
-float textureProj(sampler1DShadow sampler, float4 P, float bias);
-float textureProj(sampler2DShadow sampler, float4 P);
-float textureProj(sampler2DShadow sampler, float4 P, float bias);
-$gfloat4 textureProj($gsampler2DRect sampler, float4 P);
-float textureProj(sampler2DRectShadow sampler, float4 P);
-$gfloat4 textureLod($gsampler1D sampler, float P, float lod);
-$gfloat4 textureLod($gsampler2D sampler, float2 P, float lod);
-$gfloat4 textureLod($gsampler3D sampler, float3 P, float lod);
-$gfloat4 textureLod($gsamplerCube sampler, float3 P, float lod);
-float textureLod(sampler1DShadow sampler, float3 P, float lod);
-float textureLod(sampler2DShadow sampler, float3 P, float lod);
-$gfloat4 textureLod($gsampler1DArray sampler, float2 P, float lod);
-$gfloat4 textureLod($gsampler2DArray sampler, float3 P, float lod);
-float textureLod(sampler1DArrayShadow sampler, float3 P, float lod);
-$gfloat4 textureLod($gsamplerCubeArray sampler, float4 P, float lod);
-$gfloat4 textureOffset($gsampler1D sampler, float P, int offset);
-$gfloat4 textureOffset($gsampler1D sampler, float P, int offset, float bias);
-$gfloat4 textureOffset($gsampler2D sampler, float2 P, int2 offset);
-$gfloat4 textureOffset($gsampler2D sampler, float2 P, int2 offset, float bias);
-$gfloat4 textureOffset($gsampler3D sampler, float3 P, int3 offset);
-$gfloat4 textureOffset($gsampler3D sampler, float3 P, int3 offset, float bias);
-$gfloat4 textureOffset($gsampler2DRect sampler, float2 P, int2 offset);
-float textureOffset(sampler2DRectShadow sampler, float3 P, int2 offset);
-float textureOffset(sampler1DShadow sampler, float3 P, int offset);
-float textureOffset(sampler1DShadow sampler, float3 P, int offset, float bias);
-float textureOffset(sampler2DShadow sampler, float3 P, int2 offset);
-float textureOffset(sampler2DShadow sampler, float3 P, int2 offset, float bias);
-$gfloat4 textureOffset($gsampler1DArray sampler, float2 P, int offset);
-$gfloat4 textureOffset($gsampler1DArray sampler, float2 P, int offset, float bias);
-$gfloat4 textureOffset($gsampler2DArray sampler, float3 P, int2 offset);
-$gfloat4 textureOffset($gsampler2DArray sampler, float3 P, int2 offset, float bias);
-float textureOffset(sampler1DArrayShadow sampler, float3 P, int offset);
-float textureOffset(sampler1DArrayShadow sampler, float3 P, int offset, float bias);
-float textureOffset(sampler2DArrayShadow sampler, float4 P, int2 offset);
+$gfloat4 textureProj($gsampler3D sampler, highfloat4 P);
+$gfloat4 textureProj($gsampler3D sampler, highfloat4 P, highfloat bias);
+highfloat textureProj(sampler1DShadow sampler, highfloat4 P);
+highfloat textureProj(sampler1DShadow sampler, highfloat4 P, highfloat bias);
+highfloat textureProj(sampler2DShadow sampler, highfloat4 P);
+highfloat textureProj(sampler2DShadow sampler, highfloat4 P, highfloat bias);
+$gfloat4 textureProj($gsampler2DRect sampler, highfloat4 P);
+highfloat textureProj(sampler2DRectShadow sampler, highfloat4 P);
+$gfloat4 textureLod($gsampler1D sampler, highfloat P, highfloat lod);
+$gfloat4 textureLod($gsampler2D sampler, highfloat2 P, highfloat lod);
+$gfloat4 textureLod($gsampler3D sampler, highfloat3 P, highfloat lod);
+$gfloat4 textureLod($gsamplerCube sampler, highfloat3 P, highfloat lod);
+highfloat textureLod(sampler1DShadow sampler, highfloat3 P, highfloat lod);
+highfloat textureLod(sampler2DShadow sampler, highfloat3 P, highfloat lod);
+$gfloat4 textureLod($gsampler1DArray sampler, highfloat2 P, highfloat lod);
+$gfloat4 textureLod($gsampler2DArray sampler, highfloat3 P, highfloat lod);
+highfloat textureLod(sampler1DArrayShadow sampler, highfloat3 P, highfloat lod);
+$gfloat4 textureLod($gsamplerCubeArray sampler, highfloat4 P, highfloat lod);
+$gfloat4 textureOffset($gsampler1D sampler, highfloat P, int offset);
+$gfloat4 textureOffset($gsampler1D sampler, highfloat P, int offset, highfloat bias);
+$gfloat4 textureOffset($gsampler2D sampler, highfloat2 P, int2 offset);
+$gfloat4 textureOffset($gsampler2D sampler, highfloat2 P, int2 offset, highfloat bias);
+$gfloat4 textureOffset($gsampler3D sampler, highfloat3 P, int3 offset);
+$gfloat4 textureOffset($gsampler3D sampler, highfloat3 P, int3 offset, highfloat bias);
+$gfloat4 textureOffset($gsampler2DRect sampler, highfloat2 P, int2 offset);
+highfloat textureOffset(sampler2DRectShadow sampler, highfloat3 P, int2 offset);
+highfloat textureOffset(sampler1DShadow sampler, highfloat3 P, int offset);
+highfloat textureOffset(sampler1DShadow sampler, highfloat3 P, int offset, highfloat bias);
+highfloat textureOffset(sampler2DShadow sampler, highfloat3 P, int2 offset);
+highfloat textureOffset(sampler2DShadow sampler, highfloat3 P, int2 offset, highfloat bias);
+$gfloat4 textureOffset($gsampler1DArray sampler, highfloat2 P, int offset);
+$gfloat4 textureOffset($gsampler1DArray sampler, highfloat2 P, int offset, highfloat bias);
+$gfloat4 textureOffset($gsampler2DArray sampler, highfloat3 P, int2 offset);
+$gfloat4 textureOffset($gsampler2DArray sampler, highfloat3 P, int2 offset, highfloat bias);
+highfloat textureOffset(sampler1DArrayShadow sampler, highfloat3 P, int offset);
+highfloat textureOffset(sampler1DArrayShadow sampler, highfloat3 P, int offset, highfloat bias);
+highfloat textureOffset(sampler2DArrayShadow sampler, highfloat4 P, int2 offset);
*/
-float4 texelFetch(samplerBuffer sampler, int P);
+highfloat4 texelFetch(samplerBuffer sampler, int P);
$gfloat4 texelFetch($gsampler1D sampler, int P, int lod);
$gfloat4 texelFetch($gsampler2D sampler, int2 P, int lod);
@@ -396,123 +396,123 @@
$gfloat4 texelFetchOffset($gsampler2DRect sampler, int2 P, int2 offset);
$gfloat4 texelFetchOffset($gsampler1DArray sampler, int2 P, int lod, int offset);
$gfloat4 texelFetchOffset($gsampler2DArray sampler, int3 P, int lod, int2 offset);
-$gfloat4 textureProjOffset($gsampler1D sampler, float2 P, int offset);
-$gfloat4 textureProjOffset($gsampler1D sampler, float2 P, int offset, float bias);
-$gfloat4 textureProjOffset($gsampler1D sampler, float4 P, int offset);
-$gfloat4 textureProjOffset($gsampler1D sampler, float4 P, int offset, float bias);
-$gfloat4 textureProjOffset($gsampler2D sampler, float3 P, int2 offset);
-$gfloat4 textureProjOffset($gsampler2D sampler, float3 P, int2 offset, float bias);
-$gfloat4 textureProjOffset($gsampler2D sampler, float4 P, int2 offset);
-$gfloat4 textureProjOffset($gsampler2D sampler, float4 P, int2 offset, float bias);
-$gfloat4 textureProjOffset($gsampler3D sampler, float4 P, int3 offset);
-$gfloat4 textureProjOffset($gsampler3D sampler, float4 P, int3 offset, float bias);
-$gfloat4 textureProjOffset($gsampler2DRect sampler, float3 P, int2 offset);
-$gfloat4 textureProjOffset($gsampler2DRect sampler, float4 P, int2 offset);
-float textureProjOffset(sampler2DRectShadow sampler, float4 P, int2 offset);
-float textureProjOffset(sampler1DShadow sampler, float4 P, int offset);
-float textureProjOffset(sampler1DShadow sampler, float4 P, int offset, float bias);
-float textureProjOffset(sampler2DShadow sampler, float4 P, int2 offset);
-float textureProjOffset(sampler2DShadow sampler, float4 P, int2 offset, float bias);
-$gfloat4 textureLodOffset($gsampler1D sampler, float P, float lod, int offset);
-$gfloat4 textureLodOffset($gsampler2D sampler, float2 P, float lod, int2 offset);
-$gfloat4 textureLodOffset($gsampler3D sampler, float3 P, float lod, int3 offset);
-float textureLodOffset(sampler1DShadow sampler, float3 P, float lod, int offset);
-float textureLodOffset(sampler2DShadow sampler, float3 P, float lod, int2 offset);
-$gfloat4 textureLodOffset($gsampler1DArray sampler, float2 P, float lod, int offset);
-$gfloat4 textureLodOffset($gsampler2DArray sampler, float3 P, float lod, int2 offset);
-float textureLodOffset(sampler1DArrayShadow sampler, float3 P, float lod, int offset);
-$gfloat4 textureProjLod($gsampler1D sampler, float2 P, float lod);
-$gfloat4 textureProjLod($gsampler1D sampler, float4 P, float lod);
-$gfloat4 textureProjLod($gsampler2D sampler, float3 P, float lod);
-$gfloat4 textureProjLod($gsampler2D sampler, float4 P, float lod);
-$gfloat4 textureProjLod($gsampler3D sampler, float4 P, float lod);
-float textureProjLod(sampler1DShadow sampler, float4 P, float lod);
-float textureProjLod(sampler2DShadow sampler, float4 P, float lod);
-$gfloat4 textureProjLodOffset($gsampler1D sampler, float2 P, float lod, int offset);
-$gfloat4 textureProjLodOffset($gsampler1D sampler, float4 P, float lod, int offset);
-$gfloat4 textureProjLodOffset($gsampler2D sampler, float3 P, float lod, int2 offset);
-$gfloat4 textureProjLodOffset($gsampler2D sampler, float4 P, float lod, int2 offset);
-$gfloat4 textureProjLodOffset($gsampler3D sampler, float4 P, float lod, int3 offset);
-float textureProjLodOffset(sampler1DShadow sampler, float4 P, float lod, int offset);
-float textureProjLodOffset(sampler2DShadow sampler, float4 P, float lod, int2 offset);
-$gfloat4 textureGrad($gsampler1D sampler, float P, float dPdx, float dPdy);
-$gfloat4 textureGrad($gsampler2D sampler, float2 P, float2 dPdx, float2 dPdy);
-$gfloat4 textureGrad($gsampler3D sampler, float3 P, float3 dPdx, float3 dPdy);
-$gfloat4 textureGrad($gsamplerCube sampler, float3 P, float3 dPdx, float3 dPdy);
-$gfloat4 textureGrad($gsampler2DRect sampler, float2 P, float2 dPdx, float2 dPdy);
-float textureGrad(sampler2DRectShadow sampler, float3 P, float2 dPdx, float2 dPdy);
-float textureGrad(sampler1DShadow sampler, float3 P, float dPdx, float dPdy);
-float textureGrad(sampler2DShadow sampler, float3 P, float2 dPdx, float2 dPdy);
-float textureGrad(samplerCubeShadow sampler, float4 P, float3 dPdx, float3 dPdy);
-$gfloat4 textureGrad($gsampler1DArray sampler, float2 P, float dPdx, float dPdy);
-$gfloat4 textureGrad($gsampler2DArray sampler, float3 P, float2 dPdx, float2 dPdy);
-float textureGrad(sampler1DArrayShadow sampler, float3 P, float dPdx, float dPdy);
-float textureGrad(sampler2DArrayShadow sampler, float4 P, float2 dPdx, float2 dPdy);
-$gfloat4 textureGrad($gsamplerCubeArray sampler, float4 P, float3 dPdx, float3 dPdy);
-$gfloat4 textureGradOffset($gsampler1D sampler, float P, float dPdx, float dPdy, int offset);
-$gfloat4 textureGradOffset($gsampler2D sampler, float2 P, float2 dPdx, float2 dPdy, int2 offset);
-$gfloat4 textureGradOffset($gsampler3D sampler, float3 P, float3 dPdx, float3 dPdy, int3 offset);
-$gfloat4 textureGradOffset($gsampler2DRect sampler, float2 P, float2 dPdx, float2 dPdy, int2 offset);
-float textureGradOffset(sampler2DRectShadow sampler, float3 P, float2 dPdx, float2 dPdy, int2 offset);
-float textureGradOffset(sampler1DShadow sampler, float3 P, float dPdx, float dPdy, int offset );
-float textureGradOffset(sampler2DShadow sampler, float3 P, float2 dPdx, float2 dPdy, int2 offset);
-$gfloat4 textureGradOffset($gsampler1DArray sampler, float2 P, float dPdx, float dPdy, int offset);
-$gfloat4 textureGradOffset($gsampler2DArray sampler, float3 P, float2 dPdx, float2 dPdy, int2 offset);
-float textureGradOffset(sampler1DArrayShadow sampler, float3 P, float dPdx, float dPdy, int offset);
-float textureGradOffset(sampler2DArrayShadow sampler, float4 P, float2 dPdx, float2 dPdy, int2 offset);
-$gfloat4 textureProjGrad($gsampler1D sampler, float2 P, float dPdx, float dPdy);
-$gfloat4 textureProjGrad($gsampler1D sampler, float4 P, float dPdx, float dPdy);
-$gfloat4 textureProjGrad($gsampler2D sampler, float3 P, float2 dPdx, float2 dPdy);
-$gfloat4 textureProjGrad($gsampler2D sampler, float4 P, float2 dPdx, float2 dPdy);
-$gfloat4 textureProjGrad($gsampler3D sampler, float4 P, float3 dPdx, float3 dPdy);
-$gfloat4 textureProjGrad($gsampler2DRect sampler, float3 P, float2 dPdx, float2 dPdy);
-$gfloat4 textureProjGrad($gsampler2DRect sampler, float4 P, float2 dPdx, float2 dPdy);
-float textureProjGrad(sampler2DRectShadow sampler, float4 P, float2 dPdx, float2 dPdy);
-float textureProjGrad(sampler1DShadow sampler, float4 P, float dPdx, float dPdy);
-float textureProjGrad(sampler2DShadow sampler, float4 P, float2 dPdx, float2 dPdy);
-$gfloat4 textureProjGradOffset($gsampler1D sampler, float2 P, float dPdx, float dPdy, int offset);
-$gfloat4 textureProjGradOffset($gsampler1D sampler, float4 P, float dPdx, float dPdy, int offset);
-$gfloat4 textureProjGradOffset($gsampler2D sampler, float3 P, float2 dPdx, float2 dPdy, int2 offset);
-$gfloat4 textureProjGradOffset($gsampler2D sampler, float4 P, float2 dPdx, float2 dPdy, int2 offset);
-$gfloat4 textureProjGradOffset($gsampler2DRect sampler, float3 P, float2 dPdx, float2 dPdy, int2 offset);
-$gfloat4 textureProjGradOffset($gsampler2DRect sampler, float4 P, float2 dPdx, float2 dPdy, int2 offset);
-float textureProjGradOffset(sampler2DRectShadow sampler, float4 P, float2 dPdx, float2 dPdy, int2 offset);
-$gfloat4 textureProjGradOffset($gsampler3D sampler, float4 P, float3 dPdx, float3 dPdy, int3 offset);
-float textureProjGradOffset(sampler1DShadow sampler, float4 P, float dPdx, float dPdy, int offset);
-float textureProjGradOffset(sampler2DShadow sampler, float4 P, float2 dPdx, float2 dPdy, int2 offset);
-$gfloat4 textureGather($gsampler2D sampler, float2 P);
-$gfloat4 textureGather($gsampler2D sampler, float2 P, int comp);
-$gfloat4 textureGather($gsampler2DArray sampler, float3 P);
-$gfloat4 textureGather($gsampler2DArray sampler, float3 P, int comp);
-$gfloat4 textureGather($gsamplerCube sampler, float3 P);
-$gfloat4 textureGather($gsamplerCube sampler, float3 P, int comp);
-$gfloat4 textureGather($gsamplerCubeArray sampler, float4 P);
-$gfloat4 textureGather($gsamplerCubeArray sampler, float4 P, int comp);
-$gfloat4 textureGather($gsampler2DRect sampler, float2 P);
-$gfloat4 textureGather($gsampler2DRect sampler, float2 P, int comp);
-float4 textureGather(sampler2DShadow sampler, float2 P, float refZ);
-float4 textureGather(sampler2DArrayShadow sampler, float3 P, float refZ);
-float4 textureGather(samplerCubeShadow sampler, float3 P, float refZ);
-float4 textureGather(samplerCubeArrayShadow sampler, float4 P, float refZ);
-float4 textureGather(sampler2DRectShadow sampler, float2 P, float refZ);
-$gfloat4 textureGatherOffset($gsampler2D sampler, float2 P, int2 offset);
-$gfloat4 textureGatherOffset($gsampler2D sampler, float2 P, int2 offset, int comp);
-$gfloat4 textureGatherOffset($gsampler2DArray sampler, float3 P, int2 offset);
-$gfloat4 textureGatherOffset($gsampler2DArray sampler, float3 P, int2 offset, int comp);
-$gfloat4 textureGatherOffset($gsampler2DRect sampler, float2 P, int2 offset);
-$gfloat4 textureGatherOffset($gsampler2DRect sampler, float2 P, int2 offset, int comp);
-float4 textureGatherOffset(sampler2DShadow sampler, float2 P, float refZ, int2 offset);
-float4 textureGatherOffset(sampler2DArrayShadow sampler, float3 P, float refZ, int2 offset);
-float4 textureGatherOffset(sampler2DRectShadow sampler, float2 P, float refZ, int2 offset);
-$gfloat4 textureGatherOffsets($gsampler2D sampler, float2 P, int2 offsets[4]);
-$gfloat4 textureGatherOffsets($gsampler2D sampler, float2 P, int2 offsets[4], int comp);
-$gfloat4 textureGatherOffsets($gsampler2DArray sampler, float3 P, int2 offsets[4]);
-$gfloat4 textureGatherOffsets($gsampler2DArray sampler, float3 P, int2 offsets[4], int comp);
-$gfloat4 textureGatherOffsets($gsampler2DRect sampler, float2 P, int2 offsets[4]);
-$gfloat4 textureGatherOffsets($gsampler2DRect sampler, float2 P, int2 offsets[4], int comp);
-float4 textureGatherOffsets(sampler2DShadow sampler, float2 P, float refZ, int2 offsets[4]);
-float4 textureGatherOffsets(sampler2DArrayShadow sampler, float3 P, float refZ, int2 offsets[4]);
-float4 textureGatherOffsets(sampler2DRectShadow sampler, float2 P, float refZ, int2 offsets[4]);
+$gfloat4 textureProjOffset($gsampler1D sampler, highfloat2 P, int offset);
+$gfloat4 textureProjOffset($gsampler1D sampler, highfloat2 P, int offset, highfloat bias);
+$gfloat4 textureProjOffset($gsampler1D sampler, highfloat4 P, int offset);
+$gfloat4 textureProjOffset($gsampler1D sampler, highfloat4 P, int offset, highfloat bias);
+$gfloat4 textureProjOffset($gsampler2D sampler, highfloat3 P, int2 offset);
+$gfloat4 textureProjOffset($gsampler2D sampler, highfloat3 P, int2 offset, highfloat bias);
+$gfloat4 textureProjOffset($gsampler2D sampler, highfloat4 P, int2 offset);
+$gfloat4 textureProjOffset($gsampler2D sampler, highfloat4 P, int2 offset, highfloat bias);
+$gfloat4 textureProjOffset($gsampler3D sampler, highfloat4 P, int3 offset);
+$gfloat4 textureProjOffset($gsampler3D sampler, highfloat4 P, int3 offset, highfloat bias);
+$gfloat4 textureProjOffset($gsampler2DRect sampler, highfloat3 P, int2 offset);
+$gfloat4 textureProjOffset($gsampler2DRect sampler, highfloat4 P, int2 offset);
+highfloat textureProjOffset(sampler2DRectShadow sampler, highfloat4 P, int2 offset);
+highfloat textureProjOffset(sampler1DShadow sampler, highfloat4 P, int offset);
+highfloat textureProjOffset(sampler1DShadow sampler, highfloat4 P, int offset, highfloat bias);
+highfloat textureProjOffset(sampler2DShadow sampler, highfloat4 P, int2 offset);
+highfloat textureProjOffset(sampler2DShadow sampler, highfloat4 P, int2 offset, highfloat bias);
+$gfloat4 textureLodOffset($gsampler1D sampler, highfloat P, highfloat lod, int offset);
+$gfloat4 textureLodOffset($gsampler2D sampler, highfloat2 P, highfloat lod, int2 offset);
+$gfloat4 textureLodOffset($gsampler3D sampler, highfloat3 P, highfloat lod, int3 offset);
+highfloat textureLodOffset(sampler1DShadow sampler, highfloat3 P, highfloat lod, int offset);
+highfloat textureLodOffset(sampler2DShadow sampler, highfloat3 P, highfloat lod, int2 offset);
+$gfloat4 textureLodOffset($gsampler1DArray sampler, highfloat2 P, highfloat lod, int offset);
+$gfloat4 textureLodOffset($gsampler2DArray sampler, highfloat3 P, highfloat lod, int2 offset);
+highfloat textureLodOffset(sampler1DArrayShadow sampler, highfloat3 P, highfloat lod, int offset);
+$gfloat4 textureProjLod($gsampler1D sampler, highfloat2 P, highfloat lod);
+$gfloat4 textureProjLod($gsampler1D sampler, highfloat4 P, highfloat lod);
+$gfloat4 textureProjLod($gsampler2D sampler, highfloat3 P, highfloat lod);
+$gfloat4 textureProjLod($gsampler2D sampler, highfloat4 P, highfloat lod);
+$gfloat4 textureProjLod($gsampler3D sampler, highfloat4 P, highfloat lod);
+highfloat textureProjLod(sampler1DShadow sampler, highfloat4 P, highfloat lod);
+highfloat textureProjLod(sampler2DShadow sampler, highfloat4 P, highfloat lod);
+$gfloat4 textureProjLodOffset($gsampler1D sampler, highfloat2 P, highfloat lod, int offset);
+$gfloat4 textureProjLodOffset($gsampler1D sampler, highfloat4 P, highfloat lod, int offset);
+$gfloat4 textureProjLodOffset($gsampler2D sampler, highfloat3 P, highfloat lod, int2 offset);
+$gfloat4 textureProjLodOffset($gsampler2D sampler, highfloat4 P, highfloat lod, int2 offset);
+$gfloat4 textureProjLodOffset($gsampler3D sampler, highfloat4 P, highfloat lod, int3 offset);
+highfloat textureProjLodOffset(sampler1DShadow sampler, highfloat4 P, highfloat lod, int offset);
+highfloat textureProjLodOffset(sampler2DShadow sampler, highfloat4 P, highfloat lod, int2 offset);
+$gfloat4 textureGrad($gsampler1D sampler, highfloat P, highfloat dPdx, highfloat dPdy);
+$gfloat4 textureGrad($gsampler2D sampler, highfloat2 P, highfloat2 dPdx, highfloat2 dPdy);
+$gfloat4 textureGrad($gsampler3D sampler, highfloat3 P, highfloat3 dPdx, highfloat3 dPdy);
+$gfloat4 textureGrad($gsamplerCube sampler, highfloat3 P, highfloat3 dPdx, highfloat3 dPdy);
+$gfloat4 textureGrad($gsampler2DRect sampler, highfloat2 P, highfloat2 dPdx, highfloat2 dPdy);
+highfloat textureGrad(sampler2DRectShadow sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy);
+highfloat textureGrad(sampler1DShadow sampler, highfloat3 P, highfloat dPdx, highfloat dPdy);
+highfloat textureGrad(sampler2DShadow sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy);
+highfloat textureGrad(samplerCubeShadow sampler, highfloat4 P, highfloat3 dPdx, highfloat3 dPdy);
+$gfloat4 textureGrad($gsampler1DArray sampler, highfloat2 P, highfloat dPdx, highfloat dPdy);
+$gfloat4 textureGrad($gsampler2DArray sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy);
+highfloat textureGrad(sampler1DArrayShadow sampler, highfloat3 P, highfloat dPdx, highfloat dPdy);
+highfloat textureGrad(sampler2DArrayShadow sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy);
+$gfloat4 textureGrad($gsamplerCubeArray sampler, highfloat4 P, highfloat3 dPdx, highfloat3 dPdy);
+$gfloat4 textureGradOffset($gsampler1D sampler, highfloat P, highfloat dPdx, highfloat dPdy, int offset);
+$gfloat4 textureGradOffset($gsampler2D sampler, highfloat2 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+$gfloat4 textureGradOffset($gsampler3D sampler, highfloat3 P, highfloat3 dPdx, highfloat3 dPdy, int3 offset);
+$gfloat4 textureGradOffset($gsampler2DRect sampler, highfloat2 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+highfloat textureGradOffset(sampler2DRectShadow sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+highfloat textureGradOffset(sampler1DShadow sampler, highfloat3 P, highfloat dPdx, highfloat dPdy, int offset );
+highfloat textureGradOffset(sampler2DShadow sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+$gfloat4 textureGradOffset($gsampler1DArray sampler, highfloat2 P, highfloat dPdx, highfloat dPdy, int offset);
+$gfloat4 textureGradOffset($gsampler2DArray sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+highfloat textureGradOffset(sampler1DArrayShadow sampler, highfloat3 P, highfloat dPdx, highfloat dPdy, int offset);
+highfloat textureGradOffset(sampler2DArrayShadow sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+$gfloat4 textureProjGrad($gsampler1D sampler, highfloat2 P, highfloat dPdx, highfloat dPdy);
+$gfloat4 textureProjGrad($gsampler1D sampler, highfloat4 P, highfloat dPdx, highfloat dPdy);
+$gfloat4 textureProjGrad($gsampler2D sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy);
+$gfloat4 textureProjGrad($gsampler2D sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy);
+$gfloat4 textureProjGrad($gsampler3D sampler, highfloat4 P, highfloat3 dPdx, highfloat3 dPdy);
+$gfloat4 textureProjGrad($gsampler2DRect sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy);
+$gfloat4 textureProjGrad($gsampler2DRect sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy);
+highfloat textureProjGrad(sampler2DRectShadow sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy);
+highfloat textureProjGrad(sampler1DShadow sampler, highfloat4 P, highfloat dPdx, highfloat dPdy);
+highfloat textureProjGrad(sampler2DShadow sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy);
+$gfloat4 textureProjGradOffset($gsampler1D sampler, highfloat2 P, highfloat dPdx, highfloat dPdy, int offset);
+$gfloat4 textureProjGradOffset($gsampler1D sampler, highfloat4 P, highfloat dPdx, highfloat dPdy, int offset);
+$gfloat4 textureProjGradOffset($gsampler2D sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+$gfloat4 textureProjGradOffset($gsampler2D sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+$gfloat4 textureProjGradOffset($gsampler2DRect sampler, highfloat3 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+$gfloat4 textureProjGradOffset($gsampler2DRect sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+highfloat textureProjGradOffset(sampler2DRectShadow sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+$gfloat4 textureProjGradOffset($gsampler3D sampler, highfloat4 P, highfloat3 dPdx, highfloat3 dPdy, int3 offset);
+highfloat textureProjGradOffset(sampler1DShadow sampler, highfloat4 P, highfloat dPdx, highfloat dPdy, int offset);
+highfloat textureProjGradOffset(sampler2DShadow sampler, highfloat4 P, highfloat2 dPdx, highfloat2 dPdy, int2 offset);
+$gfloat4 textureGather($gsampler2D sampler, highfloat2 P);
+$gfloat4 textureGather($gsampler2D sampler, highfloat2 P, int comp);
+$gfloat4 textureGather($gsampler2DArray sampler, highfloat3 P);
+$gfloat4 textureGather($gsampler2DArray sampler, highfloat3 P, int comp);
+$gfloat4 textureGather($gsamplerCube sampler, highfloat3 P);
+$gfloat4 textureGather($gsamplerCube sampler, highfloat3 P, int comp);
+$gfloat4 textureGather($gsamplerCubeArray sampler, highfloat4 P);
+$gfloat4 textureGather($gsamplerCubeArray sampler, highfloat4 P, int comp);
+$gfloat4 textureGather($gsampler2DRect sampler, highfloat2 P);
+$gfloat4 textureGather($gsampler2DRect sampler, highfloat2 P, int comp);
+highfloat4 textureGather(sampler2DShadow sampler, highfloat2 P, highfloat refZ);
+highfloat4 textureGather(sampler2DArrayShadow sampler, highfloat3 P, highfloat refZ);
+highfloat4 textureGather(samplerCubeShadow sampler, highfloat3 P, highfloat refZ);
+highfloat4 textureGather(samplerCubeArrayShadow sampler, highfloat4 P, highfloat refZ);
+highfloat4 textureGather(sampler2DRectShadow sampler, highfloat2 P, highfloat refZ);
+$gfloat4 textureGatherOffset($gsampler2D sampler, highfloat2 P, int2 offset);
+$gfloat4 textureGatherOffset($gsampler2D sampler, highfloat2 P, int2 offset, int comp);
+$gfloat4 textureGatherOffset($gsampler2DArray sampler, highfloat3 P, int2 offset);
+$gfloat4 textureGatherOffset($gsampler2DArray sampler, highfloat3 P, int2 offset, int comp);
+$gfloat4 textureGatherOffset($gsampler2DRect sampler, highfloat2 P, int2 offset);
+$gfloat4 textureGatherOffset($gsampler2DRect sampler, highfloat2 P, int2 offset, int comp);
+highfloat4 textureGatherOffset(sampler2DShadow sampler, highfloat2 P, highfloat refZ, int2 offset);
+highfloat4 textureGatherOffset(sampler2DArrayShadow sampler, highfloat3 P, highfloat refZ, int2 offset);
+highfloat4 textureGatherOffset(sampler2DRectShadow sampler, highfloat2 P, highfloat refZ, int2 offset);
+$gfloat4 textureGatherOffsets($gsampler2D sampler, highfloat2 P, int2 offsets[4]);
+$gfloat4 textureGatherOffsets($gsampler2D sampler, highfloat2 P, int2 offsets[4], int comp);
+$gfloat4 textureGatherOffsets($gsampler2DArray sampler, highfloat3 P, int2 offsets[4]);
+$gfloat4 textureGatherOffsets($gsampler2DArray sampler, highfloat3 P, int2 offsets[4], int comp);
+$gfloat4 textureGatherOffsets($gsampler2DRect sampler, highfloat2 P, int2 offsets[4]);
+$gfloat4 textureGatherOffsets($gsampler2DRect sampler, highfloat2 P, int2 offsets[4], int comp);
+highfloat4 textureGatherOffsets(sampler2DShadow sampler, highfloat2 P, highfloat refZ, int2 offsets[4]);
+highfloat4 textureGatherOffsets(sampler2DArrayShadow sampler, highfloat3 P, highfloat refZ, int2 offsets[4]);
+highfloat4 textureGatherOffsets(sampler2DRectShadow sampler, highfloat2 P, highfloat refZ, int2 offsets[4]);
uint atomicCounterIncrement(atomic_uint c);
uint atomicCounter(atomic_uint c);
uint atomicAdd(inout uint mem, uint data);
@@ -534,18 +534,18 @@
*/
// section 8.12 Additional Image Functions will go here if and when we add
// support for them
-float4 imageLoad(image2D image, int2 P);
+highfloat4 imageLoad(image2D image, int2 P);
int4 imageLoad(iimage2D image, int2 P);
$genType dFdx($genType p);
$genType dFdy($genType p);
-float interpolateAtSample(float interpolant, int sample);
-float2 interpolateAtSample(float2 interpolant, int sample);
-float3 interpolateAtSample(float3 interpolant, int sample);
-float4 interpolateAtSample(float4 interpolant, int sample);
-float interpolateAtOffset(float interpolant, float2 offset);
-float2 interpolateAtOffset(float2 interpolant, float2 offset);
-float3 interpolateAtOffset(float3 interpolant, float2 offset);
-float4 interpolateAtOffset(float4 interpolant, float2 offset);
+highfloat interpolateAtSample(highfloat interpolant, int sample);
+highfloat2 interpolateAtSample(highfloat2 interpolant, int sample);
+highfloat3 interpolateAtSample(highfloat3 interpolant, int sample);
+highfloat4 interpolateAtSample(highfloat4 interpolant, int sample);
+highfloat interpolateAtOffset(highfloat interpolant, highfloat2 offset);
+highfloat2 interpolateAtOffset(highfloat2 interpolant, highfloat2 offset);
+highfloat3 interpolateAtOffset(highfloat3 interpolant, highfloat2 offset);
+highfloat4 interpolateAtOffset(highfloat4 interpolant, highfloat2 offset);
/*
$genType fwidth($genType p);
diff --git a/src/sksl/sksl_fp.include b/src/sksl/sksl_fp.include
index 4d6b94d..8aed48e 100644
--- a/src/sksl/sksl_fp.include
+++ b/src/sksl/sksl_fp.include
@@ -2,24 +2,24 @@
// defines built-in interfaces supported by SkiaSL fragment shaders
-layout(builtin=15) in float4 sk_FragCoord;
-layout(builtin=3) float sk_ClipDistance[1];
+layout(builtin=15) in highfloat4 sk_FragCoord;
+layout(builtin=3) highfloat sk_ClipDistance[1];
// 9999 is a temporary value that causes us to ignore these declarations beyond
// adding them to the symbol table. This works fine in GLSL (where they do not
// require any further handling) but will fail in SPIR-V. We'll have a better
// solution for this soon.
-layout(builtin=9999) float4 gl_LastFragData[1];
-layout(builtin=9999) float4 gl_LastFragColor;
-layout(builtin=9999) float4 gl_LastFragColorARM;
+layout(builtin=9999) highfloat4 gl_LastFragData[1];
+layout(builtin=9999) half4 gl_LastFragColor;
+layout(builtin=9999) half4 gl_LastFragColorARM;
layout(builtin=9999) int gl_SampleMaskIn[1];
layout(builtin=9999) out int gl_SampleMask[1];
-layout(builtin=9999) float4 gl_SecondaryFragColorEXT;
+layout(builtin=9999) half4 gl_SecondaryFragColorEXT;
-layout(builtin=10003) float4 sk_InColor;
-layout(builtin=10004) out float4 sk_OutColor;
-layout(builtin=10005) float2[] sk_TransformedCoords2D;
+layout(builtin=10003) half4 sk_InColor;
+layout(builtin=10004) out half4 sk_OutColor;
+layout(builtin=10005) highfloat2[] sk_TransformedCoords2D;
layout(builtin=10006) sampler2D[] sk_TextureSamplers;
-float4 COLORSPACE(float4 color, colorSpaceXform colorSpace);
+half4 COLORSPACE(half4 color, colorSpaceXform colorSpace);
)
diff --git a/src/sksl/sksl_frag.include b/src/sksl/sksl_frag.include
index 2cd1e52..c5f9ffe 100644
--- a/src/sksl/sksl_frag.include
+++ b/src/sksl/sksl_frag.include
@@ -2,20 +2,20 @@
// defines built-in interfaces supported by SkiaSL fragment shaders
-layout(builtin=15) in float4 sk_FragCoord;
-layout(builtin=3) float sk_ClipDistance[1];
+layout(builtin=15) in highfloat4 sk_FragCoord;
+layout(builtin=3) highfloat sk_ClipDistance[1];
// 9999 is a temporary value that causes us to ignore these declarations beyond
// adding them to the symbol table. This works fine in GLSL (where they do not
// require any further handling) but will fail in SPIR-V. We'll have a better
// solution for this soon.
-layout(builtin=9999) float4 gl_LastFragData[1];
-layout(builtin=9999) float4 gl_LastFragColor;
-layout(builtin=9999) float4 gl_LastFragColorARM;
+layout(builtin=9999) highfloat4 gl_LastFragData[1];
+layout(builtin=9999) half4 gl_LastFragColor;
+layout(builtin=9999) half4 gl_LastFragColorARM;
layout(builtin=9999) int gl_SampleMaskIn[1];
layout(builtin=9999) out int gl_SampleMask[1];
-layout(builtin=9999) out float4 gl_SecondaryFragColorEXT;
+layout(builtin=9999) out half4 gl_SecondaryFragColorEXT;
-layout(location=0,index=0,builtin=10001) out float4 sk_FragColor;
+layout(location=0,index=0,builtin=10001) out half4 sk_FragColor;
)
diff --git a/src/sksl/sksl_geom.include b/src/sksl/sksl_geom.include
index f1b3604..b1c05d1 100644
--- a/src/sksl/sksl_geom.include
+++ b/src/sksl/sksl_geom.include
@@ -3,15 +3,15 @@
// defines built-in interfaces supported by SkiaSL geometry shaders
layout(builtin=10002) in sk_PerVertex {
- layout(builtin=0) float4 gl_Position;
- layout(builtin=1) float gl_PointSize;
- layout(builtin=3) float sk_ClipDistance[];
+ layout(builtin=0) highfloat4 gl_Position;
+ layout(builtin=1) highfloat gl_PointSize;
+ layout(builtin=3) highfloat sk_ClipDistance[];
} sk_in[];
out sk_PerVertex {
- layout(builtin=0) float4 gl_Position;
- layout(builtin=1) float gl_PointSize;
- layout(builtin=3) float sk_ClipDistance[];
+ layout(builtin=0) highfloat4 gl_Position;
+ layout(builtin=1) highfloat gl_PointSize;
+ layout(builtin=3) highfloat sk_ClipDistance[];
};
layout(builtin=8) int sk_InvocationID;
diff --git a/src/sksl/sksl_vert.include b/src/sksl/sksl_vert.include
index 976877c..e7f8419 100644
--- a/src/sksl/sksl_vert.include
+++ b/src/sksl/sksl_vert.include
@@ -3,9 +3,9 @@
// defines built-in interfaces supported by SkiaSL vertex shaders
out sk_PerVertex {
- layout(builtin=0) float4 gl_Position;
- layout(builtin=1) float gl_PointSize;
- layout(builtin=3) float sk_ClipDistance[1];
+ layout(builtin=0) highfloat4 gl_Position;
+ layout(builtin=1) highfloat gl_PointSize;
+ layout(builtin=3) highfloat sk_ClipDistance[1];
};
layout(builtin=5) in int sk_VertexID;
diff --git a/tests/GrMeshTest.cpp b/tests/GrMeshTest.cpp
index 288c057..c722a5c 100644
--- a/tests/GrMeshTest.cpp
+++ b/tests/GrMeshTest.cpp
@@ -327,20 +327,20 @@
GrGLSLVertexBuilder* v = args.fVertBuilder;
if (!mp.fInstanceLocation) {
- v->codeAppendf("float2 vertex = %s;", mp.fVertex->fName);
+ v->codeAppendf("highfloat2 vertex = %s;", mp.fVertex->fName);
} else {
if (mp.fVertex) {
- v->codeAppendf("float2 offset = %s;", mp.fVertex->fName);
+ v->codeAppendf("highfloat2 offset = %s;", mp.fVertex->fName);
} else {
- v->codeAppend ("float2 offset = float2(sk_VertexID / 2, sk_VertexID % 2);");
+ v->codeAppend ("highfloat2 offset = highfloat2(sk_VertexID / 2, sk_VertexID % 2);");
}
- v->codeAppendf("float2 vertex = %s + offset * %i;",
+ v->codeAppendf("highfloat2 vertex = %s + offset * %i;",
mp.fInstanceLocation->fName, kBoxSize);
}
- gpArgs->fPositionVar.set(kVec2f_GrSLType, "vertex");
+ gpArgs->fPositionVar.set(kHighFloat2_GrSLType, "vertex");
GrGLSLPPFragmentBuilder* f = args.fFragBuilder;
- f->codeAppendf("%s = float4(1);", args.fOutputCoverage);
+ f->codeAppendf("%s = half4(1);", args.fOutputCoverage);
}
};
diff --git a/tests/GrPipelineDynamicStateTest.cpp b/tests/GrPipelineDynamicStateTest.cpp
index 2049ccb..15c76c0 100644
--- a/tests/GrPipelineDynamicStateTest.cpp
+++ b/tests/GrPipelineDynamicStateTest.cpp
@@ -91,11 +91,11 @@
varyingHandler->addPassThroughAttribute(&mp.fColor, args.fOutputColor);
GrGLSLVertexBuilder* v = args.fVertBuilder;
- v->codeAppendf("float2 vertex = %s;", mp.fVertex.fName);
- gpArgs->fPositionVar.set(kVec2f_GrSLType, "vertex");
+ v->codeAppendf("highfloat2 vertex = %s;", mp.fVertex.fName);
+ gpArgs->fPositionVar.set(kHighFloat2_GrSLType, "vertex");
GrGLSLPPFragmentBuilder* f = args.fFragBuilder;
- f->codeAppendf("%s = float4(1);", args.fOutputCoverage);
+ f->codeAppendf("%s = half4(1);", args.fOutputCoverage);
}
};
diff --git a/tests/ImageStorageTest.cpp b/tests/ImageStorageTest.cpp
index 6d5cab0..8a6023f 100644
--- a/tests/ImageStorageTest.cpp
+++ b/tests/ImageStorageTest.cpp
@@ -58,13 +58,13 @@
const TestFP& tfp = args.fFp.cast<TestFP>();
GrGLSLFPFragmentBuilder* fb = args.fFragBuilder;
SkString imageLoadStr;
- fb->codeAppend("highp float2 coord = sk_FragCoord.xy;");
+ fb->codeAppend("highfloat2 coord = sk_FragCoord.xy;");
fb->appendImageStorageLoad(&imageLoadStr, args.fImageStorages[0],
"int2(coord)");
if (GrPixelConfigIsSint(tfp.fImageStorageAccess.peekTexture()->config())) {
// Map the signed bytes so that when then get read back as unorm values they
// will have their original bit pattern.
- fb->codeAppendf("highp int4 ivals = %s;", imageLoadStr.c_str());
+ fb->codeAppendf("int4 ivals = %s;", imageLoadStr.c_str());
// NV gives a linker error for this:
// fb->codeAppend("ivals +=
// "mix(int4(0), int4(256), lessThan(ivals, int4(0)));");
@@ -72,7 +72,7 @@
fb->codeAppend("if (ivals.g < 0) { ivals.g += 256; }");
fb->codeAppend("if (ivals.b < 0) { ivals.b += 256; }");
fb->codeAppend("if (ivals.a < 0) { ivals.a += 256; }");
- fb->codeAppendf("%s = float4(ivals)/255;", args.fOutputColor);
+ fb->codeAppendf("%s = half4(ivals)/255;", args.fOutputColor);
} else {
fb->codeAppendf("%s = %s;", args.fOutputColor, imageLoadStr.c_str());
}
diff --git a/tests/PrimitiveProcessorTest.cpp b/tests/PrimitiveProcessorTest.cpp
index 1e764e1..47dff33 100644
--- a/tests/PrimitiveProcessorTest.cpp
+++ b/tests/PrimitiveProcessorTest.cpp
@@ -72,8 +72,8 @@
args.fVaryingHandler->emitAttributes(gp);
this->writeOutputPosition(args.fVertBuilder, gpArgs, gp.getAttrib(0).fName);
GrGLSLPPFragmentBuilder* fragBuilder = args.fFragBuilder;
- fragBuilder->codeAppendf("%s = float4(1);", args.fOutputColor);
- fragBuilder->codeAppendf("%s = float4(1);", args.fOutputCoverage);
+ fragBuilder->codeAppendf("%s = half4(1);", args.fOutputColor);
+ fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage);
}
void setData(const GrGLSLProgramDataManager& pdman,
const GrPrimitiveProcessor& primProc,
diff --git a/tests/SkSLErrorTest.cpp b/tests/SkSLErrorTest.cpp
index b94cc82..4943e10 100644
--- a/tests/SkSLErrorTest.cpp
+++ b/tests/SkSLErrorTest.cpp
@@ -37,39 +37,39 @@
DEF_TEST(SkSLUndefinedSymbol, r) {
test_failure(r,
- "void main() { x = float2(1); }",
+ "void main() { x = highfloat2(1); }",
"error: 1: unknown identifier 'x'\n1 error\n");
}
DEF_TEST(SkSLUndefinedFunction, r) {
test_failure(r,
- "void main() { int x = foo(1); }",
+ "void main() { int x = foo(1); }",
"error: 1: unknown identifier 'foo'\n1 error\n");
}
DEF_TEST(SkSLGenericArgumentMismatch, r) {
test_failure(r,
- "void main() { float x = sin(1, 2); }",
+ "void main() { highfloat x = sin(1, 2); }",
"error: 1: call to 'sin' expected 1 argument, but found 2\n1 error\n");
test_failure(r,
- "void main() { float x = sin(true); }",
+ "void main() { highfloat x = sin(true); }",
"error: 1: no match for sin(bool)\n1 error\n");
test_success(r,
- "void main() { float x = sin(1); }");
+ "void main() { highfloat x = sin(1); }");
}
DEF_TEST(SkSLArgumentCountMismatch, r) {
test_failure(r,
- "float foo(float x) { return x * x; }"
- "void main() { float x = foo(1, 2); }",
+ "highfloat foo(highfloat x) { return x * x; }"
+ "void main() { highfloat x = foo(1, 2); }",
"error: 1: call to 'foo' expected 1 argument, but found 2\n1 error\n");
}
DEF_TEST(SkSLArgumentMismatch, r) {
- test_failure(r,
- "float foo(float x) { return x * x; }"
- "void main() { float x = foo(true); }",
- "error: 1: expected 'float', but found 'bool'\n1 error\n");
+ test_failure(r,
+ "highfloat foo(highfloat x) { return x * x; }"
+ "void main() { highfloat x = foo(true); }",
+ "error: 1: expected 'highfloat', but found 'bool'\n1 error\n");
}
DEF_TEST(SkSLIfTypeMismatch, r) {
@@ -80,32 +80,32 @@
DEF_TEST(SkSLDoTypeMismatch, r) {
test_failure(r,
- "void main() { do { } while (float2(1)); }",
- "error: 1: expected 'bool', but found 'float2'\n1 error\n");
+ "void main() { do { } while (highfloat2(1)); }",
+ "error: 1: expected 'bool', but found 'highfloat2'\n1 error\n");
}
DEF_TEST(SkSLWhileTypeMismatch, r) {
test_failure(r,
- "void main() { while (float3(1)) { } }",
- "error: 1: expected 'bool', but found 'float3'\n1 error\n");
+ "void main() { while (highfloat3(1)) { } }",
+ "error: 1: expected 'bool', but found 'highfloat3'\n1 error\n");
}
DEF_TEST(SkSLForTypeMismatch, r) {
test_failure(r,
- "void main() { for (int x = 0; x; x++) { } }",
+ "void main() { for (int x = 0; x; x++) { } }",
"error: 1: expected 'bool', but found 'int'\n1 error\n");
}
DEF_TEST(SkSLConstructorTypeMismatch, r) {
test_failure(r,
- "void main() { float2 x = float2(1.0, false); }",
- "error: 1: expected 'float', but found 'bool'\n1 error\n");
+ "void main() { highfloat2 x = highfloat2(1.0, false); }",
+ "error: 1: expected 'highfloat', but found 'bool'\n1 error\n");
test_failure(r,
- "void main() { float2 x = float2(bool2(false)); }",
- "error: 1: 'bool2' is not a valid parameter to 'float2' constructor\n1 error\n");
+ "void main() { highfloat2 x = highfloat2(bool2(false)); }",
+ "error: 1: 'bool2' is not a valid parameter to 'highfloat2' constructor\n1 error\n");
test_failure(r,
- "void main() { bool2 x = bool2(float2(1)); }",
- "error: 1: 'float2' is not a valid parameter to 'bool2' constructor\n1 error\n");
+ "void main() { bool2 x = bool2(highfloat2(1)); }",
+ "error: 1: 'highfloat2' is not a valid parameter to 'bool2' constructor\n1 error\n");
test_failure(r,
"void main() { bool x = bool(1.0); }",
"error: 1: cannot construct 'bool'\n1 error\n");
@@ -113,69 +113,69 @@
"struct foo { int x; }; void main() { foo x = foo(5); }",
"error: 1: cannot construct 'foo'\n1 error\n");
test_failure(r,
- "struct foo { int x; } foo; void main() { float x = float(foo); }",
- "error: 1: invalid argument to 'float' constructor (expected a number or bool, but found 'foo')\n1 error\n");
+ "struct foo { int x; } foo; void main() { highfloat x = highfloat(foo); }",
+ "error: 1: invalid argument to 'highfloat' constructor (expected a number or bool, but found 'foo')\n1 error\n");
test_failure(r,
- "struct foo { int x; } foo; void main() { float2 x = float2(foo); }",
- "error: 1: 'foo' is not a valid parameter to 'float2' constructor\n1 error\n");
+ "struct foo { int x; } foo; void main() { highfloat2 x = highfloat2(foo); }",
+ "error: 1: 'foo' is not a valid parameter to 'highfloat2' constructor\n1 error\n");
test_failure(r,
- "void main() { float2x2 x = float2x2(true); }",
- "error: 1: expected 'float', but found 'bool'\n1 error\n");
+ "void main() { highfloat2x2 x = highfloat2x2(true); }",
+ "error: 1: expected 'highfloat', but found 'bool'\n1 error\n");
}
DEF_TEST(SkSLConstructorArgumentCount, r) {
test_failure(r,
- "void main() { float3 x = float3(1.0, 2.0); }",
- "error: 1: invalid arguments to 'float3' constructor (expected 3 scalars, but "
+ "void main() { highfloat3 x = highfloat3(1.0, 2.0); }",
+ "error: 1: invalid arguments to 'highfloat3' constructor (expected 3 scalars, but "
"found 2)\n1 error\n");
test_failure(r,
- "void main() { float3 x = float3(1.0, 2.0, 3.0, 4.0); }",
- "error: 1: invalid arguments to 'float3' constructor (expected 3 scalars, but found "
+ "void main() { highfloat3 x = highfloat3(1.0, 2.0, 3.0, 4.0); }",
+ "error: 1: invalid arguments to 'highfloat3' constructor (expected 3 scalars, but found "
"4)\n1 error\n");
}
DEF_TEST(SkSLSwizzleScalar, r) {
test_failure(r,
- "void main() { float x = 1; float y = x.y; }",
- "error: 1: cannot swizzle value of type 'float'\n1 error\n");
+ "void main() { highfloat x = 1; highfloat y = x.y; }",
+ "error: 1: cannot swizzle value of type 'highfloat'\n1 error\n");
}
DEF_TEST(SkSLSwizzleMatrix, r) {
test_failure(r,
- "void main() { float2x2 x = float2x2(1); float y = x.y; }",
- "error: 1: cannot swizzle value of type 'float2x2'\n1 error\n");
+ "void main() { highfloat2x2 x = highfloat2x2(1); highfloat y = x.y; }",
+ "error: 1: cannot swizzle value of type 'highfloat2x2'\n1 error\n");
}
DEF_TEST(SkSLSwizzleOutOfBounds, r) {
test_failure(r,
- "void main() { float3 test = float2(1).xyz; }",
+ "void main() { highfloat3 test = highfloat2(1).xyz; }",
"error: 1: invalid swizzle component 'z'\n1 error\n");
}
DEF_TEST(SkSLSwizzleTooManyComponents, r) {
test_failure(r,
- "void main() { float4 test = float2(1).xxxxx; }",
+ "void main() { highfloat4 test = highfloat2(1).xxxxx; }",
"error: 1: too many components in swizzle mask 'xxxxx'\n1 error\n");
}
DEF_TEST(SkSLSwizzleDuplicateOutput, r) {
test_failure(r,
- "void main() { float4 test = float4(1); test.xyyz = float4(1); }",
+ "void main() { highfloat4 test = highfloat4(1); test.xyyz = highfloat4(1); }",
"error: 1: cannot write to the same swizzle field more than once\n1 error\n");
}
DEF_TEST(SkSLAssignmentTypeMismatch, r) {
test_failure(r,
"void main() { int x = 1.0; }",
- "error: 1: expected 'int', but found 'float'\n1 error\n");
+ "error: 1: expected 'int', but found 'highfloat'\n1 error\n");
test_failure(r,
"void main() { int x; x = 1.0; }",
- "error: 1: type mismatch: '=' cannot operate on 'int', 'float'\n1 error\n");
+ "error: 1: type mismatch: '=' cannot operate on 'int', 'highfloat'\n1 error\n");
test_success(r,
- "void main() { float3 x = float3(0); x *= 1.0; }");
+ "void main() { highfloat3 x = highfloat3(0); x *= 1.0; }");
test_failure(r,
"void main() { int3 x = int3(0); x *= 1.0; }",
- "error: 1: type mismatch: '*=' cannot operate on 'int3', 'float'\n1 error\n");
+ "error: 1: type mismatch: '*=' cannot operate on 'int3', 'highfloat'\n1 error\n");
}
DEF_TEST(SkSLReturnFromVoid, r) {
@@ -192,13 +192,13 @@
DEF_TEST(SkSLReturnTypeMismatch, r) {
test_failure(r,
- "int foo() { return 1.0; } void main() { }",
- "error: 1: expected 'int', but found 'float'\n1 error\n");
+ "int foo() { return 1.0; } void main() { }",
+ "error: 1: expected 'int', but found 'highfloat'\n1 error\n");
}
DEF_TEST(SkSLDuplicateFunction, r) {
test_failure(r,
- "void main() { } void main() { }",
+ "void main() { } void main() { }",
"error: 1: duplicate definition of void main()\n1 error\n");
test_success(r,
"void main(); void main() { }");
@@ -206,29 +206,29 @@
DEF_TEST(SkSLUsingInvalidValue, r) {
test_failure(r,
- "void main() { int x = int; }",
+ "void main() { int x = int; }",
"error: 1: expected '(' to begin constructor invocation\n1 error\n");
test_failure(r,
- "int test() { return 1; } void main() { int x = test; }",
+ "int test() { return 1; } void main() { int x = test; }",
"error: 1: expected '(' to begin function call\n1 error\n");
}
DEF_TEST(SkSLDifferentReturnType, r) {
test_failure(r,
- "int main() { return 1; } void main() { }",
+ "int main() { return 1; } void main() { }",
"error: 1: functions 'void main()' and 'int main()' differ only in return type\n1 "
"error\n");
}
DEF_TEST(SkSLDifferentModifiers, r) {
test_failure(r,
- "void test(int x); void test(out int x) { }",
+ "void test(int x); void test(out int x) { }",
"error: 1: modifiers on parameter 1 differ between declaration and definition\n1 "
"error\n");
}
DEF_TEST(SkSLDuplicateSymbol, r) {
test_failure(r,
- "int main; void main() { }",
+ "int main; void main() { }",
"error: 1: symbol 'main' was already defined\n1 error\n");
test_failure(r,
@@ -240,32 +240,32 @@
DEF_TEST(SkSLBinaryTypeMismatch, r) {
test_failure(r,
- "void main() { float x = 3 * true; }",
+ "void main() { highfloat x = 3 * true; }",
"error: 1: type mismatch: '*' cannot operate on 'int', 'bool'\n1 error\n");
test_failure(r,
"void main() { bool x = 1 || 2.0; }",
- "error: 1: type mismatch: '||' cannot operate on 'int', 'float'\n1 error\n");
+ "error: 1: type mismatch: '||' cannot operate on 'int', 'highfloat'\n1 error\n");
}
DEF_TEST(SkSLCallNonFunction, r) {
test_failure(r,
- "void main() { float x = 3; x(); }",
+ "void main() { highfloat x = 3; x(); }",
"error: 1: 'x' is not a function\n1 error\n");
}
DEF_TEST(SkSLInvalidUnary, r) {
test_failure(r,
- "void main() { float4x4 x = float4x4(1); ++x; }",
- "error: 1: '++' cannot operate on 'float4x4'\n1 error\n");
+ "void main() { highfloat4x4 x = highfloat4x4(1); ++x; }",
+ "error: 1: '++' cannot operate on 'highfloat4x4'\n1 error\n");
test_failure(r,
- "void main() { float3 x = float3(1); --x; }",
- "error: 1: '--' cannot operate on 'float3'\n1 error\n");
+ "void main() { highfloat3 x = highfloat3(1); --x; }",
+ "error: 1: '--' cannot operate on 'highfloat3'\n1 error\n");
test_failure(r,
- "void main() { float4x4 x = float4x4(1); x++; }",
- "error: 1: '++' cannot operate on 'float4x4'\n1 error\n");
+ "void main() { highfloat4x4 x = highfloat4x4(1); x++; }",
+ "error: 1: '++' cannot operate on 'highfloat4x4'\n1 error\n");
test_failure(r,
- "void main() { float3 x = float3(1); x--; }",
- "error: 1: '--' cannot operate on 'float3'\n1 error\n");
+ "void main() { highfloat3 x = highfloat3(1); x--; }",
+ "error: 1: '--' cannot operate on 'highfloat3'\n1 error\n");
test_failure(r,
"void main() { int x = !12; }",
"error: 1: '!' cannot operate on 'int'\n1 error\n");
@@ -276,7 +276,7 @@
"struct foo { } bar; void main() { foo x = -bar; }",
"error: 1: '-' cannot operate on 'foo'\n1 error\n");
test_success(r,
- "void main() { float2 x = float2(1, 1); x = +x; x = -x; }");
+ "void main() { highfloat2 x = highfloat2(1, 1); x = +x; x = -x; }");
}
DEF_TEST(SkSLInvalidAssignment, r) {
@@ -296,17 +296,17 @@
"void main() { int x = 2[0]; }",
"error: 1: expected array, but found 'int'\n1 error\n");
test_failure(r,
- "void main() { float2 x = float2(0); int y = x[0][0]; }",
- "error: 1: expected array, but found 'float'\n1 error\n");
+ "void main() { highfloat2 x = highfloat2(0); int y = x[0][0]; }",
+ "error: 1: expected array, but found 'highfloat'\n1 error\n");
}
DEF_TEST(SkSLTernaryMismatch, r) {
test_failure(r,
"void main() { int x = 5 > 2 ? true : 1.0; }",
- "error: 1: ternary operator result mismatch: 'bool', 'float'\n1 error\n");
+ "error: 1: ternary operator result mismatch: 'bool', 'highfloat'\n1 error\n");
test_failure(r,
- "void main() { int x = 5 > 2 ? float3(1) : 1.0; }",
- "error: 1: ternary operator result mismatch: 'float3', 'float'\n1 error\n");
+ "void main() { int x = 5 > 2 ? highfloat3(1) : 1.0; }",
+ "error: 1: ternary operator result mismatch: 'highfloat3', 'highfloat'\n1 error\n");
}
DEF_TEST(SkSLInterfaceBlockStorageModifiers, r) {
@@ -333,7 +333,7 @@
"error: 1: 'x' has not been assigned\n1 error\n");
test_failure(r,
"void main() { int x; switch (3) { case 0: x = 0; case 1: x = 1; }"
- "sk_FragColor = float4(x); }",
+ "sk_FragColor = highfloat4(x); }",
"error: 1: 'x' has not been assigned\n1 error\n");
}
@@ -403,32 +403,32 @@
"int x = 1 / 0;",
"error: 1: division by zero\n1 error\n");
test_failure(r,
- "float x = 1 / 0;",
+ "highfloat x = 1 / 0;",
"error: 1: division by zero\n1 error\n");
test_failure(r,
- "float x = 1.0 / 0.0;",
+ "highfloat x = 1.0 / 0.0;",
"error: 1: division by zero\n1 error\n");
test_failure(r,
- "float x = -67.0 / (3.0 - 3);",
+ "highfloat x = -67.0 / (3.0 - 3);",
"error: 1: division by zero\n1 error\n");
}
DEF_TEST(SkSLUnsupportedGLSLIdentifiers, r) {
test_failure(r,
- "void main() { float x = gl_FragCoord.x; };",
+ "void main() { highfloat x = gl_FragCoord.x; };",
"error: 1: unknown identifier 'gl_FragCoord'\n1 error\n");
test_failure(r,
- "void main() { float r = gl_FragColor.r; };",
+ "void main() { highfloat r = gl_FragColor.r; };",
"error: 1: unknown identifier 'gl_FragColor'\n1 error\n");
}
DEF_TEST(SkSLWrongSwitchTypes, r) {
test_failure(r,
- "void main() { switch (float2(1)) { case 1: break; } }",
- "error: 1: expected 'int', but found 'float2'\n1 error\n");
+ "void main() { switch (highfloat2(1)) { case 1: break; } }",
+ "error: 1: expected 'int', but found 'highfloat2'\n1 error\n");
test_failure(r,
- "void main() { switch (1) { case float2(1): break; } }",
- "error: 1: expected 'int', but found 'float2'\n1 error\n");
+ "void main() { switch (1) { case highfloat2(1): break; } }",
+ "error: 1: expected 'int', but found 'highfloat2'\n1 error\n");
}
DEF_TEST(SkSLNonConstantCase, r) {
@@ -445,18 +445,18 @@
DEF_TEST(SkSLFieldAfterRuntimeArray, r) {
test_failure(r,
- "buffer broken { float x[]; float y; };",
+ "buffer broken { highfloat x[]; highfloat y; };",
"error: 1: only the last entry in an interface block may be a runtime-sized "
"array\n1 error\n");
}
DEF_TEST(SkSLStaticIf, r) {
test_success(r,
- "void main() { float x = 5; float y = 10;"
- "@if (x < y) { sk_FragColor = float4(1); } }");
+ "void main() { highfloat x = 5; highfloat y = 10;"
+ "@if (x < y) { sk_FragColor = highfloat4(1); } }");
test_failure(r,
- "void main() { float x = sqrt(25); float y = 10;"
- "@if (x < y) { sk_FragColor = float4(1); } }",
+ "void main() { highfloat x = sqrt(25); highfloat y = 10;"
+ "@if (x < y) { sk_FragColor = highfloat4(1); } }",
"error: 1: static if has non-static test\n1 error\n");
}
@@ -465,16 +465,16 @@
"void main() {"
"int x = 1;"
"@switch (x) {"
- "case 1: sk_FragColor = float4(1); break;"
- "default: sk_FragColor = float4(0);"
+ "case 1: sk_FragColor = highfloat4(1); break;"
+ "default: sk_FragColor = highfloat4(0);"
"}"
"}");
test_failure(r,
"void main() {"
"int x = int(sqrt(1));"
"@switch (x) {"
- "case 1: sk_FragColor = float4(1); break;"
- "default: sk_FragColor = float4(0);"
+ "case 1: sk_FragColor = highfloat4(1); break;"
+ "default: sk_FragColor = highfloat4(0);"
"}"
"}",
"error: 1: static switch has non-static test\n1 error\n");
@@ -482,8 +482,8 @@
"void main() {"
"int x = 1;"
"@switch (x) {"
- "case 1: sk_FragColor = float4(1); if (sqrt(0) < sqrt(1)) break;"
- "default: sk_FragColor = float4(0);"
+ "case 1: sk_FragColor = highfloat4(1); if (sqrt(0) < sqrt(1)) break;"
+ "default: sk_FragColor = highfloat4(0);"
"}"
"}",
"error: 1: static switch contains non-static conditional break\n1 error\n");
diff --git a/tests/SkSLFPTest.cpp b/tests/SkSLFPTest.cpp
index c3f9468..266169f 100644
--- a/tests/SkSLFPTest.cpp
+++ b/tests/SkSLFPTest.cpp
@@ -62,7 +62,7 @@
DEF_TEST(SkSLFPHelloWorld, r) {
test(r,
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -132,7 +132,7 @@
" GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;\n"
" const GrTest& _outer = args.fFp.cast<GrTest>();\n"
" (void) _outer;\n"
- " fragBuilder->codeAppendf(\"%s = float4(1.0);\\n\", args.fOutputColor);\n"
+ " fragBuilder->codeAppendf(\"%s = half4(1.0);\\n\", args.fOutputColor);\n"
" }\n"
"private:\n"
" void onSetData(const GrGLSLProgramDataManager& pdman, "
@@ -163,9 +163,9 @@
DEF_TEST(SkSLFPInput, r) {
test(r,
- "in float2 point;"
+ "in half2 point;"
"void main() {"
- "sk_OutColor = float4(point, point);"
+ "sk_OutColor = half4(point, point);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -176,7 +176,7 @@
", fPoint(point)"
},
{
- "fragBuilder->codeAppendf(\"%s = float4(float2(%f, %f), float2(%f, %f));\\n\", "
+ "fragBuilder->codeAppendf(\"%s = half4(half2(%f, %f), half2(%f, %f));\\n\", "
"args.fOutputColor, _outer.point().fX, _outer.point().fY, "
"_outer.point().fX, _outer.point().fY);",
"if (fPoint != that.fPoint) return false;"
@@ -185,7 +185,7 @@
DEF_TEST(SkSLFPUniform, r) {
test(r,
- "uniform float4 color;"
+ "uniform half4 color;"
"void main() {"
"sk_OutColor = color;"
"}",
@@ -194,14 +194,14 @@
"static std::unique_ptr<GrFragmentProcessor> Make()"
},
{
- "fColorVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType, "
+ "fColorVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType, "
"kDefault_GrSLPrecision, \"color\");",
});
}
DEF_TEST(SkSLFPInUniform, r) {
test(r,
- "in uniform float4 color;"
+ "in uniform half4 color;"
"void main() {"
"sk_OutColor = color;"
"}",
@@ -210,7 +210,7 @@
"static std::unique_ptr<GrFragmentProcessor> Make(SkRect color) {",
},
{
- "fColorVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kVec4f_GrSLType, "
+ "fColorVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, kHalf4_GrSLType, "
"kDefault_GrSLPrecision, \"color\");",
"const SkRect colorValue = _outer.color();",
"pdman.set4fv(fColorVar, 1, (float*) &colorValue);"
@@ -221,7 +221,7 @@
test(r,
"@header { header section }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -231,7 +231,7 @@
test(r,
"@class { class section }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -243,16 +243,16 @@
test(r,
"@cpp { cpp section }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{},
{"cpp section"});
test(r,
"@constructorParams { int x, float y, std::vector<float> z }"
- "in float w;"
+ "in highfloat w;"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = highfloat4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -265,7 +265,7 @@
test(r,
"@constructor { constructor section }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -275,7 +275,7 @@
test(r,
"@initializers { initializers section }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -283,22 +283,22 @@
},
{});
test(r,
- "float x = 10;"
- "@emitCode { fragBuilder->codeAppendf(\"float y = %d\\n\", x * 2); }"
+ "half x = 10;"
+ "@emitCode { fragBuilder->codeAppendf(\"half y = %d\\n\", x * 2); }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{},
{
"x = 10.0;\n"
- " fragBuilder->codeAppendf(\"float y = %d\\n\", x * 2);"
+ " fragBuilder->codeAppendf(\"half y = %d\\n\", x * 2);"
});
test(r,
"@fields { fields section }"
"@clone { }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -309,7 +309,7 @@
test(r,
"@make { make section }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -318,11 +318,11 @@
},
{});
test(r,
- "uniform float calculated;"
- "in float provided;"
+ "uniform half calculated;"
+ "in half provided;"
"@setData(varName) { varName.set1f(calculated, provided * 2); }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{},
@@ -336,7 +336,7 @@
test(r,
"@test(testDataName) { testDataName section }"
"void main() {"
- "sk_OutColor = float4(1);"
+ "sk_OutColor = half4(1);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{},
@@ -353,7 +353,7 @@
"in uniform sampler2D image;"
"in uniform colorSpaceXform colorXform;"
"void main() {"
- "sk_OutColor = sk_InColor * texture(image, float2(0, 0), colorXform);"
+ "sk_OutColor = sk_InColor * texture(image, highfloat2(0, 0), colorXform);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{
@@ -363,12 +363,12 @@
"sk_sp<GrColorSpaceXform> fColorXform;"
},
{
- "fragBuilder->codeAppendf(\"float4 _tmpVar1;%s = %s * %stexture(%s, "
- "float2(0.0, 0.0)).%s%s;\\n\", args.fOutputColor, args.fInputColor ? args.fInputColor : "
- "\"float4(1)\", fColorSpaceHelper.isValid() ? \"(_tmpVar1 = \" : \"\", "
+ "fragBuilder->codeAppendf(\"half4 _tmpVar1;%s = %s * %stexture(%s, "
+ "highfloat2(0.0, 0.0)).%s%s;\\n\", args.fOutputColor, args.fInputColor ? args.fInputColor : "
+ "\"half4(1)\", fColorSpaceHelper.isValid() ? \"(_tmpVar1 = \" : \"\", "
"fragBuilder->getProgramBuilder()->samplerVariable(args.fTexSamplers[0]).c_str(), "
"fragBuilder->getProgramBuilder()->samplerSwizzle(args.fTexSamplers[0]).c_str(), "
- "fColorSpaceHelper.isValid() ? SkStringPrintf(\", float4(clamp((%s * float4(_tmpVar1.rgb, "
+ "fColorSpaceHelper.isValid() ? SkStringPrintf(\", half4(clamp((%s * half4(_tmpVar1.rgb, "
"1.0)).rgb, 0.0, _tmpVar1.a), _tmpVar1.a))\", args.fUniformHandler->getUniformCStr("
"fColorSpaceHelper.gamutXformUniform())).c_str() : \"\");"
});
@@ -377,14 +377,14 @@
DEF_TEST(SkSLFPTransformedCoords, r) {
test(r,
"void main() {"
- "sk_OutColor = float4(sk_TransformedCoords2D[0], sk_TransformedCoords2D[0]);"
+ "sk_OutColor = half4(sk_TransformedCoords2D[0], sk_TransformedCoords2D[0]);"
"}",
*SkSL::ShaderCapsFactory::Default(),
{},
{
"SkString sk_TransformedCoords2D_0 = "
"fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);",
- "fragBuilder->codeAppendf(\"%s = float4(%s, %s);\\n\", args.fOutputColor, "
+ "fragBuilder->codeAppendf(\"%s = half4(%s, %s);\\n\", args.fOutputColor, "
"sk_TransformedCoords2D_0.c_str(), sk_TransformedCoords2D_0.c_str());"
});
@@ -392,7 +392,7 @@
DEF_TEST(SkSLFPLayoutWhen, r) {
test(r,
- "layout(when=someExpression(someOtherExpression())) uniform float sometimes;"
+ "layout(when=someExpression(someOtherExpression())) uniform half sometimes;"
"void main() {"
"}",
*SkSL::ShaderCapsFactory::Default(),
diff --git a/tests/SkSLGLSLTest.cpp b/tests/SkSLGLSLTest.cpp
index a7f6740..73c6dcc 100644
--- a/tests/SkSLGLSLTest.cpp
+++ b/tests/SkSLGLSLTest.cpp
@@ -51,7 +51,7 @@
DEF_TEST(SkSLHelloWorld, r) {
test(r,
- "void main() { sk_FragColor = float4(0.75); }",
+ "void main() { sk_FragColor = highfloat4(0.75); }",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -63,7 +63,7 @@
DEF_TEST(SkSLControl, r) {
test(r,
"void main() {"
- "if (sqrt(2) > 5) { sk_FragColor = float4(0.75); } else { discard; }"
+ "if (sqrt(2) > 5) { sk_FragColor = highfloat4(0.75); } else { discard; }"
"int i = 0;"
"while (i < 10) { sk_FragColor *= 0.5; i++; }"
"do { sk_FragColor += 0.01; } while (sk_FragColor.x < 0.75);"
@@ -98,9 +98,9 @@
DEF_TEST(SkSLFunctions, r) {
test(r,
- "float foo(float v[2]) { return v[0] * v[1]; }"
- "void bar(inout float x) { float y[2], z; y[0] = x; y[1] = x * 2; z = foo(y); x = z; }"
- "void main() { float x = 10; bar(x); sk_FragColor = float4(x); }",
+ "highfloat foo(highfloat v[2]) { return v[0] * v[1]; }"
+ "void bar(inout highfloat x) { highfloat y[2], z; y[0] = x; y[1] = x * 2; z = foo(y); x = z; }"
+ "void main() { highfloat x = 10; bar(x); sk_FragColor = highfloat4(x); }",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -124,7 +124,7 @@
DEF_TEST(SkSLOperators, r) {
test(r,
"void main() {"
- "float x = 1, y = 2;"
+ "highfloat x = 1, y = 2;"
"int z = 3;"
"x = x - x + y * z * x * (y - z);"
"y = x / y / z;"
@@ -142,8 +142,8 @@
"z >>= 2;"
"z <<= 4;"
"z %= 5;"
- "x = (float2(sqrt(1)) , 6);"
- "z = (float2(sqrt(1)) , 6);"
+ "x = (highfloat2(sqrt(1)) , 6);"
+ "z = (highfloat2(sqrt(1)) , 6);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -175,12 +175,12 @@
DEF_TEST(SkSLMatrices, r) {
test(r,
"void main() {"
- "float2x4 x = float2x4(1);"
- "float3x2 y = float3x2(1, 0, 0, 1, float2(2, 2));"
- "float3x4 z = x * y;"
- "float3 v1 = float3x3(1) * float3(2);"
- "float3 v2 = float3(2) * float3x3(1);"
- "sk_FragColor = float4(z[0].x, v1 + v2);"
+ "highfloat2x4 x = highfloat2x4(1);"
+ "highfloat3x2 y = highfloat3x2(1, 0, 0, 1, highfloat2(2, 2));"
+ "highfloat3x4 z = x * y;"
+ "highfloat3 v1 = highfloat3x3(1) * highfloat3(2);"
+ "highfloat3 v2 = highfloat3(2) * highfloat3x3(1);"
+ "sk_FragColor = highfloat4(z[0].x, v1 + v2);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -196,13 +196,13 @@
DEF_TEST(SkSLInterfaceBlock, r) {
test(r,
"uniform testBlock {"
- "float x;"
- "float y[2];"
- "layout(binding=12) float3x2 z;"
+ "half x;"
+ "half y[2];"
+ "layout(binding=12) half3x2 z;"
"bool w;"
"};"
"void main() {"
- " sk_FragColor = float4(x, y[0], y[1], 0);"
+ " sk_FragColor = half4(x, y[0], y[1], 0);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -218,10 +218,10 @@
"}\n");
test(r,
"uniform testBlock {"
- "float x;"
+ "highfloat x;"
"} test;"
"void main() {"
- " sk_FragColor = float4(test.x);"
+ " sk_FragColor = half4(test.x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -234,10 +234,10 @@
"}\n");
test(r,
"uniform testBlock {"
- "float x;"
+ "highfloat x;"
"} test[2];"
"void main() {"
- " sk_FragColor = float4(test[1].x);"
+ " sk_FragColor = half4(test[1].x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -258,8 +258,8 @@
"} a1, a2;"
"A a3;"
"struct B {"
- "float x;"
- "float y[2];"
+ "highfloat x;"
+ "highfloat y[2];"
"layout(binding=1) A z;"
"};"
"B b1, b2, b3;"
@@ -284,7 +284,7 @@
DEF_TEST(SkSLVersion, r) {
test(r,
- "in float test; void main() { sk_FragColor = float4(0.75); }",
+ "in highfloat test; void main() { sk_FragColor = highfloat4(0.75); }",
*SkSL::ShaderCapsFactory::Version450Core(),
"#version 450 core\n"
"out vec4 sk_FragColor;\n"
@@ -293,7 +293,7 @@
" sk_FragColor = vec4(0.75);\n"
"}\n");
test(r,
- "in float test; void main() { sk_FragColor = float4(0.75); }",
+ "in highfloat test; void main() { sk_FragColor = highfloat4(0.75); }",
*SkSL::ShaderCapsFactory::Version110(),
"#version 110\n"
"varying float test;\n"
@@ -304,8 +304,8 @@
DEF_TEST(SkSLUsesPrecisionModifiers, r) {
test(r,
- "void main() { float x = 0.75; highp float y = 1; x++; y++;"
- "sk_FragColor.rg = float2(x, y); }",
+ "void main() { half x = 0.75; highfloat y = 1; x++; y++;"
+ "sk_FragColor.rg = half2(x, y); }",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -317,15 +317,14 @@
" sk_FragColor.xy = vec2(x, y);\n"
"}\n");
test(r,
- "void main() { float x = 0.75; half y = 1; x++; y++;"
- "sk_FragColor.rg = float2(x, y); }",
+ "void main() { half x = 0.75; highfloat y = 1; x++; y++;"
+ "sk_FragColor.rg = half2(x, y); }",
*SkSL::ShaderCapsFactory::UsesPrecisionModifiers(),
"#version 400\n"
- "precision highp float;\n"
"out mediump vec4 sk_FragColor;\n"
"void main() {\n"
- " float x = 0.75;\n"
- " mediump float y = 1.0;\n"
+ " mediump float x = 0.75;\n"
+ " highp float y = 1.0;\n"
" x++;\n"
" y++;\n"
" sk_FragColor.xy = vec2(x, y);\n"
@@ -335,7 +334,7 @@
DEF_TEST(SkSLMinAbs, r) {
test(r,
"void main() {"
- "float x = -5;"
+ "highfloat x = -5;"
"sk_FragColor.r = min(abs(x), 6);"
"}",
*SkSL::ShaderCapsFactory::Default(),
@@ -347,7 +346,7 @@
test(r,
"void main() {"
- "float x = -5.0;"
+ "highfloat x = -5.0;"
"sk_FragColor.r = min(abs(x), 6.0);"
"}",
*SkSL::ShaderCapsFactory::CannotUseMinAndAbsTogether(),
@@ -364,7 +363,7 @@
DEF_TEST(SkSLFractNegative, r) {
static constexpr char input[] =
"void main() {"
- "float x = -42.0;"
+ "highfloat x = -42.0;"
"sk_FragColor.r = fract(x);"
"}";
static constexpr char output_default[] =
@@ -386,7 +385,7 @@
DEF_TEST(SkSLNegatedAtan, r) {
test(r,
- "void main() { float2 x = float2(sqrt(2)); sk_FragColor.r = atan(x.x, -x.y); }",
+ "void main() { highfloat2 x = highfloat2(sqrt(2)); sk_FragColor.r = atan(x.x, -x.y); }",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -395,7 +394,7 @@
" sk_FragColor.x = atan(x.x, -x.y);\n"
"}\n");
test(r,
- "void main() { float2 x = float2(sqrt(2)); sk_FragColor.r = atan(x.x, -x.y); }",
+ "void main() { highfloat2 x = highfloat2(sqrt(2)); sk_FragColor.r = atan(x.x, -x.y); }",
*SkSL::ShaderCapsFactory::MustForceNegatedAtanParamToFloat(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -466,13 +465,13 @@
DEF_TEST(SkSLVectorConstructors, r) {
test(r,
- "float2 v1 = float2(1);"
- "float2 v2 = float2(1, 2);"
- "float2 v3 = float2(float2(1));"
- "float3 v4 = float3(float2(1), 1.0);"
+ "highfloat2 v1 = highfloat2(1);"
+ "highfloat2 v2 = highfloat2(1, 2);"
+ "highfloat2 v3 = highfloat2(highfloat2(1));"
+ "highfloat3 v4 = highfloat3(highfloat2(1), 1.0);"
"int2 v5 = int2(1);"
- "int2 v6 = int2(float2(1, 2));"
- "float2 v7 = float2(int2(1, 2));",
+ "int2 v6 = int2(highfloat2(1, 2));"
+ "highfloat2 v7 = highfloat2(int2(1, 2));",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -487,9 +486,9 @@
DEF_TEST(SkSLArrayConstructors, r) {
test(r,
- "float test1[] = float[](1, 2, 3, 4);"
- "float2 test2[] = float2[](float2(1, 2), float2(3, 4));"
- "float4x4 test3[] = float4x4[]();",
+ "highfloat test1[] = highfloat[](1, 2, 3, 4);"
+ "highfloat2 test2[] = highfloat2[](highfloat2(1, 2), highfloat2(3, 4));"
+ "highfloat4x4 test3[] = highfloat4x4[]();",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -511,7 +510,6 @@
"void main() { sk_FragColor.r = 1; }",
*SkSL::ShaderCapsFactory::ShaderDerivativeExtensionString(),
"#version 400\n"
- "precision highp float;\n"
"out mediump vec4 sk_FragColor;\n"
"void main() {\n"
" sk_FragColor.x = 1.0;\n"
@@ -521,7 +519,6 @@
*SkSL::ShaderCapsFactory::ShaderDerivativeExtensionString(),
"#version 400\n"
"#extension GL_OES_standard_derivatives : require\n"
- "precision highp float;\n"
"out mediump vec4 sk_FragColor;\n"
"void main() {\n"
" sk_FragColor.x = dFdx(1.0);\n"
@@ -717,55 +714,55 @@
DEF_TEST(SkSLVecFolding, r) {
test(r,
"void main() {"
- "sk_FragColor.r = float4(0.5, 1, 1, 1).x;"
- "sk_FragColor = float4(float2(1), float2(2, 3)) + float4(5, 6, 7, 8);"
- "sk_FragColor = float4(8, float3(10)) - float4(1);"
- "sk_FragColor = float4(2) * float4(1, 2, 3, 4);"
- "sk_FragColor = float4(12) / float4(1, 2, 3, 4);"
- "sk_FragColor.r = (float4(12) / float4(1, 2, 3, 4)).y;"
- "sk_FragColor.x = float4(1) == float4(1) ? 1.0 : -1.0;"
- "sk_FragColor.x = float4(1) == float4(2) ? 2.0 : -2.0;"
- "sk_FragColor.x = float2(1) == float2(1, 1) ? 3.0 : -3.0;"
- "sk_FragColor.x = float2(1, 1) == float2(1, 1) ? 4.0 : -4.0;"
- "sk_FragColor.x = float2(1) == float2(1, 0) ? 5.0 : -5.0;"
- "sk_FragColor.x = float4(1) == float4(float2(1), float2(1)) ? 6.0 : -6.0;"
- "sk_FragColor.x = float4(float3(1), 1) == float4(float2(1), float2(1)) ? 7.0 : -7.0;"
- "sk_FragColor.x = float4(float3(1), 1) == float4(float2(1), 1, 0) ? 8.0 : -8.0;"
- "sk_FragColor.x = float2(1) != float2(1, 0) ? 9.0 : -9.0;"
- "sk_FragColor.x = float4(1) != float4(float2(1), float2(1)) ? 10.0 : -10.0;"
- "sk_FragColor = float4(sqrt(1)) * float4(1);"
- "sk_FragColor = float4(1) * float4(sqrt(2));"
- "sk_FragColor = float4(0) * float4(sqrt(3));"
- "sk_FragColor = float4(sqrt(4)) * float4(0);"
- "sk_FragColor = float4(0) / float4(sqrt(5));"
- "sk_FragColor = float4(0) + float4(sqrt(6));"
- "sk_FragColor = float4(sqrt(7)) + float4(0);"
- "sk_FragColor = float4(sqrt(8)) - float4(0);"
- "sk_FragColor = float4(0) + sqrt(9);"
- "sk_FragColor = float4(0) * sqrt(10);"
- "sk_FragColor = float4(0) / sqrt(11);"
- "sk_FragColor = float4(1) * sqrt(12);"
- "sk_FragColor = 0 + float4(sqrt(13));"
- "sk_FragColor = 0 * float4(sqrt(14));"
- "sk_FragColor = 0 / float4(sqrt(15));"
- "sk_FragColor = 1 * float4(sqrt(16));"
- "sk_FragColor = float4(sqrt(17)) + 0;"
- "sk_FragColor = float4(sqrt(18)) * 0;"
- "sk_FragColor = float4(sqrt(19)) * 1;"
- "sk_FragColor = float4(sqrt(19.5)) - 0;"
- "sk_FragColor = sqrt(20) * float4(1);"
- "sk_FragColor = sqrt(21) + float4(0);"
- "sk_FragColor = sqrt(22) - float4(0);"
- "sk_FragColor = sqrt(23) / float4(1);"
- "sk_FragColor = float4(sqrt(24)) / 1;"
- "sk_FragColor += float4(1);"
- "sk_FragColor += float4(0);"
- "sk_FragColor -= float4(1);"
- "sk_FragColor -= float4(0);"
- "sk_FragColor *= float4(1);"
- "sk_FragColor *= float4(2);"
- "sk_FragColor /= float4(1);"
- "sk_FragColor /= float4(2);"
+ "sk_FragColor.r = highfloat4(0.5, 1, 1, 1).x;"
+ "sk_FragColor = highfloat4(highfloat2(1), highfloat2(2, 3)) + highfloat4(5, 6, 7, 8);"
+ "sk_FragColor = highfloat4(8, highfloat3(10)) - highfloat4(1);"
+ "sk_FragColor = highfloat4(2) * highfloat4(1, 2, 3, 4);"
+ "sk_FragColor = highfloat4(12) / highfloat4(1, 2, 3, 4);"
+ "sk_FragColor.r = (highfloat4(12) / highfloat4(1, 2, 3, 4)).y;"
+ "sk_FragColor.x = highfloat4(1) == highfloat4(1) ? 1.0 : -1.0;"
+ "sk_FragColor.x = highfloat4(1) == highfloat4(2) ? 2.0 : -2.0;"
+ "sk_FragColor.x = highfloat2(1) == highfloat2(1, 1) ? 3.0 : -3.0;"
+ "sk_FragColor.x = highfloat2(1, 1) == highfloat2(1, 1) ? 4.0 : -4.0;"
+ "sk_FragColor.x = highfloat2(1) == highfloat2(1, 0) ? 5.0 : -5.0;"
+ "sk_FragColor.x = highfloat4(1) == highfloat4(highfloat2(1), highfloat2(1)) ? 6.0 : -6.0;"
+ "sk_FragColor.x = highfloat4(highfloat3(1), 1) == highfloat4(highfloat2(1), highfloat2(1)) ? 7.0 : -7.0;"
+ "sk_FragColor.x = highfloat4(highfloat3(1), 1) == highfloat4(highfloat2(1), 1, 0) ? 8.0 : -8.0;"
+ "sk_FragColor.x = highfloat2(1) != highfloat2(1, 0) ? 9.0 : -9.0;"
+ "sk_FragColor.x = highfloat4(1) != highfloat4(highfloat2(1), highfloat2(1)) ? 10.0 : -10.0;"
+ "sk_FragColor = highfloat4(sqrt(1)) * highfloat4(1);"
+ "sk_FragColor = highfloat4(1) * highfloat4(sqrt(2));"
+ "sk_FragColor = highfloat4(0) * highfloat4(sqrt(3));"
+ "sk_FragColor = highfloat4(sqrt(4)) * highfloat4(0);"
+ "sk_FragColor = highfloat4(0) / highfloat4(sqrt(5));"
+ "sk_FragColor = highfloat4(0) + highfloat4(sqrt(6));"
+ "sk_FragColor = highfloat4(sqrt(7)) + highfloat4(0);"
+ "sk_FragColor = highfloat4(sqrt(8)) - highfloat4(0);"
+ "sk_FragColor = highfloat4(0) + sqrt(9);"
+ "sk_FragColor = highfloat4(0) * sqrt(10);"
+ "sk_FragColor = highfloat4(0) / sqrt(11);"
+ "sk_FragColor = highfloat4(1) * sqrt(12);"
+ "sk_FragColor = 0 + highfloat4(sqrt(13));"
+ "sk_FragColor = 0 * highfloat4(sqrt(14));"
+ "sk_FragColor = 0 / highfloat4(sqrt(15));"
+ "sk_FragColor = 1 * highfloat4(sqrt(16));"
+ "sk_FragColor = highfloat4(sqrt(17)) + 0;"
+ "sk_FragColor = highfloat4(sqrt(18)) * 0;"
+ "sk_FragColor = highfloat4(sqrt(19)) * 1;"
+ "sk_FragColor = highfloat4(sqrt(19.5)) - 0;"
+ "sk_FragColor = sqrt(20) * highfloat4(1);"
+ "sk_FragColor = sqrt(21) + highfloat4(0);"
+ "sk_FragColor = sqrt(22) - highfloat4(0);"
+ "sk_FragColor = sqrt(23) / highfloat4(1);"
+ "sk_FragColor = highfloat4(sqrt(24)) / 1;"
+ "sk_FragColor += highfloat4(1);"
+ "sk_FragColor += highfloat4(0);"
+ "sk_FragColor -= highfloat4(1);"
+ "sk_FragColor -= highfloat4(0);"
+ "sk_FragColor *= highfloat4(1);"
+ "sk_FragColor *= highfloat4(2);"
+ "sk_FragColor /= highfloat4(1);"
+ "sk_FragColor /= highfloat4(2);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -822,24 +819,24 @@
DEF_TEST(SkSLMatFolding, r) {
test(r,
"void main() {"
- "sk_FragColor.x = float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) == "
- "float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) ? 1 : -1;"
- "sk_FragColor.x = float2x2(float2(1.0, 0.0), float2(1.0, 1.0)) == "
- "float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) ? 2 : -2;"
- "sk_FragColor.x = float2x2(1) == float2x2(1) ? 3 : -3;"
- "sk_FragColor.x = float2x2(1) == float2x2(0) ? 4 : -4;"
- "sk_FragColor.x = float2x2(1) == float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) ? 5 : -5;"
- "sk_FragColor.x = float2x2(2) == float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) ? 6 : -6;"
- "sk_FragColor.x = float3x2(2) == float3x2(float2(2.0, 0.0), float2(0.0, 2.0), float2(0.0))"
+ "sk_FragColor.x = highfloat2x2(highfloat2(1.0, 0.0), highfloat2(0.0, 1.0)) == "
+ "highfloat2x2(highfloat2(1.0, 0.0), highfloat2(0.0, 1.0)) ? 1 : -1;"
+ "sk_FragColor.x = highfloat2x2(highfloat2(1.0, 0.0), highfloat2(1.0, 1.0)) == "
+ "highfloat2x2(highfloat2(1.0, 0.0), highfloat2(0.0, 1.0)) ? 2 : -2;"
+ "sk_FragColor.x = highfloat2x2(1) == highfloat2x2(1) ? 3 : -3;"
+ "sk_FragColor.x = highfloat2x2(1) == highfloat2x2(0) ? 4 : -4;"
+ "sk_FragColor.x = highfloat2x2(1) == highfloat2x2(highfloat2(1.0, 0.0), highfloat2(0.0, 1.0)) ? 5 : -5;"
+ "sk_FragColor.x = highfloat2x2(2) == highfloat2x2(highfloat2(1.0, 0.0), highfloat2(0.0, 1.0)) ? 6 : -6;"
+ "sk_FragColor.x = highfloat3x2(2) == highfloat3x2(highfloat2(2.0, 0.0), highfloat2(0.0, 2.0), highfloat2(0.0))"
"? 7 : -7;"
- "sk_FragColor.x = float2x2(1) != float2x2(1) ? 8 : -8;"
- "sk_FragColor.x = float2x2(1) != float2x2(0) ? 9 : -9;"
- "sk_FragColor.x = float3x3(float3(1.0, 0.0, 0.0), float3(0.0, 1.0, 0.0), "
- "float3(0.0, 0.0, 0.0)) == float3x3(float2x2(1.0)) ? 10 : -10;"
- "sk_FragColor.x = float2x2(float3x3(1.0)) == float2x2(1.0) ? 11 : -11;"
- "sk_FragColor.x = float2x2(float4(1.0, 0.0, 0.0, 1.0)) == float2x2(1.0) ? 12 : -12;"
- "sk_FragColor.x = float2x2(1.0, 0.0, float2(0.0, 1.0)) == float2x2(1.0) ? 13 : -13;"
- "sk_FragColor.x = float2x2(float2(1.0, 0.0), 0.0, 1.0) == float2x2(1.0) ? 14 : -14;"
+ "sk_FragColor.x = highfloat2x2(1) != highfloat2x2(1) ? 8 : -8;"
+ "sk_FragColor.x = highfloat2x2(1) != highfloat2x2(0) ? 9 : -9;"
+ "sk_FragColor.x = highfloat3x3(highfloat3(1.0, 0.0, 0.0), highfloat3(0.0, 1.0, 0.0), "
+ "highfloat3(0.0, 0.0, 0.0)) == highfloat3x3(highfloat2x2(1.0)) ? 10 : -10;"
+ "sk_FragColor.x = highfloat2x2(highfloat3x3(1.0)) == highfloat2x2(1.0) ? 11 : -11;"
+ "sk_FragColor.x = highfloat2x2(highfloat4(1.0, 0.0, 0.0, 1.0)) == highfloat2x2(1.0) ? 12 : -12;"
+ "sk_FragColor.x = highfloat2x2(1.0, 0.0, highfloat2(0.0, 1.0)) == highfloat2x2(1.0) ? 13 : -13;"
+ "sk_FragColor.x = highfloat2x2(highfloat2(1.0, 0.0), 0.0, 1.0) == highfloat2x2(1.0) ? 14 : -14;"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -891,7 +888,7 @@
"if (sk_Caps.fbFetchSupport) y = 1;"
"if (sk_Caps.dropsTileOnZeroDivide && sk_Caps.texelFetchSupport) z = 1;"
"if (sk_Caps.dropsTileOnZeroDivide && sk_Caps.canUseAnyFunctionInShader) w = 1;"
- "sk_FragColor = float4(x, y, z, w);"
+ "sk_FragColor = half4(x, y, z, w);"
"}",
*SkSL::ShaderCapsFactory::VariousCaps(),
"#version 400\n"
@@ -906,11 +903,11 @@
"uniform sampler1D one;"
"uniform sampler2D two;"
"void main() {"
- "float4 a = texture(one, 0);"
- "float4 b = texture(two, float2(0));"
- "float4 c = texture(one, float2(0));"
- "float4 d = texture(two, float3(0));"
- "sk_FragColor = float4(a.x, b.x, c.x, d.x);"
+ "highfloat4 a = texture(one, 0);"
+ "highfloat4 b = texture(two, highfloat2(0));"
+ "highfloat4 c = texture(one, highfloat2(0));"
+ "highfloat4 d = texture(two, highfloat3(0));"
+ "sk_FragColor = half4(a.x, b.x, c.x, d.x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -928,11 +925,11 @@
"uniform sampler1D one;"
"uniform sampler2D two;"
"void main() {"
- "float4 a = texture(one, 0);"
- "float4 b = texture(two, float2(0));"
- "float4 c = texture(one, float2(0));"
- "float4 d = texture(two, float3(0));"
- "sk_FragColor = float4(a.x, b.x, c.x, d.x);"
+ "highfloat4 a = texture(one, 0);"
+ "highfloat4 b = texture(two, highfloat2(0));"
+ "highfloat4 c = texture(one, highfloat2(0));"
+ "highfloat4 d = texture(two, highfloat3(0));"
+ "sk_FragColor = half4(a.x, b.x, c.x, d.x);"
"}",
*SkSL::ShaderCapsFactory::Version110(),
"#version 110\n"
@@ -1047,7 +1044,7 @@
"}\n",
SkSL::Program::kVertex_Kind);
test(r,
- "void main() { sk_FragColor = float4(sk_ClipDistance[0]); }",
+ "void main() { sk_FragColor = half4(sk_ClipDistance[0]); }",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -1058,9 +1055,9 @@
DEF_TEST(SkSLArrayTypes, r) {
test(r,
- "void main() { float2 x[2] = float2[2](float2(1), float2(2));"
- "float2[2] y = float2[2](float2(3), float2(4));"
- "sk_FragColor = float4(x[0], y[1]); }",
+ "void main() { highfloat2 x[2] = highfloat2[2](highfloat2(1), highfloat2(2));"
+ "highfloat2[2] y = highfloat2[2](highfloat2(3), highfloat2(4));"
+ "sk_FragColor = highfloat4(x[0], y[1]); }",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -1076,9 +1073,9 @@
"layout(invocations = 2) in;"
"layout(line_strip, max_vertices = 2) out;"
"void main() {"
- "gl_Position = sk_in[0].gl_Position + float4(-0.5, 0, 0, sk_InvocationID);"
+ "gl_Position = sk_in[0].gl_Position + highfloat4(-0.5, 0, 0, sk_InvocationID);"
"EmitVertex();"
- "gl_Position = sk_in[0].gl_Position + float4(0.5, 0, 0, sk_InvocationID);"
+ "gl_Position = sk_in[0].gl_Position + highfloat4(0.5, 0, 0, sk_InvocationID);"
"EmitVertex();"
"EndPrimitive();"
"}",
@@ -1101,7 +1098,7 @@
// basic "does a switch even work" test
test(r,
"void main() {"
- " float x;"
+ " highfloat x;"
" switch (int(sqrt(1))) {"
" case 0:"
" x = 0.0;"
@@ -1112,7 +1109,7 @@
" default:"
" x = 2.0;"
" }"
- " sk_FragColor = float4(x);"
+ " sk_FragColor = highfloat4(x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1134,7 +1131,7 @@
// dead code inside of switch
test(r,
"void main() {"
- " float x;"
+ " highfloat x;"
" switch (int(sqrt(2))) {"
" case 0:"
" x = 0.0;"
@@ -1143,7 +1140,7 @@
" default:"
" x = 2.0;"
" }"
- " sk_FragColor = float4(x);"
+ " sk_FragColor = half4(x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1162,14 +1159,14 @@
// non-static test w/ fallthrough
test(r,
"void main() {"
- " float x = 0.0;"
+ " highfloat x = 0.0;"
" switch (int(sqrt(3))) {"
" case 0:"
" x = 0.0;"
" case 1:"
" x = 1.0;"
" }"
- " sk_FragColor = float4(x);"
+ " sk_FragColor = half4(x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1187,14 +1184,14 @@
// static test w/ fallthrough
test(r,
"void main() {"
- " float x = 0.0;"
+ " highfloat x = 0.0;"
" switch (0) {"
" case 0:"
" x = 0.0;"
" case 1:"
" x = 1.0;"
" }"
- " sk_FragColor = float4(x);"
+ " sk_FragColor = half4(x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1205,14 +1202,14 @@
// static test w/ fallthrough, different entry point
test(r,
"void main() {"
- " float x = 0.0;"
+ " highfloat x = 0.0;"
" switch (1) {"
" case 0:"
" x = 0.0;"
" case 1:"
" x = 1.0;"
" }"
- " sk_FragColor = float4(x);"
+ " sk_FragColor = half4(x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1223,7 +1220,7 @@
// static test w/ break
test(r,
"void main() {"
- " float x = 0.0;"
+ " highfloat x = 0.0;"
" switch (0) {"
" case 0:"
" x = 0.0;"
@@ -1231,7 +1228,7 @@
" case 1:"
" x = 1.0;"
" }"
- " sk_FragColor = float4(x);"
+ " sk_FragColor = half4(x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1242,7 +1239,7 @@
// static test w/ static conditional break
test(r,
"void main() {"
- " float x = 0.0;"
+ " highfloat x = 0.0;"
" switch (0) {"
" case 0:"
" x = 0.0;"
@@ -1250,7 +1247,7 @@
" case 1:"
" x = 1.0;"
" }"
- " sk_FragColor = float4(x);"
+ " sk_FragColor = half4(x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1261,7 +1258,7 @@
// static test w/ non-static conditional break
test(r,
"void main() {"
- " float x = 0.0;"
+ " highfloat x = 0.0;"
" switch (0) {"
" case 0:"
" x = 0.0;"
@@ -1269,7 +1266,7 @@
" case 1:"
" x = 1.0;"
" }"
- " sk_FragColor = float4(x);"
+ " sk_FragColor = half4(x);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1291,7 +1288,7 @@
test(r,
"uniform sampler2D test;"
"void main() {"
- " sk_FragColor = texture(test, float2(0.5));"
+ " sk_FragColor = texture(test, highfloat2(0.5));"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1303,7 +1300,7 @@
test(r,
"uniform sampler2DRect test;"
"void main() {"
- " sk_FragColor = texture(test, float2(0.5));"
+ " sk_FragColor = texture(test, highfloat2(0.5));"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1315,7 +1312,7 @@
test(r,
"uniform sampler2DRect test;"
"void main() {"
- " sk_FragColor = texture(test, float3(0.5));"
+ " sk_FragColor = texture(test, highfloat3(0.5));"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1329,12 +1326,12 @@
DEF_TEST(SkSLUnusedVars, r) {
test(r,
"void main() {"
- "float a = 1, b = 2, c = 3;"
- "float d = c;"
- "float e = d;"
+ "highfloat a = 1, b = 2, c = 3;"
+ "highfloat d = c;"
+ "highfloat e = d;"
"b++;"
"d++;"
- "sk_FragColor = float4(b, b, d, d);"
+ "sk_FragColor = highfloat4(b, b, d, d);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1351,11 +1348,11 @@
DEF_TEST(SkSLMultipleAssignments, r) {
test(r,
"void main() {"
- "float x;"
- "float y;"
+ "highfloat x;"
+ "highfloat y;"
"int z;"
"x = y = z = 1;"
- "sk_FragColor = float4(z);"
+ "sk_FragColor = highfloat4(z);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1367,13 +1364,13 @@
DEF_TEST(SkSLComplexDelete, r) {
test(r,
- "uniform float4x4 colorXform;"
+ "uniform highfloat4x4 colorXform;"
"uniform sampler2D sampler;"
"void main() {"
- "float4 tmpColor;"
- "sk_FragColor = float4(1.0) * (tmpColor = texture(sampler, float2(1)) , "
- "colorXform != float4x4(1.0) ? float4(clamp((float4x4(colorXform) * "
- "float4(tmpColor.xyz, 1.0)).xyz, "
+ "highfloat4 tmpColor;"
+ "sk_FragColor = highfloat4(1.0) * (tmpColor = texture(sampler, highfloat2(1)) , "
+ "colorXform != highfloat4x4(1.0) ? highfloat4(clamp((highfloat4x4(colorXform) * "
+ "highfloat4(tmpColor.xyz, 1.0)).xyz, "
"0.0, tmpColor.w), tmpColor.w) : tmpColor);"
"}",
*SkSL::ShaderCapsFactory::Default(),
@@ -1392,8 +1389,8 @@
DEF_TEST(SkSLDependentInitializers, r) {
test(r,
"void main() {"
- "float x = 0.5, y = x * 2;"
- "sk_FragColor = float4(y);"
+ "highfloat x = 0.5, y = x * 2;"
+ "sk_FragColor = highfloat4(y);"
"}",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
@@ -1427,11 +1424,11 @@
"layout(invocations = 2) in;"
"layout(line_strip, max_vertices = 2) out;"
"void test() {"
- "gl_Position = sk_in[0].gl_Position + float4(0.5, 0, 0, sk_InvocationID);"
+ "gl_Position = sk_in[0].gl_Position + highfloat4(0.5, 0, 0, sk_InvocationID);"
"EmitVertex();"
"}"
"void main() {"
- "gl_Position = sk_in[0].gl_Position + float4(-0.5, 0, 0, sk_InvocationID);"
+ "gl_Position = sk_in[0].gl_Position + highfloat4(-0.5, 0, 0, sk_InvocationID);"
"EmitVertex();"
"}",
*SkSL::ShaderCapsFactory::MustImplementGSInvocationsWithLoop(),
@@ -1458,13 +1455,13 @@
DEF_TEST(SkSLTypePrecision, r) {
test(r,
- "float f = 1;"
+ "highfloat f = 1;"
"half h = 2;"
"double d = 3;"
- "float2 f2 = float2(1, 2);"
+ "highfloat2 f2 = highfloat2(1, 2);"
"half3 h3 = half3(1, 2, 3);"
"double4 d4 = double4(1, 2, 3, 4);"
- "float2x2 f22 = float2x2(1, 2, 3, 4);"
+ "highfloat2x2 f22 = highfloat2x2(1, 2, 3, 4);"
"half2x4 h24 = half2x4(1, 2, 3, 4, 5, 6, 7, 8);"
"double4x2 d42 = double4x2(1, 2, 3, 4, 5, 6, 7, 8);",
*SkSL::ShaderCapsFactory::Default(),
@@ -1480,21 +1477,20 @@
"mat2x4 h24 = mat2x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n"
"dmat4x2 d42 = dmat4x2(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n");
test(r,
- "float f = 1;"
+ "highfloat f = 1;"
"half h = 2;"
- "float2 f2 = float2(1, 2);"
+ "highfloat2 f2 = highfloat2(1, 2);"
"half3 h3 = half3(1, 2, 3);"
- "float2x2 f22 = float2x2(1, 2, 3, 4);"
+ "highfloat2x2 f22 = highfloat2x2(1, 2, 3, 4);"
"half2x4 h24 = half2x4(1, 2, 3, 4, 5, 6, 7, 8);",
*SkSL::ShaderCapsFactory::UsesPrecisionModifiers(),
"#version 400\n"
- "precision highp float;\n"
"out mediump vec4 sk_FragColor;\n"
- "float f = 1.0;\n"
+ "highp float f = 1.0;\n"
"mediump float h = 2.0;\n"
- "vec2 f2 = vec2(1.0, 2.0);\n"
+ "highp vec2 f2 = vec2(1.0, 2.0);\n"
"mediump vec3 h3 = vec3(1.0, 2.0, 3.0);\n"
- "mat2 f22 = mat2(1.0, 2.0, 3.0, 4.0);\n"
+ "highp mat2 f22 = mat2(1.0, 2.0, 3.0, 4.0);\n"
"mediump mat2x4 h24 = mat2x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n");
}
@@ -1505,50 +1501,37 @@
"ushort us = ushort(sqrt(1));"
"uint ui = uint(sqrt(1));"
"half h = sqrt(1);"
- "float f = sqrt(1);"
- "double d = sqrt(1);"
+ "highfloat f = sqrt(1);"
"short s2s = s;"
"short i2s = i;"
"short us2s = short(us);"
"short ui2s = short(ui);"
"short h2s = short(h);"
"short f2s = short(f);"
- "short d2fs = short(d);"
"int s2i = s;"
"int i2i = i;"
"int us2i = int(us);"
"int ui2i = int(ui);"
"int h2i = int(h);"
"int f2i = int(f);"
- "int d2fi = int(d);"
"ushort s2us = ushort(s);"
"ushort i2us = ushort(i);"
"ushort us2us = us;"
"ushort ui2us = ui;"
"ushort h2us = ushort(h);"
"ushort f2us = ushort(f);"
- "ushort d2fus = ushort(d);"
"uint s2ui = uint(s);"
"uint i2ui = uint(i);"
"uint us2ui = us;"
"uint ui2ui = ui;"
"uint h2ui = uint(h);"
"uint f2ui = uint(f);"
- "uint d2fui = uint(d);"
- "float s2f = s;"
- "float i2f = i;"
- "float us2f = us;"
- "float ui2f = ui;"
- "float h2f = h;"
- "float f2f = f;"
- "float d2f = d;"
- "double s2d = s;"
- "double i2d = i;"
- "double us2d = us;"
- "double ui2d = ui;"
- "double h2d = h;"
- "double f2d = f;"
- "double d2d = d;",
+ "highfloat s2f = s;"
+ "highfloat i2f = i;"
+ "highfloat us2f = us;"
+ "highfloat ui2f = ui;"
+ "highfloat h2f = h;"
+ "highfloat f2f = f;",
*SkSL::ShaderCapsFactory::Default(),
"#version 400\n"
"out vec4 sk_FragColor;\n"
@@ -1558,49 +1541,36 @@
"uint ui = uint(sqrt(1.0));\n"
"float h = sqrt(1.0);\n"
"float f = sqrt(1.0);\n"
- "double d = sqrt(1.0);\n"
"int s2s = s;\n"
"int i2s = i;\n"
"int us2s = int(us);\n"
"int ui2s = int(ui);\n"
"int h2s = int(h);\n"
"int f2s = int(f);\n"
- "int d2fs = int(d);\n"
"int s2i = s;\n"
"int i2i = i;\n"
"int us2i = int(us);\n"
"int ui2i = int(ui);\n"
"int h2i = int(h);\n"
"int f2i = int(f);\n"
- "int d2fi = int(d);\n"
"uint s2us = uint(s);\n"
"uint i2us = uint(i);\n"
"uint us2us = us;\n"
"uint ui2us = ui;\n"
"uint h2us = uint(h);\n"
"uint f2us = uint(f);\n"
- "uint d2fus = uint(d);\n"
"uint s2ui = uint(s);\n"
"uint i2ui = uint(i);\n"
"uint us2ui = us;\n"
"uint ui2ui = ui;\n"
"uint h2ui = uint(h);\n"
"uint f2ui = uint(f);\n"
- "uint d2fui = uint(d);\n"
"float s2f = float(s);\n"
"float i2f = float(i);\n"
"float us2f = float(us);\n"
"float ui2f = float(ui);\n"
"float h2f = h;\n"
- "float f2f = f;\n"
- "float d2f = d;\n"
- "double s2d = double(s);\n"
- "double i2d = double(i);\n"
- "double us2d = double(us);\n"
- "double ui2d = double(ui);\n"
- "double h2d = h;\n"
- "double f2d = f;\n"
- "double d2d = d;\n");
+ "float f2f = f;\n");
}
#endif