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