Add experimental geometry shader code to gpu backend
Review URL: http://codereview.appspot.com/5129047/
git-svn-id: http://skia.googlecode.com/svn/trunk@2365 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gpu/include/GrGLDefines.h b/gpu/include/GrGLDefines.h
index 73c2a71..dcacb77 100644
--- a/gpu/include/GrGLDefines.h
+++ b/gpu/include/GrGLDefines.h
@@ -299,6 +299,7 @@
/* Shaders */
#define GR_GL_FRAGMENT_SHADER 0x8B30
#define GR_GL_VERTEX_SHADER 0x8B31
+#define GR_GL_GEOMETRY_SHADER 0x8DD9
#define GR_GL_MAX_VERTEX_ATTRIBS 0x8869
#define GR_GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB
#define GR_GL_MAX_VARYING_VECTORS 0x8DFC
diff --git a/gpu/include/GrGLInterface.h b/gpu/include/GrGLInterface.h
index 2687956..8271dcb 100644
--- a/gpu/include/GrGLInterface.h
+++ b/gpu/include/GrGLInterface.h
@@ -25,16 +25,22 @@
*/
typedef uint32_t GrGLVersion;
+typedef uint32_t GrGLSLVersion;
-#define GR_GL_VER(major, minor) (((int)(major) << 16) | ((int)(minor)))
+#define GR_GL_VER(major, minor) ((static_cast<int>(major) << 16) | \
+ static_cast<int>(minor))
+#define GR_GLSL_VER(major, minor) ((static_cast<int>(major) << 16) | \
+ static_cast<int>(minor))
// these variants assume caller already has a string from glGetString()
GrGLVersion GrGLGetVersionFromString(const char* versionString);
+GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString);
bool GrGLHasExtensionFromString(const char* ext, const char* extensionString);
// these variants call glGetString()
bool GrGLGetString(const GrGLInterface*, const char* ext);
GrGLVersion GrGLGetVersion(const GrGLInterface*);
+GrGLSLVersion GrGLGetGLSLVersion(const GrGLInterface*);
////////////////////////////////////////////////////////////////////////////////
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index 51e6fdd..79b3da8 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -1076,6 +1076,7 @@
GrPrintf("HW AA Lines Support : %s\n", gNY[fHWAALineSupport]);
GrPrintf("Shader Support : %s\n", gNY[fShaderSupport]);
GrPrintf("Shader Derivative Support : %s\n", gNY[fShaderDerivativeSupport]);
+ GrPrintf("Geometry Shader Support : %s\n", gNY[fGeometryShaderSupport]);
GrPrintf("FSAA Support : %s\n", gNY[fFSAASupport]);
GrPrintf("Dual Source Blending Support: %s\n", gNY[fDualSourceBlendingSupport]);
GrPrintf("Buffer Lock Support : %s\n", gNY[fBufferLockSupport]);
diff --git a/gpu/src/GrDrawTarget.h b/gpu/src/GrDrawTarget.h
index 81d0b2b..a1667e4 100644
--- a/gpu/src/GrDrawTarget.h
+++ b/gpu/src/GrDrawTarget.h
@@ -49,6 +49,7 @@
bool fHWAALineSupport : 1;
bool fShaderSupport : 1;
bool fShaderDerivativeSupport : 1;
+ bool fGeometryShaderSupport : 1;
bool fFSAASupport : 1;
bool fDualSourceBlendingSupport : 1;
bool fBufferLockSupport : 1;
diff --git a/gpu/src/GrGLInterface.cpp b/gpu/src/GrGLInterface.cpp
index 0b433d1..70dd019 100644
--- a/gpu/src/GrGLInterface.cpp
+++ b/gpu/src/GrGLInterface.cpp
@@ -20,7 +20,11 @@
#endif
GrGLVersion GrGLGetVersionFromString(const char* versionString) {
- GrAssert(versionString);
+ if (NULL == versionString) {
+ GrAssert(!"NULL GL version string.");
+ return 0;
+ }
+
int major, minor;
int n = sscanf(versionString, "%d.%d", &major, &minor);
@@ -43,6 +47,26 @@
return 0;
}
+GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString) {
+ if (NULL == versionString) {
+ GrAssert(!"NULL GLSL version string.");
+ return 0;
+ }
+
+ int major, minor;
+
+ int n = sscanf(versionString, "%d.%d", &major, &minor);
+ if (2 == n) {
+ return GR_GLSL_VER(major, minor);
+ }
+
+ n = sscanf(versionString, "OpenGL ES GLSL ES %d.%d", &major, &minor);
+ if (2 == n) {
+ return GR_GLSL_VER(major, minor);
+ }
+ return 0;
+}
+
bool GrGLHasExtensionFromString(const char* ext, const char* extensionString) {
int extLength = strlen(ext);
@@ -72,6 +96,12 @@
return GrGLGetVersionFromString((const char*) v);
}
+GrGLSLVersion GrGLGetGLSLVersion(const GrGLInterface* gl) {
+ const GrGLubyte* v;
+ GR_GL_CALL_RET(gl, v, GetString(GR_GL_SHADING_LANGUAGE_VERSION));
+ return GrGLGetGLSLVersionFromString((const char*) v);
+}
+
GrGLInterface::GrGLInterface() {
fBindingsExported = (GrGLBinding)0;
fNPOTRenderTargetSupport = kProbe_GrGLCapability;
diff --git a/gpu/src/GrGLProgram.cpp b/gpu/src/GrGLProgram.cpp
index 015be61..cbe2f42 100644
--- a/gpu/src/GrGLProgram.cpp
+++ b/gpu/src/GrGLProgram.cpp
@@ -47,18 +47,29 @@
ShaderCodeSegments()
: fVSUnis(gVarsPerBlock)
, fVSAttrs(gVarsPerBlock)
- , fVaryings(gVarsPerBlock)
+ , fVSOutputs(gVarsPerBlock)
+ , fGSInputs(gVarsPerBlock)
+ , fGSOutputs(gVarsPerBlock)
+ , fFSInputs(gVarsPerBlock)
, fFSUnis(gVarsPerBlock)
- , fFSOutputs(gMaxFSOutputs) {}
+ , fFSOutputs(gMaxFSOutputs)
+ , fUsesGS(false) {}
GrStringBuilder fHeader; // VS+FS, GLSL version, etc
VarArray fVSUnis;
VarArray fVSAttrs;
- VarArray fVaryings;
+ VarArray fVSOutputs;
+ VarArray fGSInputs;
+ VarArray fGSOutputs;
+ VarArray fFSInputs;
+ GrStringBuilder fGSHeader; // layout qualifiers specific to GS
VarArray fFSUnis;
VarArray fFSOutputs;
GrStringBuilder fFSFunctions;
GrStringBuilder fVSCode;
+ GrStringBuilder fGSCode;
GrStringBuilder fFSCode;
+
+ bool fUsesGS;
};
@@ -148,21 +159,11 @@
s->appendS32(stage);
}
-inline void stage_varying_name(int stage, GrStringBuilder* s) {
- *s = "vStage";
- s->appendS32(stage);
-}
-
inline void radial2_param_name(int stage, GrStringBuilder* s) {
*s = "uRadial2Params";
s->appendS32(stage);
}
-inline void radial2_varying_name(int stage, GrStringBuilder* s) {
- *s = "vB";
- s->appendS32(stage);
-}
-
inline void convolve_param_names(int stage, GrStringBuilder* k, GrStringBuilder* i) {
*k = "uKernel";
k->appendS32(stage);
@@ -372,12 +373,65 @@
case GrGLProgram::k130_GLSLVersion:
GrAssert(!gl->supportsES());
return "#version 130\n";
+ case GrGLProgram::k150_GLSLVersion:
+ GrAssert(!gl->supportsES());
+ return "#version 150\n";
default:
GrCrash("Unknown GL version.");
return ""; // suppress warning
}
}
+// Adds a var that is computed in the VS and read in FS.
+// If there is a GS it will just pass it through.
+void append_varying(GrGLShaderVar::Type type,
+ const char* name,
+ ShaderCodeSegments* segments,
+ const char** vsOutName = NULL,
+ const char** fsInName = NULL) {
+ segments->fVSOutputs.push_back();
+ segments->fVSOutputs.back().setType(type);
+ segments->fVSOutputs.back().accessName()->printf("v%s", name);
+ if (vsOutName) {
+ *vsOutName = segments->fVSOutputs.back().getName().c_str();
+ }
+ // input to FS comes either from VS or GS
+ const GrStringBuilder* fsName;
+ if (segments->fUsesGS) {
+ // if we have a GS take each varying in as an array
+ // and output as non-array.
+ segments->fGSInputs.push_back();
+ segments->fGSInputs.back().setType(type);
+ segments->fGSInputs.back().setUnsizedArray();
+ *segments->fGSInputs.back().accessName() =
+ segments->fVSOutputs.back().getName();
+ segments->fGSOutputs.push_back();
+ segments->fGSOutputs.back().setType(type);
+ segments->fGSOutputs.back().accessName()->printf("g%s", name);
+ fsName = segments->fGSOutputs.back().accessName();
+ } else {
+ fsName = segments->fVSOutputs.back().accessName();
+ }
+ segments->fFSInputs.push_back();
+ segments->fFSInputs.back().setType(type);
+ segments->fFSInputs.back().setName(*fsName);
+ if (fsInName) {
+ *fsInName = fsName->c_str();
+ }
+}
+
+// version of above that adds a stage number to the
+// the var name (for uniqueness)
+void append_varying(GrGLShaderVar::Type type,
+ const char* name,
+ int stageNum,
+ ShaderCodeSegments* segments,
+ const char** vsOutName = NULL,
+ const char** fsInName = NULL) {
+ GrStringBuilder nameWithStage(name);
+ nameWithStage.appendS32(stageNum);
+ append_varying(type, nameWithStage.c_str(), segments, vsOutName, fsInName);
+}
}
void GrGLProgram::genEdgeCoverage(const GrGLInterface* gl,
@@ -435,20 +489,21 @@
}
*coverageVar = "edgeAlpha";
} else if (layout & GrDrawTarget::kEdge_VertexLayoutBit) {
- segments->fVaryings.push_back().set(GrGLShaderVar::kVec4f_Type, "vEdge");
+ const char *vsName, *fsName;
+ append_varying(GrGLShaderVar::kVec4f_Type, "Edge", segments, &vsName, &fsName);
segments->fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type, EDGE_ATTR_NAME);
- segments->fVSCode.append("\tvEdge = " EDGE_ATTR_NAME ";\n");
+ segments->fVSCode.appendf("\t%s = " EDGE_ATTR_NAME ";\n", vsName);
if (GrDrawTarget::kHairLine_EdgeType == fProgramDesc.fVertexEdgeType) {
- segments->fFSCode.append("\tfloat edgeAlpha = abs(dot(vec3(gl_FragCoord.xy,1), vEdge.xyz));\n");
+ segments->fFSCode.appendf("\tfloat edgeAlpha = abs(dot(vec3(gl_FragCoord.xy,1), %s.xyz));\n", fsName);
} else {
GrAssert(GrDrawTarget::kHairQuad_EdgeType == fProgramDesc.fVertexEdgeType);
// for now we know we're not in perspective, so we could compute this
// per-quadratic rather than per pixel
- segments->fFSCode.append("\tvec2 duvdx = dFdx(vEdge.xy);\n");
- segments->fFSCode.append("\tvec2 duvdy = dFdy(vEdge.xy);\n");
- segments->fFSCode.append("\tfloat dfdx = 2.0*vEdge.x*duvdx.x - duvdx.y;\n");
- segments->fFSCode.append("\tfloat dfdy = 2.0*vEdge.x*duvdy.x - duvdy.y;\n");
- segments->fFSCode.append("\tfloat edgeAlpha = (vEdge.x*vEdge.x - vEdge.y);\n");
+ segments->fFSCode.appendf("\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
+ segments->fFSCode.appendf("\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
+ segments->fFSCode.appendf("\tfloat dfdx = 2.0*%s.x*duvdx.x - duvdx.y;\n", fsName);
+ segments->fFSCode.appendf("\tfloat dfdy = 2.0*%s.x*duvdy.x - duvdy.y;\n", fsName);
+ segments->fFSCode.appendf("\tfloat edgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, fsName);
segments->fFSCode.append("\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / (dfdx*dfdx + dfdy*dfdy));\n");
if (gl->supportsES()) {
segments->fHeader.printf("#extension GL_OES_standard_derivatives: enable\n");
@@ -472,7 +527,8 @@
*name = "gl_FragColor";
return false;
break;
- case GrGLProgram::k130_GLSLVersion:
+ case GrGLProgram::k130_GLSLVersion: // fallthru
+ case GrGLProgram::k150_GLSLVersion:
*name = declared_color_output_name();
fsOutputs->push_back().set(GrGLShaderVar::kVec4f_Type,
declared_color_output_name());
@@ -486,6 +542,35 @@
}
+void GrGLProgram::genGeometryShader(const GrGLInterface* gl,
+ GLSLVersion glslVersion,
+ ShaderCodeSegments* segments) const {
+#if GR_GL_EXPERIMENTAL_GS
+ if (fProgramDesc.fExperimentalGS) {
+ GrAssert(glslVersion >= k150_GLSLVersion);
+ segments->fGSHeader.append("layout(triangles) in;\n"
+ "layout(triangle_strip, max_vertices = 6) out;\n");
+ segments->fGSCode.append("void main() {\n"
+ "\tfor (int i = 0; i < 3; ++i) {\n"
+ "\t\tgl_Position = gl_in[i].gl_Position;\n");
+ if (this->fProgramDesc.fEmitsPointSize) {
+ segments->fGSCode.append("\t\tgl_PointSize = 1.0;\n");
+ }
+ GrAssert(segments->fGSInputs.count() == segments->fGSOutputs.count());
+ int count = segments->fGSInputs.count();
+ for (int i = 0; i < count; ++i) {
+ segments->fGSCode.appendf("\t\t%s = %s[i];\n",
+ segments->fGSOutputs[i].getName().c_str(),
+ segments->fGSInputs[i].getName().c_str());
+ }
+ segments->fGSCode.append("\t\tEmitVertex();\n"
+ "\t}\n"
+ "\tEndPrimitive();\n"
+ "}\n");
+ }
+#endif
+}
+
bool GrGLProgram::genProgram(const GrGLInterface* gl,
GLSLVersion glslVersion,
GrGLProgram::CachedData* programData) const {
@@ -495,6 +580,10 @@
programData->fUniLocations.reset();
+#if GR_GL_EXPERIMENTAL_GS
+ segments.fUsesGS = fProgramDesc.fExperimentalGS;
+#endif
+
SkXfermode::Coeff colorCoeff, uniformCoeff;
// The rest of transfer mode color filters have not been implemented
if (fProgramDesc.fColorFilterXfermode < SkXfermode::kCoeffModesCnt) {
@@ -541,14 +630,14 @@
if (needComputedColor) {
switch (fProgramDesc.fColorType) {
- case ProgramDesc::kAttribute_ColorType:
+ case ProgramDesc::kAttribute_ColorType: {
segments.fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type,
COL_ATTR_NAME);
- segments.fVaryings.push_back().set(GrGLShaderVar::kVec4f_Type,
- "vColor");
- segments.fVSCode.append("\tvColor = " COL_ATTR_NAME ";\n");
- inColor = "vColor";
- break;
+ const char *vsName, *fsName;
+ append_varying(GrGLShaderVar::kVec4f_Type, "Color", &segments, &vsName, &fsName);
+ segments.fVSCode.appendf("\t%s = " COL_ATTR_NAME ";\n", vsName);
+ inColor = fsName;
+ } break;
case ProgramDesc::kUniform_ColorType:
segments.fFSUnis.push_back().set(GrGLShaderVar::kVec4f_Type,
COL_UNI_NAME);
@@ -561,7 +650,8 @@
}
}
- if (fProgramDesc.fEmitsPointSize){
+ // we output point size in the GS if present
+ if (fProgramDesc.fEmitsPointSize && !segments.fUsesGS){
segments.fVSCode.append("\tgl_PointSize = 1.0;\n");
}
@@ -738,9 +828,15 @@
segments.fFSCode.append("}\n");
///////////////////////////////////////////////////////////////////////////
+ // insert GS
+#if GR_DEBUG
+ this->genGeometryShader(gl, glslVersion, &segments);
+#endif
+
+ ///////////////////////////////////////////////////////////////////////////
// compile and setup attribs and unis
- if (!CompileFSAndVS(gl, glslVersion, segments, programData)) {
+ if (!CompileShaders(gl, glslVersion, segments, programData)) {
return false;
}
@@ -758,22 +854,22 @@
namespace {
-void expand_decls(const VarArray& unis,
- const GrGLInterface* gl,
- const char* prefix,
- GrStringBuilder* string) {
- const int count = unis.count();
+inline void expand_decls(const VarArray& vars,
+ const GrGLInterface* gl,
+ const char* prefix,
+ GrStringBuilder* string) {
+ const int count = vars.count();
for (int i = 0; i < count; ++i) {
string->append(prefix);
string->append(" ");
- unis[i].appendDecl(gl, string);
+ vars[i].appendDecl(gl, string);
string->append(";\n");
}
}
-void print_shader(int stringCnt,
- const char** strings,
- int* stringLengths) {
+inline void print_shader(int stringCnt,
+ const char** strings,
+ int* stringLengths) {
for (int i = 0; i < stringCnt; ++i) {
if (NULL == stringLengths || stringLengths[i] < 0) {
GrPrintf(strings[i]);
@@ -782,126 +878,124 @@
}
}
}
+
+typedef SkTArray<const char*, true> StrArray;
+#define PREALLOC_STR_ARRAY(N) SkSTArray<(N), const char*, true>
+
+typedef SkTArray<int, true> LengthArray;
+#define PREALLOC_LENGTH_ARRAY(N) SkSTArray<(N), int, true>
+
+// these shouldn't relocate
+typedef GrTAllocator<GrStringBuilder> TempArray;
+#define PREALLOC_TEMP_ARRAY(N) GrSTAllocator<(N), GrStringBuilder>
+
+inline void append_string(const GrStringBuilder& str,
+ StrArray* strings,
+ LengthArray* lengths) {
+ int length = (int) str.size();
+ if (length) {
+ strings->push_back(str.c_str());
+ lengths->push_back(length);
+ }
+ GrAssert(strings->count() == lengths->count());
}
-bool GrGLProgram::CompileFSAndVS(const GrGLInterface* gl,
+inline void append_decls(const VarArray& vars,
+ const GrGLInterface* gl,
+ const char* prefix,
+ StrArray* strings,
+ LengthArray* lengths,
+ TempArray* temp) {
+ expand_decls(vars, gl, prefix, &temp->push_back());
+ append_string(temp->back(), strings, lengths);
+}
+
+}
+
+bool GrGLProgram::CompileShaders(const GrGLInterface* gl,
GLSLVersion glslVersion,
const ShaderCodeSegments& segments,
CachedData* programData) {
+ enum { kPreAllocStringCnt = 8 };
- static const int MAX_STRINGS = 6;
- const char* strings[MAX_STRINGS];
- int lengths[MAX_STRINGS];
- int stringCnt = 0;
- GrStringBuilder attrs;
- GrStringBuilder varyings;
+ PREALLOC_STR_ARRAY(kPreAllocStringCnt) strs;
+ PREALLOC_LENGTH_ARRAY(kPreAllocStringCnt) lengths;
+ PREALLOC_TEMP_ARRAY(kPreAllocStringCnt) temps;
+
GrStringBuilder unis;
- GrStringBuilder fsOutputs;
+ GrStringBuilder inputs;
+ GrStringBuilder outputs;
static const char* gVaryingPrefixes[2][2] = {{"varying", "varying"},
{"out", "in"}};
- const char** varyingPrefixes = glslVersion == k120_GLSLVersion ?
+ const char** varyingPrefixes = k120_GLSLVersion == glslVersion ?
gVaryingPrefixes[0] :
gVaryingPrefixes[1];
- const char* attributePrefix = glslVersion == k120_GLSLVersion ?
+ const char* attributePrefix = k120_GLSLVersion == glslVersion ?
"attribute" :
"in";
- if (segments.fHeader.size()) {
- strings[stringCnt] = segments.fHeader.c_str();
- lengths[stringCnt] = segments.fHeader.size();
- ++stringCnt;
- }
- expand_decls(segments.fVSUnis, gl, "uniform", &unis);
- if (unis.size()) {
- strings[stringCnt] = unis.c_str();
- lengths[stringCnt] = unis.size();
- ++stringCnt;
- }
- expand_decls(segments.fVSAttrs, gl, attributePrefix, &attrs);
- if (attrs.size()) {
- strings[stringCnt] = attrs.c_str();
- lengths[stringCnt] = attrs.size();
- ++stringCnt;
- }
- expand_decls(segments.fVaryings, gl, varyingPrefixes[0], &varyings);
- if (varyings.size()) {
- strings[stringCnt] = varyings.c_str();
- lengths[stringCnt] = varyings.size();
- ++stringCnt;
- }
-
- GrAssert(segments.fVSCode.size());
- strings[stringCnt] = segments.fVSCode.c_str();
- lengths[stringCnt] = segments.fVSCode.size();
- ++stringCnt;
+ append_string(segments.fHeader, &strs, &lengths);
+ append_decls(segments.fVSUnis, gl, "uniform", &strs, &lengths, &temps);
+ append_decls(segments.fVSAttrs, gl, attributePrefix, &strs, &lengths, &temps);
+ append_decls(segments.fVSOutputs, gl, varyingPrefixes[0], &strs, &lengths, &temps);
+ append_string(segments.fVSCode, &strs, &lengths);
#if PRINT_SHADERS
- print_shader(stringCnt, strings, lengths);
+ print_shader(strs.count(), &strs[0], &lengths[0]);
GrPrintf("\n");
#endif
- GrAssert(stringCnt <= MAX_STRINGS);
- programData->fVShaderID = CompileShader(gl, GR_GL_VERTEX_SHADER,
- stringCnt, strings, lengths);
+ programData->fVShaderID =
+ CompileShader(gl, GR_GL_VERTEX_SHADER, strs.count(),
+ &strs[0], &lengths[0]);
if (!programData->fVShaderID) {
return false;
}
-
- stringCnt = 0;
-
- if (segments.fHeader.size()) {
- strings[stringCnt] = segments.fHeader.c_str();
- lengths[stringCnt] = segments.fHeader.size();
- ++stringCnt;
- }
- if (strlen(GrShaderPrecision(gl)) > 1) {
- strings[stringCnt] = GrShaderPrecision(gl);
- lengths[stringCnt] = strlen(GrShaderPrecision(gl));
- ++stringCnt;
- }
- unis.reset();
- expand_decls(segments.fFSUnis, gl, "uniform", &unis);
- if (unis.size()) {
- strings[stringCnt] = unis.c_str();
- lengths[stringCnt] = unis.size();
- ++stringCnt;
- }
- varyings.reset();
- expand_decls(segments.fVaryings, gl, varyingPrefixes[1], &varyings);
- if (varyings.size()) {
- strings[stringCnt] = varyings.c_str();
- lengths[stringCnt] = varyings.size();
- ++stringCnt;
- }
- expand_decls(segments.fFSOutputs, gl, "out", &fsOutputs);
- if (fsOutputs.size()) {
- // We shouldn't have declared outputs on 1.2
- GrAssert(k120_GLSLVersion != glslVersion);
- strings[stringCnt] = fsOutputs.c_str();
- lengths[stringCnt] = fsOutputs.size();
- ++stringCnt;
- }
- if (segments.fFSFunctions.size()) {
- strings[stringCnt] = segments.fFSFunctions.c_str();
- lengths[stringCnt] = segments.fFSFunctions.size();
- ++stringCnt;
+ if (segments.fUsesGS) {
+ strs.reset();
+ lengths.reset();
+ temps.reset();
+ append_string(segments.fHeader, &strs, &lengths);
+ append_string(segments.fGSHeader, &strs, &lengths);
+ append_decls(segments.fGSInputs, gl, "in", &strs, &lengths, &temps);
+ append_decls(segments.fGSOutputs, gl, "out", &strs, &lengths, &temps);
+ append_string(segments.fGSCode, &strs, &lengths);
+#if PRINT_SHADERS
+ print_shader(strs.count(), &strs[0], &lengths[0]);
+ GrPrintf("\n");
+#endif
+ programData->fGShaderID =
+ CompileShader(gl, GR_GL_GEOMETRY_SHADER, strs.count(),
+ &strs[0], &lengths[0]);
+ } else {
+ programData->fGShaderID = 0;
}
- GrAssert(segments.fFSCode.size());
- strings[stringCnt] = segments.fFSCode.c_str();
- lengths[stringCnt] = segments.fFSCode.size();
- ++stringCnt;
+ strs.reset();
+ lengths.reset();
+ temps.reset();
+
+ append_string(segments.fHeader, &strs, &lengths);
+ GrStringBuilder precisionStr(GrShaderPrecision(gl));
+ append_string(precisionStr, &strs, &lengths);
+ append_decls(segments.fFSUnis, gl, "uniform", &strs, &lengths, &temps);
+ append_decls(segments.fFSInputs, gl, varyingPrefixes[1], &strs, &lengths, &temps);
+ // We shouldn't have declared outputs on 1.2
+ GrAssert(k120_GLSLVersion != glslVersion || segments.fFSOutputs.empty());
+ append_decls(segments.fFSOutputs, gl, "out", &strs, &lengths, &temps);
+ append_string(segments.fFSFunctions, &strs, &lengths);
+ append_string(segments.fFSCode, &strs, &lengths);
#if PRINT_SHADERS
- print_shader(stringCnt, strings, lengths);
+ print_shader(strs.count(), &strs[0], &lengths[0]);
GrPrintf("\n");
#endif
- GrAssert(stringCnt <= MAX_STRINGS);
- programData->fFShaderID = CompileShader(gl, GR_GL_FRAGMENT_SHADER,
- stringCnt, strings, lengths);
+ programData->fFShaderID =
+ CompileShader(gl, GR_GL_FRAGMENT_SHADER, strs.count(),
+ &strs[0], &lengths[0]);
if (!programData->fFShaderID) {
return false;
@@ -962,6 +1056,9 @@
const GrGLint& progID = programData->fProgramID;
GR_GL_CALL(gl, AttachShader(progID, programData->fVShaderID));
+ if (programData->fGShaderID) {
+ GR_GL_CALL(gl, AttachShader(progID, programData->fGShaderID));
+ }
GR_GL_CALL(gl, AttachShader(progID, programData->fFShaderID));
if (bindColorOut) {
@@ -1194,24 +1291,27 @@
texelSizeName = segments->fFSUnis.back().getName().c_str();
}
- const char* varyingName;
- GrGLShaderVar* varying = &segments->fVaryings.push_back();
- stage_varying_name(stageNum, varying->accessName());
- varying->setType(float_vector_type(varyingDims));
- varyingName = varying->getName().c_str();
+ const char *varyingVSName, *varyingFSName;
+ append_varying(float_vector_type(varyingDims),
+ "Stage",
+ stageNum,
+ segments,
+ &varyingVSName,
+ &varyingFSName);
if (!matName) {
GrAssert(varyingDims == coordDims);
- segments->fVSCode.appendf("\t%s = %s;\n", varyingName, vsInCoord);
+ segments->fVSCode.appendf("\t%s = %s;\n", varyingVSName, vsInCoord);
} else {
// varying = texMatrix * texCoord
segments->fVSCode.appendf("\t%s = (%s * vec3(%s, 1))%s;\n",
- varyingName, matName, vsInCoord,
+ varyingVSName, matName, vsInCoord,
vector_all_coords(varyingDims));
}
const char* radial2ParamsName = NULL;
- const char* radial2VaryingName = NULL;
+ const char *radial2VaryingVSName = NULL;
+ const char *radial2VaryingFSName = NULL;
if (StageDesc::kRadial2Gradient_CoordMapping == desc.fCoordMapping ||
StageDesc::kRadial2GradientDegenerate_CoordMapping == desc.fCoordMapping) {
@@ -1229,18 +1329,18 @@
// part of the quadratic as a varying.
if (varyingDims == coordDims) {
GrAssert(2 == coordDims);
-
- GrGLShaderVar* radial2Varying = &segments->fVaryings.push_back();
- radial2Varying->setType(GrGLShaderVar::kFloat_Type);
- radial2_varying_name(stageNum, radial2Varying->accessName());
- radial2VaryingName = radial2Varying->getName().c_str();
+ append_varying(GrGLShaderVar::kFloat_Type,
+ "Radial2BCoeff",
+ stageNum,
+ segments,
+ &radial2VaryingVSName,
+ &radial2VaryingFSName);
// r2Var = 2 * (r2Parm[2] * varCoord.x - r2Param[3])
const char* r2ParamName = radial2FSParams->getName().c_str();
- const char* r2VarName = radial2Varying->getName().c_str();
segments->fVSCode.appendf("\t%s = 2.0 *(%s[2] * %s.x - %s[3]);\n",
- r2VarName, r2ParamName, varyingName,
- r2ParamName);
+ radial2VaryingVSName, r2ParamName,
+ varyingVSName, r2ParamName);
}
}
@@ -1267,7 +1367,7 @@
locations->fImageIncrementUni = kUseUniform;
float scale = (desc.fKernelWidth - 1) * 0.5f;
segments->fVSCode.appendf("\t%s -= vec2(%g, %g) * %s;\n",
- varyingName, scale, scale,
+ varyingVSName, scale, scale,
imageIncrementName);
}
@@ -1278,7 +1378,7 @@
if (desc.fOptFlags & (StageDesc::kIdentityMatrix_OptFlagBit |
StageDesc::kNoPerspective_OptFlagBit)) {
GrAssert(varyingDims == coordDims);
- fsCoordName = varyingName;
+ fsCoordName = varyingFSName;
} else {
// if we have to do some special op on the varyings to get
// our final tex coords then when in perspective we have to
@@ -1286,16 +1386,16 @@
if (StageDesc::kIdentity_CoordMapping == desc.fCoordMapping &&
StageDesc::kSingle_FetchMode == desc.fFetchMode) {
texFunc.append("Proj");
- fsCoordName = varyingName;
+ fsCoordName = varyingFSName;
} else {
fsCoordName = "inCoord";
fsCoordName.appendS32(stageNum);
segments->fFSCode.appendf("\t%s %s = %s%s / %s%s;\n",
GrGLShaderVar::TypeString(float_vector_type(coordDims)),
fsCoordName.c_str(),
- varyingName,
+ varyingFSName,
vector_nonhomog_coords(varyingDims),
- varyingName,
+ varyingFSName,
vector_homog_coord(varyingDims));
}
}
@@ -1327,7 +1427,7 @@
// otherwise compute it
GrStringBuilder bVar;
if (coordDims == varyingDims) {
- bVar = radial2VaryingName;
+ bVar = radial2VaryingFSName;
GrAssert(2 == varyingDims);
} else {
GrAssert(3 == varyingDims);
@@ -1370,7 +1470,7 @@
// otherwise compute it
GrStringBuilder bVar;
if (coordDims == varyingDims) {
- bVar = radial2VaryingName;
+ bVar = radial2VaryingFSName;
GrAssert(2 == varyingDims);
} else {
GrAssert(3 == varyingDims);
diff --git a/gpu/src/GrGLProgram.h b/gpu/src/GrGLProgram.h
index 6b07f30..c186ba1 100644
--- a/gpu/src/GrGLProgram.h
+++ b/gpu/src/GrGLProgram.h
@@ -20,6 +20,10 @@
struct ShaderCodeSegments;
+// optionally compile the experimental GS code. Set to GR_DEBUG
+// so that debug build bots will execute the code.
+#define GR_GL_EXPERIMENTAL_GS GR_DEBUG
+
/**
* This class manages a GPU program and records per-program information.
* We can specify the attribute locations so that they are constant
@@ -32,8 +36,9 @@
class GrGLProgram {
public:
enum GLSLVersion {
- k120_GLSLVersion, // Desktop GLSL 1.2 and ES2 shading lang
- k130_GLSLVersion // Desktop GLSL 1.3
+ k120_GLSLVersion, // Desktop GLSL 1.20 and ES2 shading lang
+ k130_GLSLVersion, // Desktop GLSL 1.30
+ k150_GLSLVersion // Dekstop GLSL 1.50
};
class CachedData;
@@ -155,6 +160,12 @@
StageDesc fStages[GrDrawTarget::kNumStages];
+ // To enable experimental geometry shader code (not for use in
+ // production)
+#if GR_GL_EXPERIMENTAL_GS
+ bool fExperimentalGS;
+#endif
+
uint8_t fColorType; // casts to enum ColorType
uint8_t fDualSrcOutput; // casts to enum DualSrcOutput
int8_t fFirstCoverageStage;
@@ -167,6 +178,7 @@
uint8_t fPadTo32bLengthMultiple [1];
} fProgramDesc;
+ GR_STATIC_ASSERT(!(sizeof(ProgramDesc) % 4));
const ProgramDesc& getDesc() { return fProgramDesc; }
@@ -231,6 +243,7 @@
// IDs
GrGLuint fVShaderID;
+ GrGLuint fGShaderID;
GrGLuint fFShaderID;
GrGLuint fProgramID;
// shader uniform locations (-1 if shader doesn't use them)
@@ -283,6 +296,10 @@
ShaderCodeSegments* segments,
StageUniLocations* locations) const;
+ void genGeometryShader(const GrGLInterface* gl,
+ GLSLVersion glslVersion,
+ ShaderCodeSegments* segments) const;
+
// generates code to compute coverage based on edge AA.
void genEdgeCoverage(const GrGLInterface* gl,
GrVertexLayout layout,
@@ -290,7 +307,7 @@
GrStringBuilder* coverageVar,
ShaderCodeSegments* segments) const;
- static bool CompileFSAndVS(const GrGLInterface* gl,
+ static bool CompileShaders(const GrGLInterface* gl,
GLSLVersion glslVersion,
const ShaderCodeSegments& segments,
CachedData* programData);
diff --git a/gpu/src/GrGpuGLShaders.cpp b/gpu/src/GrGpuGLShaders.cpp
index 05f6652..4f39965 100644
--- a/gpu/src/GrGpuGLShaders.cpp
+++ b/gpu/src/GrGpuGLShaders.cpp
@@ -130,6 +130,9 @@
void GrGpuGLShaders::DeleteProgram(const GrGLInterface* gl,
CachedData* programData) {
GR_GL_CALL(gl, DeleteShader(programData->fVShaderID));
+ if (programData->fGShaderID) {
+ GR_GL_CALL(gl, DeleteShader(programData->fGShaderID));
+ }
GR_GL_CALL(gl, DeleteShader(programData->fFShaderID));
GR_GL_CALL(gl, DeleteProgram(programData->fProgramID));
GR_DEBUGCODE(memset(programData, 0, sizeof(*programData));)
@@ -141,14 +144,22 @@
namespace {
-GrGLProgram::GLSLVersion get_glsl_version(GrGLBinding binding, GrGLVersion glVersion) {
+GrGLProgram::GLSLVersion get_glsl_version(GrGLBinding binding,
+ const GrGLInterface* gl) {
+ GrGLSLVersion ver = GrGLGetGLSLVersion(gl);
switch (binding) {
case kDesktop_GrGLBinding:
- // TODO: proper check of the glsl version string
- return (glVersion >= GR_GL_VER(3,0)) ?
- GrGLProgram::k130_GLSLVersion :
- GrGLProgram::k120_GLSLVersion;
+ GrAssert(ver >= GR_GLSL_VER(1,20));
+ if (ver >= GR_GLSL_VER(1,50)) {
+ return GrGLProgram::k150_GLSLVersion;
+ } else if (ver >= GR_GLSL_VER(1,30)) {
+ return GrGLProgram::k130_GLSLVersion;
+ } else {
+ return GrGLProgram::k120_GLSLVersion;
+ }
case kES2_GrGLBinding:
+ // version 1.00 of ES GLSL based on ver 1.20 of desktop GLSL
+ GrAssert(ver >= GR_GL_VER(1,00));
return GrGLProgram::k120_GLSLVersion;
default:
GrCrash("Attempting to get GLSL version in unknown or fixed-"
@@ -167,7 +178,7 @@
bool GrGpuGLShaders::programUnitTest() {
GrGLProgram::GLSLVersion glslVersion =
- get_glsl_version(this->glBinding(), this->glVersion());
+ get_glsl_version(this->glBinding(), this->glInterface());
static const int STAGE_OPTS[] = {
0,
StageDesc::kNoPerspective_OptFlagBit,
@@ -208,6 +219,10 @@
idx = (int)(random.nextF() * (kNumStages+1));
pdesc.fFirstCoverageStage = idx;
+#if GR_GL_EXPERIMENTAL_GS
+ pdesc.fExperimentalGS = random.nextF() > .5f;
+#endif
+
bool edgeAA = random.nextF() > .5f;
if (edgeAA) {
bool vertexEdgeAA = random.nextF() > .5f;
@@ -290,21 +305,26 @@
GrGpuGLShaders::GrGpuGLShaders(const GrGLInterface* gl)
: GrGpuGL(gl, get_binding_in_use(gl)) {
+ GrGLProgram::GLSLVersion glslVersion =
+ get_glsl_version(this->glBinding(), gl);
+
+ // Enable supported shader-releated caps
fCaps.fShaderSupport = true;
if (kDesktop_GrGLBinding == this->glBinding()) {
fCaps.fDualSourceBlendingSupport =
this->glVersion() >= GR_GL_VER(3,3) ||
this->hasExtension("GL_ARB_blend_func_extended");
fCaps.fShaderDerivativeSupport = true;
+ // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS
+ fCaps.fGeometryShaderSupport =
+ this->glVersion() >= GR_GL_VER(3,2) &&
+ glslVersion >= GrGLProgram::k150_GLSLVersion;
} else {
- fCaps.fDualSourceBlendingSupport = false;
fCaps.fShaderDerivativeSupport =
this->hasExtension("GL_OES_standard_derivatives");
}
fProgramData = NULL;
- GrGLProgram::GLSLVersion glslVersion =
- get_glsl_version(this->glBinding(), this->glVersion());
fProgramCache = new ProgramCache(gl, glslVersion);
#if 0
@@ -923,6 +943,14 @@
}
desc.fDualSrcOutput = ProgramDesc::kNone_DualSrcOutput;
+
+ // currently the experimental GS will only work with triangle prims
+ // (and it doesn't do anything other than pass through values from
+ // the VS to the FS anyway).
+#if 0 && GR_GL_EXPERIMENTAL_GS
+ desc.fExperimentalGS = this->getCaps().fGeometryShaderSupport;
+#endif
+
// use canonical value when coverage/color distinction won't affect
// generated code to prevent duplicate programs.
desc.fFirstCoverageStage = kNumStages;