void piglit_init(int argc, char **argv)
{
bool pass = true;
GLuint fb;
GLuint tex;
piglit_require_extension("GL_ARB_framebuffer_object");
glGenTextures(1, &tex);
glGenFramebuffers(1, &fb);
glBindTexture(GL_TEXTURE_2D, tex);
glBindFramebuffer(GL_FRAMEBUFFER, fb);
glTexImage2D(GL_TEXTURE_2D,
0, /*level*/
GL_DEPTH_STENCIL,
200, 200, /*width, height*/
0, /*border*/
GL_DEPTH_STENCIL,
GL_UNSIGNED_INT_24_8,
NULL);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER,
GL_DEPTH_STENCIL_ATTACHMENT,
GL_TEXTURE_2D,
tex,
0); /*level*/
pass = piglit_check_gl_error(0) && pass;
pass = check_attachment(GL_DEPTH_ATTACHMENT, tex) && pass;
pass = check_attachment(GL_STENCIL_ATTACHMENT, tex) && pass;
pass = check_attachment(GL_DEPTH_STENCIL_ATTACHMENT, tex) && pass;
pass = piglit_check_gl_error(0) && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
/**
* Conformance test #1 in the EGL_EXT_client_extensions spec:
*
* 1. Before any call to eglGetDisplay, call `eglQueryString(EGL_NO_DISPLAY,
* EGL_EXTENSIONS)`. Verify that either
*
* a. The call returns NULL and generates EGL_BAD_DISPLAY.
* b. The call returns an extension string that contains, at a minimum,
* this extension and generates no error.
*/
static void
test_1(void)
{
enum piglit_result result = PIGLIT_PASS;
const char *client_extensions;
printf("Making process's first EGL call, "
"eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS) ...\n");
client_extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
if (client_extensions == NULL) {
printf("Returned NULL\n");
if (piglit_check_egl_error(EGL_BAD_DISPLAY)) {
printf("And correctly emitted EGL_BAD_DISPLAY\n");
} else {
printf("But did not emit EGL_BAD_DISPLAY\n");
result = PIGLIT_FAIL;
}
} else {
printf("Returned a non-null extension string\n");
if (!piglit_check_egl_error(EGL_SUCCESS)) {
result = PIGLIT_FAIL;
}
if (!piglit_is_extension_in_string(client_extensions,
"EGL_EXT_client_extensions")) {
printf("But it does not contain "
"EGL_EXT_client_extensions\n");
result = PIGLIT_FAIL;
} else {
printf("And contains EGL_EXT_client_extensions "
"as expected\n");
}
}
piglit_report_result(result);
}
static GLuint
make_vao(void)
{
static const float pos_tc[12][2] = {
{ -1.0, -1.0 },
{ 0.0, -1.0 },
{ 0.0, 1.0 },
{ 0.0, 1.0 },
{ -1.0, 1.0 },
{ -1.0, -1.0 },
{ -1.0, -1.0 },
{ 1.0, -1.0 },
{ 1.0, 1.0 },
{ 1.0, 1.0 },
{ -1.0, 1.0 },
{ -1.0, -1.0 }
};
const int stride = sizeof(pos_tc[0]);
GLuint vbo, vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(pos_tc), pos_tc, GL_STATIC_DRAW);
piglit_check_gl_error(GL_NO_ERROR);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, stride, (void *) 0);
glEnableVertexAttribArray(0);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
piglit_report_result(PIGLIT_FAIL);
}
return vbo;
}
PIGLIT_GL_TEST_CONFIG_END
void
piglit_init(int argc, char **argv)
{
static const GLubyte ubytes[4] = { 255, 0, 0, 127 };
bool pass = true;
GLint size;
piglit_require_gl_version(20);
piglit_require_extension("GL_ARB_vertex_array_bgra");
glColorPointer(GL_BGRA, GL_UNSIGNED_BYTE, sizeof ubytes, ubytes);
size = 0;
glGetIntegerv(GL_COLOR_ARRAY_SIZE, &size);
if (size != GL_BGRA) {
fprintf(stderr, "glGetIntegerv(GL_COLOR_ARRAY_SIZE) returned %i, GL_BGRA expected\n", size);
pass = false;
}
glSecondaryColorPointer(GL_BGRA, GL_UNSIGNED_BYTE, sizeof ubytes, ubytes);
size = 0;
glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_SIZE, &size);
if (size != GL_BGRA) {
fprintf(stderr, "glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_SIZE) returned %i, GL_BGRA expected\n", size);
pass = false;
}
glVertexAttribPointer(1, GL_BGRA, GL_UNSIGNED_BYTE, GL_TRUE, sizeof ubytes, ubytes);
size = 0;
glGetVertexAttribiv(1, GL_VERTEX_ATTRIB_ARRAY_SIZE, &size);
if (size != GL_BGRA) {
fprintf(stderr, "glGetVertexAttribiv(GL_VERTEX_ATTRIB_ARRAY_SIZE) returned %i, GL_BGRA expected\n", size);
pass = false;
}
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
static void
init(void)
{
if (piglit_is_extension_supported("GL_ARB_vertex_shader")) {
glGetIntegerv(GL_MAX_TEXTURE_COORDS, &MaxTextureCoordUnits);
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &MaxTextureImageUnits);
glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &MaxTextureVertexUnits);
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &MaxTextureCombinedUnits);
}
else if (piglit_is_extension_supported("GL_ARB_fragment_shader") ||
piglit_is_extension_supported("GL_ARB_fragment_program")) {
glGetIntegerv(GL_MAX_TEXTURE_COORDS, &MaxTextureCoordUnits);
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &MaxTextureImageUnits);
MaxTextureVertexUnits = 0;
MaxTextureCombinedUnits = MaxTextureImageUnits;
}
else {
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &MaxTextureCoordUnits);
MaxTextureImageUnits =
MaxTextureCombinedUnits = MaxTextureCoordUnits;
MaxTextureVertexUnits = 0;
}
report_info();
if (MaxTextureCombinedUnits > MAX_UNITS) {
/* Need to increase the MAX_UNITS limit */
piglit_report_result(PIGLIT_WARN);
}
generate_random_numbers();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
const struct uniform_type *
get_transposed_type(const struct uniform_type *type)
{
const char *name = NULL;
int i;
switch (type->gl_type) {
case GL_FLOAT_MAT2x3:
name = "mat3x2";
break;
case GL_FLOAT_MAT2x4:
name = "mat4x2";
break;
case GL_FLOAT_MAT3x2:
name = "mat2x3";
break;
case GL_FLOAT_MAT3x4:
name = "mat4x3";
break;
case GL_FLOAT_MAT4x2:
name = "mat2x4";
break;
case GL_FLOAT_MAT4x3:
name = "mat3x4";
break;
default:
return type;
}
for (i = 0; uniform_types[i].type; i++) {
if (strcmp(uniform_types[i].type, name) == 0)
return &uniform_types[i];
}
printf("failed lookup of %s\n", name);
piglit_report_result(PIGLIT_FAIL);
return type;
}
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-preprocessor-comments.vert");
fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
"shaders/glsl-preprocessor-comments.frag");
prog = piglit_link_simple_program(vs, fs);
glUseProgram(prog);
args1_location = glGetUniformLocation(prog, "args1");
}
void
piglit_init(int argc, char **argv)
{
const GLenum expect = (piglit_is_extension_supported("GL_ARB_geometry_shader4")
|| piglit_is_extension_supported("GL_EXT_geometry_shader4")
|| piglit_is_extension_supported("GL_NV_geometry_shader4"))
? 0 : GL_INVALID_ENUM;
GLboolean pass;
piglit_require_gl_version(20);
piglit_require_extension("GL_EXT_separate_shader_objects");
pass = try_UseShaderProgram(GL_PROXY_TEXTURE_3D, GL_INVALID_ENUM);
pass = try_UseShaderProgram(GL_VERTEX_SHADER, 0)
&& pass;
pass = try_UseShaderProgram(GL_FRAGMENT_SHADER, 0)
&& pass;
pass = try_UseShaderProgram(GL_GEOMETRY_SHADER_ARB, expect)
&& pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
GLuint bo;
piglit_require_extension("GL_ARB_vertex_type_10f_11f_11f_rev");
/* a small temporary bo for tests to work with. content doesn't matter,
* we won't be rendering from it. */
glGenBuffers(1, &bo);
glBindBuffer(GL_ARRAY_BUFFER, bo);
glBufferData(GL_ARRAY_BUFFER, 64, (GLvoid const *)0, GL_STATIC_DRAW);
if (piglit_is_extension_supported("GL_ARB_vertex_attrib_binding")) {
pass = test_vertex_attrib_format() && pass;
}
pass = test_legacy_vertex_attribs() && pass;
pass = test_vertex_attribs() && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
XVisualInfo *
get_single_buffer_visual(Display *dpy)
{
XVisualInfo *visinfo;
int attrib[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_ALPHA_SIZE, 1,
None
};
int screen = DefaultScreen(dpy);
visinfo = glXChooseVisual(dpy, screen, attrib);
if (visinfo == NULL) {
fprintf(stderr,
"Couldn't get a single buffered, RGBA visual\n");
piglit_report_result(PIGLIT_SKIP);
}
return visinfo;
}
XVisualInfo *
piglit_get_glx_visual(Display *dpy)
{
XVisualInfo *visinfo;
int attrib[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER,
None
};
int screen = DefaultScreen(dpy);
visinfo = glXChooseVisual(dpy, screen, attrib);
if (visinfo == NULL) {
fprintf(stderr,
"Couldn't get an RGBA, double-buffered visual\n");
piglit_report_result(PIGLIT_FAIL);
}
return visinfo;
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
/* The first 5 indices should be ignored */
const unsigned indices[6] = {0, 0, 0, 0, 0, 1};
piglit_require_extension("GL_ARB_shader_subroutine");
piglit_require_extension("GL_ARB_explicit_uniform_location");
piglit_require_extension("GL_ARB_explicit_attrib_location");
prog = piglit_build_simple_program(NULL, frag_shader_text);
glUseProgram(prog);
glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 6, indices);
if (!piglit_check_gl_error(0)) {
pass = false;
}
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
GLint num;
int i;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "clear") == 0) {
puts("Testing glClear.");
test_clear = GL_TRUE;
}
}
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
piglit_require_extension("GL_EXT_framebuffer_object");
piglit_require_extension("GL_ARB_draw_buffers");
piglit_require_extension("GL_EXT_draw_buffers2");
glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &num);
if (num < 2)
piglit_report_result(PIGLIT_SKIP);
}
static GLuint link_program(GLuint vs, GLuint fs)
{
GLuint program;
GLint status;
program = glCreateProgramObjectARB();
if (vs)
glAttachObjectARB(program, vs);
if (fs)
glAttachObjectARB(program, fs);
glLinkProgramARB(program);
glGetObjectParameterivARB(program, GL_OBJECT_LINK_STATUS_ARB, &status);
if (!status) {
GLchar log[1000];
GLsizei len;
glGetInfoLogARB(program, 1000, &len, log);
fprintf(stderr, "Error: problem linking program: %s\n", log);
piglit_report_result(PIGLIT_FAIL);
}
return program;
}
void
piglit_init(int argc, char **argv)
{
GLuint buffer;
double ssbo_values[SSBO_SIZE] = {0};
piglit_require_extension("GL_ARB_shader_storage_buffer_object");
piglit_require_GLSL_version(400);
prog = piglit_build_simple_program(vs_pass_thru_text, fs_source);
glUseProgram(prog);
glClearColor(0, 0, 0, 1);
glGenBuffers(1, &buffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, buffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, SSBO_SIZE*sizeof(GLdouble),
&ssbo_values[0], GL_DYNAMIC_DRAW);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
}
int
main(int argc, char **argv)
{
int ret;
pthread_t thread1, thread2;
pthread_mutex_init(&mutex, NULL);
/* Now, spawn some threads that compile simple shaders.
*/
pthread_create(&thread1, NULL, thread_func, NULL);
pthread_create(&thread2, NULL, thread_func, NULL);
ret = pthread_join(thread1, NULL);
assert(ret == 0);
ret = pthread_join(thread2, NULL);
assert(ret == 0);
pthread_mutex_destroy(&mutex);
piglit_report_result(PIGLIT_PASS);
return 0;
}
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)
{
piglit_require_extension("GL_ARB_vertex_program");
printf("%-50s %8s %8s\n", "token", "minimum", "value");
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, 96);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, 96);
MIN_INTEGER_TEST(GL_MAX_PROGRAM_MATRICES_ARB, 8);
MIN_INTEGER_TEST(GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, 1);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_INSTRUCTIONS_ARB, 128);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_TEMPORARIES_ARB, 12);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_PARAMETERS_ARB, 96);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_ATTRIBS_ARB, 16);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB, 1);
/* No specified minimum, but test that we can query them anyway. */
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, 0);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, 0);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, 0);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, 0);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, 0);
/* See the GL_ARB_fragment_program specification for this
* consistency requirement.
*/
if (piglit_is_extension_supported("GL_ARB_fragment_program")) {
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, 0);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, 0);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, 0);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, 0);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, 0);
MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, 0);
}
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
static bool
test_glBlitFramebuffer(const GLenum drawbufs[4])
{
GLuint rb, readfb;
GLenum status;
/* Create a new renderbuffer and attach it to a new FBO. */
glGenRenderbuffers(1, &rb);
glBindRenderbuffer(GL_RENDERBUFFER, rb);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, FB_SIZE, FB_SIZE);
glGenFramebuffers(1, &readfb);
glBindFramebuffer(GL_FRAMEBUFFER, readfb);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, rb);
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) {
fprintf(stderr,
"Framebuffer with color"
"attachment was not complete: 0x%04x\n",
status);
piglit_report_result(PIGLIT_FAIL);
}
/* Clear the renderbuffer to red. */
glClearColor(1, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
/* Blit the renderbuffer to our FBO with MRT. */
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb);
glBlitFramebuffer(0, 0, FB_SIZE, FB_SIZE, 0, 0, FB_SIZE, FB_SIZE,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_FRAMEBUFFER, fb);
return probe_buffers(drawbufs, colors_all_red);
}
int main(int argc, char **argv)
{
static const int invalid_render_types[] = {
GLX_COLOR_INDEX_BIT,
GLX_RGBA_BIT,
GLX_RGBA_FLOAT_BIT_ARB,
GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT,
0,
-1,
~GLX_RGBA_TYPE,
~GLX_COLOR_INDEX_TYPE
};
bool pass = true;
unsigned i;
GLX_ARB_create_context_setup();
for (i = 0; i < ARRAY_SIZE(invalid_render_types); i++) {
pass = try_render_type(invalid_render_types[i])
&& pass;
}
if (!piglit_is_glx_extension_supported(dpy, "GLX_ARB_fbconfig_float")) {
pass = try_render_type(GLX_RGBA_FLOAT_TYPE_ARB)
&& pass;
}
if (!piglit_is_glx_extension_supported(dpy, "GLX_EXT_fbconfig_packed_float")) {
pass = try_render_type(GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT)
&& pass;
}
GLX_ARB_create_context_teardown();
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
return 0;
}
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)
{
bool pass = true;
piglit_require_extension("GL_ARB_texture_storage");
piglit_require_extension("GL_ARB_texture_view");
piglit_require_extension("GL_ARB_texture_cube_map_array");
piglit_require_extension("GL_EXT_texture_array");
piglit_require_extension("GL_ARB_texture_rectangle");
if (piglit_get_gl_version() < 31)
piglit_require_extension("GL_ARB_texture_cube_map");
X(test_target_errors(GL_TEXTURE_1D), "1D tex target validity");
X(test_target_errors(GL_TEXTURE_2D), "2D tex target validity");
X(test_target_errors(GL_TEXTURE_3D), "3D tex target validity");
X(test_target_errors(GL_TEXTURE_CUBE_MAP),
"Cubemap tex target validity");
X(test_target_errors(GL_TEXTURE_RECTANGLE),
"Rectangle tex target validity");
X(test_target_errors(GL_TEXTURE_1D_ARRAY),
"1D Array tex target validity");
X(test_target_errors(GL_TEXTURE_2D_ARRAY),
"2D Array tex target validity");
X(test_target_errors(GL_TEXTURE_CUBE_MAP_ARRAY),
"Cubemap Array tex target validity");
if (piglit_is_extension_supported("GL_ARB_texture_storage_multisample")) {
X(test_target_errors(GL_TEXTURE_2D_MULTISAMPLE),
"Multisample 2D tex target validity");
X(test_target_errors(GL_TEXTURE_2D_MULTISAMPLE_ARRAY),
"Multisample 2D array tex target 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)
{
GLuint tex;
int i, texf;
enum piglit_result result = PIGLIT_SKIP;
/* Note: We test later extensions by testing them against all
* combinations of (storage format, read format) including the
* formats from previous extensions.
*/
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "GL_ARB_texture_rg") == 0) {
piglit_require_extension(argv[i]);
test_rg = true;
} else if (strcmp(argv[i], "GL_ARB_texture_rgb10_a2ui") == 0) {
piglit_require_extension(argv[i]);
test_rg = true;
test_rgb10_a2ui = true;
} else {
usage();
exit(1);
}
}
piglit_require_extension("GL_EXT_texture_integer");
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
for (texf = 0; texf < ARRAY_SIZE(formats); texf++)
piglit_merge_result(&result, test_format(&formats[texf]));
piglit_report_result(result);
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
int i;
const int buffer_size = 3<<20;
unsigned int buffer;
piglit_require_extension("GL_ARB_clear_buffer_object");
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER, buffer_size, NULL, GL_STREAM_READ);
for (i = 0; i < ARRAY_SIZE(formats); ++i)
pass = test_format(i) && pass;
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &buffer);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
int main(int argc, char **argv)
{
bool pass = true;
pid_t child;
int status;
GLX_EXT_import_context_setup();
get_context_IDs();
child = fork();
if (child == 0) {
GLX_EXT_import_context_setup_for_child();
pass = try_import_context(directID, direct_rendering)
&& pass;
pass = try_import_context(indirectID, indirect_rendering)
&& pass;
pass = try_import_context(None, invalid)
&& pass;
pass = try_import_context(0xDEADBEEF, invalid)
&& pass;
exit(pass ? 0 : 1);
}
/* The test passes if the child exited normally with a return value of
* zero.
*/
waitpid(child, &status, 0);
pass = WIFEXITED(status) && (WEXITSTATUS(status) == 0);
GLX_EXT_import_context_teardown();
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
return 0;
}
int
piglit_cl_get_device_cl_c_version(cl_device_id device)
{
char* version_string;
const char *version_number_string;
int scanf_count;
int major;
int minor;
/* OpenCL 1.0 does not have enum CL_DEVICE_OPENCL_C_VERSION */
if(piglit_cl_get_device_version(device) == 10) {
return 10;
}
/*
* Returned format:
* OpenCL<space>C<space><major_version.minor_version><space><vendor-specific information>
*/
version_string = piglit_cl_get_device_info(device,
CL_DEVICE_OPENCL_C_VERSION);
/* skip to version number */
version_number_string = version_string + 8;
/* Interpret version number */
scanf_count = sscanf(version_number_string, "%i.%i", &major, &minor);
if (scanf_count != 2) {
printf("Unable to interpret CL_DEVICE_OPENCL_C_VERSION string: %s\n",
version_string);
free(version_string);
piglit_report_result(PIGLIT_FAIL);
}
free(version_string);
return 10*major+minor;
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
unsigned int i;
GLuint prog;
piglit_require_extension("GL_ARB_shading_language_420pack");
piglit_require_extension("GL_ARB_uniform_buffer_object");
prog = piglit_build_simple_program(NULL, source);
for (i = 0; i < ARRAY_SIZE(uniforms); i++) {
GLuint index;
GLint row_major;
glGetUniformIndices(prog, 1, &uniforms[i].name, &index);
if (index == GL_INVALID_INDEX) {
printf("Failed to get index for %s\n",
uniforms[i].name);
pass = false;
continue;
}
glGetActiveUniformsiv(prog, 1, &index, GL_UNIFORM_IS_ROW_MAJOR,
&row_major);
if (row_major != uniforms[i].row_major) {
fprintf(stderr, "Uniform %s should %sbe row major\n",
uniforms[i].name,
uniforms[i].row_major ? "" : "not ");
pass = false;
}
}
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void
piglit_init(int argc, char **argv)
{
if (argc == 2) {
unsigned i;
for (i = 0; i < ARRAY_SIZE(target); i++) {
if (strcmp(target[i].name, argv[1]) == 0) {
test_target = i;
if (!supported_target(i)) {
printf("Test requires OpenGL %1.1f", target[i].gl_version * 0.1);
if (target[i].extension)
printf(" or %s", target[i].extension);
printf(".\n");
piglit_report_result(PIGLIT_SKIP);
}
break;
}
}
}
glClearColor(0.0, 0.0, 0.0, 1.0);
piglit_ortho_projection(piglit_width, piglit_height, GL_TRUE);
}
void
piglit_init(int argc, char **argv)
{
GLuint vs;
GLuint fs;
GLboolean ok;
piglit_require_vertex_shader();
piglit_require_fragment_shader();
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");
glLinkProgram(prog);
ok = piglit_link_check_status(prog);
if (!ok)
piglit_report_result(PIGLIT_FAIL);
glUseProgram(prog);
glClearColor(blue[0], blue[1], blue[2], blue[3]);
}
void
piglit_init(int argc, char **argv)
{
GLuint vs;
piglit_require_gl_version(20);
glClearColor(0.3, 0.3, 0.3, 0.0);
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text);
prog = piglit_link_simple_program(vs, 0);
glDeleteShader(vs);
/* 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);
}
