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