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 * Client-side GLX interface for current context management.
40 #include "glxclient.h"
41 #ifdef GLX_USE_APPLEGL
44 #include "apple_glx.h"
45 #include "apple_glx_context.h"
51 ** We setup some dummy structures here so that the API can be used
52 ** even if no context is current.
55 static GLubyte dummyBuffer[__GLX_BUFFER_LIMIT_SIZE];
58 ** Dummy context used by small commands when there is no current context.
60 ** gl and glx entry points are designed to operate as nop's when using
61 ** the dummy context structure.
63 struct glx_context dummyContext = {
67 &dummyBuffer[__GLX_BUFFER_LIMIT_SIZE],
72 * Current context management and locking
75 #if defined( PTHREADS )
77 _X_HIDDEN pthread_mutex_t __glXmutex = PTHREAD_MUTEX_INITIALIZER;
79 # if defined( GLX_USE_TLS )
82 * Per-thread GLX context pointer.
84 * \c __glXSetCurrentContext is written is such a way that this pointer can
85 * \b never be \c NULL. This is important! Because of this
86 * \c __glXGetCurrentContext can be implemented as trivial macro.
88 __thread void *__glX_tls_Context __attribute__ ((tls_model("initial-exec")))
92 __glXSetCurrentContext(struct glx_context * c)
94 __glX_tls_Context = (c != NULL) ? c : &dummyContext;
99 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
102 * Per-thread data key.
104 * Once \c init_thread_data has been called, the per-thread data key will
105 * take a value of \c NULL. As each new thread is created the default
106 * value, in that thread, will be \c NULL.
108 static pthread_key_t ContextTSD;
111 * Initialize the per-thread data key.
113 * This function is called \b exactly once per-process (not per-thread!) to
114 * initialize the per-thread data key. This is ideally done using the
115 * \c pthread_once mechanism.
118 init_thread_data(void)
120 if (pthread_key_create(&ContextTSD, NULL) != 0) {
121 perror("pthread_key_create");
127 __glXSetCurrentContext(struct glx_context * c)
129 pthread_once(&once_control, init_thread_data);
130 pthread_setspecific(ContextTSD, c);
133 _X_HIDDEN struct glx_context *
134 __glXGetCurrentContext(void)
138 pthread_once(&once_control, init_thread_data);
140 v = pthread_getspecific(ContextTSD);
141 return (v == NULL) ? &dummyContext : (struct glx_context *) v;
144 # endif /* defined( GLX_USE_TLS ) */
146 #elif defined( THREADS )
148 #error Unknown threading method specified.
152 /* not thread safe */
153 _X_HIDDEN struct glx_context *__glXcurrentContext = &dummyContext;
159 __glXSetCurrentContextNull(void)
161 __glXSetCurrentContext(&dummyContext);
162 #ifndef GLX_USE_APPLEGL
163 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
164 _glapi_set_dispatch(NULL); /* no-op functions */
165 _glapi_set_context(NULL);
171 glXGetCurrentContext(void)
173 struct glx_context *cx = __glXGetCurrentContext();
175 if (cx == &dummyContext) {
179 return (GLXContext) cx;
183 _X_EXPORT GLXDrawable
184 glXGetCurrentDrawable(void)
186 struct glx_context *gc = __glXGetCurrentContext();
187 return gc->currentDrawable;
191 __glXGenerateError(Display * dpy, struct glx_context *gc, XID resource,
192 BYTE errorCode, CARD16 minorCode)
196 error.errorCode = errorCode;
197 error.resourceID = resource;
198 error.sequenceNumber = dpy->request;
199 error.type = X_Error;
200 error.majorCode = gc->majorOpcode;
201 error.minorCode = minorCode;
202 _XError(dpy, &error);
206 * Make a particular context current.
208 * \note This is in this file so that it can access dummyContext.
211 MakeContextCurrent(Display * dpy, GLXDrawable draw,
212 GLXDrawable read, GLXContext gc_user)
214 struct glx_context *gc = (struct glx_context *) gc_user;
215 struct glx_context *oldGC = __glXGetCurrentContext();
218 /* Make sure that the new context has a nonzero ID. In the request,
219 * a zero context ID is used only to mean that we bind to no current
222 if ((gc != NULL) && (gc->xid == None)) {
226 if (gc == NULL && (draw != None || read != None)) {
227 __glXGenerateError(dpy, gc, (draw != None) ? draw : read,
228 BadMatch, X_GLXMakeContextCurrent);
231 if (gc != NULL && (draw == None || read == None)) {
232 __glXGenerateError(dpy, gc, None, BadMatch, X_GLXMakeContextCurrent);
236 _glapi_check_multithread();
238 if (gc != NULL && gc->thread_id != 0 && gc->thread_id != _glthread_GetID()) {
239 __glXGenerateError(dpy, gc, gc->xid,
240 BadAccess, X_GLXMakeContextCurrent);
244 if (oldGC != &dummyContext && oldGC != gc) {
245 oldGC->vtable->unbind(oldGC, gc);
246 oldGC->currentDpy = 0;
247 oldGC->currentDrawable = None;
248 oldGC->currentReadable = None;
249 oldGC->thread_id = 0;
250 if (oldGC->xid == None)
251 /* We are switching away from a context that was
252 * previously destroyed, so we need to free the memory
253 * for the old handle.
255 oldGC->vtable->destroy(oldGC);
259 ret = gc->vtable->bind(gc, oldGC, draw, read);
260 gc->currentDpy = dpy;
261 gc->currentDrawable = draw;
262 gc->currentReadable = read;
263 gc->thread_id = _glthread_GetID();
264 __glXSetCurrentContext(gc);
266 __glXSetCurrentContextNull();
270 __glXGenerateError(dpy, gc, None, ret, X_GLXMakeContextCurrent);
279 glXMakeCurrent(Display * dpy, GLXDrawable draw, GLXContext gc)
281 return MakeContextCurrent(dpy, draw, draw, gc);
285 GLX_ALIAS(Bool, glXMakeCurrentReadSGI,
286 (Display * dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
287 (dpy, d, r, ctx), MakeContextCurrent)
290 GLX_ALIAS(Bool, glXMakeContextCurrent,
291 (Display * dpy, GLXDrawable d, GLXDrawable r,
292 GLXContext ctx), (dpy, d, r, ctx), MakeContextCurrent)