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