int main(int argc, char **argv) { int i, samples = 0; for(i = 1; i < argc; ++i) { if (!strcmp(argv[i], "-auto")) piglit_automatic = 1; else if (!strncmp(argv[i], "-samples=", 9)) { samples = atoi(argv[i]+9); } 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, "GLX_MESA_copy_sub_buffer"); CopySubBuffer = (PFNGLXCOPYSUBBUFFERMESAPROC) glXGetProcAddressARB((GLubyte *)"glXCopySubBufferMESA"); visinfo = get_glx_visual(dpy, samples); win_one = piglit_get_glx_window(dpy, visinfo); XMapWindow(dpy, win_one); piglit_glx_event_loop(dpy, draw); 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); }
enum piglit_result draw(Display *dpy) { GLboolean pass = GL_TRUE; float green[] = {0.0, 1.0, 0.0, 1.0}; float blue[] = {0.0, 0.0, 1.0, 1.0}; float gray[] = {0.5, 0.5, 0.5, 1.0}; pthread_t thread1, thread2; void *retval; int ret; int x1 = 10, x2 = 30; ctx = piglit_get_glx_context(dpy, visinfo); glXMakeCurrent(dpy, win, ctx); glewInit(); piglit_require_glx_extension(dpy, "MESA_multithread_makecurrent"); /* Clear background to gray */ glClearColor(0.5, 0.5, 0.5, 1.0); glClear(GL_COLOR_BUFFER_BIT); piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); pthread_mutex_init(&mutex, NULL); /* Now, spawn some threads that do some drawing, both with this * context */ pthread_create(&thread1, NULL, thread1_func, &x1); pthread_create(&thread2, NULL, thread2_func, &x2); ret = pthread_join(thread1, &retval); assert(ret == 0); ret = pthread_join(thread2, &retval); assert(ret == 0); pthread_mutex_destroy(&mutex); glColor4f(0.0, 1.0, 0.0, 0.0); piglit_draw_rect(50, 10, 10, 10); pass &= piglit_probe_rect_rgba( 0, 10, 10, 10, gray); pass &= piglit_probe_rect_rgba(10, 10, 10, 10, green); pass &= piglit_probe_rect_rgba(20, 10, 10, 10, gray); pass &= piglit_probe_rect_rgba(30, 10, 10, 10, blue); pass &= piglit_probe_rect_rgba(40, 10, 10, 10, gray); pass &= piglit_probe_rect_rgba(50, 10, 10, 10, green); pass &= piglit_probe_rect_rgba(60, 10, 10, 10, gray); pass &= piglit_probe_rect_rgba(0, 0, piglit_width, 10, gray); pass &= piglit_probe_rect_rgba(0, 20, piglit_width, 10, gray); glXSwapBuffers(dpy, win); glXMakeCurrent(dpy, None, None); glXDestroyContext(dpy, ctx); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
int main(int argc, char **argv) { bool pass = true; uint32_t i; GLX_ARB_create_context_setup(); piglit_require_glx_extension(dpy, "GLX_ARB_create_context_profile"); /* The GLX_ARB_create_context_profile spec says: * * "* If attribute GLX_CONTEXT_PROFILE_MASK_ARB has no bits set; * has any bits set other than GLX_CONTEXT_CORE_PROFILE_BIT_ARB * and GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; has more than * one of these bits set...then GLXBadProfileARB is generated." */ pass = try_profile(0) && pass; pass = try_profile(GLX_CONTEXT_CORE_PROFILE_BIT_ARB | GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB) && pass; /* This loop will need to be modified as new profiles are defined by * the GLX spec. The conditional code below for * GLX_EXT_create_context_es2_profile is an example of how this should * be handled. */ for (i = 0x00000008; i != 0; i <<= 1) { pass = try_profile(i) && pass; } if (!piglit_is_glx_extension_supported(dpy, "GLX_EXT_create_context_es2_profile")) { pass = try_profile(GLX_CONTEXT_ES2_PROFILE_BIT_EXT) && pass; } GLX_ARB_create_context_teardown(); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); return 0; }
int main(int argc, char **argv) { bool pass = true; GLX_ARB_create_context_setup(); piglit_require_glx_extension(dpy, "GLX_ARB_create_context_robustness"); /* The GLX_ARB_create_context_robustness spec says: * * "If the GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB bit is set in * GLX_CONTEXT_FLAGS_ARB, then a context supporting <robust buffer * access> will be created. Robust buffer access is defined in the * GL_ARB_robustness extension specification, and the resulting * context must also support either the GL_ARB_robustness * extension, or a version of OpenGL incorporating equivalent * functionality." * * It also says: * * "The attribute name GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB * specifies the <reset notification behavior> of the rendering * context. Reset notification behavior is defined in the * GL_ARB_robustness extension specification, and the resulting * context must also support either the GL_ARB_robustness * extension, or a version of OpenGL incorporating equivalent * functionality." */ pass = try_context(GLX_NO_RESET_NOTIFICATION_ARB, GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB) && pass; pass = try_context(GLX_LOSE_CONTEXT_ON_RESET_ARB, 0) && pass; pass = try_context(GLX_LOSE_CONTEXT_ON_RESET_ARB, GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB) && pass; GLX_ARB_create_context_teardown(); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); 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) { 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; }
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); }
int main(int argc, char **argv) { static const int attribs[] = { GLX_CONTEXT_MAJOR_VERSION_ARB, 2, GLX_CONTEXT_MINOR_VERSION_ARB, 0, GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_ES2_PROFILE_BIT_EXT, None }; bool pass = true; GLXContext ctx; GLX_ARB_create_context_setup(); piglit_require_glx_extension(dpy, "GLX_ARB_create_context_profile"); piglit_require_glx_extension(dpy, "GLX_EXT_create_context_es2_profile"); /* The GLX_EXT_create_context_es2_profile doesn't say anything about * indirect-rendering contexts for ES2. However, there is no protocol * defined, so it seems impossible that this could ever work. */ ctx = glXCreateContextAttribsARB(dpy, fbconfig, NULL, False, attribs); XSync(dpy, 0); if (ctx != NULL) { PFNGLGETSHADERPRECISIONFORMATPROC func; GLint r[] = { ~0, ~0 }; GLint p = ~0; /* Try to call an ES2 function that does not exist in desktop * OpenGL or have GLX protocol defined. If this works, then * we'll assume the implementation is using some magic * protocol for ES2. If it doesn't work, then the test fails. */ func = (PFNGLGETSHADERPRECISIONFORMATPROC) glXGetProcAddress((const GLubyte *) "glGetShaderPrecisionFormat"); if (func == NULL) { fprintf(stderr, "Indirect rendering OpenGL ES 2.0 context was " "created, but could not get\n" "function address for " "glGetShaderPrecisionFormat.\n"); pass = false; goto done; } if (!glXMakeCurrent(dpy, glxWin, ctx)) { fprintf(stderr, "Indirect rendering OpenGL ES 2.0 " "context was created, but\n" "it could not be made current.\n"); pass = false; goto done; } (*func)(GL_VERTEX_SHADER, GL_MEDIUM_FLOAT, r, &p); if (r[0] < 14 || r[1] < 14 || p < 10) { fprintf(stderr, "Indirect rendering OpenGL ES 2.0 " "context was created, but\n" "glGetShaderPrecisionFormat produced " "incorrect results.\n"); pass = false; } } else { /* The GLX_ARB_create_context_profile spec says: * * "* If <config> does not support compatible OpenGL * contexts providing the requested API major and minor * version, forward-compatible flag, and debug context * flag, GLXBadFBConfig is generated." */ if (!validate_glx_error_code(Success, GLXBadFBConfig)) pass = false; } done: if (ctx != NULL) { glXMakeCurrent(dpy, None, NULL); glXDestroyContext(dpy, ctx); } GLX_ARB_create_context_teardown(); piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); return 0; }