Mangle function names as a separate step before emitting func-bodies.
This is necessary to support function calls in FP files properly; in
some cases, functions can be referenced before they have been emitted,
and we need to be able to name them.
This CL resolves the remaining errors in GrRecursion.cpp. There are
still additional errors in GrNestedCall.cpp that will be fixed in
followup CLs.
Change-Id: Iec98ef02ea6a98a9945a4e0e3cfa3537dff01305
Bug: skia:10684, skia:10872
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/329676
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>
Auto-Submit: John Stiles <johnstiles@google.com>
diff --git a/src/effects/imagefilters/SkLightingImageFilter.cpp b/src/effects/imagefilters/SkLightingImageFilter.cpp
index 6413c4a..7414cb3 100644
--- a/src/effects/imagefilters/SkLightingImageFilter.cpp
+++ b/src/effects/imagefilters/SkLightingImageFilter.cpp
@@ -1755,7 +1755,7 @@
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
SkString lightFunc;
this->emitLightFunc(&le, uniformHandler, fragBuilder, &lightFunc);
- const GrShaderVar gSobelArgs[] = {
+ const GrShaderVar gSobelArgs[] = {
GrShaderVar("a", kHalf_GrSLType),
GrShaderVar("b", kHalf_GrSLType),
GrShaderVar("c", kHalf_GrSLType),
@@ -1764,41 +1764,38 @@
GrShaderVar("f", kHalf_GrSLType),
GrShaderVar("scale", kHalf_GrSLType),
};
- SkString sobelFuncName;
+ SkString sobelFuncName = fragBuilder->getMangledFunctionName("sobel");
fragBuilder->emitFunction(kHalf_GrSLType,
- "sobel",
+ sobelFuncName.c_str(),
SK_ARRAY_COUNT(gSobelArgs),
gSobelArgs,
- "\treturn (-a + b - 2.0 * c + 2.0 * d -e + f) * scale;\n",
- &sobelFuncName);
- const GrShaderVar gPointToNormalArgs[] = {
+ "\treturn (-a + b - 2.0 * c + 2.0 * d -e + f) * scale;\n");
+ const GrShaderVar gPointToNormalArgs[] = {
GrShaderVar("x", kHalf_GrSLType),
GrShaderVar("y", kHalf_GrSLType),
GrShaderVar("scale", kHalf_GrSLType),
};
- SkString pointToNormalName;
+ SkString pointToNormalName = fragBuilder->getMangledFunctionName("pointToNormal");
fragBuilder->emitFunction(kHalf3_GrSLType,
- "pointToNormal",
+ pointToNormalName.c_str(),
SK_ARRAY_COUNT(gPointToNormalArgs),
gPointToNormalArgs,
- "\treturn normalize(half3(-x * scale, -y * scale, 1));\n",
- &pointToNormalName);
+ "\treturn normalize(half3(-x * scale, -y * scale, 1));\n");
- const GrShaderVar gInteriorNormalArgs[] = {
+ const GrShaderVar gInteriorNormalArgs[] = {
GrShaderVar("m", kHalf_GrSLType, 9),
GrShaderVar("surfaceScale", kHalf_GrSLType),
};
SkString normalBody = emitNormalFunc(le.boundaryMode(),
pointToNormalName.c_str(),
sobelFuncName.c_str());
- SkString normalName;
+ SkString normalName = fragBuilder->getMangledFunctionName("normal");
fragBuilder->emitFunction(kHalf3_GrSLType,
- "normal",
+ normalName.c_str(),
SK_ARRAY_COUNT(gInteriorNormalArgs),
gInteriorNormalArgs,
- normalBody.c_str(),
- &normalName);
+ normalBody.c_str());
fragBuilder->codeAppendf("\t\tfloat2 coord = %s;\n", args.fSampleCoord);
fragBuilder->codeAppend("\t\thalf m[9];\n");
@@ -1864,12 +1861,12 @@
SkString lightBody;
lightBody.appendf("\thalf colorScale = %s * dot(normal, surfaceToLight);\n", kd);
lightBody.appendf("\treturn half4(lightColor * saturate(colorScale), 1.0);\n");
+ *funcName = fragBuilder->getMangledFunctionName("light");
fragBuilder->emitFunction(kHalf4_GrSLType,
- "light",
+ funcName->c_str(),
SK_ARRAY_COUNT(gLightArgs),
gLightArgs,
- lightBody.c_str(),
- funcName);
+ lightBody.c_str());
}
void GrGLDiffuseLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman,
@@ -1973,12 +1970,12 @@
ks, shininess);
lightBody.appendf("\thalf3 color = lightColor * saturate(colorScale);\n");
lightBody.appendf("\treturn half4(color, max(max(color.r, color.g), color.b));\n");
+ *funcName = fragBuilder->getMangledFunctionName("light");
fragBuilder->emitFunction(kHalf4_GrSLType,
- "light",
+ funcName->c_str(),
SK_ARRAY_COUNT(gLightArgs),
gLightArgs,
- lightBody.c_str(),
- funcName);
+ lightBody.c_str());
}
void GrGLSpecularLightingEffect::onSetData(const GrGLSLProgramDataManager& pdman,
@@ -2115,12 +2112,12 @@
color, cosOuter, coneScale);
lightColorBody.appendf("\t}\n");
lightColorBody.appendf("\treturn %s;\n", color);
+ fLightColorFunc = fragBuilder->getMangledFunctionName("lightColor");
fragBuilder->emitFunction(kHalf3_GrSLType,
- "lightColor",
+ fLightColorFunc.c_str(),
SK_ARRAY_COUNT(gLightColorArgs),
gLightColorArgs,
- lightColorBody.c_str(),
- &fLightColorFunc);
+ lightColorBody.c_str());
fragBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight);
}
diff --git a/src/gpu/ccpr/GrGSCoverageProcessor.cpp b/src/gpu/ccpr/GrGSCoverageProcessor.cpp
index 867b510..be1d2ee 100644
--- a/src/gpu/ccpr/GrGSCoverageProcessor.cpp
+++ b/src/gpu/ccpr/GrGSCoverageProcessor.cpp
@@ -67,7 +67,7 @@
g->codeAppendf("%s *= half(sk_in[0].sk_Position.w);", wind.c_str());
}
- SkString emitVertexFn;
+ SkString emitVertexFn = g->getMangledFunctionName("emitVertex");
SkSTArray<3, GrShaderVar> emitArgs;
const char* corner = emitArgs.emplace_back("corner", kFloat2_GrSLType).c_str();
const char* bloatdir = emitArgs.emplace_back("bloatdir", kFloat2_GrSLType).c_str();
@@ -79,7 +79,8 @@
if (Subpass::kCorners == proc.fSubpass) {
cornerCoverage = emitArgs.emplace_back("corner_coverage", kHalf2_GrSLType).c_str();
}
- g->emitFunction(kVoid_GrSLType, "emitVertex", emitArgs.count(), emitArgs.begin(), [&]() {
+ g->emitFunction(kVoid_GrSLType, emitVertexFn.c_str(),
+ emitArgs.count(), emitArgs.begin(), [&] {
SkString fnBody;
fnBody.appendf("float2 vertexpos = fma(%s, float2(bloat), %s);", bloatdir, corner);
const char* coverage = inputCoverage;
@@ -103,7 +104,7 @@
"vertexpos", coverage, cornerCoverage, wind.c_str());
g->emitVertex(&fnBody, "vertexpos");
return fnBody;
- }().c_str(), &emitVertexFn);
+ }().c_str());
float bloat = kAABloatRadius;
#ifdef SK_DEBUG
diff --git a/src/gpu/effects/GrSkSLFP.cpp b/src/gpu/effects/GrSkSLFP.cpp
index 186f7c8..494a7f8 100644
--- a/src/gpu/effects/GrSkSLFP.cpp
+++ b/src/gpu/effects/GrSkSLFP.cpp
@@ -95,16 +95,15 @@
}
}
for (const auto& f : fArgs.fFunctions) {
- fFunctionNames.emplace_back();
+ fFunctionNames.push_back(fragBuilder->getMangledFunctionName(f.fName.c_str()));
auto fmtArgIter = f.fFormatArgs.cbegin();
SkSL::String body = this->expandFormatArgs(f.fBody, args, fmtArgIter);
SkASSERT(fmtArgIter == f.fFormatArgs.cend());
fragBuilder->emitFunction(f.fReturnType,
- f.fName.c_str(),
+ fFunctionNames.back().c_str(),
f.fParameters.size(),
f.fParameters.data(),
- body.c_str(),
- &fFunctionNames.back());
+ body.c_str());
}
fragBuilder->codeAppendf("%s = %s;\n", args.fOutputColor, args.fInputColor);
auto fmtArgIter = fArgs.fFormatArgs.cbegin();
diff --git a/src/gpu/effects/generated/GrHighContrastFilterEffect.cpp b/src/gpu/effects/generated/GrHighContrastFilterEffect.cpp
index 58f9aca..798e6ab 100644
--- a/src/gpu/effects/generated/GrHighContrastFilterEffect.cpp
+++ b/src/gpu/effects/generated/GrHighContrastFilterEffect.cpp
@@ -38,16 +38,15 @@
(void)linearize;
contrastModVar = args.fUniformHandler->addUniform(&_outer, kFragment_GrShaderFlag,
kHalf_GrSLType, "contrastMod");
- SkString HSLToRGB_name;
+ SkString HSLToRGB_name = fragBuilder->getMangledFunctionName("HSLToRGB");
const GrShaderVar HSLToRGB_args[] = {GrShaderVar("p", kHalf_GrSLType),
GrShaderVar("q", kHalf_GrSLType),
GrShaderVar("t", kHalf_GrSLType)};
- fragBuilder->emitFunction(kHalf_GrSLType, "HSLToRGB", 3, HSLToRGB_args,
+ fragBuilder->emitFunction(kHalf_GrSLType, HSLToRGB_name.c_str(), 3, HSLToRGB_args,
R"SkSL(if (t < 0.0) t += 1.0;
if (t > 1.0) t -= 1.0;
return t < 0.1666666716337204 ? p + ((q - p) * 6.0) * t : (t < 0.5 ? q : (t < 0.66666668653488159 ? p + ((q - p) * (0.66666668653488159 - t)) * 6.0 : p));
-)SkSL",
- &HSLToRGB_name);
+)SkSL");
fragBuilder->codeAppendf(
R"SkSL(;)SkSL");
SkString _sample896 = this->invokeChild(0, args);
diff --git a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
index d554f0f..fb6f20c 100644
--- a/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLFragmentShaderBuilder.cpp
@@ -197,12 +197,12 @@
this->codeAppendf("return %s;\n", args.fOutputColor);
}
- SkString result;
- this->emitFunction(kHalf4_GrSLType, args.fFp.name(), paramCount, params,
- this->code().c_str(), &result, args.fForceInline);
+ SkString funcName = this->getMangledFunctionName(args.fFp.name());
+ this->emitFunction(kHalf4_GrSLType, funcName.c_str(), paramCount, params,
+ this->code().c_str(), args.fForceInline);
this->deleteStage();
this->onAfterChildProcEmitCode();
- return result;
+ return funcName;
}
const char* GrGLSLFragmentShaderBuilder::dstColor() {
diff --git a/src/gpu/glsl/GrGLSLShaderBuilder.cpp b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
index 8a5b071..c54fcea 100644
--- a/src/gpu/glsl/GrGLSLShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
@@ -41,23 +41,24 @@
this->definitions().append(";");
}
+SkString GrGLSLShaderBuilder::getMangledFunctionName(const char* baseName) {
+ return fProgramBuilder->nameVariable(/*prefix=*/'\0', baseName);
+}
+
void GrGLSLShaderBuilder::emitFunction(GrSLType returnType,
- const char* name,
+ const char* mangledName,
int argCnt,
const GrShaderVar* args,
const char* body,
- SkString* outName,
bool forceInline) {
- *outName = fProgramBuilder->nameVariable(/*prefix=*/'\0', name);
- this->functions().appendf("%s%s %s(",
- forceInline ? "inline " : "",
- GrGLSLTypeString(returnType),
- outName->c_str());
+ this->functions().appendf("%s%s %s(", forceInline ? "inline " : "",
+ GrGLSLTypeString(returnType),
+ mangledName);
for (int i = 0; i < argCnt; ++i) {
- args[i].appendDecl(fProgramBuilder->shaderCaps(), &this->functions());
- if (i < argCnt - 1) {
+ if (i > 0) {
this->functions().append(", ");
}
+ args[i].appendDecl(fProgramBuilder->shaderCaps(), &this->functions());
}
this->functions().appendf(") {\n"
"%s"
@@ -168,9 +169,9 @@
break;
}
body.append("return s * x;");
- SkString funcName;
- this->emitFunction(kHalf_GrSLType, name, SK_ARRAY_COUNT(gTFArgs), gTFArgs, body.c_str(),
- &funcName);
+ SkString funcName = this->getMangledFunctionName(name);
+ this->emitFunction(kHalf_GrSLType, funcName.c_str(), SK_ARRAY_COUNT(gTFArgs), gTFArgs,
+ body.c_str());
return funcName;
};
@@ -193,8 +194,9 @@
SkString body;
body.appendf("color.rgb = (%s * color.rgb);", xform);
body.append("return color;");
- this->emitFunction(kHalf4_GrSLType, "gamut_xform", SK_ARRAY_COUNT(gGamutXformArgs),
- gGamutXformArgs, body.c_str(), &gamutXformFuncName);
+ gamutXformFuncName = this->getMangledFunctionName("gamut_xform");
+ this->emitFunction(kHalf4_GrSLType, gamutXformFuncName.c_str(),
+ SK_ARRAY_COUNT(gGamutXformArgs), gGamutXformArgs, body.c_str());
}
// Now define a wrapper function that applies all the intermediate steps
@@ -228,9 +230,9 @@
body.append("color.rgb *= color.a;");
}
body.append("return half4(color);");
- SkString colorXformFuncName;
- this->emitFunction(kHalf4_GrSLType, "color_xform", SK_ARRAY_COUNT(gColorXformArgs),
- gColorXformArgs, body.c_str(), &colorXformFuncName);
+ SkString colorXformFuncName = this->getMangledFunctionName("color_xform");
+ this->emitFunction(kHalf4_GrSLType, colorXformFuncName.c_str(),
+ SK_ARRAY_COUNT(gColorXformArgs), gColorXformArgs, body.c_str());
out->appendf("%s(%s)", colorXformFuncName.c_str(), srcColor);
}
}
diff --git a/src/gpu/glsl/GrGLSLShaderBuilder.h b/src/gpu/glsl/GrGLSLShaderBuilder.h
index b7f44b5..14dc021 100644
--- a/src/gpu/glsl/GrGLSLShaderBuilder.h
+++ b/src/gpu/glsl/GrGLSLShaderBuilder.h
@@ -95,8 +95,8 @@
}
/**
- * Called by GrGLSLProcessors to add code to one of the shaders.
- */
+ * Called by GrGLSLProcessors to add code to one of the shaders.
+ */
void codeAppendf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
va_list args;
va_start(args, format);
@@ -120,22 +120,27 @@
*/
void declAppend(const GrShaderVar& var);
+ /**
+ * Generates a mangled name for a helper function in the fragment shader. Will give consistent
+ * results if called more than once.
+ */
+ SkString getMangledFunctionName(const char* baseName);
+
/** Emits a helper function outside of main() in the fragment shader. */
void emitFunction(GrSLType returnType,
- const char* name,
+ const char* mangledName,
int argCnt,
const GrShaderVar* args,
const char* body,
- SkString* outName,
bool forceInline = false);
- /*
+ /**
* Combines the various parts of the shader to create a single finalized shader string.
*/
void finalize(uint32_t visibility);
- /*
- * Get parent builder for adding uniforms
+ /**
+ * Get parent builder for adding uniforms.
*/
GrGLSLProgramBuilder* getProgramBuilder() { return fProgramBuilder; }
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index 9e00222..a6b298f 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -397,15 +397,14 @@
GrShaderVar("angleToEdge", kFloat_GrSLType),
GrShaderVar("diameter", kFloat_GrSLType),
};
- SkString fnName;
- fragBuilder->emitFunction(kFloat_GrSLType, "coverage_from_dash_edge",
+ SkString fnName = fragBuilder->getMangledFunctionName("coverage_from_dash_edge");
+ fragBuilder->emitFunction(kFloat_GrSLType, fnName.c_str(),
SK_ARRAY_COUNT(fnArgs), fnArgs, R"(
float linearDist;
angleToEdge = clamp(angleToEdge, -3.1415, 3.1415);
linearDist = diameter * sin(angleToEdge / 2);
return saturate(linearDist + 0.5);
- )",
- &fnName);
+ )");
fragBuilder->codeAppend(R"(
float d = length(circleEdge.xy) * circleEdge.z;
diff --git a/src/shaders/SkPerlinNoiseShader.cpp b/src/shaders/SkPerlinNoiseShader.cpp
index 081abc2..f700a7f 100644
--- a/src/shaders/SkPerlinNoiseShader.cpp
+++ b/src/shaders/SkPerlinNoiseShader.cpp
@@ -944,15 +944,15 @@
// Compute the noise as a linear interpolation of 'a' and 'b'
noiseCode.append("return mix(ab.x, ab.y, noiseSmooth.y);");
- SkString noiseFuncName;
+ SkString noiseFuncName = fragBuilder->getMangledFunctionName("noiseFuncName");
if (pne.stitchTiles()) {
- fragBuilder->emitFunction(kHalf_GrSLType,
- "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseStitchArgs),
- gPerlinNoiseStitchArgs, noiseCode.c_str(), &noiseFuncName);
+ fragBuilder->emitFunction(kHalf_GrSLType, noiseFuncName.c_str(),
+ SK_ARRAY_COUNT(gPerlinNoiseStitchArgs), gPerlinNoiseStitchArgs,
+ noiseCode.c_str());
} else {
- fragBuilder->emitFunction(kHalf_GrSLType,
- "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseArgs),
- gPerlinNoiseArgs, noiseCode.c_str(), &noiseFuncName);
+ fragBuilder->emitFunction(kHalf_GrSLType, noiseFuncName.c_str(),
+ SK_ARRAY_COUNT(gPerlinNoiseArgs), gPerlinNoiseArgs,
+ noiseCode.c_str());
}
// There are rounding errors if the floor operation is not performed here
@@ -1210,52 +1210,51 @@
const char* zUni = uniformHandler->getUniformCStr(fZUni);
// fade function
- const GrShaderVar fadeArgs[] = {
+ const GrShaderVar fadeArgs[] = {
GrShaderVar("t", kHalf3_GrSLType)
};
- SkString fadeFuncName;
- fragBuilder->emitFunction(kHalf3_GrSLType, "fade", SK_ARRAY_COUNT(fadeArgs),
- fadeArgs,
- "return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);",
- &fadeFuncName);
+ SkString fadeFuncName = fragBuilder->getMangledFunctionName("fade");
+ fragBuilder->emitFunction(kHalf3_GrSLType, fadeFuncName.c_str(),
+ SK_ARRAY_COUNT(fadeArgs), fadeArgs,
+ "return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);");
// perm function
- const GrShaderVar permArgs[] = {
+ const GrShaderVar permArgs[] = {
{"x", kHalf_GrSLType}
};
SkString samplePerm = this->invokeChild(0, "half4(1)", args, "float2(x, 0.5)");
- SkString permFuncName;
+ SkString permFuncName = fragBuilder->getMangledFunctionName("perm");
SkString permCode = SkStringPrintf("return %s.r * 255;", samplePerm.c_str());
- fragBuilder->emitFunction(kHalf_GrSLType, "perm", SK_ARRAY_COUNT(permArgs), permArgs,
- permCode.c_str(), &permFuncName);
+ fragBuilder->emitFunction(kHalf_GrSLType, permFuncName.c_str(), SK_ARRAY_COUNT(permArgs),
+ permArgs, permCode.c_str());
// grad function
- const GrShaderVar gradArgs[] = {
+ const GrShaderVar gradArgs[] = {
{"x", kHalf_GrSLType},
{"p", kHalf3_GrSLType}
};
SkString sampleGrad = this->invokeChild(1, "half4(1)", args, "float2(x, 0.5)");
- SkString gradFuncName;
+ SkString gradFuncName = fragBuilder->getMangledFunctionName("grad");
SkString gradCode = SkStringPrintf("return half(dot(%s.rgb * 255.0 - float3(1.0), p));",
sampleGrad.c_str());
- fragBuilder->emitFunction(kHalf_GrSLType, "grad", SK_ARRAY_COUNT(gradArgs), gradArgs,
- gradCode.c_str(), &gradFuncName);
+ fragBuilder->emitFunction(kHalf_GrSLType, gradFuncName.c_str(), SK_ARRAY_COUNT(gradArgs),
+ gradArgs, gradCode.c_str());
// lerp function
- const GrShaderVar lerpArgs[] = {
+ const GrShaderVar lerpArgs[] = {
{"a", kHalf_GrSLType},
{"b", kHalf_GrSLType},
{"w", kHalf_GrSLType}
};
- SkString lerpFuncName;
- fragBuilder->emitFunction(kHalf_GrSLType, "lerp", SK_ARRAY_COUNT(lerpArgs), lerpArgs,
- "return a + w * (b - a);", &lerpFuncName);
+ SkString lerpFuncName = fragBuilder->getMangledFunctionName("lerp");
+ fragBuilder->emitFunction(kHalf_GrSLType, lerpFuncName.c_str(), SK_ARRAY_COUNT(lerpArgs),
+ lerpArgs, "return a + w * (b - a);");
// noise function
const GrShaderVar noiseArgs[] = {
{"p", kHalf3_GrSLType},
};
- SkString noiseFuncName;
+ SkString noiseFuncName = fragBuilder->getMangledFunctionName("noise");
SkString noiseCode;
noiseCode.append("half3 P = mod(floor(p), 256.0);");
noiseCode.append("p -= floor(p);");
@@ -1285,14 +1284,14 @@
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(kHalf_GrSLType, "noise", SK_ARRAY_COUNT(noiseArgs), noiseArgs,
- noiseCode.c_str(), &noiseFuncName);
+ fragBuilder->emitFunction(kHalf_GrSLType, noiseFuncName.c_str(), SK_ARRAY_COUNT(noiseArgs),
+ noiseArgs, noiseCode.c_str());
// noiseOctaves function
- const GrShaderVar noiseOctavesArgs[] = {
+ const GrShaderVar noiseOctavesArgs[] = {
{"p", kHalf3_GrSLType}
};
- SkString noiseOctavesFuncName;
+ SkString noiseOctavesFuncName = fragBuilder->getMangledFunctionName("noiseOctaves");
SkString noiseOctavesCode;
noiseOctavesCode.append("half result = 0.0;");
noiseOctavesCode.append("half ratio = 1.0;");
@@ -1302,8 +1301,9 @@
noiseOctavesCode.append("ratio *= 2.0;");
noiseOctavesCode.append("}");
noiseOctavesCode.append("return (result + 1.0) / 2.0;");
- fragBuilder->emitFunction(kHalf_GrSLType, "noiseOctaves", SK_ARRAY_COUNT(noiseOctavesArgs),
- noiseOctavesArgs, noiseOctavesCode.c_str(), &noiseOctavesFuncName);
+ fragBuilder->emitFunction(kHalf_GrSLType, noiseOctavesFuncName.c_str(),
+ SK_ARRAY_COUNT(noiseOctavesArgs), noiseOctavesArgs,
+ noiseOctavesCode.c_str());
fragBuilder->codeAppendf("half2 coords = half2(%s * %s);", args.fSampleCoord, baseFrequencyUni);
fragBuilder->codeAppendf("half r = %s(half3(coords, %s));", noiseOctavesFuncName.c_str(),
diff --git a/src/sksl/SkSLCPPCodeGenerator.cpp b/src/sksl/SkSLCPPCodeGenerator.cpp
index a387ac8..f5b2122 100644
--- a/src/sksl/SkSLCPPCodeGenerator.cpp
+++ b/src/sksl/SkSLCPPCodeGenerator.cpp
@@ -615,7 +615,8 @@
this->write(fFunctionHeader);
this->write(buffer.str());
} else {
- this->addExtraEmitCodeLine("SkString " + decl.name() + "_name;");
+ this->addExtraEmitCodeLine("SkString " + decl.name() + "_name = "
+ "fragBuilder->getMangledFunctionName(\"" + decl.name() + "\");");
String args = "const GrShaderVar " + decl.name() + "_args[] = { ";
const char* separator = "";
for (const Variable* param : decl.parameters()) {
@@ -643,11 +644,10 @@
String emit = "fragBuilder->emitFunction(";
emit += glsltype_string(fContext, decl.returnType());
- emit += ", \"" + decl.name() + "\"";
+ emit += ", " + decl.name() + "_name.c_str()";
emit += ", " + to_string((int64_t) decl.parameters().size());
emit += ", " + decl.name() + "_args";
- emit += "," + funcImpl;
- emit += ", &" + decl.name() + "_name);";
+ emit += "," + funcImpl + ");";
this->addExtraEmitCodeLine(emit.c_str());
}
}