1 /* -*- mode: c; tab-width: 3; indent-tabs-mode: nil; c-basic-offset: 3; coding: utf-8-unix -*- */
3 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
4 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice including the dates of first publication and
14 * either this permission notice or a reference to
15 * http://oss.sgi.com/projects/FreeB/
16 * shall be included in all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
23 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * Except as contained in this notice, the name of Silicon Graphics, Inc.
27 * shall not be used in advertising or otherwise to promote the sale, use or
28 * other dealings in this Software without prior written authorization from
29 * Silicon Graphics, Inc.
34 * Direct rendering support added by Precision Insight, Inc.
36 * \author Kevin E. Martin <kevin@precisioninsight.com>
39 #ifndef _GLX_client_h_
40 #define _GLX_client_h_
43 #include <X11/Xproto.h>
44 #include <X11/Xlibint.h>
45 #define GLX_GLXEXT_PROTOTYPES
47 #include <GL/glxext.h>
54 #include "GL/glxint.h"
55 #include "GL/glxproto.h"
56 #include "GL/internal/glcore.h"
57 #include "glapi/glapitable.h"
59 #if defined( USE_XTHREADS )
60 # include <X11/Xthreads.h>
61 #elif defined( PTHREADS )
65 #include "glxextensions.h"
68 /* If we build the library with gcc's -fvisibility=hidden flag, we'll
69 * use the PUBLIC macro to mark functions that are to be exported.
71 * We also need to define a USED attribute, so the optimizer doesn't
72 * inline a static function that we later use in an alias. - ajax
74 #if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303
75 # define PUBLIC __attribute__((visibility("default")))
76 # define USED __attribute__((used))
84 #define GLX_MAJOR_VERSION 1 /* current version numbers */
85 #define GLX_MINOR_VERSION 4
87 #define __GLX_MAX_TEXTURE_UNITS 32
89 typedef struct __GLXscreenConfigsRec __GLXscreenConfigs
;
90 typedef struct __GLXcontextRec __GLXcontext
;
91 typedef struct __GLXdrawableRec __GLXdrawable
;
92 typedef struct __GLXdisplayPrivateRec __GLXdisplayPrivate
;
93 typedef struct _glapi_table __GLapi
;
95 /************************************************************************/
97 #ifdef GLX_DIRECT_RENDERING
99 #define containerOf(ptr, type, member) \
100 (type *)( (char *)ptr - offsetof(type,member) )
102 #include <GL/internal/dri_interface.h>
106 * Display dependent methods. This structure is initialized during the
107 * \c driCreateDisplay call.
109 typedef struct __GLXDRIdisplayRec __GLXDRIdisplay
;
110 typedef struct __GLXDRIscreenRec __GLXDRIscreen
;
111 typedef struct __GLXDRIdrawableRec __GLXDRIdrawable
;
112 typedef struct __GLXDRIcontextRec __GLXDRIcontext
;
114 #include "glxextensions.h"
116 struct __GLXDRIdisplayRec
119 * Method to destroy the private DRI display data.
121 void (*destroyDisplay
) (__GLXDRIdisplay
* display
);
123 __GLXDRIscreen
*(*createScreen
) (__GLXscreenConfigs
* psc
, int screen
,
124 __GLXdisplayPrivate
* priv
);
127 struct __GLXDRIscreenRec
130 void (*destroyScreen
) (__GLXscreenConfigs
* psc
);
132 __GLXDRIcontext
*(*createContext
) (__GLXscreenConfigs
* psc
,
133 const __GLcontextModes
* mode
,
135 GLXContext shareList
, int renderType
);
137 __GLXDRIdrawable
*(*createDrawable
) (__GLXscreenConfigs
* psc
,
139 GLXDrawable glxDrawable
,
140 const __GLcontextModes
* modes
);
142 void (*swapBuffers
) (__GLXDRIdrawable
* pdraw
);
145 struct __GLXDRIcontextRec
147 void (*destroyContext
) (__GLXDRIcontext
* context
,
148 __GLXscreenConfigs
* psc
, Display
* dpy
);
149 Bool(*bindContext
) (__GLXDRIcontext
* context
, __GLXDRIdrawable
* pdraw
,
150 __GLXDRIdrawable
* pread
);
152 void (*unbindContext
) (__GLXDRIcontext
* context
);
155 struct __GLXDRIdrawableRec
157 void (*destroyDrawable
) (__GLXDRIdrawable
* drawable
);
161 __GLXscreenConfigs
*psc
;
162 GLenum textureTarget
;
163 __DRIdrawable
*driDrawable
;
167 ** Function to create and DRI display data and initialize the display
168 ** dependent methods.
170 extern __GLXDRIdisplay
*driswCreateDisplay(Display
* dpy
);
171 extern __GLXDRIdisplay
*driCreateDisplay(Display
* dpy
);
172 extern __GLXDRIdisplay
*dri2CreateDisplay(Display
* dpy
);
174 extern void DRI_glXUseXFont(Font font
, int first
, int count
, int listbase
);
177 ** Functions to obtain driver configuration information from a direct
178 ** rendering client application
180 extern const char *glXGetScreenDriver(Display
* dpy
, int scrNum
);
182 extern const char *glXGetDriverConfig(const char *driverName
);
186 /************************************************************************/
188 #define __GL_CLIENT_ATTRIB_STACK_DEPTH 16
190 typedef struct __GLXpixelStoreModeRec
192 GLboolean swapEndian
;
201 } __GLXpixelStoreMode
;
204 typedef struct __GLXattributeRec
209 * Pixel storage state. Most of the pixel store mode state is kept
210 * here and used by the client code to manage the packing and
211 * unpacking of data sent to/received from the server.
213 __GLXpixelStoreMode storePack
, storeUnpack
;
216 * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically
219 GLboolean NoDrawArraysProtocol
;
222 * Vertex Array storage state. The vertex array component
223 * state is stored here and is used to manage the packing of
224 * DrawArrays data sent to the server.
226 struct array_state_vector
*array_state
;
229 typedef struct __GLXattributeMachineRec
231 __GLXattribute
*stack
[__GL_CLIENT_ATTRIB_STACK_DEPTH
];
232 __GLXattribute
**stackPointer
;
233 } __GLXattributeMachine
;
236 * GLX state that needs to be kept on the client. One of these records
237 * exist for each context that has been made current by this client.
239 struct __GLXcontextRec
242 * \name Drawing command buffer.
244 * Drawing commands are packed into this buffer before being sent as a
245 * single GLX protocol request. The buffer is sent when it overflows or
246 * is flushed by \c __glXFlushRenderBuffer. \c pc is the next location
247 * in the buffer to be filled. \c limit is described above in the buffer
250 * Commands that require large amounts of data to be transfered will
251 * also use this buffer to hold a header that describes the large
254 * These must be the first 6 fields since they are static initialized
255 * in the dummy context in glxext.c
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 __GLXscreenConfigs
*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 * This is \c GL_TRUE if the pixel unpack modes are such that an image
315 * can be unpacked from the clients memory by just copying. It may
316 * still be true that the server will have to do some work. This
317 * just promises that a straight copy will fetch the correct bytes.
319 GLboolean fastImageUnpack
;
322 * Fill newImage with the unpacked form of \c oldImage getting it
323 * ready for transport to the server.
325 void (*fillImage
) (__GLXcontext
*, GLint
, GLint
, GLint
, GLint
, GLenum
,
326 GLenum
, const GLvoid
*, GLubyte
*, GLubyte
*);
329 * Client side attribs.
331 __GLXattributeMachine attributes
;
334 * Client side error code. This is set when client side gl API
335 * routines need to set an error because of a bad enumerant or
336 * running out of memory, etc.
341 * Whether this context does direct rendering.
346 * \c dpy of current display for this context. Will be \c NULL if not
347 * current to any display, or if this is the "dummy context".
352 * The current drawable for this context. Will be None if this
353 * context is not current to any drawable. currentReadable is below.
355 GLXDrawable currentDrawable
;
358 * \name GL Constant Strings
360 * Constant strings that describe the server implementation
361 * These pertain to GL attributes, not to be confused with
362 * GLX versioning attributes.
372 * Record the dpy this context was created on for later freeing
377 * Maximum small render command size. This is the smaller of 64k and
378 * the size of the above buffer.
380 GLint maxSmallRenderCommandSize
;
383 * Major opcode for the extension. Copied here so a lookup isn't
389 * Pointer to the mode used to create this context.
391 const __GLcontextModes
*mode
;
393 #ifdef GLX_DIRECT_RENDERING
394 __GLXDRIcontext
*driContext
;
395 __DRIcontext
*__driContext
;
399 * The current read-drawable for this context. Will be None if this
400 * context is not current to any drawable.
402 * \since Internal API version 20030606.
404 GLXDrawable currentReadable
;
407 * Pointer to client-state data that is private to libGL. This is only
408 * used for indirect rendering contexts.
410 * No internal API version change was made for this change. Client-side
411 * drivers should NEVER use this data or even care that it exists.
413 void *client_state_private
;
416 * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE.
421 * \name Raw server GL version
423 * True core GL version supported by the server. This is the raw value
424 * returned by the server, and it may not reflect what is actually
425 * supported (or reported) by the client-side library.
428 int server_major
; /**< Major version number. */
429 int server_minor
; /**< Minor version number. */
432 char gl_extension_bits
[__GL_EXT_BYTES
];
435 #define __glXSetError(gc,code) \
436 if (!(gc)->error) { \
437 (gc)->error = code; \
440 extern void __glFreeAttributeState(__GLXcontext
*);
442 /************************************************************************/
445 * The size of the largest drawing command known to the implementation
446 * that will use the GLXRender GLX command. In this case it is
447 * \c glPolygonStipple.
449 #define __GLX_MAX_SMALL_RENDER_CMD_SIZE 156
452 * To keep the implementation fast, the code uses a "limit" pointer
453 * to determine when the drawing command buffer is too full to hold
454 * another fixed size command. This constant defines the amount of
455 * space that must always be available in the drawing command buffer
456 * at all times for the implementation to work. It is important that
457 * the number be just large enough, but not so large as to reduce the
458 * efficacy of the buffer. The "+32" is just to keep the code working
459 * in case somebody counts wrong.
461 #define __GLX_BUFFER_LIMIT_SIZE (__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32)
464 * This implementation uses a smaller threshold for switching
465 * to the RenderLarge protocol than the protcol requires so that
466 * large copies don't occur.
468 #define __GLX_RENDER_CMD_SIZE_LIMIT 4096
471 * One of these records exists per screen of the display. It contains
472 * a pointer to the config data for that screen (if the screen supports GL).
474 struct __GLXscreenConfigsRec
477 * GLX extension string reported by the X-server.
479 const char *serverGLXexts
;
482 * GLX extension string to be reported to applications. This is the
483 * set of extensions that the application can actually use.
485 char *effectiveGLXexts
;
487 #ifdef GLX_DIRECT_RENDERING
489 * Per screen direct rendering interface functions and data.
491 __DRIscreen
*__driScreen
;
492 const __DRIcoreExtension
*core
;
493 const __DRIlegacyExtension
*legacy
;
494 const __DRIswrastExtension
*swrast
;
495 const __DRIdri2Extension
*dri2
;
496 __glxHashTable
*drawHash
;
501 __GLXDRIscreen
*driScreen
;
503 #ifdef __DRI_COPY_SUB_BUFFER
504 const __DRIcopySubBufferExtension
*copySubBuffer
;
507 #ifdef __DRI_SWAP_CONTROL
508 const __DRIswapControlExtension
*swapControl
;
511 #ifdef __DRI_ALLOCATE
512 const __DRIallocateExtension
*allocate
;
515 #ifdef __DRI_FRAME_TRACKING
516 const __DRIframeTrackingExtension
*frameTracking
;
519 #ifdef __DRI_MEDIA_STREAM_COUNTER
520 const __DRImediaStreamCounterExtension
*msc
;
523 #ifdef __DRI_TEX_BUFFER
524 const __DRItexBufferExtension
*texBuffer
;
530 * Linked list of glx visuals and fbconfigs for this screen.
532 __GLcontextModes
*visuals
, *configs
;
535 * Per-screen dynamic GLX extension tracking. The \c direct_support
536 * field only contains enough bits for 64 extensions. Should libGL
537 * ever need to track more than 64 GLX extensions, we can safely grow
538 * this field. The \c __GLXscreenConfigs structure is not used outside
542 unsigned char direct_support
[8];
543 GLboolean ext_list_first_time
;
549 * Per display private data. One of these records exists for each display
550 * that is using the OpenGL (GLX) extension.
552 struct __GLXdisplayPrivateRec
555 * Back pointer to the display
560 * The \c majorOpcode is common to all connections to the same server.
561 * It is also copied into the context structure.
566 * \name Server Version
568 * Major and minor version returned by the server during initialization.
571 int majorVersion
, minorVersion
;
575 * \name Storage for the servers GLX vendor and versions strings.
577 * These are the same for all screens on this display. These fields will
578 * be filled in on demand.
581 const char *serverGLXvendor
;
582 const char *serverGLXversion
;
586 * Configurations of visuals for all screens on this display.
587 * Also, per screen data which now includes the server \c GLX_EXTENSION
590 __GLXscreenConfigs
*screenConfigs
;
592 #ifdef GLX_DIRECT_RENDERING
594 * Per display direct rendering interface functions and data.
596 __GLXDRIdisplay
*driswDisplay
;
597 __GLXDRIdisplay
*driDisplay
;
598 __GLXDRIdisplay
*dri2Display
;
603 extern GLubyte
*__glXFlushRenderBuffer(__GLXcontext
*, GLubyte
*);
605 extern void __glXSendLargeChunk(__GLXcontext
* gc
, GLint requestNumber
,
607 const GLvoid
* data
, GLint dataLen
);
609 extern void __glXSendLargeCommand(__GLXcontext
*, const GLvoid
*, GLint
,
610 const GLvoid
*, GLint
);
612 /* Initialize the GLX extension for dpy */
613 extern __GLXdisplayPrivate
*__glXInitialize(Display
*);
615 extern void __glXPreferEGL(int state
);
617 /************************************************************************/
619 extern int __glXDebug
;
621 /* This is per-thread storage in an MT environment */
622 #if defined( USE_XTHREADS ) || defined( PTHREADS )
624 extern void __glXSetCurrentContext(__GLXcontext
* c
);
626 # if defined( GLX_USE_TLS )
628 extern __thread
void *__glX_tls_Context
629 __attribute__ ((tls_model("initial-exec")));
631 # define __glXGetCurrentContext() __glX_tls_Context
635 extern __GLXcontext
*__glXGetCurrentContext(void);
637 # endif /* defined( GLX_USE_TLS ) */
641 extern __GLXcontext
*__glXcurrentContext
;
642 #define __glXGetCurrentContext() __glXcurrentContext
643 #define __glXSetCurrentContext(gc) __glXcurrentContext = gc
645 #endif /* defined( USE_XTHREADS ) || defined( PTHREADS ) */
647 extern void __glXSetCurrentContextNull(void);
649 extern void __glXFreeContext(__GLXcontext
*);
653 ** Global lock for all threads in this address space using the GLX
656 #if defined( USE_XTHREADS )
657 extern xmutex_rec __glXmutex
;
658 #define __glXLock() xmutex_lock(&__glXmutex)
659 #define __glXUnlock() xmutex_unlock(&__glXmutex)
660 #elif defined( PTHREADS )
661 extern pthread_mutex_t __glXmutex
;
662 #define __glXLock() pthread_mutex_lock(&__glXmutex)
663 #define __glXUnlock() pthread_mutex_unlock(&__glXmutex)
666 #define __glXUnlock()
670 ** Setup for a command. Initialize the extension for dpy if necessary.
672 extern CARD8
__glXSetupForCommand(Display
* dpy
);
674 /************************************************************************/
677 ** Data conversion and packing support.
680 extern const GLuint __glXDefaultPixelStore
[9];
682 /* Send an image to the server using RenderLarge. */
683 extern void __glXSendLargeImage(__GLXcontext
* gc
, GLint compsize
, GLint dim
,
684 GLint width
, GLint height
, GLint depth
,
685 GLenum format
, GLenum type
,
686 const GLvoid
* src
, GLubyte
* pc
,
689 /* Return the size, in bytes, of some pixel data */
690 extern GLint
__glImageSize(GLint
, GLint
, GLint
, GLenum
, GLenum
, GLenum
);
692 /* Return the number of elements per group of a specified format*/
693 extern GLint
__glElementsPerGroup(GLenum format
, GLenum type
);
695 /* Return the number of bytes per element, based on the element type (other
698 extern GLint
__glBytesPerElement(GLenum type
);
701 ** Fill the transport buffer with the data from the users buffer,
702 ** applying some of the pixel store modes (unpack modes) to the data
703 ** first. As a side effect of this call, the "modes" field is
704 ** updated to contain the modes needed by the server to decode the
707 extern void __glFillImage(__GLXcontext
*, GLint
, GLint
, GLint
, GLint
, GLenum
,
708 GLenum
, const GLvoid
*, GLubyte
*, GLubyte
*);
710 /* Copy map data with a stride into a packed buffer */
711 extern void __glFillMap1f(GLint
, GLint
, GLint
, const GLfloat
*, GLubyte
*);
712 extern void __glFillMap1d(GLint
, GLint
, GLint
, const GLdouble
*, GLubyte
*);
713 extern void __glFillMap2f(GLint
, GLint
, GLint
, GLint
, GLint
,
714 const GLfloat
*, GLfloat
*);
715 extern void __glFillMap2d(GLint
, GLint
, GLint
, GLint
, GLint
,
716 const GLdouble
*, GLdouble
*);
719 ** Empty an image out of the reply buffer into the clients memory applying
720 ** the pack modes to pack back into the clients requested format.
722 extern void __glEmptyImage(__GLXcontext
*, GLint
, GLint
, GLint
, GLint
, GLenum
,
723 GLenum
, const GLubyte
*, GLvoid
*);
727 ** Allocate and Initialize Vertex Array client state, and free.
729 extern void __glXInitVertexArrayState(__GLXcontext
*);
730 extern void __glXFreeVertexArrayState(__GLXcontext
*);
733 ** Inform the Server of the major and minor numbers and of the client
734 ** libraries extension string.
736 extern void __glXClientInfo(Display
* dpy
, int opcode
);
738 /************************************************************************/
741 ** Declarations that should be in Xlib
743 #ifdef __GL_USE_OUR_PROTOTYPES
744 extern void _XFlush(Display
*);
745 extern Status
_XReply(Display
*, xReply
*, int, Bool
);
746 extern void _XRead(Display
*, void *, long);
747 extern void _XSend(Display
*, const void *, long);
751 extern void __glXInitializeVisualConfigFromTags(__GLcontextModes
* config
,
752 int count
, const INT32
* bp
,
754 Bool fbconfig_style_tags
);
756 extern char *__glXGetStringFromServer(Display
* dpy
, int opcode
,
757 CARD32 glxCode
, CARD32 for_whom
,
760 extern char *__glXstrdup(const char *str
);
763 extern const char __glXGLClientVersion
[];
764 extern const char __glXGLClientExtensions
[];
766 /* Get the unadjusted system time */
767 extern int __glXGetUST(int64_t * ust
);
769 extern GLboolean
__glXGetMscRateOML(Display
* dpy
, GLXDrawable drawable
,
771 int32_t * denominator
);
773 #ifdef GLX_DIRECT_RENDERING
775 __driGetMscRateOML(__DRIdrawable
* draw
,
776 int32_t * numerator
, int32_t * denominator
, void *private);
779 #endif /* !__GLX_client_h__ */