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