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