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 * Client side attribs. 332 */ 333 __GLXattributeMachine attributes; 334 335 /** 336 * Client side error code. This is set when client side gl API 337 * routines need to set an error because of a bad enumerant or 338 * running out of memory, etc. 339 */ 340 GLenum error; 341 342 /** 343 * Whether this context does direct rendering. 344 */ 345 Bool isDirect; 346 347 #if defined(GLX_DIRECT_RENDERING) && defined(GLX_USE_APPLEGL) 348 void *driContext; 349 #endif 350 351 /** 352 * \c dpy of current display for this context. Will be \c NULL if not 353 * current to any display, or if this is the "dummy context". 354 */ 355 Display *currentDpy; 356 357 /** 358 * The current drawable for this context. Will be None if this 359 * context is not current to any drawable. currentReadable is below. 360 */ 361 GLXDrawable currentDrawable; 362 363 /** 364 * \name GL Constant Strings 365 * 366 * Constant strings that describe the server implementation 367 * These pertain to GL attributes, not to be confused with 368 * GLX versioning attributes. 369 */ 370 /*@{ */ 371 GLubyte *vendor; 372 GLubyte *renderer; 373 GLubyte *version; 374 GLubyte *extensions; 375 /*@} */ 376 377 /** 378 * Maximum small render command size. This is the smaller of 64k and 379 * the size of the above buffer. 380 */ 381 GLint maxSmallRenderCommandSize; 382 383 /** 384 * Major opcode for the extension. Copied here so a lookup isn't 385 * needed. 386 */ 387 GLint majorOpcode; 388 389 /** 390 * Pointer to the config used to create this context. 391 */ 392 struct glx_config *config; 393 394 /** 395 * The current read-drawable for this context. Will be None if this 396 * context is not current to any drawable. 397 * 398 * \since Internal API version 20030606. 399 */ 400 GLXDrawable currentReadable; 401 402 /** 403 * Pointer to client-state data that is private to libGL. This is only 404 * used for indirect rendering contexts. 405 * 406 * No internal API version change was made for this change. Client-side 407 * drivers should NEVER use this data or even care that it exists. 408 */ 409 void *client_state_private; 410 411 /** 412 * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE. 413 */ 414 int renderType; 415 416 /** 417 * \name Raw server GL version 418 * 419 * True core GL version supported by the server. This is the raw value 420 * returned by the server, and it may not reflect what is actually 421 * supported (or reported) by the client-side library. 422 */ 423 /*@{ */ 424 int server_major; /**< Major version number. */ 425 int server_minor; /**< Minor version number. */ 426 /*@} */ 427 428 /** 429 * Number of threads we're currently current in. 430 */ 431 unsigned long thread_refcount; 432 433 /** 434 * GLX_ARB_create_context_no_error setting for this context. 435 * This needs to be kept here to enforce shared context rules. 436 */ 437 Bool noError; 438 439 char gl_extension_bits[__GL_EXT_BYTES]; 440 }; 441 442 extern Bool 443 glx_context_init(struct glx_context *gc, 444 struct glx_screen *psc, struct glx_config *fbconfig); 445 446 #define __glXSetError(gc,code) \ 447 if (!(gc)->error) { \ 448 (gc)->error = code; \ 449 } 450 451 extern void __glFreeAttributeState(struct glx_context *); 452 453 /************************************************************************/ 454 455 /** 456 * The size of the largest drawing command known to the implementation 457 * that will use the GLXRender GLX command. In this case it is 458 * \c glPolygonStipple. 459 */ 460 #define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156 461 462 /** 463 * To keep the implementation fast, the code uses a "limit" pointer 464 * to determine when the drawing command buffer is too full to hold 465 * another fixed size command. This constant defines the amount of 466 * space that must always be available in the drawing command buffer 467 * at all times for the implementation to work. It is important that 468 * the number be just large enough, but not so large as to reduce the 469 * efficacy of the buffer. The "+32" is just to keep the code working 470 * in case somebody counts wrong. 471 */ 472 #define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32) 473 474 /** 475 * This implementation uses a smaller threshold for switching 476 * to the RenderLarge protocol than the protcol requires so that 477 * large copies don't occur. 478 */ 479 #define __GLX_RENDER_CMD_SIZE_LIMIT 4096 480 481 /** 482 * One of these records exists per screen of the display. It contains 483 * a pointer to the config data for that screen (if the screen supports GL). 484 */ 485 struct glx_screen_vtable { 486 struct glx_context *(*create_context)(struct glx_screen *psc, 487 struct glx_config *config, 488 struct glx_context *shareList, 489 int renderType); 490 491 struct glx_context *(*create_context_attribs)(struct glx_screen *psc, 492 struct glx_config *config, 493 struct glx_context *shareList, 494 unsigned num_attrib, 495 const uint32_t *attribs, 496 unsigned *error); 497 int (*query_renderer_integer)(struct glx_screen *psc, 498 int attribute, 499 unsigned int *value); 500 int (*query_renderer_string)(struct glx_screen *psc, 501 int attribute, 502 const char **value); 503 504 char *(*get_driver_name)(struct glx_screen *psc); 505 }; 506 507 struct glx_screen 508 { 509 const struct glx_screen_vtable *vtable; 510 511 /** 512 * GLX extension string reported by the X-server. 513 */ 514 const char *serverGLXexts; 515 516 /** 517 * GLX extension string to be reported to applications. This is the 518 * set of extensions that the application can actually use. 519 */ 520 char *effectiveGLXexts; 521 522 struct glx_display *display; 523 524 Display *dpy; 525 int scr; 526 527 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 528 /** 529 * Per screen direct rendering interface functions and data. 530 */ 531 __GLXDRIscreen *driScreen; 532 #endif 533 534 /** 535 * Linked list of glx visuals and fbconfigs for this screen. 536 */ 537 struct glx_config *visuals, *configs; 538 539 /** 540 * Per-screen dynamic GLX extension tracking. The \c direct_support 541 * field only contains enough bits for 64 extensions. Should libGL 542 * ever need to track more than 64 GLX extensions, we can safely grow 543 * this field. The \c struct glx_screen structure is not used outside 544 * libGL. 545 */ 546 /*@{ */ 547 unsigned char direct_support[__GLX_EXT_BYTES]; 548 GLboolean ext_list_first_time; 549 550 unsigned char glx_force_enabled[__GLX_EXT_BYTES]; 551 unsigned char glx_force_disabled[__GLX_EXT_BYTES]; 552 553 unsigned char gl_force_enabled[__GL_EXT_BYTES]; 554 unsigned char gl_force_disabled[__GL_EXT_BYTES]; 555 /*@} */ 556 557 }; 558 559 /** 560 * Per display private data. One of these records exists for each display 561 * that is using the OpenGL (GLX) extension. 562 */ 563 struct glx_display 564 { 565 /* The extension protocol codes */ 566 XExtCodes *codes; 567 struct glx_display *next; 568 569 /** 570 * Back pointer to the display 571 */ 572 Display *dpy; 573 574 /** 575 * The \c majorOpcode is common to all connections to the same server. 576 * It is also copied into the context structure. 577 */ 578 int majorOpcode; 579 580 /** 581 * \name Server Version 582 * 583 * Major and minor version returned by the server during initialization. 584 */ 585 /*@{ */ 586 int majorVersion, minorVersion; 587 /*@} */ 588 589 /** 590 * \name Storage for the servers GLX vendor and versions strings. 591 * 592 * These are the same for all screens on this display. These fields will 593 * be filled in on demand. 594 */ 595 /*@{ */ 596 const char *serverGLXvendor; 597 const char *serverGLXversion; 598 /*@} */ 599 600 /** 601 * Configurations of visuals for all screens on this display. 602 * Also, per screen data which now includes the server \c GLX_EXTENSION 603 * string. 604 */ 605 struct glx_screen **screens; 606 607 __glxHashTable *glXDrawHash; 608 609 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 610 __glxHashTable *drawHash; 611 612 /** 613 * Per display direct rendering interface functions and data. 614 */ 615 __GLXDRIdisplay *driswDisplay; 616 __GLXDRIdisplay *driDisplay; 617 __GLXDRIdisplay *dri2Display; 618 __GLXDRIdisplay *dri3Display; 619 #endif 620 #ifdef GLX_USE_WINDOWSGL 621 __GLXDRIdisplay *windowsdriDisplay; 622 #endif 623 }; 624 625 struct glx_drawable { 626 XID xDrawable; 627 XID drawable; 628 629 uint32_t lastEventSbc; 630 int64_t eventSbcWrap; 631 }; 632 633 extern int 634 glx_screen_init(struct glx_screen *psc, 635 int screen, struct glx_display * priv); 636 extern void 637 glx_screen_cleanup(struct glx_screen *psc); 638 639 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 640 extern __GLXDRIdrawable * 641 dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id); 642 #endif 643 644 extern GLubyte *__glXFlushRenderBuffer(struct glx_context *, GLubyte *); 645 646 extern void __glXSendLargeChunk(struct glx_context * gc, GLint requestNumber, 647 GLint totalRequests, 648 const GLvoid * data, GLint dataLen); 649 650 extern void __glXSendLargeCommand(struct glx_context *, const GLvoid *, GLint, 651 const GLvoid *, GLint); 652 653 /* Initialize the GLX extension for dpy */ 654 extern struct glx_display *__glXInitialize(Display *); 655 656 /************************************************************************/ 657 658 extern int __glXDebug; 659 660 /* This is per-thread storage in an MT environment */ 661 662 extern void __glXSetCurrentContext(struct glx_context * c); 663 664 # if defined( USE_ELF_TLS ) 665 666 extern __thread void *__glX_tls_Context 667 __attribute__ ((tls_model("initial-exec"))); 668 669 # define __glXGetCurrentContext() __glX_tls_Context 670 671 # else 672 673 extern struct glx_context *__glXGetCurrentContext(void); 674 675 # endif /* defined( USE_ELF_TLS ) */ 676 677 extern void __glXSetCurrentContextNull(void); 678 679 680 /* 681 ** Global lock for all threads in this address space using the GLX 682 ** extension 683 */ 684 extern pthread_mutex_t __glXmutex; 685 #define __glXLock() pthread_mutex_lock(&__glXmutex) 686 #define __glXUnlock() pthread_mutex_unlock(&__glXmutex) 687 688 /* 689 ** Setup for a command. Initialize the extension for dpy if necessary. 690 */ 691 extern CARD8 __glXSetupForCommand(Display * dpy); 692 693 /************************************************************************/ 694 695 /* 696 ** Data conversion and packing support. 697 */ 698 699 extern const GLuint __glXDefaultPixelStore[9]; 700 701 /* Send an image to the server using RenderLarge. */ 702 extern void __glXSendLargeImage(struct glx_context * gc, GLint compsize, GLint dim, 703 GLint width, GLint height, GLint depth, 704 GLenum format, GLenum type, 705 const GLvoid * src, GLubyte * pc, 706 GLubyte * modes); 707 708 /* Return the size, in bytes, of some pixel data */ 709 extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum); 710 711 /* Return the number of elements per group of a specified format*/ 712 extern GLint __glElementsPerGroup(GLenum format, GLenum type); 713 714 /* Return the number of bytes per element, based on the element type (other 715 ** than GL_BITMAP). 716 */ 717 extern GLint __glBytesPerElement(GLenum type); 718 719 /* 720 ** Fill the transport buffer with the data from the users buffer, 721 ** applying some of the pixel store modes (unpack modes) to the data 722 ** first. As a side effect of this call, the "modes" field is 723 ** updated to contain the modes needed by the server to decode the 724 ** sent data. 725 */ 726 extern void __glFillImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum, 727 GLenum, const GLvoid *, GLubyte *, GLubyte *); 728 729 /* Copy map data with a stride into a packed buffer */ 730 extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *); 731 extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *); 732 extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint, 733 const GLfloat *, GLfloat *); 734 extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint, 735 const GLdouble *, GLdouble *); 736 737 /* 738 ** Empty an image out of the reply buffer into the clients memory applying 739 ** the pack modes to pack back into the clients requested format. 740 */ 741 extern void __glEmptyImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum, 742 GLenum, const GLubyte *, GLvoid *); 743 744 745 /* 746 ** Allocate and Initialize Vertex Array client state, and free. 747 */ 748 extern void __glXInitVertexArrayState(struct glx_context *); 749 extern void __glXFreeVertexArrayState(struct glx_context *); 750 751 /* 752 ** Inform the Server of the major and minor numbers and of the client 753 ** libraries extension string. 754 */ 755 extern void __glXClientInfo(Display * dpy, int opcode); 756 757 _X_HIDDEN void 758 __glX_send_client_info(struct glx_display *glx_dpy); 759 760 /************************************************************************/ 761 762 /* 763 ** Declarations that should be in Xlib 764 */ 765 #ifdef __GL_USE_OUR_PROTOTYPES 766 extern void _XFlush(Display *); 767 extern Status _XReply(Display *, xReply *, int, Bool); 768 extern void _XRead(Display *, void *, long); 769 extern void _XSend(Display *, const void *, long); 770 #endif 771 772 773 extern void __glXInitializeVisualConfigFromTags(struct glx_config * config, 774 int count, const INT32 * bp, 775 Bool tagged_only, 776 Bool fbconfig_style_tags); 777 778 extern char *__glXQueryServerString(Display * dpy, int opcode, 779 CARD32 screen, CARD32 name); 780 extern char *__glXGetString(Display * dpy, int opcode, 781 CARD32 screen, CARD32 name); 782 783 extern const char __glXGLClientVersion[]; 784 extern const char __glXGLClientExtensions[]; 785 786 extern GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable, 787 int32_t * numerator, 788 int32_t * denominator); 789 790 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 791 extern GLboolean 792 __glxGetMscRate(struct glx_screen *psc, 793 int32_t * numerator, int32_t * denominator); 794 795 /* So that dri2.c:DRI2WireToEvent() can access 796 * glx_info->codes->first_event */ 797 XExtDisplayInfo *__glXFindDisplay (Display *dpy); 798 799 extern void 800 GarbageCollectDRIDrawables(struct glx_screen *psc); 801 802 extern __GLXDRIdrawable * 803 GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable); 804 #endif 805 806 extern struct glx_screen *GetGLXScreenConfigs(Display * dpy, int scrn); 807 808 #ifdef GLX_USE_APPLEGL 809 extern struct glx_screen * 810 applegl_create_screen(int screen, struct glx_display * priv); 811 812 extern struct glx_context * 813 applegl_create_context(struct glx_screen *psc, 814 struct glx_config *mode, 815 struct glx_context *shareList, int renderType); 816 817 extern int 818 applegl_create_display(struct glx_display *display); 819 #endif 820 821 extern Bool validate_renderType_against_config(const struct glx_config *config, 822 int renderType); 823 824 825 extern struct glx_drawable *GetGLXDrawable(Display *dpy, GLXDrawable drawable); 826 extern int InitGLXDrawable(Display *dpy, struct glx_drawable *glxDraw, 827 XID xDrawable, GLXDrawable drawable); 828 extern void DestroyGLXDrawable(Display *dpy, GLXDrawable drawable); 829 830 extern struct glx_context dummyContext; 831 832 extern struct glx_screen * 833 indirect_create_screen(int screen, struct glx_display * priv); 834 extern struct glx_context * 835 indirect_create_context(struct glx_screen *psc, 836 struct glx_config *mode, 837 struct glx_context *shareList, int renderType); 838 extern struct glx_context * 839 indirect_create_context_attribs(struct glx_screen *base, 840 struct glx_config *config_base, 841 struct glx_context *shareList, 842 unsigned num_attribs, 843 const uint32_t *attribs, 844 unsigned *error); 845 846 847 extern int __glXGetDrawableAttribute(Display * dpy, GLXDrawable drawable, 848 int attribute, unsigned int *value); 849 850 #ifdef __cplusplus 851 } 852 #endif 853 854 #endif /* !__GLX_client_h__ */ 855