glxclient.h revision 6e8897ff9f90601ebf6eed500ad942c11b54d1f7
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#define NEED_REPLIES 41#define NEED_EVENTS 42#include <X11/Xproto.h> 43#include <X11/Xlibint.h> 44#include <X11/extensions/extutil.h> 45#define GLX_GLXEXT_PROTOTYPES 46#include <GL/glx.h> 47#include <GL/glxext.h> 48#include <string.h> 49#include <stdlib.h> 50#include <stdio.h> 51#ifdef WIN32 52#include <stdint.h> 53#endif 54#include "GL/glxint.h" 55#include "GL/glxproto.h" 56#include "GL/internal/glcore.h" 57#include "glapi/glapitable.h" 58#include "glxhash.h" 59#if defined( PTHREADS ) 60# include <pthread.h> 61#endif 62 63#include "glxextensions.h" 64 65 66/* If we build the library with gcc's -fvisibility=hidden flag, we'll 67 * use the PUBLIC macro to mark functions that are to be exported. 68 * 69 * We also need to define a USED attribute, so the optimizer doesn't 70 * inline a static function that we later use in an alias. - ajax 71 */ 72#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303 73# define PUBLIC __attribute__((visibility("default"))) 74# define USED __attribute__((used)) 75#else 76# define PUBLIC 77# define USED 78#endif 79 80 81 82#define GLX_MAJOR_VERSION 1 /* current version numbers */ 83#define GLX_MINOR_VERSION 4 84 85#define __GLX_MAX_TEXTURE_UNITS 32 86 87typedef struct __GLXscreenConfigsRec __GLXscreenConfigs; 88typedef struct __GLXcontextRec __GLXcontext; 89typedef struct __GLXdrawableRec __GLXdrawable; 90typedef struct __GLXdisplayPrivateRec __GLXdisplayPrivate; 91typedef struct _glapi_table __GLapi; 92 93/************************************************************************/ 94 95#ifdef GLX_DIRECT_RENDERING 96 97#define containerOf(ptr, type, member) \ 98 (type *)( (char *)ptr - offsetof(type,member) ) 99 100#include <GL/internal/dri_interface.h> 101 102 103/** 104 * Display dependent methods. This structure is initialized during the 105 * \c driCreateDisplay call. 106 */ 107typedef struct __GLXDRIdisplayRec __GLXDRIdisplay; 108typedef struct __GLXDRIscreenRec __GLXDRIscreen; 109typedef struct __GLXDRIdrawableRec __GLXDRIdrawable; 110typedef struct __GLXDRIcontextRec __GLXDRIcontext; 111 112#include "glxextensions.h" 113 114struct __GLXDRIdisplayRec 115{ 116 /** 117 * Method to destroy the private DRI display data. 118 */ 119 void (*destroyDisplay) (__GLXDRIdisplay * display); 120 121 __GLXDRIscreen *(*createScreen) (__GLXscreenConfigs * psc, int screen, 122 __GLXdisplayPrivate * priv); 123}; 124 125struct __GLXDRIscreenRec { 126 127 void (*destroyScreen)(__GLXscreenConfigs *psc); 128 129 __GLXDRIcontext *(*createContext)(__GLXscreenConfigs *psc, 130 const __GLcontextModes *mode, 131 GLXContext gc, 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 void (*waitX)(__GLXDRIdrawable *pdraw); 144 void (*waitGL)(__GLXDRIdrawable *pdraw); 145 int (*getDrawableMSC)(__GLXscreenConfigs *psc, __GLXDRIdrawable *pdraw, 146 int64_t *ust, int64_t *msc, int64_t *sbc); 147 int (*waitForMSC)(__GLXDRIdrawable *pdraw, int64_t target_msc, 148 int64_t divisor, int64_t remainder, int64_t *ust, 149 int64_t *msc, int64_t *sbc); 150 int (*waitForSBC)(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust, 151 int64_t *msc, int64_t *sbc); 152 void (*setSwapInterval)(__GLXDRIdrawable *pdraw, int interval); 153 int (*getSwapInterval)(__GLXDRIdrawable *pdraw); 154}; 155 156struct __GLXDRIcontextRec 157{ 158 void (*destroyContext) (__GLXDRIcontext * context, 159 __GLXscreenConfigs * psc, Display * dpy); 160 Bool(*bindContext) (__GLXDRIcontext * context, __GLXDRIdrawable * pdraw, 161 __GLXDRIdrawable * pread); 162 163 void (*unbindContext) (__GLXDRIcontext * context); 164}; 165 166struct __GLXDRIdrawableRec 167{ 168 void (*destroyDrawable) (__GLXDRIdrawable * drawable); 169 170 XID xDrawable; 171 XID drawable; 172 __GLXscreenConfigs *psc; 173 GLenum textureTarget; 174 __DRIdrawable *driDrawable; 175 GLenum textureFormat; /* EXT_texture_from_pixmap support */ 176}; 177 178/* 179** Function to create and DRI display data and initialize the display 180** dependent methods. 181*/ 182extern __GLXDRIdisplay *driswCreateDisplay(Display * dpy); 183extern __GLXDRIdisplay *driCreateDisplay(Display * dpy); 184extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy); 185 186extern void DRI_glXUseXFont(Font font, int first, int count, int listbase); 187 188/* 189** Functions to obtain driver configuration information from a direct 190** rendering client application 191*/ 192extern const char *glXGetScreenDriver(Display * dpy, int scrNum); 193 194extern const char *glXGetDriverConfig(const char *driverName); 195 196#endif 197 198/************************************************************************/ 199 200#define __GL_CLIENT_ATTRIB_STACK_DEPTH 16 201 202typedef struct __GLXpixelStoreModeRec 203{ 204 GLboolean swapEndian; 205 GLboolean lsbFirst; 206 GLuint rowLength; 207 GLuint imageHeight; 208 GLuint imageDepth; 209 GLuint skipRows; 210 GLuint skipPixels; 211 GLuint skipImages; 212 GLuint alignment; 213} __GLXpixelStoreMode; 214 215 216typedef struct __GLXattributeRec 217{ 218 GLuint mask; 219 220 /** 221 * Pixel storage state. Most of the pixel store mode state is kept 222 * here and used by the client code to manage the packing and 223 * unpacking of data sent to/received from the server. 224 */ 225 __GLXpixelStoreMode storePack, storeUnpack; 226 227 /** 228 * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically 229 * disabled? 230 */ 231 GLboolean NoDrawArraysProtocol; 232 233 /** 234 * Vertex Array storage state. The vertex array component 235 * state is stored here and is used to manage the packing of 236 * DrawArrays data sent to the server. 237 */ 238 struct array_state_vector *array_state; 239} __GLXattribute; 240 241typedef struct __GLXattributeMachineRec 242{ 243 __GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]; 244 __GLXattribute **stackPointer; 245} __GLXattributeMachine; 246 247/** 248 * GLX state that needs to be kept on the client. One of these records 249 * exist for each context that has been made current by this client. 250 */ 251struct __GLXcontextRec 252{ 253 /** 254 * \name Drawing command buffer. 255 * 256 * Drawing commands are packed into this buffer before being sent as a 257 * single GLX protocol request. The buffer is sent when it overflows or 258 * is flushed by \c __glXFlushRenderBuffer. \c pc is the next location 259 * in the buffer to be filled. \c limit is described above in the buffer 260 * slop discussion. 261 * 262 * Commands that require large amounts of data to be transfered will 263 * also use this buffer to hold a header that describes the large 264 * command. 265 * 266 * These must be the first 6 fields since they are static initialized 267 * in the dummy context in glxext.c 268 */ 269 /*@{ */ 270 GLubyte *buf; 271 GLubyte *pc; 272 GLubyte *limit; 273 GLubyte *bufEnd; 274 GLint bufSize; 275 /*@} */ 276 277 /** 278 * The XID of this rendering context. When the context is created a 279 * new XID is allocated. This is set to None when the context is 280 * destroyed but is still current to some thread. In this case the 281 * context will be freed on next MakeCurrent. 282 */ 283 XID xid; 284 285 /** 286 * The XID of the \c shareList context. 287 */ 288 XID share_xid; 289 290 /** 291 * Screen number. 292 */ 293 GLint screen; 294 __GLXscreenConfigs *psc; 295 296 /** 297 * \c GL_TRUE if the context was created with ImportContext, which 298 * means the server-side context was created by another X client. 299 */ 300 GLboolean imported; 301 302 /** 303 * The context tag returned by MakeCurrent when this context is made 304 * current. This tag is used to identify the context that a thread has 305 * current so that proper server context management can be done. It is 306 * used for all context specific commands (i.e., \c Render, \c RenderLarge, 307 * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old 308 * context)). 309 */ 310 GLXContextTag currentContextTag; 311 312 /** 313 * \name Rendering mode 314 * 315 * The rendering mode is kept on the client as well as the server. 316 * When \c glRenderMode is called, the buffer associated with the 317 * previous rendering mode (feedback or select) is filled. 318 */ 319 /*@{ */ 320 GLenum renderMode; 321 GLfloat *feedbackBuf; 322 GLuint *selectBuf; 323 /*@} */ 324 325 /** 326 * This is \c GL_TRUE if the pixel unpack modes are such that an image 327 * can be unpacked from the clients memory by just copying. It may 328 * still be true that the server will have to do some work. This 329 * just promises that a straight copy will fetch the correct bytes. 330 */ 331 GLboolean fastImageUnpack; 332 333 /** 334 * Fill newImage with the unpacked form of \c oldImage getting it 335 * ready for transport to the server. 336 */ 337 void (*fillImage) (__GLXcontext *, GLint, GLint, GLint, GLint, GLenum, 338 GLenum, const GLvoid *, GLubyte *, GLubyte *); 339 340 /** 341 * Client side attribs. 342 */ 343 __GLXattributeMachine attributes; 344 345 /** 346 * Client side error code. This is set when client side gl API 347 * routines need to set an error because of a bad enumerant or 348 * running out of memory, etc. 349 */ 350 GLenum error; 351 352 /** 353 * Whether this context does direct rendering. 354 */ 355 Bool isDirect; 356 357 /** 358 * \c dpy of current display for this context. Will be \c NULL if not 359 * current to any display, or if this is the "dummy context". 360 */ 361 Display *currentDpy; 362 363 /** 364 * The current drawable for this context. Will be None if this 365 * context is not current to any drawable. currentReadable is below. 366 */ 367 GLXDrawable currentDrawable; 368 369 /** 370 * \name GL Constant Strings 371 * 372 * Constant strings that describe the server implementation 373 * These pertain to GL attributes, not to be confused with 374 * GLX versioning attributes. 375 */ 376 /*@{ */ 377 GLubyte *vendor; 378 GLubyte *renderer; 379 GLubyte *version; 380 GLubyte *extensions; 381 /*@} */ 382 383 /** 384 * Record the dpy this context was created on for later freeing 385 */ 386 Display *createDpy; 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 __GLXDRIcontext *driContext; 407 __DRIcontext *__driContext; 408#endif 409 410 /** 411 * The current read-drawable for this context. Will be None if this 412 * context is not current to any drawable. 413 * 414 * \since Internal API version 20030606. 415 */ 416 GLXDrawable currentReadable; 417 418 /** 419 * Pointer to client-state data that is private to libGL. This is only 420 * used for indirect rendering contexts. 421 * 422 * No internal API version change was made for this change. Client-side 423 * drivers should NEVER use this data or even care that it exists. 424 */ 425 void *client_state_private; 426 427 /** 428 * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE. 429 */ 430 int renderType; 431 432 /** 433 * \name Raw server GL version 434 * 435 * True core GL version supported by the server. This is the raw value 436 * returned by the server, and it may not reflect what is actually 437 * supported (or reported) by the client-side library. 438 */ 439 /*@{ */ 440 int server_major; /**< Major version number. */ 441 int server_minor; /**< Minor version number. */ 442 /*@} */ 443 444 /** 445 * Thread ID we're currently current in. Zero if none. 446 */ 447 unsigned long thread_id; 448 449 char gl_extension_bits[__GL_EXT_BYTES]; 450}; 451 452#define __glXSetError(gc,code) \ 453 if (!(gc)->error) { \ 454 (gc)->error = code; \ 455 } 456 457extern void __glFreeAttributeState(__GLXcontext *); 458 459/************************************************************************/ 460 461/** 462 * The size of the largest drawing command known to the implementation 463 * that will use the GLXRender GLX command. In this case it is 464 * \c glPolygonStipple. 465 */ 466#define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156 467 468/** 469 * To keep the implementation fast, the code uses a "limit" pointer 470 * to determine when the drawing command buffer is too full to hold 471 * another fixed size command. This constant defines the amount of 472 * space that must always be available in the drawing command buffer 473 * at all times for the implementation to work. It is important that 474 * the number be just large enough, but not so large as to reduce the 475 * efficacy of the buffer. The "+32" is just to keep the code working 476 * in case somebody counts wrong. 477 */ 478#define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32) 479 480/** 481 * This implementation uses a smaller threshold for switching 482 * to the RenderLarge protocol than the protcol requires so that 483 * large copies don't occur. 484 */ 485#define __GLX_RENDER_CMD_SIZE_LIMIT 4096 486 487/** 488 * One of these records exists per screen of the display. It contains 489 * a pointer to the config data for that screen (if the screen supports GL). 490 */ 491struct __GLXscreenConfigsRec 492{ 493 /** 494 * GLX extension string reported by the X-server. 495 */ 496 const char *serverGLXexts; 497 498 /** 499 * GLX extension string to be reported to applications. This is the 500 * set of extensions that the application can actually use. 501 */ 502 char *effectiveGLXexts; 503 504#ifdef GLX_DIRECT_RENDERING 505 /** 506 * Per screen direct rendering interface functions and data. 507 */ 508 __DRIscreen *__driScreen; 509 const __DRIcoreExtension *core; 510 const __DRIlegacyExtension *legacy; 511 const __DRIswrastExtension *swrast; 512 const __DRIdri2Extension *dri2; 513 __glxHashTable *drawHash; 514 Display *dpy; 515 int scr, fd; 516 void *driver; 517 518 __GLXDRIscreen *driScreen; 519 520 const __DRIconfig **driver_configs; 521 522#ifdef __DRI_COPY_SUB_BUFFER 523 const __DRIcopySubBufferExtension *driCopySubBuffer; 524#endif 525 526#ifdef __DRI_SWAP_CONTROL 527 const __DRIswapControlExtension *swapControl; 528#endif 529 530#ifdef __DRI_ALLOCATE 531 const __DRIallocateExtension *allocate; 532#endif 533 534#ifdef __DRI_FRAME_TRACKING 535 const __DRIframeTrackingExtension *frameTracking; 536#endif 537 538#ifdef __DRI_MEDIA_STREAM_COUNTER 539 const __DRImediaStreamCounterExtension *msc; 540#endif 541 542#ifdef __DRI_TEX_BUFFER 543 const __DRItexBufferExtension *texBuffer; 544#endif 545 546#ifdef __DRI2_FLUSH 547 const __DRI2flushExtension *f; 548#endif 549 550#endif 551 552 /** 553 * Linked list of glx visuals and fbconfigs for this screen. 554 */ 555 __GLcontextModes *visuals, *configs; 556 557 /** 558 * Per-screen dynamic GLX extension tracking. The \c direct_support 559 * field only contains enough bits for 64 extensions. Should libGL 560 * ever need to track more than 64 GLX extensions, we can safely grow 561 * this field. The \c __GLXscreenConfigs structure is not used outside 562 * libGL. 563 */ 564 /*@{ */ 565 unsigned char direct_support[8]; 566 GLboolean ext_list_first_time; 567 /*@} */ 568 569}; 570 571/** 572 * Per display private data. One of these records exists for each display 573 * that is using the OpenGL (GLX) extension. 574 */ 575struct __GLXdisplayPrivateRec 576{ 577 /** 578 * Back pointer to the display 579 */ 580 Display *dpy; 581 582 /** 583 * The \c majorOpcode is common to all connections to the same server. 584 * It is also copied into the context structure. 585 */ 586 int majorOpcode; 587 588 /** 589 * \name Server Version 590 * 591 * Major and minor version returned by the server during initialization. 592 */ 593 /*@{ */ 594 int majorVersion, minorVersion; 595 /*@} */ 596 597 /** 598 * \name Storage for the servers GLX vendor and versions strings. 599 * 600 * These are the same for all screens on this display. These fields will 601 * be filled in on demand. 602 */ 603 /*@{ */ 604 const char *serverGLXvendor; 605 const char *serverGLXversion; 606 /*@} */ 607 608 /** 609 * Configurations of visuals for all screens on this display. 610 * Also, per screen data which now includes the server \c GLX_EXTENSION 611 * string. 612 */ 613 __GLXscreenConfigs *screenConfigs; 614 615#ifdef GLX_DIRECT_RENDERING 616 /** 617 * Per display direct rendering interface functions and data. 618 */ 619 __GLXDRIdisplay *driswDisplay; 620 __GLXDRIdisplay *driDisplay; 621 __GLXDRIdisplay *dri2Display; 622#endif 623}; 624 625 626extern GLubyte *__glXFlushRenderBuffer(__GLXcontext *, GLubyte *); 627 628extern void __glXSendLargeChunk(__GLXcontext * gc, GLint requestNumber, 629 GLint totalRequests, 630 const GLvoid * data, GLint dataLen); 631 632extern void __glXSendLargeCommand(__GLXcontext *, const GLvoid *, GLint, 633 const GLvoid *, GLint); 634 635/* Initialize the GLX extension for dpy */ 636extern __GLXdisplayPrivate *__glXInitialize(Display *); 637 638extern void __glXPreferEGL(int state); 639 640/************************************************************************/ 641 642extern int __glXDebug; 643 644/* This is per-thread storage in an MT environment */ 645#if defined( PTHREADS ) 646 647extern void __glXSetCurrentContext(__GLXcontext * c); 648 649# if defined( GLX_USE_TLS ) 650 651extern __thread void *__glX_tls_Context 652 __attribute__ ((tls_model("initial-exec"))); 653 654# define __glXGetCurrentContext() __glX_tls_Context 655 656# else 657 658extern __GLXcontext *__glXGetCurrentContext(void); 659 660# endif /* defined( GLX_USE_TLS ) */ 661 662#else 663 664extern __GLXcontext *__glXcurrentContext; 665#define __glXGetCurrentContext() __glXcurrentContext 666#define __glXSetCurrentContext(gc) __glXcurrentContext = gc 667 668#endif /* defined( PTHREADS ) */ 669 670extern void __glXSetCurrentContextNull(void); 671 672extern void __glXFreeContext(__GLXcontext *); 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#ifdef GLX_DIRECT_RENDERING 794GLboolean 795__driGetMscRateOML(__DRIdrawable * draw, 796 int32_t * numerator, int32_t * denominator, void *private); 797 798/* So that dri2.c:DRI2WireToEvent() can access 799 * glx_info->codes->first_event */ 800XExtDisplayInfo *__glXFindDisplay (Display *dpy); 801#endif 802 803#endif /* !__GLX_client_h__ */ 804