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