void piglit_init(int argc, char **argv)
{
bool pass = true;
ObjectPtrLabel = GET_FUNC(glObjectPtrLabel);
GetObjectPtrLabel = GET_FUNC(glGetObjectPtrLabel);
ObjectLabel = GET_FUNC(glObjectLabel);
GetObjectLabel = GET_FUNC(glGetObjectLabel);
#ifdef PIGLIT_USE_OPENGL
piglit_require_gl_version(15);
#endif
piglit_require_extension("GL_KHR_debug");
pass = test_object_label_types() && pass;
pass = test_object_label() && pass;
pass = test_get_object_label() && pass;
/* Test only if is GLES 3.0 or GL 3.2 or has ARB_sync */
if ((piglit_is_gles() && piglit_get_gl_version() >= 30) ||
piglit_get_gl_version() >= 32 ||
piglit_is_extension_supported("GL_ARB_sync"))
pass = test_object_ptr_label() && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
int vuniforms = 0, vblocks = 0;
int guniforms = 0, gblocks = 0;
int funiforms = 0, fblocks = 0;
int blocksize = 0;
bool gs = piglit_is_extension_supported("GL_ARB_geometry_shader4");
piglit_require_extension("GL_ARB_uniform_buffer_object");
piglit_print_minmax_header();
piglit_test_min_int(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, 1024);
piglit_test_min_int(GL_MAX_VERTEX_UNIFORM_BLOCKS, 12);
piglit_test_min_int(GL_MAX_FRAGMENT_UNIFORM_BLOCKS, 12);
if (gs)
piglit_test_min_int(GL_MAX_GEOMETRY_UNIFORM_BLOCKS, 12);
piglit_test_min_int(GL_MAX_COMBINED_UNIFORM_BLOCKS, gs ? 36 : 24);
piglit_test_min_int(GL_MAX_UNIFORM_BUFFER_BINDINGS, gs ? 36 : 24);
piglit_test_min_int(GL_MAX_UNIFORM_BLOCK_SIZE, 16384);
/* Minimum value for OpenGL 3.1 is
* (MAX_<stage>_UNIFORM_BLOCKS * MAX_UNIFORM_BLOCK_SIZE) +
* MAX_<stage>_UNIFORM_COMPONENTS. Minimum value prior to
* OpenGL 3.1 is MAX_<stage>_UNIFORM_COMPONENTS.
*/
if (piglit_get_gl_version() >= 31) {
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, &vblocks);
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_BLOCKS, &fblocks);
}
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &vuniforms);
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &funiforms);
glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &blocksize);
piglit_test_min_int(GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS,
vblocks * blocksize + vuniforms);
piglit_test_min_int(GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS,
fblocks * blocksize + funiforms);
if (gs) {
if (piglit_get_gl_version() >= 31) {
glGetIntegerv(GL_MAX_GEOMETRY_UNIFORM_BLOCKS, &gblocks);
}
glGetIntegerv(GL_MAX_GEOMETRY_UNIFORM_COMPONENTS, &guniforms);
piglit_test_min_int(GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS,
gblocks * blocksize + guniforms);
}
piglit_test_min_int(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, 1);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
piglit_report_result(piglit_minmax_pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
if (!piglit_is_extension_supported("GL_ATI_separate_stencil") && piglit_get_gl_version() < 20) {
printf("Sorry, this program requires either "
"GL_ATI_separate_stencil or OpenGL 2.0.\n");
piglit_report_result(PIGLIT_SKIP);
}
if (piglit_get_gl_version() < 20) {
use20syntax = 0;
}
printf("\nAll 5 (or 6) squares should be the same color.\n");
}
static bool
supported_target(unsigned i)
{
/* Array targets are only supported if GLSL is available.
*/
if ((target[i].target == GL_TEXTURE_1D_ARRAY
|| target[i].target == GL_TEXTURE_2D_ARRAY)
&& (piglit_get_gl_version() < 20
&& !piglit_is_extension_supported("GL_ARB_fragment_shader")))
return false;
return piglit_get_gl_version() >= target[i].gl_version ||
(target[i].extension &&
piglit_is_extension_supported(target[i].extension));
}
void piglit_init(int argc, char **argv)
{
GLint vert[2];
GLint prog;
GLboolean ok;
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
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)
{
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
}
PIGLIT_GL_TEST_CONFIG_END
void
piglit_init(int argc, char **argv)
{
bool pass = true;
GLuint textures[3];
if(piglit_get_gl_version() < 32) {
piglit_require_extension("GL_ARB_texture_multisample");
}
glGenTextures(3, textures);
/* Pass a Texture 2D Multisample */
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textures[0]);
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGB,
1024, 1024, GL_FALSE);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
/* Pass a Proxy Texture 2d Multisample */
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textures[1]);
glTexImage2DMultisample(GL_PROXY_TEXTURE_2D_MULTISAMPLE, 4, GL_RGB,
1024, 1024, GL_FALSE);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
/* Pass an Invalid Enum */
glBindTexture(GL_TEXTURE_2D, textures[2]);
glTexImage2DMultisample(GL_TEXTURE_2D, 4, GL_RGB,
1024, 1024, GL_FALSE);
pass = piglit_check_gl_error(GL_INVALID_ENUM) && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
GLsync valid_sync;
GLsync invalid_sync = (GLsync)20;
if (piglit_get_gl_version() < 32) {
piglit_require_extension("GL_ARB_sync");
}
valid_sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
/* test that valid parameters passed results in NO_ERROR */
glWaitSync(valid_sync, 0, GL_TIMEOUT_IGNORED);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
/* test that invalid sync results in INVALID_VALUE */
glWaitSync(invalid_sync, 0, GL_TIMEOUT_IGNORED);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
/* test that invalid flag value results in INVALID_VALUE */
glWaitSync(valid_sync, 3, GL_TIMEOUT_IGNORED);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
glDeleteSync(valid_sync);
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLint ok;
GLuint prog;
GLuint fs[2];
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
piglit_require_extension("GL_AMD_conservative_depth");
fs[0] = piglit_compile_shader_text(GL_FRAGMENT_SHADER, layout_greater);
fs[1] = piglit_compile_shader_text(GL_FRAGMENT_SHADER, layout_less);
prog = glCreateProgram();
glAttachShader(prog, fs[0]);
glAttachShader(prog, fs[1]);
glLinkProgram(prog);
glDeleteShader(fs[0]);
glDeleteShader(fs[1]);
ok = piglit_link_check_status_quiet(prog);
if (ok) {
fprintf(stderr,
"Linking with mismatched gl_FragDepth layouts "
"succeeded when it should have failed.\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_report_result(PIGLIT_PASS);
}
void
piglit_init(int argc, char **argv)
{
Have_NV = piglit_is_extension_supported("GL_NV_primitive_restart");
Have_31 = piglit_get_gl_version() >= 31;
if (argc >= 2) {
VBO_CFG vbo_cfg;
for (vbo_cfg = 0; vbo_cfg < ARRAY_SIZE(vbo_cfg_names); vbo_cfg++) {
if (strcmp(argv[1], vbo_cfg_names[vbo_cfg]) == 0) {
vbo_init_cfg = vbo_cfg;
break;
}
}
}
/* Debug */
/* NOTE! glew 1.5.2's OpenGL 3.1 detection is broken. You'll need
* to upgrade to a newer version if you want to test the GL 3.1
* primitive restart feature!
*/
if (0) {
printf("Have NV: %d\n", Have_NV);
printf("Have 31: %d\n", Have_31);
}
if (!Have_NV && !Have_31) {
piglit_report_result(PIGLIT_SKIP);
exit(1);
}
glClearColor(0, 0, 0, 0);
}
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)
{
int i;
GLuint vs;
/* Parse params */
if (argc != 2)
print_usage_and_exit(argv[0]);
for (i = 0; i < ARRAY_SIZE(tests); i++) {
if (strcmp(argv[1], tests[i].name) == 0) {
test = &tests[i];
break;
}
}
if (test == NULL)
print_usage_and_exit(argv[0]);
piglit_require_GLSL_version(110);
if (!piglit_is_extension_supported("GL_NV_primitive_restart") &&
piglit_get_gl_version() < 31) {
printf("GL_NV_primitive_restart or GL 3.1 required\n");
piglit_report_result(PIGLIT_SKIP);
}
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text);
prog = piglit_link_simple_program(vs, 0);
if (!prog)
piglit_report_result(PIGLIT_FAIL);
glDeleteShader(vs);
vertex_attr = glGetAttribLocation(prog, "vertex");
window_size_loc = glGetUniformLocation(prog, "window_size");
offset_loc = glGetUniformLocation(prog, "offset");
color_loc = glGetUniformLocation(prog, "color");
}
void piglit_init(int argc, char **argv)
{
GLuint fs, vs;
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
piglit_require_extension("GL_EXT_framebuffer_object");
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_source);
prog = piglit_link_simple_program(vs, fs);
if (!prog) {
piglit_report_result(PIGLIT_SKIP);
}
color_location = glGetUniformLocation(prog, "color");
if (color_location == -1) {
fprintf(stderr, "Failed to get uniform location");
piglit_report_result(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)
{
bool pass = true;
piglit_require_extension("GL_ARB_texture_storage");
piglit_require_extension("GL_ARB_texture_view");
piglit_require_extension("GL_EXT_texture_integer");
piglit_require_extension("GL_ARB_texture_float");
if (piglit_get_gl_version() < 31)
piglit_require_extension("GL_ARB_texture_cube_map");
X(test_format_errors(GL_VIEW_CLASS_128_BITS), "Format 128 bits validity");
X(test_format_errors(GL_VIEW_CLASS_96_BITS), "Format 96 bits validity");
X(test_format_errors(GL_VIEW_CLASS_64_BITS), "Format 64 bits validity");
X(test_format_errors(GL_VIEW_CLASS_48_BITS), "Format 48 bits validity");
X(test_format_errors(GL_VIEW_CLASS_32_BITS), "Format 32 bits validity");
X(test_format_errors(GL_VIEW_CLASS_24_BITS), "Format 24 bits validity");
X(test_format_errors(GL_VIEW_CLASS_16_BITS), "Format 16 bits validity");
X(test_format_errors(GL_VIEW_CLASS_8_BITS), "Format 8 bits validity");
X(test_format_errors(VIEW_CLASS_NOT_IN_TABLE), "Format misc validity");
#undef X
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
Have_NV = piglit_is_extension_supported("GL_NV_primitive_restart");
Have_31 = piglit_get_gl_version() >= 31;
if (argc >= 2) {
VBO_CFG vbo_cfg;
for (vbo_cfg = 0; vbo_cfg < ARRAY_SIZE(vbo_cfg_names); vbo_cfg++) {
if (strcmp(argv[1], vbo_cfg_names[vbo_cfg]) == 0) {
vbo_init_cfg = vbo_cfg;
break;
}
}
}
/* Debug */
if (0) {
printf("Have NV: %d\n", Have_NV);
printf("Have 31: %d\n", Have_31);
}
if (!Have_NV && !Have_31) {
piglit_report_result(PIGLIT_SKIP);
exit(1);
}
glClearColor(0, 0, 0, 0);
}
void
piglit_init(int argc, char **argv)
{
GLint max_attachments;
printf("The result should be a rows of boxes of differing colors, \n"
"one for each drawbuffer target used (none black).\n");
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);
}
piglit_require_extension("GL_EXT_framebuffer_object");
piglit_require_extension("GL_ARB_draw_buffers");
glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_targets);
if (max_targets < 2)
piglit_report_result(PIGLIT_SKIP);
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &max_attachments);
if (max_targets > max_attachments)
max_targets = max_attachments;
if (max_targets > 16)
max_targets = 16;
}
void piglit_init(int argc, char **argv)
{
int a,i;
piglit_require_gl_version(20);
piglit_require_extension("GL_ARB_explicit_attrib_location");
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
snorm_equation_23 = piglit_get_gl_version() >= 42;
glClearColor(0.2, 0.2, 0.2, 1.0);
for (a = 1; a < argc; a++) {
for (i = 0; i < ARRAY_SIZE(test_sets); i++) {
if (strcmp(argv[a], test_sets[i].name) == 0) {
if (test_sets[i].gl_version)
piglit_require_gl_version(test_sets[i].gl_version);
if (test_sets[i].extension)
piglit_require_extension(test_sets[i].extension);
test_set = &test_sets[i];
return;
}
}
}
}
void
piglit_init(int argc, char **argv)
{
#ifdef GL_ARB_ES2_compatibility
static const float verts[] = {
-1.0, 1.0, 0.0, 1.0,
-1.0, -1.0, 0.0, 1.0,
+0.0, 1.0, 0.0, 1.0,
+0.0, -1.0, 0.0, 1.0,
};
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
if (!piglit_is_extension_supported("GL_ARB_ES2_compatibility")) {
printf("Requires ARB_ES2_compatibility\n");
piglit_report_result(PIGLIT_SKIP);
}
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 4,
verts);
glEnableVertexAttribArray(0);
#endif
}
PIGLIT_GL_TEST_CONFIG_END
void
piglit_init(int argc, char **argv)
{
bool pass;
/* We can create depth/stencil textures if either:
* 1. We have GL 3.0 or later
* 2. We have GL_EXT_packed_depth_stencil and GL_ARB_depth_texture
*/
if (piglit_get_gl_version() < 30
&& !(piglit_is_extension_supported("GL_EXT_packed_depth_stencil") &&
piglit_is_extension_supported("GL_ARB_depth_texture"))) {
printf("OpenGL 3.0 or GL_EXT_packed_depth_stencil + "
"GL_ARB_depth_texture is required.\n");
piglit_report_result(PIGLIT_SKIP);
}
pass = test_format(GL_DEPTH24_STENCIL8_EXT,
GL_DEPTH_STENCIL_EXT,
GL_UNSIGNED_INT_24_8_EXT,
4);
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL_version(140);
if (piglit_get_gl_version() < 31)
piglit_require_extension("GL_ARB_texture_buffer_object");
}
void
piglit_init(int argc, char **argv)
{
piglit_require_GLSL_version(140);
if (argc != 3)
usage(argv[0]);
test_vs = strcmp(argv[1], "vs") == 0;
if (!test_vs && strcmp(argv[1], "fs") != 0)
usage(argv[0]);
test_arb = strcmp(argv[2], "arb") == 0;
if (!test_arb && strcmp(argv[2], "core") != 0)
usage(argv[0]);
piglit_require_extension("GL_EXT_texture_integer");
piglit_require_extension("GL_ARB_texture_rg");
if (test_arb) {
piglit_require_extension("GL_ARB_texture_buffer_object");
} else {
if (piglit_get_gl_version() < 31)
piglit_require_extension("GL_ARB_texture_buffer_object");
}
init_programs();
}
/**
* Check that the context's actual version no less than the requested
* version for \a flavor.
*/
static bool
check_gl_version(const struct piglit_gl_test_config *test_config,
enum context_flavor flavor,
const char *context_description)
{
switch (flavor) {
case CONTEXT_GL_CORE:
case CONTEXT_GL_ES:
/* There is no need to check the context version here, because
* Piglit explicitly supplied the desired version to
* waffle_config_choose().
*/
return true;
case CONTEXT_GL_COMPAT: {
int actual_version = piglit_get_gl_version();
if (actual_version >= test_config->supports_gl_compat_version)
return true;
fprintf(stderr, "piglit: error: Requested a %s, but actual "
"context version is %d.%d\n",
context_description,
actual_version / 10,
actual_version % 10);
return false;
}
default:
assert(0);
return false;
}
}
bool
atomic_counters_supported(GLenum shader_stage)
{
int n = 0;
switch (shader_stage) {
case GL_NONE:
case GL_FRAGMENT_SHADER:
return true;
case GL_VERTEX_SHADER:
glGetIntegerv(GL_MAX_VERTEX_ATOMIC_COUNTERS, &n);
return n;
case GL_GEOMETRY_SHADER:
if (piglit_get_gl_version() >= 32)
glGetIntegerv(GL_MAX_GEOMETRY_ATOMIC_COUNTERS, &n);
return n;
case GL_TESS_CONTROL_SHADER:
if (piglit_is_extension_supported("GL_ARB_tessellation_shader"))
glGetIntegerv(GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS, &n);
return n;
case GL_TESS_EVALUATION_SHADER:
if (piglit_is_extension_supported("GL_ARB_tessellation_shader"))
glGetIntegerv(GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS,
&n);
return n;
default:
assert(!"Unreachable");
abort();
}
}
void
piglit_init(int argc, char **argv)
{
GLint vs, fs1, fs2;
const char *vs_source =
"void main()\n"
"{\n"
" gl_Position = gl_Vertex;\n"
"}\n";
const char *fs1_source =
"void main()\n"
"{\n"
" gl_FragColor = vec4(0.0, 1.0, 0.0, 0.0);\n"
"}\n";
const char *fs2_source =
"void main()\n"
"{\n"
" gl_FragColor = vec4(0.0, 0.0, 1.0, 0.0);\n"
"}\n";
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source);
fs1 = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs1_source);
fs2 = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs2_source);
prog1 = piglit_link_simple_program(vs, fs1);
prog2 = piglit_link_simple_program(vs, fs2);
}
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)
{
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)
{
GLint fsr;
GLint fsg;
GLint vs;
if (piglit_get_gl_version() < 20) {
printf("Requires OpenGL 2.0\n");
piglit_report_result(PIGLIT_SKIP);
}
glClearColor(0.2, 0.2, 0.2, 1.0);
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vertShaderText);
fsr = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fragShaderTextRed);
fsg =
piglit_compile_shader_text(GL_FRAGMENT_SHADER, fragShaderTextGreen);
progr = piglit_link_simple_program(vs, fsr);
progg = piglit_link_simple_program(vs, fsg);
list = glGenLists(1);
glNewList(list, GL_COMPILE);
glUseProgram(progg);
glEndList();
}
void
piglit_init(int argc, char **argv)
{
GLint maxColorTextureSamples;
/* glClearTexture is either in the GL_ARB_clear_texture
* extension or in core in GL 4.4
*/
if (piglit_get_gl_version() < 44 &&
!piglit_is_extension_supported("GL_ARB_clear_texture")) {
printf("OpenGL 4.4 or GL_ARB_clear_texture is required.\n");
piglit_report_result(PIGLIT_SKIP);
}
piglit_require_extension("GL_ARB_texture_multisample");
piglit_require_GLSL_version(130);
/* We need to support multisample textures with at least 4
* samples */
glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxColorTextureSamples);
if (maxColorTextureSamples < TEX_SAMPLES) {
printf("At least %i texture samples are required\n",
TEX_SAMPLES);
piglit_report_result(PIGLIT_SKIP);
}
init_program();
}
void
piglit_init(int argc, char **argv)
{
GLint max_attachments;
printf("The result should be increasing lengths of rows of green\n"
"boxes as the test increases the number of drawbuffers \n"
"targets used.\n");
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);
}
piglit_require_extension("GL_EXT_framebuffer_object");
piglit_require_extension("GL_ARB_draw_buffers");
glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_targets);
if (max_targets < 2)
piglit_report_result(PIGLIT_SKIP);
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &max_attachments);
if (max_targets > max_attachments)
max_targets = max_attachments;
if (max_targets > 16)
max_targets = 16;
}
