void piglit_require_GLSL_version(int version) { bool es; int major, minor; piglit_require_GLSL(); piglit_get_glsl_version(&es, &major, &minor); if (es || 100 * major + minor < version) { printf("GLSL %d.%d not supported.\n", version / 100, version % 100); piglit_report_result(PIGLIT_SKIP); exit(1); } }
GLuint dsa_create_program(GLenum target) { char *fs_source; char *vs_source; GLuint prog; bool es; int major; int minor; const char * ver; GLint loc; GLfloat xform[9]; piglit_get_glsl_version(&es, &major, &minor); ver = ((major * 100 + minor) >= 140) ? "140" : "110"; (void)!asprintf(&vs_source, vs_template, ver); switch (target) { case GL_TEXTURE_1D: (void)!asprintf(&fs_source, fs_1d_template, ver); break; case GL_TEXTURE_2D: (void)!asprintf(&fs_source, fs_2d_template, ver); break; case GL_TEXTURE_3D: (void)!asprintf(&fs_source, fs_3d_template, ver); break; case GL_TEXTURE_RECTANGLE_ARB: (void)!asprintf(&fs_source, fs_rect_template, ver); break; default: fprintf(stderr, "Invalid texture target in %s\n", __func__); piglit_report_result(PIGLIT_FAIL); } prog = piglit_build_simple_program(vs_source, fs_source); free(vs_source); free(fs_source); /* Note: the default value for all uniforms after linking is zero, so * there is no need to explicitly set it here. However, the xform * matrix needs to be set to the identity matrix. */ loc = glGetUniformLocation(prog, "xform"); xform[0] = 1.0; xform[1] = 0.0; xform[2] = 0.0; xform[3] = 0.0; xform[4] = 1.0; xform[5] = 0.0; xform[6] = 0.0; xform[7] = 0.0; xform[8] = 1.0; glProgramUniformMatrix3fv(prog, loc, 1, GL_FALSE, xform); return prog; }
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; bool es; int glsl_major; int glsl_minor; char *source; piglit_require_extension("GL_ARB_separate_shader_objects"); piglit_get_glsl_version(&es, &glsl_major, &glsl_minor); glsl_version = ((glsl_major * 100) + glsl_minor) >= 140 ? 140 : ((glsl_major * 100) + glsl_minor); glGenProgramPipelines(1, &pipe); pass = piglit_check_gl_error(GL_NO_ERROR) && pass; glBindProgramPipeline(pipe); 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 piglit_init(int argc, char **argv) { unsigned glsl_version; GLuint vs_prog; GLuint fs_prog_same_declaration_order; GLuint fs_prog_same_location_order; bool es; int glsl_major; int glsl_minor; char *source; piglit_require_vertex_shader(); piglit_require_fragment_shader(); piglit_require_extension("GL_ARB_separate_shader_objects"); piglit_require_extension("GL_ARB_explicit_attrib_location"); /* Some NVIDIA drivers have issues with layout qualifiers, 'in' * keywords, and 'out' keywords in "lower" GLSL versions. If the * driver supports GLSL >= 1.40, use 1.40. Otherwise, pick the * highest version that the driver supports. */ piglit_get_glsl_version(&es, &glsl_major, &glsl_minor); glsl_version = ((glsl_major * 100) + glsl_minor) >= 140 ? 140 : ((glsl_major * 100) + glsl_minor); asprintf(&source, vs_code_template, glsl_version); vs_prog = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, (const GLchar *const *) &source); piglit_link_check_status(vs_prog); free(source); asprintf(&source, fs_code_same_declaration_order_template, glsl_version); fs_prog_same_declaration_order = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, (const GLchar *const *) &source); piglit_link_check_status(fs_prog_same_declaration_order); free(source); asprintf(&source, fs_code_same_location_order_template, glsl_version); fs_prog_same_location_order = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, (const GLchar *const *) &source); piglit_link_check_status(fs_prog_same_location_order); free(source); glGenProgramPipelines(1, &pipeline_same_declaration_order); glUseProgramStages(pipeline_same_declaration_order, GL_VERTEX_SHADER_BIT, vs_prog); glUseProgramStages(pipeline_same_declaration_order, GL_FRAGMENT_SHADER_BIT, fs_prog_same_declaration_order); piglit_program_pipeline_check_status(pipeline_same_declaration_order); glGenProgramPipelines(1, &pipeline_same_location_order); glUseProgramStages(pipeline_same_location_order, GL_VERTEX_SHADER_BIT, vs_prog); glUseProgramStages(pipeline_same_location_order, GL_FRAGMENT_SHADER_BIT, fs_prog_same_location_order); piglit_program_pipeline_check_status(pipeline_same_location_order); if (!piglit_check_gl_error(0)) piglit_report_result(PIGLIT_FAIL); }
void piglit_init(int argc, char **argv) { bool pass = true; int gl_version; int glsl_major; int glsl_minor; int glsl_version; const char *version_for_float_shader = NULL; const char *version_for_double_shader = NULL; const char *version_for_int_shader = NULL; GLint context_flags = 0; piglit_require_vertex_shader(); piglit_require_extension("GL_ARB_separate_shader_objects"); gl_version = piglit_get_gl_version(); if (gl_version >= 30) glGetIntegerv(GL_CONTEXT_FLAGS, &context_flags); piglit_get_glsl_version(NULL, &glsl_major, &glsl_minor); glsl_version = (glsl_major * 100) + glsl_minor; /* Select a shading language version string based on the GL version * and whether or not we're running in a core profile. */ switch (gl_version / 10) { case 1: case 2: /* Selecting 1.20 will enable the non-square matrix tests. */ version_for_float_shader = (glsl_version >= 120) ? "#version 120\n" : "#version 110\n"; if (glsl_version >= 130) version_for_int_shader = "#version 130\n"; break; case 3: /* OpenGL 3.0 deprecated GLSL 1.10 and 1.20. OpenGL 3.1 * removed almost all deprecated features. * Forworad-compatible contexts remove all deprecated * features. */ if (gl_version == 30) { version_for_float_shader = (context_flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT) ? "#version 130\n" : "#version 120\n"; version_for_int_shader = "#version 130\n"; } else { /* Section 1.6.1 (OpenGL Shading Language) of the * OpenGL 3.1 spec says: * * "OpenGL 3.1 implementations are guaranteed to * support at least version 1.30 of the shading * language." * * This is likely a copy-and-paste error from version * 3.0. This should be 1.40. * * Section 1.6.1 (OpenGL Shading Language) of the * OpenGL 3.2 spec says: * * "OpenGL 3.2 implementations are guaranteed to * support versions 1.40 and 1.50 of the OpenGL * Shading Language." * * Section 1.7.1 (OpenGL Shading Language) of the * OpenGL 3.3 spec says: * * "OpenGL 3.3 implementations are guaranteed to * support version 3.30 of the OpenGL Shading * Language." * * Based on all of this, pick version 1.40 for OpenGL * versions before 3.3, and version 3.30 for version * 3.3. */ if (gl_version < 33) { version_for_float_shader = "#version 140\n"; version_for_int_shader = "#version 140\n"; } else { version_for_float_shader = "#version 330 core\n"; version_for_int_shader = "#version 330 core\n"; } if (piglit_is_extension_supported("GL_ARB_gpu_shader_fp64")) { /* The GL_ARB_gpu_shader_fp64 extensions spec * says: * * "OpenGL 3.2 and GLSL 1.50 are required." */ version_for_double_shader = "#version 150 core\n" "#extension GL_ARB_gpu_shader_fp64: require\n" ; } } break; case 4: /* Section 1.7.1 (OpenGL Shading Language) of the * OpenGL 4.0 spec says: * * "OpenGL 4.0 implementations are guaranteed to support * version 4.00 of the OpenGL Shading Language." * * Section 1.7.1 (OpenGL Shading Language) of the * OpenGL 4.1 spec says: * * "OpenGL 4.1 implementations are guaranteed to support * version 4.10 of the OpenGL Shading Language." * * Section 1.7.1 (OpenGL Shading Language) of the * OpenGL 4.2 spec says: * * "OpenGL 4.2 implementations are guaranteed to support * version 4.20 of the OpenGL Shading Language....The core * profile of OpenGL 4.2 is also guaranteed to support all * previous versions of the OpenGL Shading Language back * to version 1.40." * * Section 1.3.1 (OpenGL Shading Language) of the * OpenGL 4.3 spec says: * * "OpenGL 4.3 implementations are guaranteed to support * version 4.30 of the OpenGL Shading Language....The core * profile of OpenGL 4.3 is also guaranteed to support all * previous versions of the OpenGL Shading Language back * to version 1.40." * * Section 1.3.1 (OpenGL Shading Language) of the * OpenGL 4.4 spec says: * * "OpenGL 4.4 implementations are guaranteed to support * version 4.40 of the OpenGL Shading Language....The core * profile of OpenGL 4.4 is also guaranteed to support all * previous versions of the OpenGL Shading Language back * to version 1.40." * * Even though 4.1 doesn't say anything about GLSL 4.00, the * inference is that the addition starting in 4.2 was a * clarification. */ version_for_float_shader = "#version 400 core\n"; version_for_double_shader = "#version 400 core\n"; version_for_int_shader = "#version 400 core\n"; break; default: fprintf(stderr, "Unknown GL version!\n"); piglit_report_result(PIGLIT_FAIL); } pass = test_float(version_for_float_shader) && pass; pass = test_square_mat(version_for_float_shader) && pass; pass = test_nonsquare_mat(version_for_float_shader) && pass; pass = test_int(version_for_int_shader) && pass; pass = test_uint(version_for_int_shader) && pass; pass = test_double(version_for_double_shader) && pass; pass = test_dmat(version_for_double_shader) && pass; piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }