int
main(int argc, char **argv)
{
Display *dpy;
Window win;
XVisualInfo *visinfo;
int i;
int (*old_handler)(Display *, XErrorEvent *);
GLXContext ctx;
int attrib[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER,
None
};
GLXFBConfig config, *configs;
int nconfigs;
for(i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-auto"))
piglit_automatic = 1;
else
fprintf(stderr, "Unknown option: %s\n", argv[i]);
}
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
visinfo = piglit_get_glx_visual(dpy);
win = piglit_get_glx_window(dpy, visinfo);
configs = glXChooseFBConfig(dpy, DefaultScreen(dpy),
attrib, &nconfigs);
assert(nconfigs > 0);
config = configs[0];
XFree(configs);
old_handler = XSetErrorHandler(expect_badvalue);
ctx = glXCreateNewContext(dpy, config, 0x1010, NULL, True);
XSync(dpy, 0);
XSetErrorHandler(old_handler);
if (!found_badvalue) {
printf("Failed to get BadValue from glXCreateContext().\n");
piglit_report_result(PIGLIT_FAIL);
}
if (ctx != NULL) {
glXMakeCurrent(dpy, win, ctx);
piglit_report_result(PIGLIT_PASS);
} else {
piglit_report_result(PIGLIT_SKIP);
}
return 0;
}
void
piglit_oml_sync_control_test_run(bool fullscreen, enum piglit_result (*draw)(Display *dpy))
{
Display *dpy;
GLXContext ctx;
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_require_glx_extension(dpy, "GLX_OML_sync_control");
piglit_glx_get_all_proc_addresses(procs, ARRAY_SIZE(procs));
visinfo = piglit_get_glx_visual(dpy);
if (fullscreen)
win = piglit_get_glx_window_fullscreen(dpy, visinfo);
else
win = piglit_get_glx_window(dpy, visinfo);
ctx = piglit_get_glx_context(dpy, visinfo);
glXMakeCurrent(dpy, win, ctx);
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
XMapWindow(dpy, win);
piglit_glx_event_loop(dpy, draw);
}
int
main(int argc, char **argv)
{
int i;
for(i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-auto"))
piglit_automatic = 1;
else
fprintf(stderr, "Unknown option: %s\n", argv[i]);
}
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
visinfo = piglit_get_glx_visual(dpy);
win = piglit_get_glx_window(dpy, visinfo);
XMapWindow(dpy, win);
piglit_glx_event_loop(dpy, draw);
return 0;
}
int
main(int argc, char **argv)
{
int i;
for(i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-auto"))
piglit_automatic = 1;
else
fprintf(stderr, "Unknown option: %s\n", argv[i]);
}
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_require_glx_extension(dpy, "MESA_copy_sub_buffer");
CopySubBuffer = (PFNGLXCOPYSUBBUFFERMESAPROC)
glXGetProcAddressARB((GLubyte *)"glXCopySubBufferMESA");
visinfo = piglit_get_glx_visual(dpy);
win_one = piglit_get_glx_window(dpy, visinfo);
XMapWindow(dpy, win_one);
piglit_glx_event_loop(dpy, draw);
return 0;
}
int
main(int argc, char **argv)
{
int i;
Pixmap pixmap;
for(i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-auto"))
piglit_automatic = 1;
else
fprintf(stderr, "Unknown option: %s\n", argv[i]);
}
XInitThreads();
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
visinfo = piglit_get_glx_visual(dpy);
draw_win = piglit_get_glx_window(dpy, visinfo);
pixmap = XCreatePixmap(dpy, DefaultRootWindow(dpy),
piglit_width, piglit_height, visinfo->depth);
load_win = glXCreateGLXPixmap(dpy, visinfo, pixmap);
XMapWindow(dpy, draw_win);
piglit_glx_event_loop(dpy, draw);
return 0;
}
int
main(int argc, char **argv)
{
Pixmap p;
GLXPixmap g;
GLXContext ctx;
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_glx_get_error(dpy, NULL);
piglit_require_glx_version(dpy, 1, 3);
visinfo = piglit_get_glx_visual(dpy);
p = XCreatePixmap(dpy, DefaultRootWindow(dpy), piglit_width,
piglit_height, visinfo->depth);
g = glXCreateGLXPixmap(dpy, visinfo, p);
ctx = piglit_get_glx_context(dpy, visinfo);
glXMakeCurrent(dpy, g, ctx);
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
/* Clear to green */
glClearColor(0.0, 1.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
/* Noop */
XSetErrorHandler(handler);
glXSwapBuffers(dpy, p);
/* We want to actually catch any X error that leaks through as
* a result of glXSwapBuffers() before we go saying "pass" or
* "fail".
*/
XSync(dpy, False);
glXDestroyPixmap(dpy, g);
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
return 0;
}
static void
piglit_framework_fbo_glx_init()
{
piglit_glx_dpy = piglit_get_glx_display();
/* Unfortunately in GLX we need a drawable to bind our context
* to. Make an unmapped window.
*/
piglit_glx_visinfo = piglit_get_glx_visual(piglit_glx_dpy);
piglit_glx_context = piglit_get_glx_context(piglit_glx_dpy,
piglit_glx_visinfo);
piglit_glx_window = piglit_get_glx_window_unmapped(piglit_glx_dpy,
piglit_glx_visinfo);
glXMakeCurrent(piglit_glx_dpy, piglit_glx_window, piglit_glx_context);
}
static void *
thread_func(void *arg)
{
Display *dpy;
XVisualInfo *visinfo;
Window win;
unsigned i;
dpy = piglit_get_glx_display();
visinfo = piglit_get_glx_visual(dpy);
win = piglit_get_glx_window(dpy, visinfo);
for (i = 0; i < 100; ++i) {
GLXContext ctx;
GLuint vert_shader, frag_shader;
GLuint program;
ctx = piglit_get_glx_context(dpy, visinfo);
glXMakeCurrent(dpy, win, ctx);
/* Ok, not nice but should be safe due to all threads working
* on the same type of context.
*/
pthread_mutex_lock(&mutex);
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
pthread_mutex_unlock(&mutex);
vert_shader = piglit_compile_shader_text(GL_VERTEX_SHADER, vert_shader_text);
piglit_check_gl_error(GL_NO_ERROR);
frag_shader = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag_shader_text);
piglit_check_gl_error(GL_NO_ERROR);
program = piglit_link_simple_program(vert_shader, frag_shader);
piglit_check_gl_error(GL_NO_ERROR);
glUseProgram(program);
piglit_check_gl_error(GL_NO_ERROR);
glXDestroyContext(dpy, ctx);
}
return NULL;
}
int
main(int argc, char **argv)
{
XVisualInfo *visinfo;
int i;
for (i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-auto"))
piglit_automatic = 1;
else
fprintf(stderr, "Unknown option: %s\n", argv[i]);
}
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
visinfo = piglit_get_glx_visual(dpy);
win = piglit_get_glx_window(dpy, visinfo);
XMapWindow(dpy, win);
for (i = 0; i < num_contexts; i++) {
ctx[i] = piglit_get_glx_context(dpy, visinfo);
}
glXMakeCurrent(dpy, win, ctx[0]);
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
piglit_glx_event_loop(dpy, draw);
XFree(visinfo);
glXDestroyWindow(dpy, win);
for (i = 0; i < num_contexts; i++) {
glXDestroyContext(dpy, ctx[i]);
}
return 0;
}
int main(int argc, char **argv) {
Display *display;
XVisualInfo *visual;
Window window;
GLXContext ctx;
void (*test_func)(Display*, GLXDrawable);
parse_args(argc, argv, &test_func);
display = piglit_get_glx_display();
visual = piglit_get_glx_visual(display);
window = piglit_get_glx_window(display, visual);
ctx = piglit_get_glx_context(display, visual);
glXMakeCurrent(display, window, ctx);
/* Must initialize static variables of this function. */
piglit_glx_get_error(display, NULL);
test_func(display, window);
return 0;
}
void
GLX_ARB_create_context_setup(void)
{
dpy = piglit_get_glx_display();
piglit_require_glx_version(dpy, 1, 4);
piglit_require_glx_extension(dpy, "GLX_ARB_create_context");
__piglit_glXCreateContextAttribsARB =
(PFNGLXCREATECONTEXTATTRIBSARBPROC)
glXGetProcAddress((const GLubyte *)
"glXCreateContextAttribsARB");
assert(__piglit_glXCreateContextAttribsARB != NULL);
visinfo = piglit_get_glx_visual(dpy);
fbconfig = piglit_glx_get_fbconfig_for_visinfo(dpy, visinfo);
win = piglit_get_glx_window_unmapped(dpy, visinfo);
glxWin = glXCreateWindow(dpy, fbconfig, win, NULL);
piglit_glx_get_error(dpy, NULL);
old_handler = XSetErrorHandler(x_error_handler);
}
int
main(int argc, char **argv)
{
int i;
for(i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-auto"))
piglit_automatic = 1;
else
fprintf(stderr, "Unknown option: %s\n", argv[i]);
}
dpy = piglit_get_glx_display();
piglit_require_glx_extension(dpy, "GLX_EXT_buffer_age");
visinfo = piglit_get_glx_visual(dpy);
window = piglit_get_glx_window(dpy, visinfo);
XMapWindow(dpy, window);
piglit_glx_event_loop(dpy, draw);
return 0;
}
int
main(int argc, char **argv)
{
Display *dpy;
XVisualInfo *visinfo;
int i;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-auto") == 0) {
piglit_automatic = 1;
break;
}
}
dpy = XOpenDisplay(NULL);
if (!dpy) {
fprintf(stderr, "Failed to open display\n");
piglit_report_result(PIGLIT_FAIL);
}
visinfo = piglit_get_glx_visual(dpy);
Windows[0] = piglit_get_glx_window(dpy, visinfo);
Windows[1] = piglit_get_glx_window(dpy, visinfo);
XMapWindow(dpy, Windows[0]);
XMapWindow(dpy, Windows[1]);
ctx = piglit_get_glx_context(dpy, visinfo);
glXMakeCurrent(dpy, Windows[0], ctx);
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
piglit_glx_event_loop(dpy, draw);
return 0;
}
int main(int argc, char**argv)
{
XVisualInfo *visinfo;
GLXContext ctx;
int i;
for(i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-auto"))
piglit_automatic = 1;
else
fprintf(stderr, "Unknown option: %s\n", argv[i]);
}
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
visinfo = piglit_get_glx_visual(dpy);
ctx = piglit_get_glx_context(dpy, visinfo);
win = piglit_get_glx_window(dpy, visinfo);
XFree(visinfo);
glXMakeCurrent(dpy, win, ctx);
glewInit();
if (piglit_automatic)
piglit_glx_set_no_input();
XMapWindow(dpy, win);
piglit_require_glx_extension(dpy, "GLX_EXT_texture_from_pixmap");
if (!piglit_is_extension_supported("GL_ARB_texture_env_combine")) {
fprintf(stderr, "Test requires GL_ARB_texture_env_combine\n");
piglit_report_result(PIGLIT_SKIP);
}
pglXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)
glXGetProcAddress((GLubyte *)"glXBindTexImageEXT");
pglXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)
glXGetProcAddress((GLubyte *)"glXReleaseTexImageEXT");
if (pglXBindTexImageEXT == NULL || pglXReleaseTexImageEXT == NULL) {
fprintf(stderr, "Couldn't get TFP functions\n");
piglit_report_result(PIGLIT_FAIL);
exit(1);
}
init();
if (!piglit_automatic) {
printf("Left rectangle (RGB) should be green on the top and\n"
"red on the bottom. The right rectangle (RGBA) should\n"
"be the same, but darker on the right half.\n");
printf("Press Escape to quit\n");
}
piglit_glx_event_loop(dpy, draw);
return 0;
}
int
main(int argc, char **argv)
{
Pixmap p;
GLXPixmap g;
static const float green_alpha_zero[4] = {0.0, 1.0, 0.0, 0.0};
static const float green_alpha_one[4] = {0.0, 1.0, 0.0, 1.0};
GLXContext ctx;
bool pass;
GLint alpha_bits;
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_glx_get_error(dpy, NULL);
piglit_require_glx_version(dpy, 1, 3);
visinfo = piglit_get_glx_visual(dpy);
p = XCreatePixmap(dpy, DefaultRootWindow(dpy), piglit_width,
piglit_height, visinfo->depth);
g = glXCreateGLXPixmap(dpy, visinfo, p);
ctx = piglit_get_glx_context(dpy, visinfo);
glXMakeCurrent(dpy, g, ctx);
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
/* Clear to green */
glClearColor(0.0, 1.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
/* Noop */
glXSwapBuffers(dpy, g);
/* We want to actually catch any X error that leaks through as
* a result of glXSwapBuffers() before we go saying "pass" or
* "fail".
*/
XSync(dpy, False);
/* If the visual has no alpha, then the GL spec requires that 1.0 be
* read back. Otherwise, we should read back the 0.0 that we wrote.
*/
glGetIntegerv(GL_ALPHA_BITS, &alpha_bits);
if (alpha_bits == 0) {
pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height,
green_alpha_one);
} else {
pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height,
green_alpha_zero);
}
glXDestroyPixmap(dpy, g);
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
return 0;
}
void GLX_EXT_import_context_setup(void)
{
const char *const names[] = {
"glXGetCurrentDisplayEXT",
"glXQueryContextInfoEXT",
"glXGetContextIDEXT",
"glXImportContextEXT",
"glXFreeContextEXT"
};
__GLXextFuncPtr *procedures[ARRAY_SIZE(names)] = {
(__GLXextFuncPtr *) & __piglit_glXGetCurrentDisplayEXT,
(__GLXextFuncPtr *) & __piglit_glXQueryContextInfoEXT,
(__GLXextFuncPtr *) & __piglit_glXGetContextIDEXT,
(__GLXextFuncPtr *) & __piglit_glXImportContextEXT,
(__GLXextFuncPtr *) & __piglit_glXFreeContextEXT
};
const char *vendor;
dpy = piglit_get_glx_display();
/* NVIDIA incorrectly only list the extension in the client
* extenstions list. If the extension is available for applications
* to use, it is supposed to be included in the list returned by
* glXQueryExtensionsString.
*
* The glXImportContextEXT manual page is somewhat clear on this
* topic:
*
* "If _glxextstring(EXT_import_context) is included in the string
* returned by glXQueryExtensionsString, when called with argument
* GLX_EXTENSIONS, extension EXT_import_context is supported."
*
* The text is a little weird because the only parameters to
* glXQueryExtensionsString are the display and the screen.
*/
vendor = glXGetClientString(dpy, GLX_VENDOR);
if (strcmp("NVIDIA Corporation", vendor) == 0) {
const char *const client_extensions =
glXGetClientString(dpy, GLX_EXTENSIONS);
if (!piglit_is_extension_in_string(client_extensions,
"GLX_EXT_import_context")) {
fprintf(stderr,
"Test requires GLX_EXT_import_context.\n");
piglit_report_result(PIGLIT_SKIP);
}
} else {
piglit_require_glx_extension(dpy, "GLX_EXT_import_context");
}
piglit_glx_get_all_proc_addresses(procedures, names, ARRAY_SIZE(names));
visinfo = piglit_get_glx_visual(dpy);
directCtx = glXCreateContext(dpy, visinfo, NULL, True);
if (directCtx == NULL) {
fprintf(stderr,
"Could not create initial direct-rendering context.\n");
piglit_report_result(PIGLIT_FAIL);
}
if (!glXIsDirect(dpy, directCtx)) {
glXDestroyContext(dpy, directCtx);
directCtx = NULL;
}
indirectCtx = glXCreateContext(dpy, visinfo, NULL, False);
if (indirectCtx == NULL) {
fprintf(stderr,
"Could not create initial indirect-rendering "
"context.\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_glx_get_error(dpy, NULL);
old_handler = XSetErrorHandler(x_error_handler);
}
