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/Xfuncproto.h> 43 #include <X11/extensions/extutil.h> 44 #define GLX_GLXEXT_PROTOTYPES 45 #include <GL/glx.h> 46 #include <GL/glxext.h> 47 #include <string.h> 48 #include <stdlib.h> 49 #include <stdio.h> 50 #include <stdint.h> 51 #include <pthread.h> 52 #include "GL/glxproto.h" 53 #include "glxconfig.h" 54 #include "glxhash.h" 55 #include "util/macros.h" 56 #include "util/u_thread.h" 57 #include "util/set.h" 58 #include "loader.h" 59 #include "glxextensions.h" 60 61 #if defined(USE_LIBGLVND) 62 #define _GLX_PUBLIC _X_HIDDEN 63 #else 64 #define _GLX_PUBLIC _X_EXPORT 65 #endif 66 67 #ifdef __cplusplus 68 extern "C" { 69 #endif 70 71 extern void glx_message(int level, const char *f, ...) PRINTFLIKE(2, 3); 72 73 #define DebugMessageF(...) glx_message(_LOADER_DEBUG, __VA_ARGS__) 74 #define InfoMessageF(...) glx_message(_LOADER_INFO, __VA_ARGS__) 75 #define ErrorMessageF(...) glx_message(_LOADER_WARNING, __VA_ARGS__) 76 #define CriticalErrorMessageF(...) glx_message(_LOADER_FATAL, __VA_ARGS__) 77 78 79 #define GLX_MAJOR_VERSION 1 /* current version numbers */ 80 #define GLX_MINOR_VERSION 4 81 82 struct glx_display; 83 struct glx_context; 84 85 /************************************************************************/ 86 87 #ifdef GLX_DIRECT_RENDERING 88 89 extern void DRI_glXUseXFont(struct glx_context *ctx, 90 Font font, int first, int count, int listbase); 91 92 #endif 93 94 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 95 96 /** 97 * Display dependent methods. This structure is initialized during the 98 * \c driCreateDisplay call. 99 */ 100 typedef struct __GLXDRIdisplayRec __GLXDRIdisplay; 101 typedef struct __GLXDRIscreenRec __GLXDRIscreen; 102 typedef struct __GLXDRIdrawableRec __GLXDRIdrawable; 103 104 struct __GLXDRIdisplayRec 105 { 106 /** 107 * Method to destroy the private DRI display data. 108 */ 109 void (*destroyDisplay) (__GLXDRIdisplay * display); 110 111 struct glx_screen *(*createScreen)(int screen, struct glx_display * priv); 112 }; 113 114 struct __GLXDRIscreenRec { 115 116 void (*destroyScreen)(struct glx_screen *psc); 117 118 __GLXDRIdrawable *(*createDrawable)(struct glx_screen *psc, 119 XID drawable, 120 GLXDrawable glxDrawable, 121 int type, 122 struct glx_config *config); 123 124 int64_t (*swapBuffers)(__GLXDRIdrawable *pdraw, int64_t target_msc, 125 int64_t divisor, int64_t remainder, Bool flush); 126 void (*copySubBuffer)(__GLXDRIdrawable *pdraw, 127 int x, int y, int width, int height, Bool flush); 128 int (*getDrawableMSC)(struct glx_screen *psc, __GLXDRIdrawable *pdraw, 129 int64_t *ust, int64_t *msc, int64_t *sbc); 130 int (*waitForMSC)(__GLXDRIdrawable *pdraw, int64_t target_msc, 131 int64_t divisor, int64_t remainder, int64_t *ust, 132 int64_t *msc, int64_t *sbc); 133 int (*waitForSBC)(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust, 134 int64_t *msc, int64_t *sbc); 135 int (*setSwapInterval)(__GLXDRIdrawable *pdraw, int interval); 136 int (*getSwapInterval)(__GLXDRIdrawable *pdraw); 137 int (*getBufferAge)(__GLXDRIdrawable *pdraw); 138 void (*bindTexImage)(__GLXDRIdrawable *pdraw, int buffer, const int *attribs); 139 void (*releaseTexImage)(__GLXDRIdrawable *pdraw, int buffer); 140 141 int maxSwapInterval; 142 }; 143 144 struct __GLXDRIdrawableRec 145 { 146 void (*destroyDrawable) (__GLXDRIdrawable * drawable); 147 148 XID xDrawable; 149 XID drawable; 150 struct glx_screen *psc; 151 GLenum textureTarget; 152 GLenum textureFormat; /* EXT_texture_from_pixmap support */ 153 unsigned long eventMask; 154 int refcount; 155 }; 156 157 /* 158 ** Function to create and DRI display data and initialize the display 159 ** dependent methods. 160 */ 161 extern __GLXDRIdisplay *driswCreateDisplay(Display * dpy, bool zink); 162 extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy); 163 extern __GLXDRIdisplay *dri3_create_display(Display * dpy); 164 extern __GLXDRIdisplay *driwindowsCreateDisplay(Display * dpy); 165 166 /* 167 ** 168 */ 169 extern void dri2InvalidateBuffers(Display *dpy, XID drawable); 170 extern unsigned dri2GetSwapEventType(Display *dpy, XID drawable); 171 172 /* 173 ** Functions to obtain driver configuration information from a direct 174 ** rendering client application 175 */ 176 extern const char *glXGetScreenDriver(Display * dpy, int scrNum); 177 178 extern const char *glXGetDriverConfig(const char *driverName); 179 180 #endif 181 182 /************************************************************************/ 183 184 #define __GL_CLIENT_ATTRIB_STACK_DEPTH 16 185 186 typedef struct __GLXpixelStoreModeRec 187 { 188 GLboolean swapEndian; 189 GLboolean lsbFirst; 190 GLuint rowLength; 191 GLuint imageHeight; 192 GLuint imageDepth; 193 GLuint skipRows; 194 GLuint skipPixels; 195 GLuint skipImages; 196 GLuint alignment; 197 } __GLXpixelStoreMode; 198 199 200 typedef struct __GLXattributeRec 201 { 202 GLuint mask; 203 204 /** 205 * Pixel storage state. Most of the pixel store mode state is kept 206 * here and used by the client code to manage the packing and 207 * unpacking of data sent to/received from the server. 208 */ 209 __GLXpixelStoreMode storePack, storeUnpack; 210 211 /** 212 * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically 213 * disabled? 214 */ 215 GLboolean NoDrawArraysProtocol; 216 217 /** 218 * Vertex Array storage state. The vertex array component 219 * state is stored here and is used to manage the packing of 220 * DrawArrays data sent to the server. 221 */ 222 struct array_state_vector *array_state; 223 } __GLXattribute; 224 225 typedef struct __GLXattributeMachineRec 226 { 227 __GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]; 228 __GLXattribute **stackPointer; 229 } __GLXattributeMachine; 230 231 struct mesa_glinterop_device_info; 232 struct mesa_glinterop_export_in; 233 struct mesa_glinterop_export_out; 234 235 struct glx_context_vtable { 236 void (*destroy)(struct glx_context *ctx); 237 int (*bind)(struct glx_context *context, struct glx_context *old, 238 GLXDrawable draw, GLXDrawable read); 239 void (*unbind)(struct glx_context *context, struct glx_context *new_ctx); 240 void (*wait_gl)(struct glx_context *ctx); 241 void (*wait_x)(struct glx_context *ctx); 242 int (*interop_query_device_info)(struct glx_context *ctx, 243 struct mesa_glinterop_device_info *out); 244 int (*interop_export_object)(struct glx_context *ctx, 245 struct mesa_glinterop_export_in *in, 246 struct mesa_glinterop_export_out *out); 247 }; 248 249 /** 250 * GLX state that needs to be kept on the client. One of these records 251 * exist for each context that has been made current by this client. 252 */ 253 struct glx_context 254 { 255 /** 256 * \name Drawing command buffer. 257 * 258 * Drawing commands are packed into this buffer before being sent as a 259 * single GLX protocol request. The buffer is sent when it overflows or 260 * is flushed by \c __glXFlushRenderBuffer. \c pc is the next location 261 * in the buffer to be filled. \c limit is described above in the buffer 262 * slop discussion. 263 * 264 * Commands that require large amounts of data to be transfered will 265 * also use this buffer to hold a header that describes the large 266 * command. 267 * 268 * These must be the first 6 fields since they are static initialized 269 * in the dummy context in glxext.c 270 */ 271 /*@{ */ 272 GLubyte *buf; 273 GLubyte *pc; 274 GLubyte *limit; 275 GLubyte *bufEnd; 276 GLint bufSize; 277 /*@} */ 278 279 const struct glx_context_vtable *vtable; 280 281 /** 282 * The XID of this rendering context. When the context is created a 283 * new XID is allocated. This is set to None when the context is 284 * destroyed but is still current to some thread. In this case the 285 * context will be freed on next MakeCurrent. 286 */ 287 XID xid; 288 289 /** 290 * The XID of the \c shareList context. 291 */ 292 XID share_xid; 293 294 /** 295 * Screen number. 296 */ 297 GLint screen; 298 struct glx_screen *psc; 299 300 /** 301 * \c GL_TRUE if the context was created with ImportContext, which 302 * means the server-side context was created by another X client. 303 */ 304 GLboolean imported; 305 306 /** 307 * The context tag returned by MakeCurrent when this context is made 308 * current. This tag is used to identify the context that a thread has 309 * current so that proper server context management can be done. It is 310 * used for all context specific commands (i.e., \c Render, \c RenderLarge, 311 * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old 312 * context)). 313 */ 314 GLXContextTag currentContextTag; 315 316 /** 317 * \name Rendering mode 318 * 319 * The rendering mode is kept on the client as well as the server. 320 * When \c glRenderMode is called, the buffer associated with the 321 * previous rendering mode (feedback or select) is filled. 322 */ 323 /*@{ */ 324 GLenum renderMode; 325 GLfloat *feedbackBuf; 326 GLuint *selectBuf; 327 /*@} */ 328 329 /** 330 * Client side attribs. 331 */ 332 __GLXattributeMachine attributes; 333 334 /** 335 * Client side error code. This is set when client side gl API 336 * routines need to set an error because of a bad enumerant or 337 * running out of memory, etc. 338 */ 339 GLenum error; 340 341 /** 342 * Whether this context does direct rendering. 343 */ 344 Bool isDirect; 345 346 #if defined(GLX_DIRECT_RENDERING) && defined(GLX_USE_APPLEGL) 347 void *driContext; 348 #endif 349 350 /** 351 * \c dpy of current display for this context. Will be \c NULL if not 352 * current to any display, or if this is the "dummy context". 353 */ 354 Display *currentDpy; 355 356 /** 357 * The current drawable for this context. Will be None if this 358 * context is not current to any drawable. currentReadable is below. 359 */ 360 GLXDrawable currentDrawable; 361 362 /** 363 * \name GL Constant Strings 364 * 365 * Constant strings that describe the server implementation 366 * These pertain to GL attributes, not to be confused with 367 * GLX versioning attributes. 368 */ 369 /*@{ */ 370 GLubyte *vendor; 371 GLubyte *renderer; 372 GLubyte *version; 373 GLubyte *extensions; 374 /*@} */ 375 376 /** 377 * Maximum small render command size. This is the smaller of 64k and 378 * the size of the above buffer. 379 */ 380 GLint maxSmallRenderCommandSize; 381 382 /** 383 * Major opcode for the extension. Copied here so a lookup isn't 384 * needed. 385 */ 386 GLint majorOpcode; 387 388 /** 389 * Pointer to the config used to create this context. 390 */ 391 struct glx_config *config; 392 393 /** 394 * The current read-drawable for this context. Will be None if this 395 * context is not current to any drawable. 396 * 397 * \since Internal API version 20030606. 398 */ 399 GLXDrawable currentReadable; 400 401 /** 402 * Pointer to client-state data that is private to libGL. This is only 403 * used for indirect rendering contexts. 404 * 405 * No internal API version change was made for this change. Client-side 406 * drivers should NEVER use this data or even care that it exists. 407 */ 408 void *client_state_private; 409 410 /** 411 * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE. 412 */ 413 int renderType; 414 415 /** 416 * \name Raw server GL version 417 * 418 * True core GL version supported by the server. This is the raw value 419 * returned by the server, and it may not reflect what is actually 420 * supported (or reported) by the client-side library. 421 */ 422 /*@{ */ 423 int server_major; /**< Major version number. */ 424 int server_minor; /**< Minor version number. */ 425 /*@} */ 426 427 /** 428 * GLX_ARB_create_context_no_error setting for this context. 429 * This needs to be kept here to enforce shared context rules. 430 */ 431 Bool noError; 432 433 char gl_extension_bits[__GL_EXT_BYTES]; 434 }; 435 436 extern Bool 437 glx_context_init(struct glx_context *gc, 438 struct glx_screen *psc, struct glx_config *fbconfig); 439 440 #define __glXSetError(gc,code) \ 441 if (!(gc)->error) { \ 442 (gc)->error = code; \ 443 } 444 445 /************************************************************************/ 446 447 /** 448 * The size of the largest drawing command known to the implementation 449 * that will use the GLXRender GLX command. In this case it is 450 * \c glPolygonStipple. 451 */ 452 #define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156 453 454 /** 455 * To keep the implementation fast, the code uses a "limit" pointer 456 * to determine when the drawing command buffer is too full to hold 457 * another fixed size command. This constant defines the amount of 458 * space that must always be available in the drawing command buffer 459 * at all times for the implementation to work. It is important that 460 * the number be just large enough, but not so large as to reduce the 461 * efficacy of the buffer. The "+32" is just to keep the code working 462 * in case somebody counts wrong. 463 */ 464 #define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32) 465 466 /** 467 * This implementation uses a smaller threshold for switching 468 * to the RenderLarge protocol than the protcol requires so that 469 * large copies don't occur. 470 */ 471 #define __GLX_RENDER_CMD_SIZE_LIMIT 4096 472 473 /** 474 * One of these records exists per screen of the display. It contains 475 * a pointer to the config data for that screen (if the screen supports GL). 476 */ 477 struct glx_screen_vtable { 478 struct glx_context *(*create_context)(struct glx_screen *psc, 479 struct glx_config *config, 480 struct glx_context *shareList, 481 int renderType); 482 483 struct glx_context *(*create_context_attribs)(struct glx_screen *psc, 484 struct glx_config *config, 485 struct glx_context *shareList, 486 unsigned num_attrib, 487 const uint32_t *attribs, 488 unsigned *error); 489 int (*query_renderer_integer)(struct glx_screen *psc, 490 int attribute, 491 unsigned int *value); 492 int (*query_renderer_string)(struct glx_screen *psc, 493 int attribute, 494 const char **value); 495 496 char *(*get_driver_name)(struct glx_screen *psc); 497 }; 498 499 struct glx_screen 500 { 501 const struct glx_screen_vtable *vtable; 502 const struct glx_context_vtable *context_vtable; 503 504 /** 505 * \name Storage for the GLX vendor, version, and extension strings 506 */ 507 /*@{ */ 508 const char *serverGLXexts; 509 const char *serverGLXvendor; 510 const char *serverGLXversion; 511 /*@} */ 512 513 /** 514 * GLX extension string to be reported to applications. This is the 515 * set of extensions that the application can actually use. 516 */ 517 char *effectiveGLXexts; 518 519 struct glx_display *display; 520 521 Display *dpy; 522 int scr; 523 bool force_direct_context; 524 bool allow_invalid_glx_destroy_window; 525 bool keep_native_window_glx_drawable; 526 527 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 528 /** 529 * Per screen direct rendering interface functions and data. 530 */ 531 __GLXDRIscreen *driScreen; 532 #endif 533 534 /** 535 * Linked list of glx visuals and fbconfigs for this screen. 536 */ 537 struct glx_config *visuals, *configs; 538 539 /** 540 * Per-screen dynamic GLX extension tracking. The \c direct_support 541 * field only contains enough bits for 64 extensions. Should libGL 542 * ever need to track more than 64 GLX extensions, we can safely grow 543 * this field. The \c struct glx_screen structure is not used outside 544 * libGL. 545 */ 546 /*@{ */ 547 unsigned char direct_support[__GLX_EXT_BYTES]; 548 GLboolean ext_list_first_time; 549 550 unsigned char glx_force_enabled[__GLX_EXT_BYTES]; 551 unsigned char glx_force_disabled[__GLX_EXT_BYTES]; 552 553 unsigned char gl_force_enabled[__GL_EXT_BYTES]; 554 unsigned char gl_force_disabled[__GL_EXT_BYTES]; 555 /*@} */ 556 557 }; 558 559 /** 560 * Per display private data. One of these records exists for each display 561 * that is using the OpenGL (GLX) extension. 562 */ 563 struct glx_display 564 { 565 struct glx_display *next; 566 567 /* The extension protocol codes */ 568 XExtCodes codes; 569 570 /** 571 * Back pointer to the display 572 */ 573 Display *dpy; 574 575 /** 576 * \name Minor Version 577 * 578 * Minor version returned by the server during initialization. The major 579 * version is asserted to be 1 during extension setup. 580 */ 581 /*@{ */ 582 int minorVersion; 583 /*@} */ 584 585 /** 586 * Configurations of visuals for all screens on this display. 587 * Also, per screen data which now includes the server \c GLX_EXTENSION 588 * string. 589 */ 590 struct glx_screen **screens; 591 592 __glxHashTable *glXDrawHash; 593 594 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 595 __glxHashTable *drawHash; 596 597 /** 598 * GLXDrawable created from native window and about to be released. 599 */ 600 struct set *zombieGLXDrawable; 601 602 /** 603 * Per display direct rendering interface functions and data. 604 */ 605 __GLXDRIdisplay *driswDisplay; 606 __GLXDRIdisplay *dri2Display; 607 __GLXDRIdisplay *dri3Display; 608 #endif 609 #ifdef GLX_USE_WINDOWSGL 610 __GLXDRIdisplay *windowsdriDisplay; 611 #endif 612 }; 613 614 struct glx_drawable { 615 XID xDrawable; 616 XID drawable; 617 618 uint32_t lastEventSbc; 619 int64_t eventSbcWrap; 620 }; 621 622 extern int 623 glx_screen_init(struct glx_screen *psc, 624 int screen, struct glx_display * priv); 625 extern void 626 glx_screen_cleanup(struct glx_screen *psc); 627 628 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 629 extern __GLXDRIdrawable * 630 dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id); 631 #endif 632 633 extern GLubyte *__glXFlushRenderBuffer(struct glx_context *, GLubyte *); 634 635 extern void __glXSendLargeChunk(struct glx_context * gc, GLint requestNumber, 636 GLint totalRequests, 637 const GLvoid * data, GLint dataLen); 638 639 extern void __glXSendLargeCommand(struct glx_context *, const GLvoid *, GLint, 640 const GLvoid *, GLint); 641 642 /* Initialize the GLX extension for dpy */ 643 extern struct glx_display *__glXInitialize(Display *); 644 645 /************************************************************************/ 646 647 extern int __glXDebug; 648 649 /* This is per-thread storage in an MT environment */ 650 651 extern void __glXSetCurrentContext(struct glx_context * c); 652 653 extern __THREAD_INITIAL_EXEC void *__glX_tls_Context; 654 655 # define __glXGetCurrentContext() __glX_tls_Context 656 657 extern void __glXSetCurrentContextNull(void); 658 659 660 /* 661 ** Global lock for all threads in this address space using the GLX 662 ** extension 663 */ 664 extern pthread_mutex_t __glXmutex; 665 #define __glXLock() pthread_mutex_lock(&__glXmutex) 666 #define __glXUnlock() pthread_mutex_unlock(&__glXmutex) 667 668 /* 669 ** Setup for a command. Initialize the extension for dpy if necessary. 670 */ 671 extern CARD8 __glXSetupForCommand(Display * dpy); 672 673 /************************************************************************/ 674 675 /* 676 ** Data conversion and packing support. 677 */ 678 679 extern const GLuint __glXDefaultPixelStore[9]; 680 681 /* Send an image to the server using RenderLarge. */ 682 extern void __glXSendLargeImage(struct glx_context * gc, GLint compsize, GLint dim, 683 GLint width, GLint height, GLint depth, 684 GLenum format, GLenum type, 685 const GLvoid * src, GLubyte * pc, 686 GLubyte * modes); 687 688 /* Return the size, in bytes, of some pixel data */ 689 extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum); 690 691 /* Return the number of elements per group of a specified format*/ 692 extern GLint __glElementsPerGroup(GLenum format, GLenum type); 693 694 /* Return the number of bytes per element, based on the element type (other 695 ** than GL_BITMAP). 696 */ 697 extern GLint __glBytesPerElement(GLenum type); 698 699 /* 700 ** Fill the transport buffer with the data from the users buffer, 701 ** applying some of the pixel store modes (unpack modes) to the data 702 ** first. As a side effect of this call, the "modes" field is 703 ** updated to contain the modes needed by the server to decode the 704 ** sent data. 705 */ 706 extern void __glFillImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum, 707 GLenum, const GLvoid *, GLubyte *, GLubyte *); 708 709 /* Copy map data with a stride into a packed buffer */ 710 extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *); 711 extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *); 712 extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint, 713 const GLfloat *, GLfloat *); 714 extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint, 715 const GLdouble *, GLdouble *); 716 717 /* 718 ** Empty an image out of the reply buffer into the clients memory applying 719 ** the pack modes to pack back into the clients requested format. 720 */ 721 extern void __glEmptyImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum, 722 GLenum, const GLubyte *, GLvoid *); 723 724 725 /* 726 ** Allocate and Initialize Vertex Array client state, and free. 727 */ 728 extern void __glXInitVertexArrayState(struct glx_context *); 729 extern void __glXFreeVertexArrayState(struct glx_context *); 730 731 _X_HIDDEN void 732 __glX_send_client_info(struct glx_display *glx_dpy); 733 734 /************************************************************************/ 735 736 extern void __glXInitializeVisualConfigFromTags(struct glx_config * config, 737 int count, const INT32 * bp, 738 Bool tagged_only, 739 Bool fbconfig_style_tags); 740 741 extern char *__glXQueryServerString(Display *dpy, CARD32 screen, CARD32 name); 742 extern char *__glXGetString(Display *dpy, CARD32 screen, CARD32 name); 743 744 extern GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable, 745 int32_t * numerator, 746 int32_t * denominator); 747 748 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) 749 extern GLboolean 750 __glxGetMscRate(struct glx_screen *psc, 751 int32_t * numerator, int32_t * denominator); 752 753 /* So that dri2.c:DRI2WireToEvent() can access 754 * glx_info->codes->first_event */ 755 XExtDisplayInfo *__glXFindDisplay (Display *dpy); 756 757 extern __GLXDRIdrawable * 758 GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable); 759 #endif 760 761 extern struct glx_screen *GetGLXScreenConfigs(Display * dpy, int scrn); 762 763 #ifdef GLX_USE_APPLEGL 764 extern struct glx_screen * 765 applegl_create_screen(int screen, struct glx_display * priv); 766 767 extern struct glx_context * 768 applegl_create_context(struct glx_screen *psc, 769 struct glx_config *mode, 770 struct glx_context *shareList, int renderType); 771 772 extern int 773 applegl_create_display(struct glx_display *display); 774 775 extern void * 776 applegl_get_proc_address(const char *symbol); 777 #endif 778 779 extern Bool validate_renderType_against_config(const struct glx_config *config, 780 int renderType); 781 782 783 extern struct glx_drawable *GetGLXDrawable(Display *dpy, GLXDrawable drawable); 784 extern int InitGLXDrawable(Display *dpy, struct glx_drawable *glxDraw, 785 XID xDrawable, GLXDrawable drawable); 786 extern void DestroyGLXDrawable(Display *dpy, GLXDrawable drawable); 787 788 extern struct glx_context dummyContext; 789 790 extern struct glx_screen * 791 indirect_create_screen(int screen, struct glx_display * priv); 792 extern struct glx_context * 793 indirect_create_context(struct glx_screen *psc, 794 struct glx_config *mode, 795 struct glx_context *shareList, int renderType); 796 extern struct glx_context * 797 indirect_create_context_attribs(struct glx_screen *base, 798 struct glx_config *config_base, 799 struct glx_context *shareList, 800 unsigned num_attribs, 801 const uint32_t *attribs, 802 unsigned *error); 803 804 805 extern int __glXGetDrawableAttribute(Display * dpy, GLXDrawable drawable, 806 int attribute, unsigned int *value); 807 808 #ifdef __cplusplus 809 } 810 #endif 811 812 #endif /* !__GLX_client_h__ */ 813