void piglit_init(int argc, char **argv)
{
GLint vert[2];
GLint prog;
GLboolean ok;
piglit_require_gl_version(20);
piglit_require_extension("GL_ARB_explicit_attrib_location");
vert[0] =
piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-explicit-location-03a.vert");
vert[1] =
piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-explicit-location-03b.vert");
prog = glCreateProgram();
glAttachShader(prog, vert[0]);
glAttachShader(prog, vert[1]);
glLinkProgram(prog);
ok = piglit_link_check_status_quiet(prog);
if (ok)
fprintf(stderr,
"Linking with conflicting explicit locations "
"succeeded when it should have failed.\n");
piglit_report_result(!ok ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLint vs, fs;
/* Set up projection matrix so we can just draw using window
* coordinates.
*/
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-mvp.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-fs-loop-nested.frag");
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
color_location = glGetUniformLocation(prog, "color");
}
void piglit_init(int argc, char **argv)
{
GLint vert[3];
GLint prog_a;
GLint prog_b;
GLint prog_c;
GLint prog_d;
piglit_require_gl_version(20);
vert[0] =
piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-link-initializer-01a.vert");
vert[1] =
piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-link-initializer-01b.vert");
vert[2] =
piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-link-initializer-01c.vert");
prog_a = piglit_link_simple_program(vert[0], vert[1]);
prog_b = piglit_link_simple_program(vert[1], vert[0]);
prog_c = piglit_link_simple_program(vert[0], vert[2]);
prog_d = piglit_link_simple_program(vert[2], vert[0]);
/* piglit_link_simple_program() returns 0 on link failure. So
* verify that there was no link failure by simply checking
* that two programs were returned.
*/
piglit_report_result((prog_a && prog_b && prog_c && prog_d)
? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLboolean pass = GL_TRUE;
GLint vs, fs, num;
GLint expect;
if (argc < 3) {
printf("Usage: %s <vertex shader file> "
"<expected uniform count>\n", argv[0]);
piglit_report_result(PIGLIT_FAIL);
}
expect = (int) strtol(argv[2], NULL, 0);
piglit_require_GLSL();
vs = piglit_compile_shader(GL_VERTEX_SHADER, argv[1]);
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-color.frag");
prog = piglit_link_simple_program(vs, fs);
glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &num);
if (num != expect) {
printf("Unexpected active uniform count "
"(saw %d, expected %d)\n", num, expect);
pass = GL_FALSE;
}
if (pass)
piglit_report_result(PIGLIT_PASS);
else
piglit_report_result(PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLuint vs, fs;
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-color-mvp.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-color.frag");
prog = piglit_link_simple_program(vs, fs);
glDeleteShader(vs);
glDeleteShader(fs);
/* Don't try to render if the program failed to link, and linking
* had better succeed!
*/
if (!piglit_link_check_status(prog))
piglit_report_result(PIGLIT_FAIL);
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
GLint vs, fs;
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-mvp.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-fs-mix.frag");
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
args1_location = glGetUniformLocation(prog, "args1");
args2_location = glGetUniformLocation(prog, "args2");
args3_location = glGetUniformLocation(prog, "args3");
}
void
piglit_init(int argc, char **argv)
{
GLboolean pass = GL_TRUE;
GLint vs, fs, len, ret_len;
GLenum type;
char *name;
GLsizei size;
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-getactiveuniform-length.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-color.frag");
prog = piglit_link_simple_program(vs, fs);
/* From page 261 (page 275 of the PDF) of the OpenGL 2.1 specification:
*
* If pname is ACTIVE UNIFORM MAX LENGTH, the length of
* the longest active uniform name, including a null
* terminator, is returned.
*/
glGetProgramiv(prog, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len);
if (len != strlen("color") + 1) {
printf("Unexpected max active uniform length "
"(saw %d, expected %lu)\n", len, (unsigned long) strlen("color") + 1);
pass = GL_FALSE;
}
/* From page 80 (page 88 of the PDF) of the OpenGL 2.1 specification:
*
* The actual number of characters written into name,
* excluding the null terminator, is returned in length.
*/
name = malloc(len);
glGetActiveUniform(prog, 0, len + 20, &ret_len, &size, &type, name);
if (ret_len != strlen("color")) {
printf("Unexpected active uniform length "
"(saw %d, expected %lu) for \"%s\"\n",
ret_len, (unsigned long) strlen("color"), name);
pass = GL_FALSE;
}
if (pass)
piglit_report_result(PIGLIT_PASS);
else
piglit_report_result(PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLint vs, fs;
piglit_require_gl_version(20);
piglit_require_extension("GL_EXT_framebuffer_object");
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-mvp.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-fs-fragcoord.frag");
prog = piglit_link_simple_program(vs, fs);
}
void piglit_init(int argc, char **argv)
{
GLint vert;
GLint prog;
GLboolean ok;
piglit_require_gl_version(20);
piglit_require_extension("GL_ARB_explicit_attrib_location");
vert = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-explicit-location-01.vert");
prog = glCreateProgram();
glAttachShader(prog, vert);
glLinkProgram(prog);
ok = piglit_link_check_status(prog);
if (ok) {
GLint loc = glGetAttribLocation(prog, "vertex");
if (loc != 0) {
fprintf(stderr,
"Expected location of 'vertex' to be 0, got "
"%d instead.\n", loc);
ok = GL_FALSE;
}
}
piglit_report_result(ok ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLint vs;
GLint point_size_range[2];
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
/* If the driver doesn't claim to support the point size the
shader is going to set then we should skip the test */
glGetIntegerv(GL_ALIASED_POINT_SIZE_RANGE, point_size_range);
if (POINT_SIZE < point_size_range[0] ||
POINT_SIZE > point_size_range[1]) {
printf("Point size %i not supported\n", POINT_SIZE);
piglit_report_result(PIGLIT_SKIP);
}
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glClearColor(0.0, 0.0, 0.0, 1.0);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-vs-point-size.vert");
prog = piglit_link_simple_program(vs, 0);
glUseProgram(prog);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
}
void
piglit_init(int argc, char **argv)
{
GLint vs, fs;
piglit_require_gl_version(20);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-mvp.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-fs-fragcoord.frag");
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
GLboolean pass = GL_TRUE;
GLint vs, fs, len;
char *name;
GLsizei size;
GLenum type;
piglit_require_gl_version(20);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-getactiveuniform-array-size.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-color.frag");
prog = piglit_link_simple_program(vs, fs);
glGetProgramiv(prog, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len);
name = malloc(len + 20);
glGetActiveUniform(prog, 0, len + 20, &len, &size, &type, name);
/* From page 81 (page 89 of the PDF) of the OpenGL 2.1 specification:
*
* If one or more elements of an array are active,
* GetActiveUniform will return the name of the array in
* name, subject to the restrictions listed above. The
* type of the array is returned in type. The size
* parameter contains the highest array element index
* used, plus one.
*/
if (size != 25) {
printf("Unexpected active uniform size "
"(saw %d, expected %d)\n", size, 25);
pass = GL_FALSE;
}
if (pass)
piglit_report_result(PIGLIT_PASS);
else
piglit_report_result(PIGLIT_FAIL);
}
void piglit_init(int argc, char **argv)
{
GLint vs, fs;
int loc;
piglit_require_gl_version(20);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-vs-texturematrix-1.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-tex.frag");
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
loc = glGetUniformLocation(prog, "sampler");
glUniform1i(loc, 1);
}
void piglit_init(int argc, char **argv)
{
GLint vs, fs;
piglit_require_gl_version(20);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-vs-if-bool.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-color.frag");
prog = piglit_link_simple_program(vs, fs);
red_location = glGetUniformLocation(prog, "red");
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
GLint vs, fs;
piglit_require_gl_version(20);
piglit_require_extension("GL_ARB_fragment_coord_conventions");
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-mvp.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-arb-fragment-coord-conventions-define.frag");
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
GLint vs, fs;
/* Set up projection matrix so we can just draw using window
* coordinates.
*/
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
piglit_require_gl_version(20);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-vs-loop-nested.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-color.frag");
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
GLint vs, fs;
piglit_require_gl_version(20);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-mvp.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-fs-sqrt-branch.frag");
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
args1_location = glGetUniformLocation(prog, "args1");
args2_location = glGetUniformLocation(prog, "args2");
}
void
piglit_init(int argc, char **argv)
{
GLint vs, fs, prog;
const char *fs_source =
"void main()\n"
"{\n"
" gl_FragColor = gl_Fog.color;\n"
"}\n";
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-mvp.vert");
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_source);
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
}
void piglit_init(int argc, char **argv)
{
GLint program;
bool expect = false;
bool result;
unsigned i;
const char *invalid_file = NULL;
piglit_require_gl_version(20);
piglit_require_GLSL();
program = glCreateProgram();
for (i = 1; i < argc; i++) {
size_t len;
GLint shader;
GLenum target;
if (strcmp(argv[i], "pass") == 0) {
expect = true;
break;
}
if (strcmp(argv[i], "fail") == 0) {
expect = false;
break;
}
/* Expect that the name is at least one character plus
* ".vert", ".geom", or ".frag"
*/
len = strlen(argv[i]);
if (len < 6) {
invalid_file = argv[i];
break;
}
if (strcmp(argv[i] + len - 5, ".vert") == 0) {
target = GL_VERTEX_SHADER;
} else if (strcmp(argv[i] + len - 5, ".geom") == 0) {
target = GL_GEOMETRY_SHADER;
if (piglit_get_gl_version() < 32 && !piglit_is_extension_supported("GL_ARB_geometry_shader4")) {
printf("Requires geometry shaders.\n");
piglit_report_result(PIGLIT_SKIP);
}
} else if (strcmp(argv[i] + len - 5, ".frag") == 0) {
target = GL_FRAGMENT_SHADER;
} else {
invalid_file = argv[i];
break;
}
shader = piglit_compile_shader(target, argv[i]);
glAttachShader(program, shader);
glDeleteShader(shader);
}
/* The loop above will break when an option of either 'pass' or 'fail'
* is encountered. If this happens at the last commandline argument,
* the loop counter will be (argc-1). Any other value is an error.
*/
if (i != (argc - 1)) {
fprintf(stderr, "Last command line option must be either "
"\"pass\" or \"fail\".\n");
piglit_report_result(PIGLIT_FAIL);
}
if (invalid_file != NULL) {
fprintf(stderr, "Invalid shader file name \"%s\".\n",
invalid_file);
piglit_report_result(PIGLIT_FAIL);
}
glLinkProgram(program);
result = piglit_link_check_status_quiet(program);
if (result != expect)
fprintf(stderr,
"Program should have %s linking, but "
"it was (incorrectly) %s.\n",
expect ? "succeeded" : "failed",
expect ? "unsuccesful" : "succesful");
piglit_report_result((result == expect) ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLboolean pass = GL_TRUE;
GLint vs, fs, len, ret_len;
GLenum type;
char *name;
GLsizei size;
/* OpenGL ES 3.0 and OpenGL 4.2 require that the "[0]" be appended to
* the name. Earlier versions of the spec are ambiguous. Accept
* either name.
*/
const size_t scalar_length = strlen("color");
const size_t array_length = strlen("color[0]");
piglit_require_gl_version(20);
vs = piglit_compile_shader(GL_VERTEX_SHADER,
"shaders/glsl-getactiveuniform-length.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-color.frag");
prog = piglit_link_simple_program(vs, fs);
/* From page 261 (page 275 of the PDF) of the OpenGL 2.1 specification:
*
* If pname is ACTIVE UNIFORM MAX LENGTH, the length of
* the longest active uniform name, including a null
* terminator, is returned.
*/
glGetProgramiv(prog, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len);
if (len != (scalar_length + 1) && len != (array_length + 1)) {
printf("Unexpected max active uniform length "
"(saw %d, expected %lu or %lu)\n", len,
(unsigned long) scalar_length,
(unsigned long) array_length);
pass = GL_FALSE;
}
/* From page 80 (page 88 of the PDF) of the OpenGL 2.1 specification:
*
* The actual number of characters written into name,
* excluding the null terminator, is returned in length.
*/
name = malloc(len);
glGetActiveUniform(prog, 0, len + 20, &ret_len, &size, &type, name);
if (ret_len != scalar_length && ret_len != array_length) {
printf("Unexpected active uniform length "
"(saw %d, expected %lu or %lu) for \"%s\"\n",
ret_len,
(unsigned long) scalar_length,
(unsigned long) array_length,
name);
pass = GL_FALSE;
}
if (pass)
piglit_report_result(PIGLIT_PASS);
else
piglit_report_result(PIGLIT_FAIL);
}
