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