glxclient.h revision a0e510320009766faa5ff8c0ed744e87f8095df7
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 92#include "glxextensions.h" 93 94struct __GLXDRIdisplayRec 95{ 96 /** 97 * Method to destroy the private DRI display data. 98 */ 99 void (*destroyDisplay) (__GLXDRIdisplay * display); 100 101 struct glx_screen *(*createScreen)(int screen, struct glx_display * priv); 102}; 103 104struct __GLXDRIscreenRec { 105 106 void (*destroyScreen)(struct glx_screen *psc); 107 108 struct glx_context *(*createContext)(struct glx_screen *psc, 109 struct glx_config *config, 110 struct glx_context *shareList, 111 int renderType); 112 113 __GLXDRIdrawable *(*createDrawable)(struct glx_screen *psc, 114 XID drawable, 115 GLXDrawable glxDrawable, 116 struct glx_config *config); 117 118 int64_t (*swapBuffers)(__GLXDRIdrawable *pdraw, int64_t target_msc, 119 int64_t divisor, int64_t remainder); 120 void (*copySubBuffer)(__GLXDRIdrawable *pdraw, 121 int x, int y, int width, int height); 122 int (*getDrawableMSC)(struct glx_screen *psc, __GLXDRIdrawable *pdraw, 123 int64_t *ust, int64_t *msc, int64_t *sbc); 124 int (*waitForMSC)(__GLXDRIdrawable *pdraw, int64_t target_msc, 125 int64_t divisor, int64_t remainder, int64_t *ust, 126 int64_t *msc, int64_t *sbc); 127 int (*waitForSBC)(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust, 128 int64_t *msc, int64_t *sbc); 129 int (*setSwapInterval)(__GLXDRIdrawable *pdraw, int interval); 130 int (*getSwapInterval)(__GLXDRIdrawable *pdraw); 131}; 132 133struct __GLXDRIdrawableRec 134{ 135 void (*destroyDrawable) (__GLXDRIdrawable * drawable); 136 137 XID xDrawable; 138 XID drawable; 139 struct glx_screen *psc; 140 GLenum textureTarget; 141 GLenum textureFormat; /* EXT_texture_from_pixmap support */ 142 unsigned long eventMask; 143}; 144 145/* 146** Function to create and DRI display data and initialize the display 147** dependent methods. 148*/ 149extern __GLXDRIdisplay *driswCreateDisplay(Display * dpy); 150extern __GLXDRIdisplay *driCreateDisplay(Display * dpy); 151extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy); 152extern void dri2InvalidateBuffers(Display *dpy, XID drawable); 153extern unsigned dri2GetSwapEventType(Display *dpy, XID drawable); 154 155 156/* 157** Functions to obtain driver configuration information from a direct 158** rendering client application 159*/ 160extern const char *glXGetScreenDriver(Display * dpy, int scrNum); 161 162extern const char *glXGetDriverConfig(const char *driverName); 163 164#endif 165 166/************************************************************************/ 167 168#define __GL_CLIENT_ATTRIB_STACK_DEPTH 16 169 170typedef struct __GLXpixelStoreModeRec 171{ 172 GLboolean swapEndian; 173 GLboolean lsbFirst; 174 GLuint rowLength; 175 GLuint imageHeight; 176 GLuint imageDepth; 177 GLuint skipRows; 178 GLuint skipPixels; 179 GLuint skipImages; 180 GLuint alignment; 181} __GLXpixelStoreMode; 182 183 184typedef struct __GLXattributeRec 185{ 186 GLuint mask; 187 188 /** 189 * Pixel storage state. Most of the pixel store mode state is kept 190 * here and used by the client code to manage the packing and 191 * unpacking of data sent to/received from the server. 192 */ 193 __GLXpixelStoreMode storePack, storeUnpack; 194 195 /** 196 * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically 197 * disabled? 198 */ 199 GLboolean NoDrawArraysProtocol; 200 201 /** 202 * Vertex Array storage state. The vertex array component 203 * state is stored here and is used to manage the packing of 204 * DrawArrays data sent to the server. 205 */ 206 struct array_state_vector *array_state; 207} __GLXattribute; 208 209typedef struct __GLXattributeMachineRec 210{ 211 __GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]; 212 __GLXattribute **stackPointer; 213} __GLXattributeMachine; 214 215struct glx_context_vtable { 216 void (*destroy)(struct glx_context *ctx); 217 int (*bind)(struct glx_context *context, struct glx_context *old, 218 GLXDrawable draw, GLXDrawable read); 219 void (*unbind)(struct glx_context *context, struct glx_context *new); 220 void (*wait_gl)(struct glx_context *ctx); 221 void (*wait_x)(struct glx_context *ctx); 222 void (*use_x_font)(struct glx_context *ctx, 223 Font font, int first, int count, int listBase); 224 void (*bind_tex_image)(Display * dpy, 225 GLXDrawable drawable, 226 int buffer, const int *attrib_list); 227 void (*release_tex_image)(Display * dpy, GLXDrawable drawable, int buffer); 228 229}; 230 231extern void 232glx_send_destroy_context(Display *dpy, XID xid); 233 234/** 235 * GLX state that needs to be kept on the client. One of these records 236 * exist for each context that has been made current by this client. 237 */ 238struct glx_context 239{ 240 /** 241 * \name Drawing command buffer. 242 * 243 * Drawing commands are packed into this buffer before being sent as a 244 * single GLX protocol request. The buffer is sent when it overflows or 245 * is flushed by \c __glXFlushRenderBuffer. \c pc is the next location 246 * in the buffer to be filled. \c limit is described above in the buffer 247 * slop discussion. 248 * 249 * Commands that require large amounts of data to be transfered will 250 * also use this buffer to hold a header that describes the large 251 * command. 252 * 253 * These must be the first 6 fields since they are static initialized 254 * in the dummy context in glxext.c 255 */ 256 /*@{ */ 257 GLubyte *buf; 258 GLubyte *pc; 259 GLubyte *limit; 260 GLubyte *bufEnd; 261 GLint bufSize; 262 /*@} */ 263 264 const struct glx_context_vtable *vtable; 265 266 /** 267 * The XID of this rendering context. When the context is created a 268 * new XID is allocated. This is set to None when the context is 269 * destroyed but is still current to some thread. In this case the 270 * context will be freed on next MakeCurrent. 271 */ 272 XID xid; 273 274 /** 275 * The XID of the \c shareList context. 276 */ 277 XID share_xid; 278 279 /** 280 * Screen number. 281 */ 282 GLint screen; 283 struct glx_screen *psc; 284 285 /** 286 * \c GL_TRUE if the context was created with ImportContext, which 287 * means the server-side context was created by another X client. 288 */ 289 GLboolean imported; 290 291 /** 292 * The context tag returned by MakeCurrent when this context is made 293 * current. This tag is used to identify the context that a thread has 294 * current so that proper server context management can be done. It is 295 * used for all context specific commands (i.e., \c Render, \c RenderLarge, 296 * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old 297 * context)). 298 */ 299 GLXContextTag currentContextTag; 300 301 /** 302 * \name Rendering mode 303 * 304 * The rendering mode is kept on the client as well as the server. 305 * When \c glRenderMode is called, the buffer associated with the 306 * previous rendering mode (feedback or select) is filled. 307 */ 308 /*@{ */ 309 GLenum renderMode; 310 GLfloat *feedbackBuf; 311 GLuint *selectBuf; 312 /*@} */ 313 314 /** 315 * This is \c GL_TRUE if the pixel unpack modes are such that an image 316 * can be unpacked from the clients memory by just copying. It may 317 * still be true that the server will have to do some work. This 318 * just promises that a straight copy will fetch the correct bytes. 319 */ 320 GLboolean fastImageUnpack; 321 322 /** 323 * Fill newImage with the unpacked form of \c oldImage getting it 324 * ready for transport to the server. 325 */ 326 void (*fillImage) (struct glx_context *, GLint, GLint, GLint, GLint, GLenum, 327 GLenum, const GLvoid *, GLubyte *, GLubyte *); 328 329 /** 330 * Client side attribs. 331 */ 332 __GLXattributeMachine attributes; 333 334 /** 335 * Client side error code. This is set when client side gl API 336 * routines need to set an error because of a bad enumerant or 337 * running out of memory, etc. 338 */ 339 GLenum error; 340 341 /** 342 * Whether this context does direct rendering. 343 */ 344 Bool isDirect; 345 346 /** 347 * \c dpy of current display for this context. Will be \c NULL if not 348 * current to any display, or if this is the "dummy context". 349 */ 350 Display *currentDpy; 351 352 /** 353 * The current drawable for this context. Will be None if this 354 * context is not current to any drawable. currentReadable is below. 355 */ 356 GLXDrawable currentDrawable; 357 358 /** 359 * \name GL Constant Strings 360 * 361 * Constant strings that describe the server implementation 362 * These pertain to GL attributes, not to be confused with 363 * GLX versioning attributes. 364 */ 365 /*@{ */ 366 GLubyte *vendor; 367 GLubyte *renderer; 368 GLubyte *version; 369 GLubyte *extensions; 370 /*@} */ 371 372 /** 373 * Maximum small render command size. This is the smaller of 64k and 374 * the size of the above buffer. 375 */ 376 GLint maxSmallRenderCommandSize; 377 378 /** 379 * Major opcode for the extension. Copied here so a lookup isn't 380 * needed. 381 */ 382 GLint majorOpcode; 383 384 /** 385 * Pointer to the config used to create this context. 386 */ 387 struct glx_config *config; 388 389 /** 390 * The current read-drawable for this context. Will be None if this 391 * context is not current to any drawable. 392 * 393 * \since Internal API version 20030606. 394 */ 395 GLXDrawable currentReadable; 396 397 /** 398 * Pointer to client-state data that is private to libGL. This is only 399 * used for indirect rendering contexts. 400 * 401 * No internal API version change was made for this change. Client-side 402 * drivers should NEVER use this data or even care that it exists. 403 */ 404 void *client_state_private; 405 406 /** 407 * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE. 408 */ 409 int renderType; 410 411 /** 412 * \name Raw server GL version 413 * 414 * True core GL version supported by the server. This is the raw value 415 * returned by the server, and it may not reflect what is actually 416 * supported (or reported) by the client-side library. 417 */ 418 /*@{ */ 419 int server_major; /**< Major version number. */ 420 int server_minor; /**< Minor version number. */ 421 /*@} */ 422 423 /** 424 * Thread ID we're currently current in. Zero if none. 425 */ 426 unsigned long thread_id; 427 428 char gl_extension_bits[__GL_EXT_BYTES]; 429}; 430 431extern Bool 432glx_context_init(struct glx_context *gc, 433 struct glx_screen *psc, struct glx_config *fbconfig); 434 435#define __glXSetError(gc,code) \ 436 if (!(gc)->error) { \ 437 (gc)->error = code; \ 438 } 439 440extern void __glFreeAttributeState(struct glx_context *); 441 442/************************************************************************/ 443 444/** 445 * The size of the largest drawing command known to the implementation 446 * that will use the GLXRender GLX command. In this case it is 447 * \c glPolygonStipple. 448 */ 449#define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156 450 451/** 452 * To keep the implementation fast, the code uses a "limit" pointer 453 * to determine when the drawing command buffer is too full to hold 454 * another fixed size command. This constant defines the amount of 455 * space that must always be available in the drawing command buffer 456 * at all times for the implementation to work. It is important that 457 * the number be just large enough, but not so large as to reduce the 458 * efficacy of the buffer. The "+32" is just to keep the code working 459 * in case somebody counts wrong. 460 */ 461#define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32) 462 463/** 464 * This implementation uses a smaller threshold for switching 465 * to the RenderLarge protocol than the protcol requires so that 466 * large copies don't occur. 467 */ 468#define __GLX_RENDER_CMD_SIZE_LIMIT 4096 469 470/** 471 * One of these records exists per screen of the display. It contains 472 * a pointer to the config data for that screen (if the screen supports GL). 473 */ 474struct glx_screen_vtable { 475 struct glx_context *(*create_context)(struct glx_screen *psc, 476 struct glx_config *config, 477 struct glx_context *shareList, 478 int renderType); 479}; 480 481struct glx_screen 482{ 483 const struct glx_screen_vtable *vtable; 484 485 /** 486 * GLX extension string reported by the X-server. 487 */ 488 const char *serverGLXexts; 489 490 /** 491 * GLX extension string to be reported to applications. This is the 492 * set of extensions that the application can actually use. 493 */ 494 char *effectiveGLXexts; 495 496 struct glx_display *display; 497 498 Display *dpy; 499 int scr; 500 501#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 502 /** 503 * Per screen direct rendering interface functions and data. 504 */ 505 __GLXDRIscreen *driScreen; 506#endif 507 508 /** 509 * Linked list of glx visuals and fbconfigs for this screen. 510 */ 511 struct glx_config *visuals, *configs; 512 513 /** 514 * Per-screen dynamic GLX extension tracking. The \c direct_support 515 * field only contains enough bits for 64 extensions. Should libGL 516 * ever need to track more than 64 GLX extensions, we can safely grow 517 * this field. The \c struct glx_screen structure is not used outside 518 * libGL. 519 */ 520 /*@{ */ 521 unsigned char direct_support[8]; 522 GLboolean ext_list_first_time; 523 /*@} */ 524 525}; 526 527/** 528 * Per display private data. One of these records exists for each display 529 * that is using the OpenGL (GLX) extension. 530 */ 531struct glx_display 532{ 533 /* The extension protocol codes */ 534 XExtCodes *codes; 535 struct glx_display *next; 536 537 /** 538 * Back pointer to the display 539 */ 540 Display *dpy; 541 542 /** 543 * The \c majorOpcode is common to all connections to the same server. 544 * It is also copied into the context structure. 545 */ 546 int majorOpcode; 547 548 /** 549 * \name Server Version 550 * 551 * Major and minor version returned by the server during initialization. 552 */ 553 /*@{ */ 554 int majorVersion, minorVersion; 555 /*@} */ 556 557 /** 558 * \name Storage for the servers GLX vendor and versions strings. 559 * 560 * These are the same for all screens on this display. These fields will 561 * be filled in on demand. 562 */ 563 /*@{ */ 564 const char *serverGLXvendor; 565 const char *serverGLXversion; 566 /*@} */ 567 568 /** 569 * Configurations of visuals for all screens on this display. 570 * Also, per screen data which now includes the server \c GLX_EXTENSION 571 * string. 572 */ 573 struct glx_screen **screens; 574 575#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 576 __glxHashTable *drawHash; 577 578 /** 579 * Per display direct rendering interface functions and data. 580 */ 581 __GLXDRIdisplay *driswDisplay; 582 __GLXDRIdisplay *driDisplay; 583 __GLXDRIdisplay *dri2Display; 584#endif 585}; 586 587extern int 588glx_screen_init(struct glx_screen *psc, 589 int screen, struct glx_display * priv); 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