bool Pipeline :: setActiveProgram ( Program * program ) { if ( id == 0 || program == NULL || !program -> isOk () ) return false; glActiveShaderProgram ( id, program -> getProgram () ); return true; }
GLUSboolean update(GLUSfloat time) { glClear(GL_COLOR_BUFFER_BIT); // Setting up functions for the red triangle. glActiveShaderProgram(g_programPipeline.pipeline, g_vertexProgram.program); glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &g_getOffsetRedSubIndex); glActiveShaderProgram(g_programPipeline.pipeline, g_fragmentProgram.program); glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &g_getColorRedSubIndex); glDrawArrays(GL_TRIANGLES, 0, 3); // // Setting up functions for the green triangle. glActiveShaderProgram(g_programPipeline.pipeline, g_vertexProgram.program); glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &g_getOffsetGreenSubIndex); glActiveShaderProgram(g_programPipeline.pipeline, g_fragmentProgram.program); glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &g_getColorGreenSubIndex); glDrawArrays(GL_TRIANGLES, 0, 3); // // Setting up functions for the blue triangle. glActiveShaderProgram(g_programPipeline.pipeline, g_vertexProgram.program); glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &g_getOffsetBlueSubIndex); glActiveShaderProgram(g_programPipeline.pipeline, g_fragmentProgram.program); glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &g_getColorBlueSubIndex); glDrawArrays(GL_TRIANGLES, 0, 3); return GLUS_TRUE; }
void piglit_init(int argc, char **argv) { bool pass = true; GLuint pipe; GLuint vs_prog; GLuint active_prog; GLuint unlinked_prog; GLuint shader; unsigned glsl_version; char *source; piglit_require_extension("GL_ARB_separate_shader_objects"); glsl_version = pick_a_glsl_version(); glGenProgramPipelines(1, &pipe); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; glBindProgramPipeline(pipe); (void)!asprintf(&source, vs_code_template, glsl_version); vs_prog = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, (const GLchar *const *) &source); piglit_link_check_status(vs_prog); /* First, make a valid program active. */ glActiveShaderProgram(pipe, vs_prog); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* Next, try to make an invalid program active and verify that the * correct error is generated. Also make sure the old program is * still active. * * Section 7.4 (Program Pipeline Objects) under ActiveShaderProgram of * the OpenGL 4.4 spec says: * * "An INVALID_VALUE error is generated if program is not zero and * is not the name of either a program or shader object." */ glActiveShaderProgram(pipe, ~vs_prog); pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass; glGetProgramPipelineiv(pipe, GL_ACTIVE_PROGRAM, (GLint *) &active_prog); if (active_prog != vs_prog) { printf("glActiveShaderProgram with an invalid program name " "changed the active program state.\n"); pass = false; } else { glActiveShaderProgram(pipe, vs_prog); } /* Try the same thing with a valid shader object (that is not part of * a linked program). Verify that the correct error is generated, and * make sure the old program is still active. * * Section 7.4 (Program Pipeline Objects) under ActiveShaderProgram of * the OpenGL 4.4 spec says: * * "An INVALID_OPERATION error is generated if program is the name * of a shader object." */ shader = piglit_compile_shader_text(GL_VERTEX_SHADER, source); glActiveShaderProgram(pipe, shader); pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass; glGetProgramPipelineiv(pipe, GL_ACTIVE_PROGRAM, (GLint *) &active_prog); if (active_prog != vs_prog) { printf("glActiveShaderProgram with a shader object " "changed the active program state.\n"); pass = false; } else { glActiveShaderProgram(pipe, vs_prog); } /* Finally, try the same thing with a valid program that is not * linked. Verify that the correct error is generated, and make sure * the old program is still active. * * Section 7.4 (Program Pipeline Objects) under ActiveShaderProgram of * the OpenGL 4.4 spec says: * * "An INVALID_OPERATION error is generated if program is not zero * and has not been linked, or was last linked unsuccessfully." */ unlinked_prog = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, (const GLchar *const *) &invalid_code); glActiveShaderProgram(pipe, unlinked_prog); pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass; glGetProgramPipelineiv(pipe, GL_ACTIVE_PROGRAM, (GLint *) &active_prog); if (active_prog != vs_prog) { printf("glActiveShaderProgram with an unlinked program " "changed the active program state.\n"); pass = false; } else { glActiveShaderProgram(pipe, vs_prog); } free(source); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void dd::ShaderProgram::Unbind() { glActiveShaderProgram(0, 0); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL41_nglActiveShaderProgram(JNIEnv *env, jclass clazz, jint pipeline, jint program, jlong function_pointer) { glActiveShaderProgramPROC glActiveShaderProgram = (glActiveShaderProgramPROC)((intptr_t)function_pointer); glActiveShaderProgram(pipeline, program); }
bool testDrawArrays::initProgram() { bool Validated(true); std::size_t ShaderIndex(0); switch(this->UniformUpdate) { case CONSTANT_UNIFORM: case PER_DRAW_UNIFORM_DSA: case REDUNDANT_UNIFORM_DSA: case PER_DRAW_UNIFORM_B2E: case REDUNDANT_UNIFORM_B2E: ShaderIndex = 1; break; case PER_DRAW_UNIFORM2_DSA: case REDUNDANT_UNIFORM2_DSA: case PER_DRAW_UNIFORM2_B2E: case REDUNDANT_UNIFORM2_B2E: ShaderIndex = 2; break; case NO_UNIFORM: default: ShaderIndex = 0; break; } glGenProgramPipelines(1, &this->PipelineName); compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE[ShaderIndex], "--version 420 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE[ShaderIndex], "--version 420 --profile core"); Validated = Validated && Compiler.check(); this->ProgramName = glCreateProgram(); glProgramParameteri(this->ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE); glAttachShader(this->ProgramName, VertShaderName); glAttachShader(this->ProgramName, FragShaderName); glLinkProgram(this->ProgramName); Validated = Validated && Compiler.checkProgram(this->ProgramName); UniformDiffuse0 = glGetUniformLocation(ProgramName, "Diffuse0"); UniformDiffuse1 = glGetUniformLocation(ProgramName, "Diffuse1"); if(Validated) glUseProgramStages(this->PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName); if( this->UniformUpdate == testDrawArrays::CONSTANT_UNIFORM || this->UniformUpdate == testDrawArrays::PER_DRAW_UNIFORM_B2E || this->UniformUpdate == testDrawArrays::REDUNDANT_UNIFORM_B2E || this->UniformUpdate == testDrawArrays::PER_DRAW_UNIFORM2_B2E || this->UniformUpdate == testDrawArrays::REDUNDANT_UNIFORM2_B2E) glActiveShaderProgram(this->PipelineName, this->ProgramName); if(this->UniformUpdate == testDrawArrays::CONSTANT_UNIFORM) { glProgramUniform4f(this->ProgramName, UniformDiffuse0, 1.0f, 0.5f, 0.0f, 1.0f); if(UniformDiffuse1 != -1) glProgramUniform4f(this->ProgramName, UniformDiffuse1, 0.0f, 0.5f, 1.0f, 1.0f); } return Validated; }
void piglit_init(int argc, char **argv) { GLuint prog; GLint s2_loc; GLint s3_loc; GLuint pipe; GLuint vao; GLuint bo; bool pass = true; piglit_require_extension("GL_ARB_separate_shader_objects"); prog = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, (const GLchar *const *) &fs_code); piglit_link_check_status(prog); s2_loc = glGetUniformLocation(prog, "s2"); if (s2_loc == -1) { fprintf(stderr, "Failed to get uniform location for s2.\n"); pass = false; } s3_loc = glGetUniformLocation(prog, "s3"); if (s3_loc == -1) { fprintf(stderr, "Failed to get uniform location for s3.\n"); pass = false; } glGenProgramPipelines(1, &pipe); glUseProgramStages(pipe, GL_FRAGMENT_SHADER_BIT, prog); glActiveShaderProgram(pipe, prog); glBindProgramPipeline(pipe); glGenVertexArrays(1, &vao); glBindVertexArray(vao); /* Configure a vertex array object and buffer object that will * be used for drawing later. */ glGenBuffers(1, &bo); glBindBuffer(GL_ARRAY_BUFFER, bo); glBufferData(GL_ARRAY_BUFFER, sizeof(vert), vert, GL_STATIC_DRAW); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* First, try an invalid configuration. */ glUniform1i(s2_loc, 1); glUniform1i(s3_loc, 1); if (piglit_program_pipeline_check_status_quiet(pipe)) { fprintf(stderr, "Pipeline was validated with conflicting " "sampler configuration.\n"); pass = false; } /* Now try a valid configuration. */ glUniform1i(s2_loc, 1); glUniform1i(s3_loc, 2); if (!piglit_program_pipeline_check_status_quiet(pipe)) { fprintf(stderr, "Pipeline was not validated with non-conflicting " "sampler configuration.\n"); pass = false; } /* Switch back to the invalid configuration. Without first calling * glValidateProgramPipeline, try to draw something. Verify that * GL_INVALID_OPERATION is generated. */ glUniform1i(s2_loc, 1); glUniform1i(s3_loc, 1); glDrawArrays(GL_POINTS, 0, 1); pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass; /* Re-validate the program. */ if (piglit_program_pipeline_check_status_quiet(pipe)) { fprintf(stderr, "Pipeline was validated with conflicting " "sampler configuration (second attempt).\n"); pass = false; } pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass; /* Switch back to the valid configuration. Without first calling * glValidateProgramPipeline, try to draw something. Verify that * no error is generated. */ glUniform1i(s2_loc, 1); glUniform1i(s3_loc, 2); glDrawArrays(GL_POINTS, 0, 1); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; /* Clean up. */ glBindProgramPipeline(0); glDeleteProgram(prog); glDeleteProgramPipelines(1, &pipe); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); glDeleteBuffers(1, &bo); glDeleteVertexArrays(1, &vao); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
void piglit_init(int argc, char **argv) { GLint vs, fs, gs, tcs, tes; GLint ver; GLuint pipe = 0; GLint param = 0; char *version = NULL; const char *shader_source[2]; static const char vs_source[] = "#if __VERSION__ > 140\n" "/* At least some versions of AMD's closed-source driver\n" " * contain a bug that requires redeclaration of gl_PerVertex\n" " * interface block in core profile shaders.\n" " */\n" "out gl_PerVertex {\n" " vec4 gl_Position;\n" "};\n" "\n" "in vec4 position;\n" "#else\n" "varying vec4 position;\n" "#endif\n" "\n" "void main()\n" "{\n" " gl_Position = position;\n" "}\n"; static const char fs_source[] = "void main()\n" "{\n" " gl_FragColor = vec4(0.0, 1.0, 0.0, 0.0);\n" "}\n"; static const char gs_source[] = "/* At least some versions of AMD's closed-source driver\n" " * contain a bug that requires redeclaration of gl_PerVertex\n" " * interface block in core profile shaders.\n" " */\n" "in gl_PerVertex {\n" " vec4 gl_Position;\n" " float gl_PointSize;\n" " float gl_ClipDistance[];\n" "} gl_in[];\n" "\n" "out gl_PerVertex {\n" " vec4 gl_Position;\n" " float gl_PointSize;\n" " float gl_ClipDistance[];\n" "};\n" "\n" "layout(triangles) in;\n" "layout(triangle_strip, max_vertices = 3) out;\n" "void main() {\n" " for(int i = 0; i < gl_in.length(); i++) {\n" " gl_Position = gl_in[i].gl_Position;\n" " EmitVertex();\n" " }\n" " EndPrimitive();\n" "}\n"; static const char tc_source[] = "/* At least some versions of AMD's closed-source driver\n" " * contain a bug that requires redeclaration of gl_PerVertex\n" " * interface block in core profile shaders.\n" " */\n" "in gl_PerVertex {\n" " vec4 gl_Position;\n" " float gl_PointSize;\n" " float gl_ClipDistance[];\n" "} gl_in[];\n" "\n" "out gl_PerVertex {\n" " vec4 gl_Position;\n" " float gl_PointSize;\n" " float gl_ClipDistance[];\n" "} gl_out[];\n" "\n" "layout(vertices = 3) out;\n" "void main()\n" "{\n" " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" " gl_TessLevelOuter[0] = 1.0;\n" " gl_TessLevelOuter[1] = 1.0;\n" " gl_TessLevelOuter[2] = 1.0;\n" " gl_TessLevelInner[0] = 1.0;\n" " gl_TessLevelInner[1] = 1.0;\n" "}\n"; static const char te_source[] = "/* At least some versions of AMD's closed-source driver\n" " * contain a bug that requires redeclaration of gl_PerVertex\n" " * interface block in core profile shaders.\n" " */\n" "in gl_PerVertex {\n" " vec4 gl_Position;\n" " float gl_PointSize;\n" " float gl_ClipDistance[];\n" "} gl_in[];\n" "\n" "out gl_PerVertex {\n" " vec4 gl_Position;\n" " float gl_PointSize;\n" " float gl_ClipDistance[];\n" "};\n" "\n" "layout(triangles, equal_spacing) in;\n" "\n" "void main()\n" "{\n" " vec4 p0 = gl_in[0].gl_Position;\n" " vec4 p1 = gl_in[1].gl_Position;\n" " vec4 p2 = gl_in[2].gl_Position;\n" "\n" " vec3 p = gl_TessCoord.xyz;\n" "\n" " gl_Position = p0*p.x + p1*p.y + p2*p.z;\n" "}\n"; const bool has_gs = piglit_get_gl_version() >= 32; const bool has_tess = piglit_get_gl_version() >= 40 || piglit_is_extension_supported("GL_ARB_tessellation_shader"); piglit_require_extension("GL_ARB_separate_shader_objects"); pass = true; if (piglit_get_gl_version() >= 43) { ver = 430; } else if (piglit_get_gl_version() >= 32) { ver = 150; } else { ver = 110; } asprintf(&version, "#version %d\n" "#extension GL_ARB_separate_shader_objects: enable\n\n", ver); shader_source[0] = version; if (has_tess) { shader_source[1] = tc_source; tcs = glCreateShaderProgramv(GL_TESS_CONTROL_SHADER, 2, shader_source); pass = piglit_link_check_status(tcs) && pass; shader_source[1] = te_source; tes = glCreateShaderProgramv(GL_TESS_EVALUATION_SHADER, 2, shader_source); pass = piglit_link_check_status(tes) && pass; } else { tcs = 0; tes = 0; } if (has_gs) { shader_source[1] = gs_source; gs = glCreateShaderProgramv(GL_GEOMETRY_SHADER, 2, shader_source); pass = piglit_link_check_status(gs) && pass; } else { gs = 0; } shader_source[1] = fs_source; fs = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 2, shader_source); pass = piglit_link_check_status(fs) && pass; shader_source[1] = vs_source; vs = glCreateShaderProgramv(GL_VERTEX_SHADER, 2, shader_source); pass = piglit_link_check_status(vs) && pass; glGenProgramPipelines(1, &pipe); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; glActiveShaderProgram(pipe, fs); glGetProgramPipelineiv(pipe, GL_ACTIVE_PROGRAM, ¶m); if (param != fs) { fprintf(stderr, "Failed to get Active Program.\n"); pass = false; } pass = piglit_check_gl_error(GL_NO_ERROR) && pass; use_stage_and_check(pipe, vs, GL_VERTEX_SHADER, true); use_stage_and_check(pipe, fs, GL_FRAGMENT_SHADER, true); use_stage_and_check(pipe, gs, GL_GEOMETRY_SHADER, has_gs); use_stage_and_check(pipe, tes, GL_TESS_EVALUATION_SHADER, has_tess); use_stage_and_check(pipe, tcs, GL_TESS_CONTROL_SHADER, has_tess); glActiveShaderProgram(pipe, vs); glGetProgramPipelineiv(pipe, GL_ACTIVE_PROGRAM, ¶m); if (param != vs) { fprintf(stderr, "Failed to get Active Program.\n"); pass = false; } pass = piglit_check_gl_error(GL_NO_ERROR) && pass; glUseProgramStages(pipe, GL_ALL_SHADER_BITS, 0); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; check_stage(pipe, 0, GL_VERTEX_SHADER, true); check_stage(pipe, 0, GL_FRAGMENT_SHADER, true); check_stage(pipe, 0, GL_GEOMETRY_SHADER, has_gs); check_stage(pipe, 0, GL_TESS_EVALUATION_SHADER, has_tess); check_stage(pipe, 0, GL_TESS_CONTROL_SHADER, has_tess); free(version); piglit_present_results(); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }