unsigned int create_program_link(unsigned int sdr0, ...)
{
unsigned int prog, sdr;
va_list ap;
if(!(prog = create_program())) {
return 0;
}
attach_shader(prog, sdr0);
if(glGetError()) {
return 0;
}
va_start(ap, sdr0);
while((sdr = va_arg(ap, unsigned int))) {
attach_shader(prog, sdr);
if(glGetError()) {
return 0;
}
}
va_end(ap);
if(link_program(prog) == -1) {
free_program(prog);
return 0;
}
return prog;
}
bool GrGLFullShaderBuilder::compileAndAttachShaders(GrGLuint programId,
SkTDArray<GrGLuint>* shaderIds) const {
const GrGLContext& glCtx = this->gpu()->glContext();
SkString vertShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));
this->appendUniformDecls(kVertex_Visibility, &vertShaderSrc);
this->appendDecls(fVSAttrs, &vertShaderSrc);
this->appendDecls(fVSOutputs, &vertShaderSrc);
vertShaderSrc.append("void main() {\n");
vertShaderSrc.append(fVSCode);
vertShaderSrc.append("}\n");
GrGLuint vertShaderId = attach_shader(glCtx, programId, GR_GL_VERTEX_SHADER, vertShaderSrc);
if (!vertShaderId) {
return false;
}
*shaderIds->append() = vertShaderId;
#if GR_GL_EXPERIMENTAL_GS
if (this->desc().getHeader().fExperimentalGS) {
SkASSERT(this->ctxInfo().glslGeneration() >= k150_GrGLSLGeneration);
SkString geomShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));
geomShaderSrc.append("layout(triangles) in;\n"
"layout(triangle_strip, max_vertices = 6) out;\n");
this->appendDecls(fGSInputs, &geomShaderSrc);
this->appendDecls(fGSOutputs, &geomShaderSrc);
geomShaderSrc.append("void main() {\n");
geomShaderSrc.append("\tfor (int i = 0; i < 3; ++i) {\n"
"\t\tgl_Position = gl_in[i].gl_Position;\n");
if (this->desc().getHeader().fEmitsPointSize) {
geomShaderSrc.append("\t\tgl_PointSize = 1.0;\n");
}
SkASSERT(fGSInputs.count() == fGSOutputs.count());
for (int i = 0; i < fGSInputs.count(); ++i) {
geomShaderSrc.appendf("\t\t%s = %s[i];\n",
fGSOutputs[i].getName().c_str(),
fGSInputs[i].getName().c_str());
}
geomShaderSrc.append("\t\tEmitVertex();\n"
"\t}\n"
"\tEndPrimitive();\n");
geomShaderSrc.append("}\n");
GrGLuint geomShaderId = attach_shader(glCtx, programId, GR_GL_GEOMETRY_SHADER, geomShaderSrc);
if (!geomShaderId) {
return false;
}
*shaderIds->append() = geomShaderId;
}
#endif
return this->INHERITED::compileAndAttachShaders(programId, shaderIds);
}
bool GrGLShaderBuilder::compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const {
SkString fragShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));
fragShaderSrc.append(fFSExtensions);
append_default_precision_qualifier(kDefaultFragmentPrecision,
fGpu->glStandard(),
&fragShaderSrc);
this->appendUniformDecls(kFragment_Visibility, &fragShaderSrc);
this->appendDecls(fFSInputs, &fragShaderSrc);
// We shouldn't have declared outputs on 1.10
SkASSERT(k110_GrGLSLGeneration != fGpu->glslGeneration() || fFSOutputs.empty());
this->appendDecls(fFSOutputs, &fragShaderSrc);
fragShaderSrc.append(fFSFunctions);
fragShaderSrc.append("void main() {\n");
fragShaderSrc.append(fFSCode);
fragShaderSrc.append("}\n");
GrGLuint fragShaderId = attach_shader(fGpu->glContext(), programId, GR_GL_FRAGMENT_SHADER, fragShaderSrc);
if (!fragShaderId) {
return false;
}
*shaderIds->append() = fragShaderId;
return true;
}
/**
* For GL_EXT_separate_shader_objects
*/
GLuint GLAPIENTRY
_mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
{
GET_CURRENT_CONTEXT(ctx);
const GLuint shader = create_shader(ctx, type);
GLuint program = 0;
if (shader) {
shader_source(ctx, shader, _mesa_strdup(string));
compile_shader(ctx, shader);
program = create_shader_program(ctx);
if (program) {
struct gl_shader_program *shProg;
struct gl_shader *sh;
GLint compiled = GL_FALSE;
shProg = _mesa_lookup_shader_program(ctx, program);
sh = _mesa_lookup_shader(ctx, shader);
get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
if (compiled) {
attach_shader(ctx, program, shader);
link_program(ctx, program);
detach_shader(ctx, program, shader);
#if 0
/* Possibly... */
if (active-user-defined-varyings-in-linked-program) {
append-error-to-info-log;
shProg->LinkStatus = GL_FALSE;
}
#endif
}
ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
}
delete_shader(ctx, shader);
}
return program;
}
void GLAPIENTRY
_mesa_AttachShader(GLuint program, GLuint shader)
{
GET_CURRENT_CONTEXT(ctx);
attach_shader(ctx, program, shader);
}
void GLAPIENTRY
_mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
{
GET_CURRENT_CONTEXT(ctx);
attach_shader(ctx, program, shader);
}
void GLSL_Program::attach_vertex_shader_from_source(std::string source) {
attach_shader(load_shader_from_source(source, GL_VERTEX_SHADER));
}
void GLSL_Program::attach_fragment_shader_from_source(std::string source) {
attach_shader(load_shader_from_source(source, GL_FRAGMENT_SHADER));
}
void GLSL_Program::attach_shader_from_source(std::string source, GLenum type) {
attach_shader(load_shader_from_source(source, type));
}
void GLSL_Program::attach_vertex_shader(const char* file_name) {
attach_shader(load_shader(file_name, GL_VERTEX_SHADER));
}
void GLSL_Program::attach_fragment_shader(const char* file_name) {
attach_shader(load_shader(file_name, GL_FRAGMENT_SHADER));
}
void GLSL_Program::attach_shader(const char* file_name, GLenum type) {
attach_shader(load_shader(file_name, type));
}