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);
}
static bool
check_textures_size(void)
{
bool check_pass = true;
test_data *data = test_data_new(0, 1);
unsigned i;
int testing64;
for (i = 0; i < ARRAY_SIZE(pnames); i++) {
bool pass = true;
if (!piglit_is_gles()) {
if (pnames[i] == GL_INTERNALFORMAT_SHARED_SIZE ||
pnames[i] == GL_INTERNALFORMAT_STENCIL_SIZE) {
continue;
}
}
for (testing64 = 0; testing64 <= 1; testing64++) {
test_data_set_testing64(data, testing64);
pass = try_textures_size(texture_targets, ARRAY_SIZE(texture_targets),
valid_internalformats, num_valid_internalformats,
pnames[i],
data)
&& pass;
}
piglit_report_subtest_result(pass ? PIGLIT_PASS : PIGLIT_FAIL,
"%s", piglit_get_gl_enum_name(pnames[i]));
check_pass = check_pass && pass;
}
test_data_clear(&data);
return check_pass;
}
/* trivial tests to get/set labels on all the different types of objects */
static bool
test_object_label_types()
{
#define numObjects 12
GLsizei length[numObjects]; /* create a fresh variable for each object to test */
GLchar label[numObjects][TestLabelLen + 1];
bool pass = true;
enum test_object_indices {
BUFFER_IDX, SHADER_IDX, PROGRAM_IDX, VERTEX_ARRAY_IDX, RENDERBUFFER_IDX,
FRAMEBUFFER_IDX, QUERY_IDX, PROGRAM_PIPELINE_IDX, TRANSFORM_FEEDBACK_IDX,
SAMPLER_IDX, TEXTURE_IDX, DISPLAY_LIST_IDX
};
GLuint buffer;
GLuint shader;
GLuint program;
GLuint vertexArray;
GLuint query;
#ifdef PIGLIT_USE_OPENGL
GLuint programPipeline;
#endif
GLuint transformFeedback;
GLuint sampler;
GLuint texture;
GLuint renderbuffer;
GLuint framebuffer;
#ifdef PIGLIT_USE_OPENGL
GLuint displayList;
#endif
/* Test BUFFER */
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
ObjectLabel(GL_BUFFER, buffer, -1, TestLabel);
GetObjectLabel(GL_BUFFER, buffer, TestLabelLen + 1, &length[BUFFER_IDX], label[BUFFER_IDX]);
check_label_and_length(label[BUFFER_IDX], length[BUFFER_IDX], "GL_BUFFER");
glDeleteBuffers(1, &buffer);
if (piglit_get_gl_version() >= 20) {
/* Test SHADER */
shader = glCreateShader(GL_FRAGMENT_SHADER);
ObjectLabel(GL_SHADER, shader, -1, TestLabel);
GetObjectLabel(GL_SHADER, shader, TestLabelLen + 1,
&length[SHADER_IDX], label[SHADER_IDX]);
check_label_and_length(label[SHADER_IDX], length[SHADER_IDX], "GL_SHADER");
glDeleteShader(shader);
/* Test PROGRAM */
program = glCreateProgram();
ObjectLabel(GL_PROGRAM, program, -1, TestLabel);
GetObjectLabel(GL_PROGRAM, program, TestLabelLen + 1,
&length[PROGRAM_IDX], label[PROGRAM_IDX]);
check_label_and_length(label[PROGRAM_IDX], length[PROGRAM_IDX], "GL_PROGRAM");
glDeleteProgram(program);
}
/* GL or GLES >= 3.0 supports vertex arrays*/
if (piglit_get_gl_version() >= 30) {
/* Test VERTEX_ARRAY */
glGenVertexArrays(1, &vertexArray);
glBindVertexArray(vertexArray);
ObjectLabel(GL_VERTEX_ARRAY, vertexArray, -1, TestLabel);
GetObjectLabel(GL_VERTEX_ARRAY, vertexArray, TestLabelLen + 1,
&length[VERTEX_ARRAY_IDX], label[VERTEX_ARRAY_IDX]);
check_label_and_length(label[VERTEX_ARRAY_IDX], length[VERTEX_ARRAY_IDX], "GL_VERTEX_ARRAY");
glDeleteVertexArrays(1, &vertexArray);
}
/* GLES supports render buffer and frame buffer since 2.0 */
if (piglit_is_gles() || piglit_get_gl_version() >= 30) {
/* Test RENDERBUFFER */
glGenRenderbuffers(1, &renderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
ObjectLabel(GL_RENDERBUFFER, renderbuffer, -1, TestLabel);
GetObjectLabel(GL_RENDERBUFFER, renderbuffer, TestLabelLen + 1,
&length[RENDERBUFFER_IDX], label[RENDERBUFFER_IDX]);
check_label_and_length(label[RENDERBUFFER_IDX], length[RENDERBUFFER_IDX], "GL_RENDERBUFFER");
glDeleteRenderbuffers(1, &renderbuffer);
/* Test FRAMEBUFFER */
glGenFramebuffers(1, &framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
ObjectLabel(GL_FRAMEBUFFER, framebuffer, -1, TestLabel);
GetObjectLabel(GL_FRAMEBUFFER, framebuffer, TestLabelLen + 1,
&length[FRAMEBUFFER_IDX], label[FRAMEBUFFER_IDX]);
check_label_and_length(label[FRAMEBUFFER_IDX], length[FRAMEBUFFER_IDX], "GL_FRAMEBUFFER");
glDeleteFramebuffers(1, &framebuffer);
}
/* GLES >= 3.0 or GL compat */
if (!piglit_is_gles() || piglit_get_gl_version() >= 30) {
/* Test QUERY */
glGenQueries(1, &query);
glBeginQuery(GL_TIME_ELAPSED, query);
glEndQuery(GL_TIME_ELAPSED);
ObjectLabel(GL_QUERY, query, -1, TestLabel);
GetObjectLabel(GL_QUERY, query, TestLabelLen + 1, &length[QUERY_IDX], label[QUERY_IDX]);
check_label_and_length(label[QUERY_IDX], length[QUERY_IDX], "GL_TEST_QUERY");
glDeleteQueries(1, &query);
}
#ifdef PIGLIT_USE_OPENGL
/* Test PROGRAM_PIPELINE */
if (piglit_is_extension_supported("GL_ARB_separate_shader_objects")) {
glGenProgramPipelines(1, &programPipeline);
glBindProgramPipeline(programPipeline);
ObjectLabel(GL_PROGRAM_PIPELINE, programPipeline, -1, TestLabel);
GetObjectLabel(GL_PROGRAM_PIPELINE, programPipeline, TestLabelLen + 1,
&length[PROGRAM_PIPELINE_IDX], label[PROGRAM_PIPELINE_IDX]);
check_label_and_length(label[PROGRAM_PIPELINE_IDX], length[PROGRAM_PIPELINE_IDX], "GL_PROGRAM_PIPELINE");
glDeleteProgramPipelines(1, &programPipeline);
}
#endif /* PIGLIT_USE_OPENGL */
/* Test TRANSFORM_FEEDBACK */
if ((piglit_is_gles() && piglit_get_gl_version() >= 30) ||
piglit_is_extension_supported("GL_ARB_transform_feedback2")) {
glGenTransformFeedbacks(1, &transformFeedback);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback);
ObjectLabel(GL_TRANSFORM_FEEDBACK, transformFeedback, -1, TestLabel);
GetObjectLabel(GL_TRANSFORM_FEEDBACK, transformFeedback, TestLabelLen + 1,
&length[TRANSFORM_FEEDBACK_IDX], label[TRANSFORM_FEEDBACK_IDX]);
check_label_and_length(label[TRANSFORM_FEEDBACK_IDX], length[TRANSFORM_FEEDBACK_IDX], "GL_TRANSFORM_FEEDBACK");
glDeleteTransformFeedbacks(1, &transformFeedback);
}
/* Test SAMPLER */
if ((piglit_is_gles() && piglit_get_gl_version() >= 30) ||
piglit_is_extension_supported("GL_ARB_sampler_objects")) {
glGenSamplers(1, &sampler);
glBindSampler(0, sampler);
ObjectLabel(GL_SAMPLER, sampler, -1, TestLabel);
GetObjectLabel(GL_SAMPLER, sampler, TestLabelLen + 1, &length[SAMPLER_IDX], label[SAMPLER_IDX]);
check_label_and_length(label[SAMPLER_IDX], length[SAMPLER_IDX], "GL_SAMPLER");
glDeleteSamplers(1, &sampler);
}
/* Test TEXTURE */
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
ObjectLabel(GL_TEXTURE, texture, -1, TestLabel);
GetObjectLabel(GL_TEXTURE, texture, TestLabelLen + 1, &length[TEXTURE_IDX], label[TEXTURE_IDX]);
check_label_and_length(label[TEXTURE_IDX], length[TEXTURE_IDX], "GL_TEXTURE");
glDeleteTextures(1, &texture);
#ifdef PIGLIT_USE_OPENGL
/* Test DISPLAY_LIST - Compatibility Profile */
displayList = glGenLists(1);
glNewList(displayList, GL_COMPILE_AND_EXECUTE);
glEndList();
ObjectLabel(GL_DISPLAY_LIST, displayList, -1, TestLabel);
GetObjectLabel(GL_DISPLAY_LIST, displayList, TestLabelLen + 1, &length[DISPLAY_LIST_IDX], label[DISPLAY_LIST_IDX]);
check_label_and_length(label[DISPLAY_LIST_IDX], length[DISPLAY_LIST_IDX], "GL_DISPLAY_LIST");
glDeleteLists(displayList, 1);
#endif /* PIGLIT_USE_OPENGL */
return pass;
}
enum piglit_result
piglit_display(void)
{
GLuint tex;
static const float red[] = { 1, 0, 0, 1 };
static const float green[] = { 0, 1, 0, 1 };
static const float blue[] = { 0, 0, 1, 1 };
static const float cyan[] = { 0, 1, 1, 1 };
GLuint program;
GLenum expected_error;
pass = GL_TRUE;
extension_supported =
piglit_is_extension_supported("GL_EXT_unpack_subimage") ||
(piglit_is_gles() && piglit_get_gl_version() >= 3);
expected_error = extension_supported ? GL_NO_ERROR : GL_INVALID_ENUM;
if (!piglit_automatic) {
if (extension_supported)
printf("GL_EXT_unpack_subimage is supported\n");
else
printf("GL_EXT_unpack_subimage is not supported\n");
}
piglit_reset_gl_error();
if (!piglit_automatic)
printf("Trying GL_UNPACK_ROW_LENGTH\n");
glPixelStorei(GL_UNPACK_ROW_LENGTH, 2);
pass = piglit_check_gl_error(expected_error) && pass;
piglit_reset_gl_error();
if (!piglit_automatic)
printf("Trying GL_UNPACK_SKIP_PIXELS\n");
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 1);
pass = piglit_check_gl_error(expected_error) && pass;
piglit_reset_gl_error();
if (!piglit_automatic)
printf("Trying GL_UNPACK_SKIP_ROWS\n");
glPixelStorei(GL_UNPACK_SKIP_ROWS, 4);
pass = piglit_check_gl_error(expected_error) && pass;
glClear(GL_COLOR_BUFFER_BIT);
/* Try creating a texture with the unpacking parameters we've set */
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D,
0, /* level */
GL_RGBA, /* internalFormat */
1, /* width */
2, /* height */
0, /* border */
GL_RGBA, /* format */
GL_UNSIGNED_BYTE, /* type */
tex_data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
program = piglit_build_simple_program(vertex_shader, fragment_shader);
glUseProgram(program);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
if (extension_supported) {
pass &= piglit_probe_pixel_rgba(piglit_width / 2,
piglit_height / 4,
blue);
pass &= piglit_probe_pixel_rgba(piglit_width / 2,
piglit_height * 3 / 4,
cyan);
} else {
pass &= piglit_probe_pixel_rgba(piglit_width / 2,
piglit_height / 4,
red);
pass &= piglit_probe_pixel_rgba(piglit_width / 2,
piglit_height * 3 / 4,
green);
}
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
