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