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