2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
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:
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.
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
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.
33 * Direct rendering support added by Precision Insight, Inc.
35 * \author Kevin E. Martin <kevin@precisioninsight.com>
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
46 #include <GL/glxext.h>
53 #include "GL/glxproto.h"
54 #include "glapi/glapitable.h"
55 #include "glxconfig.h"
57 #if defined( PTHREADS )
61 #include "glxextensions.h"
63 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
65 #define GLX_MAJOR_VERSION 1 /* current version numbers */
66 #define GLX_MINOR_VERSION 4
68 #define __GLX_MAX_TEXTURE_UNITS 32
73 /************************************************************************/
75 #ifdef GLX_DIRECT_RENDERING
77 extern void DRI_glXUseXFont(struct glx_context *ctx,
78 Font font, int first, int count, int listbase);
82 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
85 * Display dependent methods. This structure is initialized during the
86 * \c driCreateDisplay call.
88 typedef struct __GLXDRIdisplayRec __GLXDRIdisplay;
89 typedef struct __GLXDRIscreenRec __GLXDRIscreen;
90 typedef struct __GLXDRIdrawableRec __GLXDRIdrawable;
92 struct __GLXDRIdisplayRec
95 * Method to destroy the private DRI display data.
97 void (*destroyDisplay) (__GLXDRIdisplay * display);
99 struct glx_screen *(*createScreen)(int screen, struct glx_display * priv);
102 struct __GLXDRIscreenRec {
104 void (*destroyScreen)(struct glx_screen *psc);
106 struct glx_context *(*createContext)(struct glx_screen *psc,
107 struct glx_config *config,
108 struct glx_context *shareList,
111 __GLXDRIdrawable *(*createDrawable)(struct glx_screen *psc,
113 GLXDrawable glxDrawable,
114 struct glx_config *config);
116 int64_t (*swapBuffers)(__GLXDRIdrawable *pdraw, int64_t target_msc,
117 int64_t divisor, int64_t remainder);
118 void (*copySubBuffer)(__GLXDRIdrawable *pdraw,
119 int x, int y, int width, int height);
120 int (*getDrawableMSC)(struct glx_screen *psc, __GLXDRIdrawable *pdraw,
121 int64_t *ust, int64_t *msc, int64_t *sbc);
122 int (*waitForMSC)(__GLXDRIdrawable *pdraw, int64_t target_msc,
123 int64_t divisor, int64_t remainder, int64_t *ust,
124 int64_t *msc, int64_t *sbc);
125 int (*waitForSBC)(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust,
126 int64_t *msc, int64_t *sbc);
127 int (*setSwapInterval)(__GLXDRIdrawable *pdraw, int interval);
128 int (*getSwapInterval)(__GLXDRIdrawable *pdraw);
131 struct __GLXDRIdrawableRec
133 void (*destroyDrawable) (__GLXDRIdrawable * drawable);
137 struct glx_screen *psc;
138 GLenum textureTarget;
139 GLenum textureFormat; /* EXT_texture_from_pixmap support */
140 unsigned long eventMask;
145 ** Function to create and DRI display data and initialize the display
146 ** dependent methods.
148 extern __GLXDRIdisplay *driswCreateDisplay(Display * dpy);
149 extern __GLXDRIdisplay *driCreateDisplay(Display * dpy);
150 extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy);
151 extern void dri2InvalidateBuffers(Display *dpy, XID drawable);
152 extern unsigned dri2GetSwapEventType(Display *dpy, XID drawable);
156 ** Functions to obtain driver configuration information from a direct
157 ** rendering client application
159 extern const char *glXGetScreenDriver(Display * dpy, int scrNum);
161 extern const char *glXGetDriverConfig(const char *driverName);
165 /************************************************************************/
167 #define __GL_CLIENT_ATTRIB_STACK_DEPTH 16
169 typedef struct __GLXpixelStoreModeRec
171 GLboolean swapEndian;
180 } __GLXpixelStoreMode;
183 typedef struct __GLXattributeRec
188 * Pixel storage state. Most of the pixel store mode state is kept
189 * here and used by the client code to manage the packing and
190 * unpacking of data sent to/received from the server.
192 __GLXpixelStoreMode storePack, storeUnpack;
195 * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically
198 GLboolean NoDrawArraysProtocol;
201 * Vertex Array storage state. The vertex array component
202 * state is stored here and is used to manage the packing of
203 * DrawArrays data sent to the server.
205 struct array_state_vector *array_state;
208 typedef struct __GLXattributeMachineRec
210 __GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
211 __GLXattribute **stackPointer;
212 } __GLXattributeMachine;
214 struct glx_context_vtable {
215 void (*destroy)(struct glx_context *ctx);
216 int (*bind)(struct glx_context *context, struct glx_context *old,
217 GLXDrawable draw, GLXDrawable read);
218 void (*unbind)(struct glx_context *context, struct glx_context *new);
219 void (*wait_gl)(struct glx_context *ctx);
220 void (*wait_x)(struct glx_context *ctx);
221 void (*use_x_font)(struct glx_context *ctx,
222 Font font, int first, int count, int listBase);
223 void (*bind_tex_image)(Display * dpy,
224 GLXDrawable drawable,
225 int buffer, const int *attrib_list);
226 void (*release_tex_image)(Display * dpy, GLXDrawable drawable, int buffer);
227 void * (*get_proc_address)(const char *symbol);
231 glx_send_destroy_context(Display *dpy, XID xid);
234 * GLX state that needs to be kept on the client. One of these records
235 * exist for each context that has been made current by this client.
240 * \name Drawing command buffer.
242 * Drawing commands are packed into this buffer before being sent as a
243 * single GLX protocol request. The buffer is sent when it overflows or
244 * is flushed by \c __glXFlushRenderBuffer. \c pc is the next location
245 * in the buffer to be filled. \c limit is described above in the buffer
248 * Commands that require large amounts of data to be transfered will
249 * also use this buffer to hold a header that describes the large
252 * These must be the first 6 fields since they are static initialized
253 * in the dummy context in glxext.c
263 const struct glx_context_vtable *vtable;
266 * The XID of this rendering context. When the context is created a
267 * new XID is allocated. This is set to None when the context is
268 * destroyed but is still current to some thread. In this case the
269 * context will be freed on next MakeCurrent.
274 * The XID of the \c shareList context.
282 struct glx_screen *psc;
285 * \c GL_TRUE if the context was created with ImportContext, which
286 * means the server-side context was created by another X client.
291 * The context tag returned by MakeCurrent when this context is made
292 * current. This tag is used to identify the context that a thread has
293 * current so that proper server context management can be done. It is
294 * used for all context specific commands (i.e., \c Render, \c RenderLarge,
295 * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old
298 GLXContextTag currentContextTag;
301 * \name Rendering mode
303 * The rendering mode is kept on the client as well as the server.
304 * When \c glRenderMode is called, the buffer associated with the
305 * previous rendering mode (feedback or select) is filled.
309 GLfloat *feedbackBuf;
314 * Fill newImage with the unpacked form of \c oldImage getting it
315 * ready for transport to the server.
317 void (*fillImage) (struct glx_context *, GLint, GLint, GLint, GLint, GLenum,
318 GLenum, const GLvoid *, GLubyte *, GLubyte *);
321 * Client side attribs.
323 __GLXattributeMachine attributes;
326 * Client side error code. This is set when client side gl API
327 * routines need to set an error because of a bad enumerant or
328 * running out of memory, etc.
333 * Whether this context does direct rendering.
337 #if defined(GLX_DIRECT_RENDERING) && defined(GLX_USE_APPLEGL)
342 * \c dpy of current display for this context. Will be \c NULL if not
343 * current to any display, or if this is the "dummy context".
348 * The current drawable for this context. Will be None if this
349 * context is not current to any drawable. currentReadable is below.
351 GLXDrawable currentDrawable;
354 * \name GL Constant Strings
356 * Constant strings that describe the server implementation
357 * These pertain to GL attributes, not to be confused with
358 * GLX versioning attributes.
368 * Maximum small render command size. This is the smaller of 64k and
369 * the size of the above buffer.
371 GLint maxSmallRenderCommandSize;
374 * Major opcode for the extension. Copied here so a lookup isn't
380 * Pointer to the config used to create this context.
382 struct glx_config *config;
385 * The current read-drawable for this context. Will be None if this
386 * context is not current to any drawable.
388 * \since Internal API version 20030606.
390 GLXDrawable currentReadable;
393 * Pointer to client-state data that is private to libGL. This is only
394 * used for indirect rendering contexts.
396 * No internal API version change was made for this change. Client-side
397 * drivers should NEVER use this data or even care that it exists.
399 void *client_state_private;
402 * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE.
407 * \name Raw server GL version
409 * True core GL version supported by the server. This is the raw value
410 * returned by the server, and it may not reflect what is actually
411 * supported (or reported) by the client-side library.
414 int server_major; /**< Major version number. */
415 int server_minor; /**< Minor version number. */
419 * Number of threads we're currently current in.
421 unsigned long thread_refcount;
423 char gl_extension_bits[__GL_EXT_BYTES];
427 glx_context_init(struct glx_context *gc,
428 struct glx_screen *psc, struct glx_config *fbconfig);
430 #define __glXSetError(gc,code) \
431 if (!(gc)->error) { \
432 (gc)->error = code; \
435 extern void __glFreeAttributeState(struct glx_context *);
437 /************************************************************************/
440 * The size of the largest drawing command known to the implementation
441 * that will use the GLXRender GLX command. In this case it is
442 * \c glPolygonStipple.
444 #define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156
447 * To keep the implementation fast, the code uses a "limit" pointer
448 * to determine when the drawing command buffer is too full to hold
449 * another fixed size command. This constant defines the amount of
450 * space that must always be available in the drawing command buffer
451 * at all times for the implementation to work. It is important that
452 * the number be just large enough, but not so large as to reduce the
453 * efficacy of the buffer. The "+32" is just to keep the code working
454 * in case somebody counts wrong.
456 #define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32)
459 * This implementation uses a smaller threshold for switching
460 * to the RenderLarge protocol than the protcol requires so that
461 * large copies don't occur.
463 #define __GLX_RENDER_CMD_SIZE_LIMIT 4096
466 * One of these records exists per screen of the display. It contains
467 * a pointer to the config data for that screen (if the screen supports GL).
469 struct glx_screen_vtable {
470 struct glx_context *(*create_context)(struct glx_screen *psc,
471 struct glx_config *config,
472 struct glx_context *shareList,
478 const struct glx_screen_vtable *vtable;
481 * GLX extension string reported by the X-server.
483 const char *serverGLXexts;
486 * GLX extension string to be reported to applications. This is the
487 * set of extensions that the application can actually use.
489 char *effectiveGLXexts;
491 struct glx_display *display;
496 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
498 * Per screen direct rendering interface functions and data.
500 __GLXDRIscreen *driScreen;
504 * Linked list of glx visuals and fbconfigs for this screen.
506 struct glx_config *visuals, *configs;
509 * Per-screen dynamic GLX extension tracking. The \c direct_support
510 * field only contains enough bits for 64 extensions. Should libGL
511 * ever need to track more than 64 GLX extensions, we can safely grow
512 * this field. The \c struct glx_screen structure is not used outside
516 unsigned char direct_support[8];
517 GLboolean ext_list_first_time;
523 * Per display private data. One of these records exists for each display
524 * that is using the OpenGL (GLX) extension.
528 /* The extension protocol codes */
530 struct glx_display *next;
533 * Back pointer to the display
538 * The \c majorOpcode is common to all connections to the same server.
539 * It is also copied into the context structure.
544 * \name Server Version
546 * Major and minor version returned by the server during initialization.
549 int majorVersion, minorVersion;
553 * \name Storage for the servers GLX vendor and versions strings.
555 * These are the same for all screens on this display. These fields will
556 * be filled in on demand.
559 const char *serverGLXvendor;
560 const char *serverGLXversion;
564 * Configurations of visuals for all screens on this display.
565 * Also, per screen data which now includes the server \c GLX_EXTENSION
568 struct glx_screen **screens;
570 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
571 __glxHashTable *drawHash;
574 * Per display direct rendering interface functions and data.
576 __GLXDRIdisplay *driswDisplay;
577 __GLXDRIdisplay *driDisplay;
578 __GLXDRIdisplay *dri2Display;
583 glx_screen_init(struct glx_screen *psc,
584 int screen, struct glx_display * priv);
586 glx_screen_cleanup(struct glx_screen *psc);
588 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
589 extern __GLXDRIdrawable *
590 dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id);
593 extern GLubyte *__glXFlushRenderBuffer(struct glx_context *, GLubyte *);
595 extern void __glXSendLargeChunk(struct glx_context * gc, GLint requestNumber,
597 const GLvoid * data, GLint dataLen);
599 extern void __glXSendLargeCommand(struct glx_context *, const GLvoid *, GLint,
600 const GLvoid *, GLint);
602 /* Initialize the GLX extension for dpy */
603 extern struct glx_display *__glXInitialize(Display *);
605 extern void __glXPreferEGL(int state);
607 /************************************************************************/
609 extern int __glXDebug;
611 /* This is per-thread storage in an MT environment */
612 #if defined( PTHREADS )
614 extern void __glXSetCurrentContext(struct glx_context * c);
616 # if defined( GLX_USE_TLS )
618 extern __thread void *__glX_tls_Context
619 __attribute__ ((tls_model("initial-exec")));
621 # define __glXGetCurrentContext() __glX_tls_Context
625 extern struct glx_context *__glXGetCurrentContext(void);
627 # endif /* defined( GLX_USE_TLS ) */
631 extern struct glx_context *__glXcurrentContext;
632 #define __glXGetCurrentContext() __glXcurrentContext
633 #define __glXSetCurrentContext(gc) __glXcurrentContext = gc
635 #endif /* defined( PTHREADS ) */
637 extern void __glXSetCurrentContextNull(void);
641 ** Global lock for all threads in this address space using the GLX
644 #if defined( PTHREADS )
645 extern pthread_mutex_t __glXmutex;
646 #define __glXLock() pthread_mutex_lock(&__glXmutex)
647 #define __glXUnlock() pthread_mutex_unlock(&__glXmutex)
650 #define __glXUnlock()
654 ** Setup for a command. Initialize the extension for dpy if necessary.
656 extern CARD8 __glXSetupForCommand(Display * dpy);
658 /************************************************************************/
661 ** Data conversion and packing support.
664 extern const GLuint __glXDefaultPixelStore[9];
666 /* Send an image to the server using RenderLarge. */
667 extern void __glXSendLargeImage(struct glx_context * gc, GLint compsize, GLint dim,
668 GLint width, GLint height, GLint depth,
669 GLenum format, GLenum type,
670 const GLvoid * src, GLubyte * pc,
673 /* Return the size, in bytes, of some pixel data */
674 extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum);
676 /* Return the number of elements per group of a specified format*/
677 extern GLint __glElementsPerGroup(GLenum format, GLenum type);
679 /* Return the number of bytes per element, based on the element type (other
682 extern GLint __glBytesPerElement(GLenum type);
685 ** Fill the transport buffer with the data from the users buffer,
686 ** applying some of the pixel store modes (unpack modes) to the data
687 ** first. As a side effect of this call, the "modes" field is
688 ** updated to contain the modes needed by the server to decode the
691 extern void __glFillImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum,
692 GLenum, const GLvoid *, GLubyte *, GLubyte *);
694 /* Copy map data with a stride into a packed buffer */
695 extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *);
696 extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *);
697 extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint,
698 const GLfloat *, GLfloat *);
699 extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint,
700 const GLdouble *, GLdouble *);
703 ** Empty an image out of the reply buffer into the clients memory applying
704 ** the pack modes to pack back into the clients requested format.
706 extern void __glEmptyImage(struct glx_context *, GLint, GLint, GLint, GLint, GLenum,
707 GLenum, const GLubyte *, GLvoid *);
711 ** Allocate and Initialize Vertex Array client state, and free.
713 extern void __glXInitVertexArrayState(struct glx_context *);
714 extern void __glXFreeVertexArrayState(struct glx_context *);
717 ** Inform the Server of the major and minor numbers and of the client
718 ** libraries extension string.
720 extern void __glXClientInfo(Display * dpy, int opcode);
722 /************************************************************************/
725 ** Declarations that should be in Xlib
727 #ifdef __GL_USE_OUR_PROTOTYPES
728 extern void _XFlush(Display *);
729 extern Status _XReply(Display *, xReply *, int, Bool);
730 extern void _XRead(Display *, void *, long);
731 extern void _XSend(Display *, const void *, long);
735 extern void __glXInitializeVisualConfigFromTags(struct glx_config * config,
736 int count, const INT32 * bp,
738 Bool fbconfig_style_tags);
740 extern char *__glXQueryServerString(Display * dpy, int opcode,
741 CARD32 screen, CARD32 name);
742 extern char *__glXGetString(Display * dpy, int opcode,
743 CARD32 screen, CARD32 name);
745 extern char *__glXstrdup(const char *str);
748 extern const char __glXGLClientVersion[];
749 extern const char __glXGLClientExtensions[];
751 /* Get the unadjusted system time */
752 extern int __glXGetUST(int64_t * ust);
754 extern GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
756 int32_t * denominator);
758 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
760 __glxGetMscRate(__GLXDRIdrawable *glxDraw,
761 int32_t * numerator, int32_t * denominator);
763 /* So that dri2.c:DRI2WireToEvent() can access
764 * glx_info->codes->first_event */
765 XExtDisplayInfo *__glXFindDisplay (Display *dpy);
768 GarbageCollectDRIDrawables(struct glx_screen *psc);
770 extern __GLXDRIdrawable *
771 GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable);
774 #ifdef GLX_USE_APPLEGL
775 extern struct glx_screen *
776 applegl_create_screen(int screen, struct glx_display * priv);
778 extern struct glx_context *
779 applegl_create_context(struct glx_screen *psc,
780 struct glx_config *mode,
781 struct glx_context *shareList, int renderType);
784 applegl_create_display(struct glx_display *display);
787 extern struct glx_context dummyContext;
789 extern struct glx_screen *
790 indirect_create_screen(int screen, struct glx_display * priv);
791 extern struct glx_context *
792 indirect_create_context(struct glx_screen *psc,
793 struct glx_config *mode,
794 struct glx_context *shareList, int renderType);
796 #endif /* !__GLX_client_h__ */