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