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