GrGLuint GLCpuPosInstancedArraysBench::setupShader(const GrGLContext* ctx) {
const GrGLSLCaps* glslCaps = ctx->caps()->glslCaps();
const char* version = glslCaps->versionDeclString();
// setup vertex shader
GrGLSLShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLSLShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLSLShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(glslCaps, &vshaderTxt);
vshaderTxt.append(";\n");
aColor.appendDecl(glslCaps, &vshaderTxt);
vshaderTxt.append(";\n");
oColor.appendDecl(glslCaps, &vshaderTxt);
vshaderTxt.append(";\n");
vshaderTxt.append(
"void main()\n"
"{\n"
"gl_Position = vec4(a_position, 0.f, 1.f);\n"
"o_color = a_color;\n"
"}\n");
const GrGLInterface* gl = ctx->interface();
// setup fragment shader
GrGLSLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
GrGLSLAppendDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, *glslCaps, &fshaderTxt);
oColor.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
oColor.appendDecl(glslCaps, &fshaderTxt);
fshaderTxt.append(";\n");
const char* fsOutName;
if (glslCaps->mustDeclareFragmentShaderOutput()) {
oFragColor.appendDecl(glslCaps, &fshaderTxt);
fshaderTxt.append(";\n");
fsOutName = oFragColor.c_str();
} else {
fsOutName = "gl_FragColor";
}
fshaderTxt.appendf(
"void main()\n"
"{\n"
"%s = vec4(o_color, 1.0f);\n"
"}\n", fsOutName);
return CreateProgram(gl, vshaderTxt.c_str(), fshaderTxt.c_str());
}
static GrGLuint compile_shader(const GrGLContext* ctx) {
const char* version = GrGLGetGLSLVersionDecl(*ctx);
// setup vertex shader
GrGLShaderVar aPosition("a_position", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLShaderVar aColor("a_color", kVec3f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
GrGLShaderVar oColor("o_color", kVec3f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
SkString vshaderTxt(version);
aPosition.appendDecl(*ctx, &vshaderTxt);
vshaderTxt.append(";\n");
aColor.appendDecl(*ctx, &vshaderTxt);
vshaderTxt.append(";\n");
oColor.appendDecl(*ctx, &vshaderTxt);
vshaderTxt.append(";\n");
vshaderTxt.append(
"void main()\n"
"{\n"
"gl_Position = vec4(a_position, 0.f, 1.f);\n"
"o_color = a_color;\n"
"}\n");
const GrGLInterface* gl = ctx->interface();
GrGLuint vertexShader = load_shader(gl, vshaderTxt.c_str(), GR_GL_VERTEX_SHADER);
// setup fragment shader
GrGLShaderVar oFragColor("o_FragColor", kVec4f_GrSLType, GrShaderVar::kOut_TypeModifier);
SkString fshaderTxt(version);
GrGLAppendGLSLDefaultFloatPrecisionDeclaration(kDefault_GrSLPrecision, gl->fStandard,
&fshaderTxt);
oColor.setTypeModifier(GrShaderVar::kVaryingIn_TypeModifier);
oColor.appendDecl(*ctx, &fshaderTxt);
fshaderTxt.append(";\n");
const char* fsOutName;
if (ctx->caps()->glslCaps()->mustDeclareFragmentShaderOutput()) {
oFragColor.appendDecl(*ctx, &fshaderTxt);
fshaderTxt.append(";\n");
fsOutName = oFragColor.c_str();
} else {
fsOutName = "gl_FragColor";
}
fshaderTxt.appendf(
"void main()\n"
"{\n"
"%s = vec4(o_color, 1.0f);\n"
"}\n", fsOutName);
GrGLuint fragmentShader = load_shader(gl, fshaderTxt.c_str(), GR_GL_FRAGMENT_SHADER);
GrGLint shaderProgram;
GR_GL_CALL_RET(gl, shaderProgram, CreateProgram());
GR_GL_CALL(gl, AttachShader(shaderProgram, vertexShader));
GR_GL_CALL(gl, AttachShader(shaderProgram, fragmentShader));
GR_GL_CALL(gl, LinkProgram(shaderProgram));
// Check for linking errors
GrGLint success;
GrGLchar infoLog[512];
GR_GL_CALL(gl, GetProgramiv(shaderProgram, GR_GL_LINK_STATUS, &success));
if (!success) {
GR_GL_CALL(gl, GetProgramInfoLog(shaderProgram, 512, NULL, infoLog));
SkDebugf("Linker Error: %s\n", infoLog);
}
GR_GL_CALL(gl, DeleteShader(vertexShader));
GR_GL_CALL(gl, DeleteShader(fragmentShader));
return shaderProgram;
}
GrGLuint GLVec4ScalarBench::setupShader(const GrGLContext* ctx) {
const GrShaderCaps* shaderCaps = ctx->caps()->shaderCaps();
const char* version = shaderCaps->versionDeclString();
// this shader draws fNumStages overlapping circles of increasing opacity (coverage) and
// decreasing size, with the center of each subsequent circle closer to the bottom-right
// 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);
SkString vshaderTxt(version);
aPosition.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
aColor.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
oPosition.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
oColor.appendDecl(shaderCaps, &vshaderTxt);
vshaderTxt.append(";\n");
vshaderTxt.append(
"void main()\n"
"{\n"
" gl_Position = vec4(a_position, 0.0, 1.0);\n"
" o_position = a_position;\n"
" o_color = a_color;\n"
"}\n");
// set up fragment shader; this fragment shader will have fNumStages coverage stages plus an
// XP stage at the end. Each coverage stage computes the pixel's distance from some hard-
// 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);
SkString fshaderTxt(version);
GrGLSLAppendDefaultFloatPrecisionDeclaration(kMedium_GrSLPrecision, *shaderCaps, &fshaderTxt);
oPosition.setTypeModifier(GrShaderVar::kIn_TypeModifier);
oPosition.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
oColor.setTypeModifier(GrShaderVar::kIn_TypeModifier);
oColor.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
const char* fsOutName;
if (shaderCaps->mustDeclareFragmentShaderOutput()) {
oFragColor.appendDecl(shaderCaps, &fshaderTxt);
fshaderTxt.append(";\n");
fsOutName = oFragColor.c_str();
} else {
fsOutName = "sk_FragColor";
}
fshaderTxt.appendf(
"void main()\n"
"{\n"
" vec4 outputColor;\n"
" %s outputCoverage;\n"
" outputColor = vec4(%s, 1.0);\n"
" outputCoverage = %s;\n",
fCoverageSetup == kUseVec4_CoverageSetup ? "vec4" : "float",
oColor.getName().c_str(),
fCoverageSetup == kUseVec4_CoverageSetup ? "vec4(1.0)" : "1.0"
);
float radius = 1.0f;
for (uint32_t i = 0; i < fNumStages; i++) {
float centerX = 1.0f - radius;
float centerY = 1.0f - radius;
fshaderTxt.appendf(
" {\n"
" float d = length(%s - vec2(%f, %f));\n"
" float 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 ? "vec4(edgeAlpha)" : "edgeAlpha"
);
radius *= 0.8f;
}
fshaderTxt.appendf(
" {\n"
" %s = outputColor * outputCoverage;\n"
" }\n"
"}\n",
fsOutName);
return CreateProgram(ctx, vshaderTxt.c_str(), fshaderTxt.c_str());
}
