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