void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL();
piglit_require_extension("GL_ARB_instanced_arrays");
VertShader = piglit_compile_shader_text(GL_VERTEX_SHADER, VertShaderText);
assert(VertShader);
FragShader = piglit_compile_shader_text(GL_FRAGMENT_SHADER, FragShaderText);
assert(FragShader);
Program = piglit_link_simple_program(VertShader, FragShader);
glUseProgram(Program);
PosAttrib = glGetAttribLocation(Program, "Pos");
ColorAttrib = glGetAttribLocation(Program, "Color");
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-5, 5, -5, 5, 10, 20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -11.0);
glScalef(0.5, 0.5, 1.0);
}
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;
GLint maxcomps, maxattrs;
unsigned i;
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
/* Check the driver. */
if (piglit_get_gl_version() < 15) {
fprintf(stderr, "OpenGL 1.5 required.\n");
piglit_report_result(PIGLIT_SKIP);
}
piglit_require_GLSL();
piglit_require_transform_feedback();
glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT, &maxattrs);
if (maxattrs < 4) {
fprintf(stderr, "Not enough separate attribs supported by transform feedback.\n");
piglit_report_result(PIGLIT_SKIP);
}
glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT, &maxcomps);
if (maxcomps < 4) {
fprintf(stderr, "Not enough separate components supported by transform feedback.\n");
piglit_report_result(PIGLIT_SKIP);
}
/* Create shaders. */
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
prog = piglit_CreateProgram();
piglit_AttachShader(prog, vs);
piglit_TransformFeedbackVaryings(prog, sizeof(varyings)/sizeof(varyings[0]),
varyings, GL_SEPARATE_ATTRIBS_EXT);
piglit_LinkProgram(prog);
if (!piglit_link_check_status(prog)) {
piglit_DeleteProgram(prog);
piglit_report_result(PIGLIT_FAIL);
}
/* Set up the transform feedback buffer. */
glGenBuffers(4, buf);
for (i = 0; i < 4; i++) {
unsigned j;
float *ptr;
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, buf[i]);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER_EXT,
NUM_OUT_VERTICES*4*sizeof(float), NULL, GL_STREAM_READ);
ptr = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, GL_WRITE_ONLY);
for (j = 0; j < NUM_OUT_VERTICES*4; j++) {
ptr[j] = 0.123456;
}
glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT);
piglit_BindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, i, buf[i]);
}
assert(glGetError() == 0);
glClearColor(0.2, 0.2, 0.2, 1.0);
glEnableClientState(GL_VERTEX_ARRAY);
}
void
piglit_init(int argc, char **argv)
{
GLuint vs;
int num_varyings;
piglit_require_GLSL();
piglit_require_transform_feedback();
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
for (num_varyings = 1; num_varyings <= 2; ++num_varyings) {
GLuint prog = piglit_CreateProgram();
piglit_AttachShader(prog, vs);
piglit_BindAttribLocation(prog, 0, "vertex_num");
piglit_TransformFeedbackVaryings(prog, num_varyings, varyings,
GL_INTERLEAVED_ATTRIBS);
piglit_LinkProgram(prog);
if (!piglit_link_check_status(prog)) {
piglit_DeleteProgram(prog);
piglit_report_result(PIGLIT_FAIL);
}
progs[num_varyings - 1] = prog;
}
glGenBuffers(1, &xfb_buf);
glGenQueries(1, &query_prims_generated);
glGenQueries(1, &query_prims_written);
}
void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL();
piglit_require_extension("GL_ARB_instanced_arrays");
Program = piglit_build_simple_program(VertShaderText, FragShaderText);
glUseProgram(Program);
PosAttrib = glGetAttribLocation(Program, "Pos");
ColorAttrib = glGetAttribLocation(Program, "Color");
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-5, 5, -5, 5, 10, 20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -11.0);
glScalef(0.5, 0.5, 1.0);
if ((argc >= 2) && (strcmp(argv[1], "vbo") == 0)) {
use_vbo = GL_TRUE;
}
}
void
piglit_init(int argc, char **argv)
{
GLuint id;
piglit_require_gl_version(15);
piglit_require_GLSL();
piglit_require_extension("GL_EXT_transform_feedback");
piglit_require_extension("GL_ARB_transform_feedback2");
glGenTransformFeedbacks(1, &id);
if (glIsTransformFeedback(id)) {
fprintf(stderr, "id recognized incorrectly as a transform feedback object.\n");
piglit_report_result(PIGLIT_FAIL);
}
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, id);
if (!glIsTransformFeedback(id)) {
fprintf(stderr, "id not recognized correctly as a transform feedback object.\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_report_result(PIGLIT_PASS);
}
void
piglit_init(int argc, char *argv[])
{
GLuint vs, gs, prog;
piglit_require_gl_version(15);
piglit_require_GLSL();
do_query_init(queries, ARRAY_SIZE(queries));
prog = glCreateProgram();
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_src);
gs = piglit_compile_shader_text(GL_GEOMETRY_SHADER, gs_src);
#ifndef DISPLAY
glEnable(GL_RASTERIZER_DISCARD);
#else
glAttachShader(prog,
piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_src));
#endif
glAttachShader(prog, vs);
glAttachShader(prog, gs);
glLinkProgram(prog);
if (!piglit_link_check_status(prog)) {
glDeleteProgram(prog);
piglit_report_result(PIGLIT_FAIL);
}
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
static const GLenum core_targets[] = {
GL_TEXTURE_1D,
GL_TEXTURE_2D,
GL_TEXTURE_3D,
GL_NONE
};
static const GLenum array_targets[] = {
GL_TEXTURE_1D_ARRAY_EXT,
GL_TEXTURE_2D_ARRAY_EXT,
GL_NONE
};
static const GLenum cube_map_array_targets[] = {
GL_TEXTURE_CUBE_MAP_ARRAY_ARB,
GL_NONE
};
int remaining_argc = 1;
int i;
test_targets = core_targets;
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "array")) {
piglit_require_extension("GL_EXT_texture_array");
piglit_require_GLSL();
test_targets = array_targets;
} else if (!strcmp(argv[i], "cube_map_array")) {
piglit_require_extension
("GL_ARB_texture_cube_map_array");
piglit_require_GLSL();
test_targets = cube_map_array_targets;
} else if (!strcmp(argv[i], "pbo")) {
piglit_require_extension("GL_ARB_pixel_buffer_object");
use_pbo = GL_TRUE;
} else {
argv[remaining_argc++] = argv[i];
}
}
fbo_formats_init(remaining_argc, argv, 0);
(void) fbo_formats_display;
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
}
void
piglit_init(int argc, char **argv)
{
piglit_require_gl_version(30);
piglit_require_GLSL();
piglit_require_GLSL_version(130);
piglit_require_extension("GL_ARB_cull_distance");
prog = piglit_build_simple_program(vert, frag);
glUseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
static const char *varyings[] = { "gl_Position", "gl_FrontColor" };
GLuint vs;
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glScalef(0.5, 0.5, 1.0);
/* Check the driver. */
piglit_require_gl_version(15);
piglit_require_GLSL();
piglit_require_transform_feedback();
/* Create shaders. */
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
prog = glCreateProgram();
glAttachShader(prog, vs);
glTransformFeedbackVaryings(prog, 2, varyings,
GL_INTERLEAVED_ATTRIBS_EXT);
glLinkProgram(prog);
if (!piglit_link_check_status(prog)) {
glDeleteProgram(prog);
piglit_report_result(PIGLIT_FAIL);
}
glUseProgram(prog);
/* Set up the vertex data buffer */
glGenBuffers(1, &vert_buf);
glBindBuffer(GL_ARRAY_BUFFER, vert_buf);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
/* Set up the transform feedback buffer. */
glGenBuffers(1, &xfb_buf);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, xfb_buf);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER_EXT,
xfb_buf_size, NULL, GL_STREAM_READ);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, 0, xfb_buf);
glClearColor(0.2, 0.2, 0.2, 1.0);
if (argc > 1 && strcmp(argv[1], "large") == 0) {
GLint range[2];
glGetIntegerv(GL_ALIASED_POINT_SIZE_RANGE, range);
if (range[1] == 1.0) {
printf("Max point size is %d, can't test large\n",
range[1]);
piglit_report_result(PIGLIT_WARN);
}
printf("Testing large points\n");
glPointSize(10.0);
}
}
void
piglit_init(int argc, char **argv)
{
const struct test_desc *test;
/* Parse params. */
if (argc != 2)
print_usage_and_exit(argv[0]);
test = find_matching_test(argv[0], argv[1]);
piglit_require_GLSL();
piglit_require_transform_feedback();
piglit_report_result(do_test(test) ? PIGLIT_PASS : PIGLIT_FAIL);
}
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);
}
}
void
piglit_init(int argc, char **argv)
{
GLuint vs;
GLuint fs;
piglit_require_GLSL();
piglit_require_GLSL_version(130);
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vert);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag);
prog = piglit_CreateProgram();
piglit_AttachShader(prog, vs);
piglit_AttachShader(prog, fs);
piglit_LinkProgram(prog);
piglit_DeleteShader(vs);
piglit_DeleteShader(fs);
piglit_UseProgram(prog);
}
void
piglit_init(int argc, char **argv)
{
const char *glsl_version_string;
float glsl_version;
GLint ok;
GLuint prog;
GLuint vs;
GLuint fs;
piglit_require_GLSL();
glsl_version_string = (char *)
glGetString(GL_SHADING_LANGUAGE_VERSION);
glsl_version = (glsl_version_string == NULL)
? 0.0 : strtod(glsl_version_string, NULL);
if (glsl_version <= 1.299999) {
printf("Test requires GLSL version >= 1.3. "
"Actual version is %.1f.\n",
glsl_version);
piglit_report_result(PIGLIT_SKIP);
}
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vert);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag);
prog = glCreateProgram();
glAttachShader(prog, vs);
glAttachShader(prog, fs);
glLinkProgram(prog);
glDeleteShader(vs);
glDeleteShader(fs);
ok = piglit_link_check_status_quiet(prog);
if (ok) {
fprintf(stderr,
"Linking with a shader that accesses both "
"gl_ClipDistance and gl_ClipVertex succeeded when it "
"should have failed.\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_report_result(PIGLIT_PASS);
}
void
piglit_init(int argc, char **argv)
{
const struct test_desc *test;
/* Parse params. */
if (argc != 2)
print_usage_and_exit(argv[0]);
test = find_matching_test(argv[0], argv[1]);
piglit_require_GLSL();
piglit_require_transform_feedback();
if (test->bind_mode == OFFSET) {
/* BindBufferOffset only exists in the EXT specification */
piglit_require_extension("GL_EXT_transform_feedback");
}
piglit_report_result(do_test(test) ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLuint prog, vbo, indirect;
piglit_require_GLSL();
piglit_require_extension("GL_ARB_draw_indirect");
prog = piglit_build_simple_program(vs_text, fs_text);
glUseProgram(prog);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &indirect);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirect);
glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(indirect_data), indirect_data, GL_STATIC_DRAW);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(rect), rect, GL_STATIC_DRAW);
/* Enable 2 vertex attrib arrays. */
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
/* Associate both arrays with binding 0. */
glVertexAttribBinding(0, 0);
glVertexAttribBinding(1, 0);
glBindVertexArray(0);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLuint vs;
GLuint fs;
GLint loc;
GLboolean ok;
piglit_require_GLSL();
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_text);
prog = piglit_link_simple_program(vs, fs);
glBindAttribLocation(prog, 0, "vertex");
glBindAttribLocation(prog, 1, "textureCoord");
glLinkProgram(prog);
ok = piglit_link_check_status(prog);
if (!ok)
piglit_report_result(PIGLIT_FAIL);
glUseProgram(prog);
loc = glGetUniformLocation(prog, "colorMatrix");
glUniformMatrix4fv(loc, 1, GL_FALSE, identity_matrix);
loc = glGetUniformLocation(prog, "texture");
glUniform1i(loc, 0);
glClearColor(0.2, 0.2, 0.2, 1.0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE,
2 * sizeof(GLfloat), vertex);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
2 * sizeof(GLfloat), tex_coord);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
}
void
piglit_init(int argc, char **argv)
{
int i;
if (argc > 1) {
for (i = 0; i < ARRAY_SIZE(sample_functions); i++) {
if (!strcmp(sample_functions[i].name, argv[1])) {
sample_function = sample_functions + i;
goto found;
}
}
fprintf(stderr, "Unknown function: %s\n", argv[1]);
piglit_report_result(PIGLIT_FAIL);
found:
(void) 0;
}
piglit_require_GLSL();
}
void piglit_init(int argc, char **argv)
{
if (argc != 2)
print_usage_and_exit(argv[0]);
if (strcmp(argv[1], "discard") == 0)
discard = GL_TRUE;
else if (strcmp(argv[1], "buffer") == 0)
buffer = GL_TRUE;
else if (strcmp(argv[1], "prims_written") == 0)
prims_written = GL_TRUE;
else if (strcmp(argv[1], "prims_generated") == 0)
prims_generated = GL_TRUE;
else
print_usage_and_exit(argv[0]);
piglit_require_transform_feedback();
if (buffer || prims_written) {
GLuint vs;
piglit_require_GLSL();
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
xfb_prog = glCreateProgram();
glAttachShader(xfb_prog, vs);
glTransformFeedbackVaryings(xfb_prog, 1, xfb_varyings,
GL_INTERLEAVED_ATTRIBS);
glLinkProgram(xfb_prog);
if (!piglit_link_check_status(xfb_prog)) {
piglit_report_result(PIGLIT_FAIL);
}
glGenBuffers(1, &xfb_buf);
}
if (prims_written) {
glGenQueries(1, &prims_written_query);
}
if (prims_generated) {
glGenQueries(1, &prims_generated_query);
}
}
void
piglit_init(int argc, char **argv)
{
if (argc != 2)
print_usage_and_exit(argv[0]);
if (strcmp(argv[1], "fixed") == 0) {
use_ff = true;
} else if (strcmp(argv[1], "arb") == 0) {
use_arb = true;
} else if (strcmp(argv[1], "pos") == 0) {
use_glsl = true;
setters = " gl_Position = rotate(position_angle) * gl_Vertex;\n";
use_glsl_130 = true;
} else if (strcmp(argv[1], "pos_clipvert") == 0) {
use_glsl = true;
setters =
" gl_Position = rotate(position_angle) * gl_Vertex;\n"
" gl_ClipVertex = rotate(clipVertex_angle) * gl_Vertex;\n";
use_clip_vertex = true;
} else if (strcmp(argv[1], "clipvert_pos") == 0) {
use_glsl = true;
setters =
" gl_ClipVertex = rotate(clipVertex_angle) * gl_Vertex;\n"
" gl_Position = rotate(position_angle) * gl_Vertex;\n";
use_clip_vertex = true;
} else {
print_usage_and_exit(argv[0]);
}
if (use_arb) {
piglit_require_extension("GL_ARB_vertex_program");
setup_arb_program();
} else if (use_glsl) {
piglit_require_GLSL();
piglit_require_GLSL_version(use_glsl_130 ? 130 : 110);
setup_glsl_programs();
}
}
void
piglit_init(int argc, char **argv)
{
GLuint vs, fs;
/* Interpret command line args */
if (argc != 2)
print_usage_and_exit(argv[0]);
if (strcmp(argv[1], "output") == 0)
test_mode = TEST_MODE_OUTPUT;
else if (strcmp(argv[1], "prims_generated") == 0)
test_mode = TEST_MODE_PRIMS_GENERATED;
else if (strcmp(argv[1], "prims_written") == 0)
test_mode = TEST_MODE_PRIMS_WRITTEN;
else
print_usage_and_exit(argv[0]);
piglit_require_GLSL();
piglit_require_transform_feedback();
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fstext);
prog = glCreateProgram();
glAttachShader(prog, vs);
glAttachShader(prog, fs);
glBindAttribLocation(prog, 0, "in_position");
glBindAttribLocation(prog, 1, "in_color");
glTransformFeedbackVaryings(prog, 2, varyings, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(prog);
if (!piglit_link_check_status(prog)) {
glDeleteProgram(prog);
piglit_report_result(PIGLIT_FAIL);
}
glGenBuffers(1, &xfb_buf);
glGenQueries(1, &query);
}
void
piglit_init(int argc, char **argv)
{
GLuint vs, fs;
piglit_require_GLSL();
piglit_require_transform_feedback();
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fstext);
prog = glCreateProgram();
glAttachShader(prog, vs);
glAttachShader(prog, fs);
glBindAttribLocation(prog, 0, "in_position");
glBindAttribLocation(prog, 1, "in_color");
glTransformFeedbackVaryings(prog, 2, varyings, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(prog);
if (!piglit_link_check_status(prog)) {
glDeleteProgram(prog);
piglit_report_result(PIGLIT_FAIL);
}
glGenBuffers(2, bufs);
}
void piglit_init(int argc, char **argv)
{
unsigned int i, j;
piglit_require_extension("GL_EXT_framebuffer_object");
piglit_require_extension("GL_NV_texture_barrier");
piglit_require_GLSL();
srand(0);
for (i = 0; i < 16 * 16 * 4; ++i) {
tex_data[i] = (rand() % 256) / 255.f;
res_data[i] = tex_data[i];
for (j = 0; j < PASSES; j++)
res_data[i] = sqrt(res_data[i]);
}
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16, 0, GL_RGBA, GL_FLOAT, NULL);
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT);
prog = piglit_build_simple_program(NULL, fstext);
texloc = glGetUniformLocation(prog, "fb");
}
void
piglit_init(int argc, char *argv[])
{
GLuint vs, prog;
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
piglit_require_gl_version(11);
piglit_require_GLSL();
do_query_init(queries, ARRAY_SIZE(queries));
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_src);
prog = glCreateProgram();
glAttachShader(prog, vs);
glLinkProgram(prog);
if (!piglit_link_check_status(prog)) {
glDeleteProgram(prog);
piglit_report_result(PIGLIT_FAIL);
}
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)
{
GLuint tex, fb;
GLenum status;
int i, dim;
GLuint fs, prog, loc_tex;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-inplace") == 0)
in_place_probing = GL_TRUE;
else if (strcmp(argv[i], "-nobias") == 0)
no_bias = GL_TRUE;
else if (strcmp(argv[i], "-nolod") == 0)
no_lod = GL_TRUE;
else if (strcmp(argv[i], "-GL_ARB_shader_texture_lod") == 0)
ARB_shader_texture_lod = GL_TRUE;
}
piglit_require_extension("GL_EXT_framebuffer_object");
if (piglit_get_gl_version() < 14)
piglit_report_result(PIGLIT_SKIP);
if (ARB_shader_texture_lod) {
piglit_require_GLSL();
piglit_require_extension("GL_ARB_shader_texture_lod");
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fscode);
prog = piglit_link_simple_program(0, fs);
glUseProgram(prog);
loc_tex = glGetUniformLocation(prog, "tex");
loc_lod = glGetUniformLocation(prog, "lod");
glUniform1i(loc_tex, 0);
puts("Testing GL_ARB_shader_texture_lod.");
}
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glTexImage2D(GL_TEXTURE_2D, i, GL_RGBA,
dim, dim,
0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
assert(glGetError() == 0);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
i);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO incomplete\n");
piglit_report_result(PIGLIT_SKIP);
}
glClearColor(colors[i][0],
colors[i][1],
colors[i][2],
0.0);
glClear(GL_COLOR_BUFFER_BIT);
assert(glGetError() == 0);
}
glDeleteFramebuffersEXT(1, &fb);
glBindTexture(GL_TEXTURE_2D, tex);
glViewport(0, 0, piglit_width, piglit_height);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
void piglit_init(int argc, char **argv)
{
GLuint vs;
unsigned i,j;
int maxcomps;
float *data;
/* Parse params. */
for (i = 1; i < argc; i++) {
struct test_desc *t;
for (t = tests; t->name; t++) {
if (!strcmp(argv[i], t->name)) {
test = t;
goto test_ready;
}
}
fprintf(stderr, "Unknown test name.\n");
exit(1);
}
test = &tests[0];
test_ready:
printf("Testing type: %s\n", test->name);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
/* Check the driver. */
piglit_require_gl_version(15);
piglit_require_GLSL();
piglit_require_transform_feedback();
if (!test->is_floating_point)
piglit_require_GLSL_version(130);
if (test->is_transform_feedback3)
piglit_require_extension("GL_ARB_transform_feedback3");
glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, &maxcomps);
for (i = 0; i < MAX_BUFFERS; i++) {
if (maxcomps < test->num_elements[i]) {
piglit_report_result(PIGLIT_SKIP);
}
}
/* Create shaders. */
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, test->vs);
prog = glCreateProgram();
glAttachShader(prog, vs);
glTransformFeedbackVaryings(prog, test->num_varyings,
test->varyings,
GL_INTERLEAVED_ATTRIBS_EXT);
glLinkProgram(prog);
if (!piglit_link_check_status(prog)) {
glDeleteProgram(prog);
piglit_report_result(PIGLIT_FAIL);
}
glGenBuffers(MAX_BUFFERS, buf);
for (j = 0; j < MAX_BUFFERS; j++) {
if (!test->num_elements[j]) {
continue;
}
if (test->is_transform_feedback3) {
GLint maxbufs;
glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_BUFFERS, &maxbufs);
if (j >= maxbufs) {
piglit_report_result(PIGLIT_SKIP);
}
}
/* Set up the transform feedback buffer. */
data = malloc(test->num_elements[j]*NUM_VERTICES*sizeof(float));
for (i = 0; i < test->num_elements[j]*NUM_VERTICES; i++) {
data[i] = DEFAULT_VALUE;
}
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, buf[j]);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER_EXT,
test->num_elements[j]*NUM_VERTICES*sizeof(float),
data, GL_STREAM_READ);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, j, buf[j]);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
free(data);
}
glClearColor(0.2, 0.2, 0.2, 1.0);
glEnableClientState(GL_VERTEX_ARRAY);
}
void piglit_init(int argc, char **argv)
{
GLuint tex, fb;
GLenum status;
int i, dim;
piglit_require_GLSL();
piglit_require_extension("GL_EXT_framebuffer_object");
piglit_require_extension("GL_ARB_shader_texture_lod");
prog_tex = piglit_build_simple_program(NULL, sh_tex);
prog_texgrad = piglit_build_simple_program(NULL, sh_texgrad);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glTexImage2D(GL_TEXTURE_2D, i, GL_RGBA,
dim, dim,
0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
i);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO incomplete\n");
piglit_report_result(PIGLIT_SKIP);
}
glClearColor(colors[i][0],
colors[i][1],
colors[i][2],
0.0);
glClear(GL_COLOR_BUFFER_BIT);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
}
glDeleteFramebuffersEXT(1, &fb);
glBindTexture(GL_TEXTURE_2D, tex);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-0.1, 0.1, -0.1, 0.1, 0.1, 1000.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(-0.5, -0.5, -1.2);
glRotatef(68, 0, 1, 0);
glScalef(2000, 1, 1);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
piglit_set_tolerance_for_bits(7, 7, 7, 7);
printf("Left: texture2D, Right: texture2DGradARB\n");
}
void
piglit_init(int argc, char **argv)
{
piglit_require_extension("GL_ARB_vertex_buffer_object");
piglit_require_GLSL();
}
void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL();
}
