1 /* 2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) 3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice including the dates of first publication and 13 * either this permission notice or a reference to 14 * http://oss.sgi.com/projects/FreeB/ 15 * shall be included in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF 22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 * SOFTWARE. 24 * 25 * Except as contained in this notice, the name of Silicon Graphics, Inc. 26 * shall not be used in advertising or otherwise to promote the sale, use or 27 * other dealings in this Software without prior written authorization from 28 * Silicon Graphics, Inc. 29 */ 30 31 /** 32 * \file glxclient.h 33 * Direct rendering support added by Precision Insight, Inc. 34 * 35 * \author Kevin E. Martin <kevin@precisioninsight.com> 36 */ 37 38 #ifndef _GLX_client_h_ 39 #define _GLX_client_h_ 40 #include <X11/Xproto.h> 41 #include <X11/Xlibint.h> 42 #include <X11/Xfuncproto.h> 43 #include <X11/extensions/extutil.h> 44 #define GLX_GLXEXT_PROTOTYPES 45 #include <GL/glx.h> 46 #include <GL/glxext.h> 47 #include <string.h> 48 #include <stdlib.h> 49 #include <stdio.h> 50 #include <stdint.h> 51 #include <pthread.h> 52 #include "GL/glxproto.h" 53 #include "glxconfig.h" 54 #include "glxhash.h" 55 #include "util/macros.h" 56 #include "util/u_thread.h" 57 #include "loader.h" 58 #include "glxextensions.h" 59 60 #if defined(USE_LIBGLVND) 61 #define _GLX_PUBLIC _X_HIDDEN 62 #else 63 #define _GLX_PUBLIC _X_EXPORT 64 #endif 65 66 #ifdef __cplusplus 67 extern "C" { 68 #endif 69 70 extern void glx_message(int level, const char *f, ...) PRINTFLIKE(2, 3); 71 72 #define DebugMessageF(...) glx_message(_LOADER_DEBUG, __VA_ARGS__) 73 #define InfoMessageF(...) glx_message(_LOADER_INFO, __VA_ARGS__) 74 #define ErrorMessageF(...) glx_message(_LOADER_WARNING, __VA_ARGS__) 75 #define CriticalErrorMessageF(...) glx_message(_LOADER_FATAL, __VA_ARGS__) 76 77 78 #define GLX_MAJOR_VERSION 1 /* current version numbers */ 79 #define GLX_MINOR_VERSION 4 80 81 struct glx_display; 82 struct glx_context; 83 84 /************************************************************************/ 85 86 #ifdef GLX_DIRECT_RENDERING 87 88 extern void DRI_glXUseXFont(struct glx_context *ctx, 89 Font font, int first, int count, int listbase); 90 91 #endif 92 93 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 94 95 /** 96 * Display dependent methods. This structure is initialized during the 97 * \c driCreateDisplay call. 98 */ 99 typedef struct __GLXDRIdisplayRec __GLXDRIdisplay; 100 typedef struct __GLXDRIscreenRec __GLXDRIscreen; 101 typedef struct __GLXDRIdrawableRec __GLXDRIdrawable; 102 103 struct __GLXDRIdisplayRec 104 { 105 /** 106 * Method to destroy the private DRI display data. 107 */ 108 void (*destroyDisplay) (__GLXDRIdisplay * display); 109 110 struct glx_screen *(*createScreen)(int screen, struct glx_display * priv); 111 }; 112 113 struct __GLXDRIscreenRec { 114 115 void (*destroyScreen)(struct glx_screen *psc); 116 117 __GLXDRIdrawable *(*createDrawable)(struct glx_screen *psc, 118 XID drawable, 119 GLXDrawable glxDrawable, 120 struct glx_config *config); 121 122 int64_t (*swapBuffers)(__GLXDRIdrawable *pdraw, int64_t target_msc, 123 int64_t divisor, int64_t remainder, Bool flush); 124 void (*copySubBuffer)(__GLXDRIdrawable *pdraw, 125 int x, int y, int width, int height, Bool flush); 126 int (*getDrawableMSC)(struct glx_screen *psc, __GLXDRIdrawable *pdraw, 127 int64_t *ust, int64_t *msc, int64_t *sbc); 128 int (*waitForMSC)(__GLXDRIdrawable *pdraw, int64_t target_msc, 129 int64_t divisor, int64_t remainder, int64_t *ust, 130 int64_t *msc, int64_t *sbc); 131 int (*waitForSBC)(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust, 132 int64_t *msc, int64_t *sbc); 133 int (*setSwapInterval)(__GLXDRIdrawable *pdraw, int interval); 134 int (*getSwapInterval)(__GLXDRIdrawable *pdraw); 135 int (*getBufferAge)(__GLXDRIdrawable *pdraw); 136 void (*bindTexImage)(__GLXDRIdrawable *pdraw, int buffer, const int *attribs); 137 void (*releaseTexImage)(__GLXDRIdrawable *pdraw, int buffer); 138 }; 139 140 struct __GLXDRIdrawableRec 141 { 142 void (*destroyDrawable) (__GLXDRIdrawable * drawable); 143 144 XID xDrawable; 145 XID drawable; 146 struct glx_screen *psc; 147 GLenum textureTarget; 148 GLenum textureFormat; /* EXT_texture_from_pixmap support */ 149 unsigned long eventMask; 150 int refcount; 151 }; 152 153 /* 154 ** Function to create and DRI display data and initialize the display 155 ** dependent methods. 156 */ 157 extern __GLXDRIdisplay *driswCreateDisplay(Display * dpy); 158 extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy); 159 extern __GLXDRIdisplay *dri3_create_display(Display * dpy); 160 extern __GLXDRIdisplay *driwindowsCreateDisplay(Display * dpy); 161 162 /* 163 ** 164 */ 165 extern void dri2InvalidateBuffers(Display *dpy, XID drawable); 166 extern unsigned dri2GetSwapEventType(Display *dpy, XID drawable); 167 168 /* 169 ** Functions to obtain driver configuration information from a direct 170 ** rendering client application 171 */ 172 extern const char *glXGetScreenDriver(Display * dpy, int scrNum); 173 174 extern const char *glXGetDriverConfig(const char *driverName); 175 176 #endif 177 178 /************************************************************************/ 179 180 #define __GL_CLIENT_ATTRIB_STACK_DEPTH 16 181 182 typedef struct __GLXpixelStoreModeRec 183 { 184 GLboolean swapEndian; 185 GLboolean lsbFirst; 186 GLuint rowLength; 187 GLuint imageHeight; 188 GLuint imageDepth; 189 GLuint skipRows; 190 GLuint skipPixels; 191 GLuint skipImages; 192 GLuint alignment; 193 } __GLXpixelStoreMode; 194 195 196 typedef struct __GLXattributeRec 197 { 198 GLuint mask; 199 200 /** 201 * Pixel storage state. Most of the pixel store mode state is kept 202 * here and used by the client code to manage the packing and 203 * unpacking of data sent to/received from the server. 204 */ 205 __GLXpixelStoreMode storePack, storeUnpack; 206 207 /** 208 * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically 209 * disabled? 210 */ 211 GLboolean NoDrawArraysProtocol; 212 213 /** 214 * Vertex Array storage state. The vertex array component 215 * state is stored here and is used to manage the packing of 216 * DrawArrays data sent to the server. 217 */ 218 struct array_state_vector *array_state; 219 } __GLXattribute; 220 221 typedef struct __GLXattributeMachineRec 222 { 223 __GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]; 224 __GLXattribute **stackPointer; 225 } __GLXattributeMachine; 226 227 struct mesa_glinterop_device_info; 228 struct mesa_glinterop_export_in; 229 struct mesa_glinterop_export_out; 230 231 struct glx_context_vtable { 232 void (*destroy)(struct glx_context *ctx); 233 int (*bind)(struct glx_context *context, struct glx_context *old, 234 GLXDrawable draw, GLXDrawable read); 235 void (*unbind)(struct glx_context *context, struct glx_context *new_ctx); 236 void (*wait_gl)(struct glx_context *ctx); 237 void (*wait_x)(struct glx_context *ctx); 238 int (*interop_query_device_info)(struct glx_context *ctx, 239 struct mesa_glinterop_device_info *out); 240 int (*interop_export_object)(struct glx_context *ctx, 241 struct mesa_glinterop_export_in *in, 242 struct mesa_glinterop_export_out *out); 243 }; 244 245 /** 246 * GLX state that needs to be kept on the client. One of these records 247 * exist for each context that has been made current by this client. 248 */ 249 struct glx_context 250 { 251 /** 252 * \name Drawing command buffer. 253 * 254 * Drawing commands are packed into this buffer before being sent as a 255 * single GLX protocol request. The buffer is sent when it overflows or 256 * is flushed by \c __glXFlushRenderBuffer. \c pc is the next location 257 * in the buffer to be filled. \c limit is described above in the buffer 258 * slop discussion. 259 * 260 * Commands that require large amounts of data to be transfered will 261 * also use this buffer to hold a header that describes the large 262 * command. 263 * 264 * These must be the first 6 fields since they are static initialized 265 * in the dummy context in glxext.c 266 */ 267 /*@{ */ 268 GLubyte *buf; 269 GLubyte *pc; 270 GLubyte *limit; 271 GLubyte *bufEnd; 272 GLint bufSize; 273 /*@} */ 274 275 const struct glx_context_vtable *vtable; 276 277 /** 278 * The XID of this rendering context. When the context is created a 279 * new XID is allocated. This is set to None when the context is 280 * destroyed but is still current to some thread. In this case the 281 * context will be freed on next MakeCurrent. 282 */ 283 XID xid; 284 285 /** 286 * The XID of the \c shareList context. 287 */ 288 XID share_xid; 289 290 /** 291 * Screen number. 292 */ 293 GLint screen; 294 struct glx_screen *psc; 295 296 /** 297 * \c GL_TRUE if the context was created with ImportContext, which 298 * means the server-side context was created by another X client. 299 */ 300 GLboolean imported; 301 302 /** 303 * The context tag returned by MakeCurrent when this context is made 304 * current. This tag is used to identify the context that a thread has 305 * current so that proper server context management can be done. It is 306 * used for all context specific commands (i.e., \c Render, \c RenderLarge, 307 * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old 308 * context)). 309 */ 310 GLXContextTag currentContextTag; 311 312 /** 313 * \name Rendering mode 314 * 315 * The rendering mode is kept on the client as well as the server. 316 * When \c glRenderMode is called, the buffer associated with the 317 * previous rendering mode (feedback or select) is filled. 318 */ 319 /*@{ */ 320 GLenum renderMode; 321 GLfloat *feedbackBuf; 322 GLuint *selectBuf; 323 /*@} */ 324 325 /** 326 * Client side attribs. 327 */ 328 __GLXattributeMachine attributes; 329 330 /** 331 * Client side error code. This is set when client side gl API 332 * routines need to set an error because of a bad enumerant or 333 * running out of memory, etc. 334 */ 335 GLenum error; 336 337 /** 338 * Whether this context does direct rendering. 339 */ 340 Bool isDirect; 341 342 #if defined(GLX_DIRECT_RENDERING) && defined(GLX_USE_APPLEGL) 343 void *driContext; 344 #endif 345 346 /** 347 * \c dpy of current display for this context. Will be \c NULL if not 348 * current to any display, or if this is the "dummy context". 349 */ 350 Display *currentDpy; 351 352 /** 353 * The current drawable for this context. Will be None if this 354 * context is not current to any drawable. currentReadable is below. 355 */ 356 GLXDrawable currentDrawable; 357 358 /** 359 * \name GL Constant Strings 360 * 361 * Constant strings that describe the server implementation 362 * These pertain to GL attributes, not to be confused with 363 * GLX versioning attributes. 364 */ 365 /*@{ */ 366 GLubyte *vendor; 367 GLubyte *renderer; 368 GLubyte *version; 369 GLubyte *extensions; 370 /*@} */ 371 372 /** 373 * Maximum small render command size. This is the smaller of 64k and 374 * the size of the above buffer. 375 */ 376 GLint maxSmallRenderCommandSize; 377 378 /** 379 * Major opcode for the extension. Copied here so a lookup isn't 380 * needed. 381 */ 382 GLint majorOpcode; 383 384 /** 385 * Pointer to the config used to create this context. 386 */ 387 struct glx_config *config; 388 389 /** 390 * The current read-drawable for this context. Will be None if this 391 * context is not current to any drawable. 392 * 393 * \since Internal API version 20030606. 394 */ 395 GLXDrawable currentReadable; 396 397 /** 398 * Pointer to client-state data that is private to libGL. This is only 399 * used for indirect rendering contexts. 400 * 401 * No internal API version change was made for this change. Client-side 402 * drivers should NEVER use this data or even care that it exists. 403 */ 404 void *client_state_private; 405 406 /** 407 * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE. 408 */ 409 int renderType; 410 411 /** 412 * \name Raw server GL version 413 * 414 * True core GL version supported by the server. This is the raw value 415 * returned by the server, and it may not reflect what is actually 416 * supported (or reported) by the client-side library. 417 */ 418 /*@{ */ 419 int server_major; /**< Major version number. */ 420 int server_minor; /**< Minor version number. */ 421 /*@} */ 422 423 /** 424 * Number of threads we're currently current in. 425 */ 426 unsigned long thread_refcount; 427 428 /** 429 * GLX_ARB_create_context_no_error setting for this context. 430 * This needs to be kept here to enforce shared context rules. 431 */ 432 Bool noError; 433 434 char gl_extension_bits[__GL_EXT_BYTES]; 435 }; 436 437 extern Bool 438 glx_context_init(struct glx_context *gc, 439 struct glx_screen *psc, struct glx_config *fbconfig); 440 441 #define __glXSetError(gc,code) \ 442 if (!(gc)->error) { \ 443 (gc)->error = code; \ 444 } 445 446 /************************************************************************/ 447 448 /** 449 * The size of the largest drawing command known to the implementation 450 * that will use the GLXRender GLX command. In this case it is 451 * \c glPolygonStipple. 452 */ 453 #define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156 454 455 /** 456 * To keep the implementation fast, the code uses a "limit" pointer 457 * to determine when the drawing command buffer is too full to hold 458 * another fixed size command. This constant defines the amount of 459 * space that must always be available in the drawing command buffer 460 * at all times for the implementation to work. It is important that 461 * the number be just large enough, but not so large as to reduce the 462 * efficacy of the buffer. The "+32" is just to keep the code working 463 * in case somebody counts wrong. 464 */ 465 #define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32) 466 467 /** 468 * This implementation uses a smaller threshold for switching 469 * to the RenderLarge protocol than the protcol requires so that 470 * large copies don't occur. 471 */ 472 #define __GLX_RENDER_CMD_SIZE_LIMIT 4096 473 474 /** 475 * One of these records exists per screen of the display. It contains 476 * a pointer to the config data for that screen (if the screen supports GL). 477 */ 478 struct glx_screen_vtable { 479 struct glx_context *(*create_context)(struct glx_screen *psc, 480 struct glx_config *config, 481 struct glx_context *shareList, 482 int renderType); 483 484 struct glx_context *(*create_context_attribs)(struct glx_screen *psc, 485 struct glx_config *config, 486 struct glx_context *shareList, 487 unsigned num_attrib, 488 const uint32_t *attribs, 489 unsigned *error); 490 int (*query_renderer_integer)(struct glx_screen *psc, 491 int attribute, 492 unsigned int *value); 493 int (*query_renderer_string)(struct glx_screen *psc, 494 int attribute, 495 const char **value); 496 497 char *(*get_driver_name)(struct glx_screen *psc); 498 }; 499 500 struct glx_screen 501 { 502 const struct glx_screen_vtable *vtable; 503 const struct glx_context_vtable *context_vtable; 504 505 /** 506 * \name Storage for the GLX vendor, version, and extension strings 507 */ 508 /*@{ */ 509 const char *serverGLXexts; 510 const char *serverGLXvendor; 511 const char *serverGLXversion; 512 /*@} */ 513 514 /** 515 * GLX extension string to be reported to applications. This is the 516 * set of extensions that the application can actually use. 517 */ 518 char *effectiveGLXexts; 519 520 struct glx_display *display; 521 522 Display *dpy; 523 int scr; 524 525 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 526 /** 527 * Per screen direct rendering interface functions and data. 528 */ 529 __GLXDRIscreen *driScreen; 530 #endif 531 532 /** 533 * Linked list of glx visuals and fbconfigs for this screen. 534 */ 535 struct glx_config *visuals, *configs; 536 537 /** 538 * Per-screen dynamic GLX extension tracking. The \c direct_support 539 * field only contains enough bits for 64 extensions. Should libGL 540 * ever need to track more than 64 GLX extensions, we can safely grow 541 * this field. The \c struct glx_screen structure is not used outside 542 * libGL. 543 */ 544 /*@{ */ 545 unsigned char direct_support[__GLX_EXT_BYTES]; 546 GLboolean ext_list_first_time; 547 548 unsigned char glx_force_enabled[__GLX_EXT_BYTES]; 549 unsigned char glx_force_disabled[__GLX_EXT_BYTES]; 550 551 unsigned char gl_force_enabled[__GL_EXT_BYTES]; 552 unsigned char gl_force_disabled[__GL_EXT_BYTES]; 553 /*@} */ 554 555 }; 556 557 /** 558 * Per display private data. One of these records exists for each display 559 * that is using the OpenGL (GLX) extension. 560 */ 561 struct glx_display 562 { 563 struct glx_display *next; 564 565 /* The extension protocol codes */ 566 XExtCodes codes; 567 568 /** 569 * Back pointer to the display 570 */ 571 Display *dpy; 572 573 /** 574 * \name Minor Version 575 * 576 * Minor version returned by the server during initialization. The major 577 * version is asserted to be 1 during extension setup. 578 */ 579 /*@{ */ 580 int minorVersion; 581 /*@} */ 582 583 /** 584 * Configurations of visuals for all screens on this display. 585 * Also, per screen data which now includes the server \c GLX_EXTENSION 586 * string. 587 */ 588 struct glx_screen **screens; 589 590 __glxHashTable *glXDrawHash; 591 592 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 593 __glxHashTable *drawHash; 594 595 /** 596 * Per display direct rendering interface functions and data. 597 */ 598 __GLXDRIdisplay *driswDisplay; 599 __GLXDRIdisplay *dri2Display; 600 __GLXDRIdisplay *dri3Display; 601 #endif 602 #ifdef GLX_USE_WINDOWSGL 603 __GLXDRIdisplay *windowsdriDisplay; 604 #endif 605 }; 606 607 struct glx_drawable { 608 XID xDrawable; 609 XID drawable; 610 611 uint32_t lastEventSbc; 612 int64_t eventSbcWrap; 613 }; 614 615 extern int 616 glx_screen_init(struct glx_screen *psc, 617 int screen, struct glx_display * priv); 618 extern void 619 glx_screen_cleanup(struct glx_screen *psc); 620 621 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 622 extern __GLXDRIdrawable * 623 dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id); 624 #endif 625 626 extern GLubyte *__glXFlushRenderBuffer(struct glx_context *, GLubyte *); 627 628 extern void __glXSendLargeChunk(struct glx_context * gc, GLint requestNumber, 629 GLint totalRequests, 630 const GLvoid * data, GLint dataLen); 631 632 extern void __glXSendLargeCommand(struct glx_context *, const GLvoid *, GLint, 633 const GLvoid *, GLint); 634 635 /* Initialize the GLX extension for dpy */ 636 extern struct glx_display *__glXInitialize(Display *); 637 638 /************************************************************************/ 639 640 extern int __glXDebug; 641 642 /* This is per-thread storage in an MT environment */ 643 644 extern void __glXSetCurrentContext(struct glx_context * c); 645 646 # if defined( USE_ELF_TLS ) 647 648 extern __THREAD_INITIAL_EXEC void *__glX_tls_Context; 649 650 # define __glXGetCurrentContext() __glX_tls_Context 651 652 # else 653 654 extern struct glx_context *__glXGetCurrentContext(void); 655 656 # endif /* defined( USE_ELF_TLS ) */ 657 658 extern void __glXSetCurrentContextNull(void); 659 660 661 /* 662 ** Global lock for all threads in this address space using the GLX 663 ** extension 664 */ 665 extern pthread_mutex_t __glXmutex; 666 #define __glXLock() pthread_mutex_lock(&__glXmutex) 667 #define __glXUnlock() pthread_mutex_unlock(&__glXmutex) 668 669 /* 670 ** Setup for a command. Initialize the extension for dpy if necessary. 671 */ 672 extern CARD8 __glXSetupForCommand(Display * dpy); 673 674 /************************************************************************/ 675 676 /* 677 ** Data conversion and packing support. 678 */ 679 680 extern const GLuint __glXDefaultPixelStore[9]; 681 682 /* Send an image to the server using RenderLarge. */ 683 extern void __glXSendLargeImage(struct glx_context * gc, GLint compsize, GLint dim, 684 GLint width, GLint height, GLint depth, 685 GLenum format, GLenum type, 686 const GLvoid * src, GLubyte * pc, 687 GLubyte * modes); 688 689 /* Return the size, in bytes, of some pixel data */ 690 extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum); 691 692 /* Return the number of elements per group of a specified format*/ 693 extern GLint __glElementsPerGroup(GLenum format, GLenum type); 694 695 /* Return the number of bytes per element, based on the element type (other 696 ** than GL_BITMAP). 697 */ 698 extern GLint __glBytesPerElement(GLenum type); 699 700 /* 701 ** Fill the transport buffer with the data from the users buffer, 702 ** applying some of the pixel store modes (unpack modes) to the data 703 ** first. As a side effect of this call, the "modes" field is 704 ** updated to contain the modes needed by the server to decode the 705 ** sent data. 706 */ 707 extern void __glFillImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum, 708 GLenum, const GLvoid *, GLubyte *, GLubyte *); 709 710 /* Copy map data with a stride into a packed buffer */ 711 extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *); 712 extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *); 713 extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint, 714 const GLfloat *, GLfloat *); 715 extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint, 716 const GLdouble *, GLdouble *); 717 718 /* 719 ** Empty an image out of the reply buffer into the clients memory applying 720 ** the pack modes to pack back into the clients requested format. 721 */ 722 extern void __glEmptyImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum, 723 GLenum, const GLubyte *, GLvoid *); 724 725 726 /* 727 ** Allocate and Initialize Vertex Array client state, and free. 728 */ 729 extern void __glXInitVertexArrayState(struct glx_context *); 730 extern void __glXFreeVertexArrayState(struct glx_context *); 731 732 _X_HIDDEN void 733 __glX_send_client_info(struct glx_display *glx_dpy); 734 735 /************************************************************************/ 736 737 extern void __glXInitializeVisualConfigFromTags(struct glx_config * config, 738 int count, const INT32 * bp, 739 Bool tagged_only, 740 Bool fbconfig_style_tags); 741 742 extern char *__glXQueryServerString(Display *dpy, CARD32 screen, CARD32 name); 743 extern char *__glXGetString(Display *dpy, CARD32 screen, CARD32 name); 744 745 extern GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable, 746 int32_t * numerator, 747 int32_t * denominator); 748 749 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 750 extern GLboolean 751 __glxGetMscRate(struct glx_screen *psc, 752 int32_t * numerator, int32_t * denominator); 753 754 /* So that dri2.c:DRI2WireToEvent() can access 755 * glx_info->codes->first_event */ 756 XExtDisplayInfo *__glXFindDisplay (Display *dpy); 757 758 extern __GLXDRIdrawable * 759 GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable); 760 #endif 761 762 extern struct glx_screen *GetGLXScreenConfigs(Display * dpy, int scrn); 763 764 #ifdef GLX_USE_APPLEGL 765 extern struct glx_screen * 766 applegl_create_screen(int screen, struct glx_display * priv); 767 768 extern struct glx_context * 769 applegl_create_context(struct glx_screen *psc, 770 struct glx_config *mode, 771 struct glx_context *shareList, int renderType); 772 773 extern int 774 applegl_create_display(struct glx_display *display); 775 776 extern void * 777 applegl_get_proc_address(const char *symbol); 778 #endif 779 780 extern Bool validate_renderType_against_config(const struct glx_config *config, 781 int renderType); 782 783 784 extern struct glx_drawable *GetGLXDrawable(Display *dpy, GLXDrawable drawable); 785 extern int InitGLXDrawable(Display *dpy, struct glx_drawable *glxDraw, 786 XID xDrawable, GLXDrawable drawable); 787 extern void DestroyGLXDrawable(Display *dpy, GLXDrawable drawable); 788 789 extern struct glx_context dummyContext; 790 791 extern struct glx_screen * 792 indirect_create_screen(int screen, struct glx_display * priv); 793 extern struct glx_context * 794 indirect_create_context(struct glx_screen *psc, 795 struct glx_config *mode, 796 struct glx_context *shareList, int renderType); 797 extern struct glx_context * 798 indirect_create_context_attribs(struct glx_screen *base, 799 struct glx_config *config_base, 800 struct glx_context *shareList, 801 unsigned num_attribs, 802 const uint32_t *attribs, 803 unsigned *error); 804 805 806 extern int __glXGetDrawableAttribute(Display * dpy, GLXDrawable drawable, 807 int attribute, unsigned int *value); 808 809 #ifdef __cplusplus 810 } 811 #endif 812 813 #endif /* !__GLX_client_h__ */ 814