glxclient.h revision 9e546ecfd446abf1236cdb0b9469157de5d084ce
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#include <GL/internal/dri_interface.h> 105 106/** 107 * Display dependent methods. This structure is initialized during the 108 * \c driCreateDisplay call. 109 */ 110typedef struct __GLXDRIdisplayRec __GLXDRIdisplay; 111typedef struct __GLXDRIscreenRec __GLXDRIscreen; 112typedef struct __GLXDRIdrawableRec __GLXDRIdrawable; 113typedef struct __GLXDRIcontextRec __GLXDRIcontext; 114 115#include "glxextensions.h" 116 117struct __GLXDRIdisplayRec 118{ 119 /** 120 * Method to destroy the private DRI display data. 121 */ 122 void (*destroyDisplay) (__GLXDRIdisplay * display); 123 124 __GLXscreenConfigs *(*createScreen)(int screen, __GLXdisplayPrivate * priv); 125}; 126 127struct __GLXDRIscreenRec { 128 129 void (*destroyScreen)(__GLXscreenConfigs *psc); 130 131 __GLXDRIcontext *(*createContext)(__GLXscreenConfigs *psc, 132 const __GLcontextModes *mode, 133 GLXContext gc, 134 GLXContext shareList, int renderType); 135 136 __GLXDRIdrawable *(*createDrawable)(__GLXscreenConfigs *psc, 137 XID drawable, 138 GLXDrawable glxDrawable, 139 const __GLcontextModes *modes); 140 141 int64_t (*swapBuffers)(__GLXDRIdrawable *pdraw, int64_t target_msc, 142 int64_t divisor, int64_t remainder); 143 void (*copySubBuffer)(__GLXDRIdrawable *pdraw, 144 int x, int y, int width, int height); 145 void (*waitX)(__GLXDRIdrawable *pdraw); 146 void (*waitGL)(__GLXDRIdrawable *pdraw); 147 int (*getDrawableMSC)(__GLXscreenConfigs *psc, __GLXDRIdrawable *pdraw, 148 int64_t *ust, int64_t *msc, int64_t *sbc); 149 int (*waitForMSC)(__GLXDRIdrawable *pdraw, int64_t target_msc, 150 int64_t divisor, int64_t remainder, int64_t *ust, 151 int64_t *msc, int64_t *sbc); 152 int (*waitForSBC)(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust, 153 int64_t *msc, int64_t *sbc); 154 void (*setSwapInterval)(__GLXDRIdrawable *pdraw, int interval); 155 int (*getSwapInterval)(__GLXDRIdrawable *pdraw); 156}; 157 158struct __GLXDRIcontextRec 159{ 160 void (*destroyContext) (__GLXDRIcontext * context, 161 __GLXscreenConfigs * psc, Display * dpy); 162 Bool(*bindContext) (__GLXDRIcontext * context, __GLXDRIdrawable * pdraw, 163 __GLXDRIdrawable * pread); 164 165 void (*unbindContext) (__GLXDRIcontext * context); 166}; 167 168struct __GLXDRIdrawableRec 169{ 170 void (*destroyDrawable) (__GLXDRIdrawable * drawable); 171 172 XID xDrawable; 173 XID drawable; 174 __GLXscreenConfigs *psc; 175 GLenum textureTarget; 176 __DRIdrawable *driDrawable; 177 GLenum textureFormat; /* EXT_texture_from_pixmap support */ 178 unsigned long eventMask; 179}; 180 181/* 182** Function to create and DRI display data and initialize the display 183** dependent methods. 184*/ 185extern __GLXDRIdisplay *driswCreateDisplay(Display * dpy); 186extern __GLXDRIdisplay *driCreateDisplay(Display * dpy); 187extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy); 188extern void dri2InvalidateBuffers(Display *dpy, XID drawable); 189 190 191/* 192** Functions to obtain driver configuration information from a direct 193** rendering client application 194*/ 195extern const char *glXGetScreenDriver(Display * dpy, int scrNum); 196 197extern const char *glXGetDriverConfig(const char *driverName); 198 199#endif 200 201/************************************************************************/ 202 203#define __GL_CLIENT_ATTRIB_STACK_DEPTH 16 204 205typedef struct __GLXpixelStoreModeRec 206{ 207 GLboolean swapEndian; 208 GLboolean lsbFirst; 209 GLuint rowLength; 210 GLuint imageHeight; 211 GLuint imageDepth; 212 GLuint skipRows; 213 GLuint skipPixels; 214 GLuint skipImages; 215 GLuint alignment; 216} __GLXpixelStoreMode; 217 218 219typedef struct __GLXattributeRec 220{ 221 GLuint mask; 222 223 /** 224 * Pixel storage state. Most of the pixel store mode state is kept 225 * here and used by the client code to manage the packing and 226 * unpacking of data sent to/received from the server. 227 */ 228 __GLXpixelStoreMode storePack, storeUnpack; 229 230 /** 231 * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically 232 * disabled? 233 */ 234 GLboolean NoDrawArraysProtocol; 235 236 /** 237 * Vertex Array storage state. The vertex array component 238 * state is stored here and is used to manage the packing of 239 * DrawArrays data sent to the server. 240 */ 241 struct array_state_vector *array_state; 242} __GLXattribute; 243 244typedef struct __GLXattributeMachineRec 245{ 246 __GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]; 247 __GLXattribute **stackPointer; 248} __GLXattributeMachine; 249 250struct glx_context_vtable { 251 void (*bind_tex_image)(Display * dpy, 252 GLXDrawable drawable, 253 int buffer, const int *attrib_list); 254 void (*release_tex_image)(Display * dpy, GLXDrawable drawable, int buffer); 255 256}; 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 * Record the dpy this context was created on for later freeing 396 */ 397 Display *createDpy; 398 399 /** 400 * Maximum small render command size. This is the smaller of 64k and 401 * the size of the above buffer. 402 */ 403 GLint maxSmallRenderCommandSize; 404 405 /** 406 * Major opcode for the extension. Copied here so a lookup isn't 407 * needed. 408 */ 409 GLint majorOpcode; 410 411 /** 412 * Pointer to the mode used to create this context. 413 */ 414 const __GLcontextModes *mode; 415 416#ifdef GLX_DIRECT_RENDERING 417#ifdef GLX_USE_APPLEGL 418 void *driContext; 419 Bool do_destroy; 420#else 421 __GLXDRIcontext *driContext; 422 __DRIcontext *__driContext; 423#endif 424#endif 425 426 /** 427 * The current read-drawable for this context. Will be None if this 428 * context is not current to any drawable. 429 * 430 * \since Internal API version 20030606. 431 */ 432 GLXDrawable currentReadable; 433 434 /** 435 * Pointer to client-state data that is private to libGL. This is only 436 * used for indirect rendering contexts. 437 * 438 * No internal API version change was made for this change. Client-side 439 * drivers should NEVER use this data or even care that it exists. 440 */ 441 void *client_state_private; 442 443 /** 444 * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE. 445 */ 446 int renderType; 447 448 /** 449 * \name Raw server GL version 450 * 451 * True core GL version supported by the server. This is the raw value 452 * returned by the server, and it may not reflect what is actually 453 * supported (or reported) by the client-side library. 454 */ 455 /*@{ */ 456 int server_major; /**< Major version number. */ 457 int server_minor; /**< Minor version number. */ 458 /*@} */ 459 460 /** 461 * Thread ID we're currently current in. Zero if none. 462 */ 463 unsigned long thread_id; 464 465 char gl_extension_bits[__GL_EXT_BYTES]; 466 467 const struct glx_context_vtable *vtable; 468}; 469 470#define __glXSetError(gc,code) \ 471 if (!(gc)->error) { \ 472 (gc)->error = code; \ 473 } 474 475extern void __glFreeAttributeState(__GLXcontext *); 476 477/************************************************************************/ 478 479/** 480 * The size of the largest drawing command known to the implementation 481 * that will use the GLXRender GLX command. In this case it is 482 * \c glPolygonStipple. 483 */ 484#define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156 485 486/** 487 * To keep the implementation fast, the code uses a "limit" pointer 488 * to determine when the drawing command buffer is too full to hold 489 * another fixed size command. This constant defines the amount of 490 * space that must always be available in the drawing command buffer 491 * at all times for the implementation to work. It is important that 492 * the number be just large enough, but not so large as to reduce the 493 * efficacy of the buffer. The "+32" is just to keep the code working 494 * in case somebody counts wrong. 495 */ 496#define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32) 497 498/** 499 * This implementation uses a smaller threshold for switching 500 * to the RenderLarge protocol than the protcol requires so that 501 * large copies don't occur. 502 */ 503#define __GLX_RENDER_CMD_SIZE_LIMIT 4096 504 505/** 506 * One of these records exists per screen of the display. It contains 507 * a pointer to the config data for that screen (if the screen supports GL). 508 */ 509struct __GLXscreenConfigsRec 510{ 511 /** 512 * GLX extension string reported by the X-server. 513 */ 514 const char *serverGLXexts; 515 516 /** 517 * GLX extension string to be reported to applications. This is the 518 * set of extensions that the application can actually use. 519 */ 520 char *effectiveGLXexts; 521 522 /** 523 * Context vtable to use for direct contexts on this screen 524 */ 525 const struct glx_context_vtable *direct_context_vtable; 526 527#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 528 /** 529 * Per screen direct rendering interface functions and data. 530 */ 531 __DRIscreen *__driScreen; 532 __glxHashTable *drawHash; 533 Display *dpy; 534 int scr; 535 536 __GLXDRIscreen *driScreen; 537 538 const __DRIconfig **driver_configs; 539 540#ifdef __DRI_COPY_SUB_BUFFER 541 const __DRIcopySubBufferExtension *driCopySubBuffer; 542#endif 543 544#ifdef __DRI_SWAP_CONTROL 545 const __DRIswapControlExtension *swapControl; 546#endif 547 548#ifdef __DRI_FRAME_TRACKING 549 const __DRIframeTrackingExtension *frameTracking; 550#endif 551 552#ifdef __DRI_MEDIA_STREAM_COUNTER 553 const __DRImediaStreamCounterExtension *msc; 554#endif 555 556#endif 557 558 /** 559 * Linked list of glx visuals and fbconfigs for this screen. 560 */ 561 __GLcontextModes *visuals, *configs; 562 563 /** 564 * Per-screen dynamic GLX extension tracking. The \c direct_support 565 * field only contains enough bits for 64 extensions. Should libGL 566 * ever need to track more than 64 GLX extensions, we can safely grow 567 * this field. The \c __GLXscreenConfigs structure is not used outside 568 * libGL. 569 */ 570 /*@{ */ 571 unsigned char direct_support[8]; 572 GLboolean ext_list_first_time; 573 /*@} */ 574 575}; 576 577/** 578 * Per display private data. One of these records exists for each display 579 * that is using the OpenGL (GLX) extension. 580 */ 581struct __GLXdisplayPrivateRec 582{ 583 /** 584 * Back pointer to the display 585 */ 586 Display *dpy; 587 588 /** 589 * The \c majorOpcode is common to all connections to the same server. 590 * It is also copied into the context structure. 591 */ 592 int majorOpcode; 593 594 /** 595 * \name Server Version 596 * 597 * Major and minor version returned by the server during initialization. 598 */ 599 /*@{ */ 600 int majorVersion, minorVersion; 601 /*@} */ 602 603 /** 604 * \name Storage for the servers GLX vendor and versions strings. 605 * 606 * These are the same for all screens on this display. These fields will 607 * be filled in on demand. 608 */ 609 /*@{ */ 610 const char *serverGLXvendor; 611 const char *serverGLXversion; 612 /*@} */ 613 614 /** 615 * Configurations of visuals for all screens on this display. 616 * Also, per screen data which now includes the server \c GLX_EXTENSION 617 * string. 618 */ 619 __GLXscreenConfigs **screenConfigs; 620 621#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 622 /** 623 * Per display direct rendering interface functions and data. 624 */ 625 __GLXDRIdisplay *driswDisplay; 626 __GLXDRIdisplay *driDisplay; 627 __GLXDRIdisplay *dri2Display; 628#endif 629}; 630 631extern int 632glx_screen_init(__GLXscreenConfigs *psc, 633 int screen, __GLXdisplayPrivate * priv); 634 635extern __GLXDRIdrawable * 636dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id); 637 638extern GLubyte *__glXFlushRenderBuffer(__GLXcontext *, GLubyte *); 639 640extern void __glXSendLargeChunk(__GLXcontext * gc, GLint requestNumber, 641 GLint totalRequests, 642 const GLvoid * data, GLint dataLen); 643 644extern void __glXSendLargeCommand(__GLXcontext *, const GLvoid *, GLint, 645 const GLvoid *, GLint); 646 647/* Initialize the GLX extension for dpy */ 648extern __GLXdisplayPrivate *__glXInitialize(Display *); 649 650extern void __glXPreferEGL(int state); 651 652/************************************************************************/ 653 654extern int __glXDebug; 655 656/* This is per-thread storage in an MT environment */ 657#if defined( PTHREADS ) 658 659extern void __glXSetCurrentContext(__GLXcontext * c); 660 661# if defined( GLX_USE_TLS ) 662 663extern __thread void *__glX_tls_Context 664 __attribute__ ((tls_model("initial-exec"))); 665 666# define __glXGetCurrentContext() __glX_tls_Context 667 668# else 669 670extern __GLXcontext *__glXGetCurrentContext(void); 671 672# endif /* defined( GLX_USE_TLS ) */ 673 674#else 675 676extern __GLXcontext *__glXcurrentContext; 677#define __glXGetCurrentContext() __glXcurrentContext 678#define __glXSetCurrentContext(gc) __glXcurrentContext = gc 679 680#endif /* defined( PTHREADS ) */ 681 682extern void __glXSetCurrentContextNull(void); 683 684extern void __glXFreeContext(__GLXcontext *); 685 686 687/* 688** Global lock for all threads in this address space using the GLX 689** extension 690*/ 691#if defined( PTHREADS ) 692extern pthread_mutex_t __glXmutex; 693#define __glXLock() pthread_mutex_lock(&__glXmutex) 694#define __glXUnlock() pthread_mutex_unlock(&__glXmutex) 695#else 696#define __glXLock() 697#define __glXUnlock() 698#endif 699 700/* 701** Setup for a command. Initialize the extension for dpy if necessary. 702*/ 703extern CARD8 __glXSetupForCommand(Display * dpy); 704 705/************************************************************************/ 706 707/* 708** Data conversion and packing support. 709*/ 710 711extern const GLuint __glXDefaultPixelStore[9]; 712 713/* Send an image to the server using RenderLarge. */ 714extern void __glXSendLargeImage(__GLXcontext * gc, GLint compsize, GLint dim, 715 GLint width, GLint height, GLint depth, 716 GLenum format, GLenum type, 717 const GLvoid * src, GLubyte * pc, 718 GLubyte * modes); 719 720/* Return the size, in bytes, of some pixel data */ 721extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum); 722 723/* Return the number of elements per group of a specified format*/ 724extern GLint __glElementsPerGroup(GLenum format, GLenum type); 725 726/* Return the number of bytes per element, based on the element type (other 727** than GL_BITMAP). 728*/ 729extern GLint __glBytesPerElement(GLenum type); 730 731/* 732** Fill the transport buffer with the data from the users buffer, 733** applying some of the pixel store modes (unpack modes) to the data 734** first. As a side effect of this call, the "modes" field is 735** updated to contain the modes needed by the server to decode the 736** sent data. 737*/ 738extern void __glFillImage(__GLXcontext *, GLint, GLint, GLint, GLint, GLenum, 739 GLenum, const GLvoid *, GLubyte *, GLubyte *); 740 741/* Copy map data with a stride into a packed buffer */ 742extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *); 743extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *); 744extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint, 745 const GLfloat *, GLfloat *); 746extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint, 747 const GLdouble *, GLdouble *); 748 749/* 750** Empty an image out of the reply buffer into the clients memory applying 751** the pack modes to pack back into the clients requested format. 752*/ 753extern void __glEmptyImage(__GLXcontext *, GLint, GLint, GLint, GLint, GLenum, 754 GLenum, const GLubyte *, GLvoid *); 755 756 757/* 758** Allocate and Initialize Vertex Array client state, and free. 759*/ 760extern void __glXInitVertexArrayState(__GLXcontext *); 761extern void __glXFreeVertexArrayState(__GLXcontext *); 762 763/* 764** Inform the Server of the major and minor numbers and of the client 765** libraries extension string. 766*/ 767extern void __glXClientInfo(Display * dpy, int opcode); 768 769/************************************************************************/ 770 771/* 772** Declarations that should be in Xlib 773*/ 774#ifdef __GL_USE_OUR_PROTOTYPES 775extern void _XFlush(Display *); 776extern Status _XReply(Display *, xReply *, int, Bool); 777extern void _XRead(Display *, void *, long); 778extern void _XSend(Display *, const void *, long); 779#endif 780 781 782extern void __glXInitializeVisualConfigFromTags(__GLcontextModes * config, 783 int count, const INT32 * bp, 784 Bool tagged_only, 785 Bool fbconfig_style_tags); 786 787extern char *__glXQueryServerString(Display * dpy, int opcode, 788 CARD32 screen, CARD32 name); 789extern char *__glXGetString(Display * dpy, int opcode, 790 CARD32 screen, CARD32 name); 791 792extern char *__glXstrdup(const char *str); 793 794 795extern const char __glXGLClientVersion[]; 796extern const char __glXGLClientExtensions[]; 797 798/* Get the unadjusted system time */ 799extern int __glXGetUST(int64_t * ust); 800 801extern GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable, 802 int32_t * numerator, 803 int32_t * denominator); 804 805#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 806GLboolean 807__driGetMscRateOML(__DRIdrawable * draw, 808 int32_t * numerator, int32_t * denominator, void *private); 809 810/* So that dri2.c:DRI2WireToEvent() can access 811 * glx_info->codes->first_event */ 812XExtDisplayInfo *__glXFindDisplay (Display *dpy); 813 814extern __GLXDRIdrawable * 815GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable, int *const scrn_num); 816 817#endif 818 819#endif /* !__GLX_client_h__ */ 820