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