2004-10-25 22:09:16 +01:00
|
|
|
/*
|
Update to SGI FreeB 2.0.
Under the terms of version 1.1, "once Covered Code has been published
under a particular version of the License, Recipient may, for the
duration of the License, continue to use it under the terms of that
version, or choose to use such Covered Code under the terms of any
subsequent version published by SGI."
FreeB 2.0 license refers to "dates of first publication". They are here
taken to be 1991-2000, as noted in the original license text:
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
Official FreeB 2.0 text:
http://oss.sgi.com/projects/FreeB/SGIFreeSWLicB.2.0.pdf
As always, this code has not been tested for conformance with the OpenGL
specification. OpenGL conformance testing is available from
http://khronos.org/ and is required for use of the OpenGL logo in
product advertising and promotion.
2008-09-19 22:16:53 +01:00
|
|
|
* SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
|
|
|
|
* Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice including the dates of first publication and
|
|
|
|
* either this permission notice or a reference to
|
|
|
|
* http://oss.sgi.com/projects/FreeB/
|
|
|
|
* shall be included in all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
|
|
|
|
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
*
|
|
|
|
* Except as contained in this notice, the name of Silicon Graphics, Inc.
|
|
|
|
* shall not be used in advertising or otherwise to promote the sale, use or
|
|
|
|
* other dealings in this Software without prior written authorization from
|
|
|
|
* Silicon Graphics, Inc.
|
|
|
|
*/
|
2004-10-25 22:09:16 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* \file glxext.c
|
|
|
|
* GLX protocol interface boot-strap code.
|
|
|
|
*
|
|
|
|
* Direct rendering support added by Precision Insight, Inc.
|
|
|
|
*
|
|
|
|
* \author Kevin E. Martin <kevin@precisioninsight.com>
|
2008-10-13 13:08:45 +01:00
|
|
|
*/
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-09-18 20:26:30 +01:00
|
|
|
#include <assert.h>
|
2004-12-20 04:53:00 +00:00
|
|
|
#include "glxclient.h"
|
2005-08-11 15:18:53 +01:00
|
|
|
#include <X11/extensions/Xext.h>
|
|
|
|
#include <X11/extensions/extutil.h>
|
2010-04-01 19:01:31 +01:00
|
|
|
#ifdef GLX_USE_APPLEGL
|
|
|
|
#include "apple_glx.h"
|
|
|
|
#include "apple_visual.h"
|
|
|
|
#endif
|
2004-10-25 22:09:16 +01:00
|
|
|
#include "glxextensions.h"
|
|
|
|
|
2006-10-09 15:55:46 +01:00
|
|
|
#include <X11/Xlib-xcb.h>
|
2006-09-27 00:56:20 +01:00
|
|
|
#include <xcb/xcb.h>
|
|
|
|
#include <xcb/glx.h>
|
2005-05-07 18:14:50 +01:00
|
|
|
|
2004-10-25 22:09:16 +01:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2010-07-28 16:16:00 +01:00
|
|
|
void __glXDumpDrawBuffer(struct glx_context * ctx);
|
2004-10-25 22:09:16 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
** You can set this cell to 1 to force the gl drawing stuff to be
|
|
|
|
** one command per packet
|
|
|
|
*/
|
2008-03-09 03:28:01 +00:00
|
|
|
_X_HIDDEN int __glXDebug = 0;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
|
|
|
/* Extension required boiler plate */
|
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
static const char __glXExtensionName[] = GLX_EXTENSION_NAME;
|
2010-07-28 16:16:00 +01:00
|
|
|
static struct glx_display *glx_displays;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
|
|
|
static /* const */ char *error_list[] = {
|
2008-10-13 13:08:45 +01:00
|
|
|
"GLXBadContext",
|
|
|
|
"GLXBadContextState",
|
|
|
|
"GLXBadDrawable",
|
|
|
|
"GLXBadPixmap",
|
|
|
|
"GLXBadContextTag",
|
|
|
|
"GLXBadCurrentWindow",
|
|
|
|
"GLXBadRenderRequest",
|
|
|
|
"GLXBadLargeRequest",
|
|
|
|
"GLXUnsupportedPrivateRequest",
|
|
|
|
"GLXBadFBConfig",
|
|
|
|
"GLXBadPbuffer",
|
|
|
|
"GLXBadCurrentDrawable",
|
|
|
|
"GLXBadWindow",
|
2012-10-17 19:34:53 +01:00
|
|
|
"GLXBadProfileARB",
|
2004-10-25 22:09:16 +01:00
|
|
|
};
|
|
|
|
|
2010-04-01 19:01:31 +01:00
|
|
|
#ifdef GLX_USE_APPLEGL
|
|
|
|
static char *__glXErrorString(Display *dpy, int code, XExtCodes *codes,
|
|
|
|
char *buf, int n);
|
|
|
|
#endif
|
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
static
|
|
|
|
XEXT_GENERATE_ERROR_STRING(__glXErrorString, __glXExtensionName,
|
|
|
|
__GLX_NUMBER_ERRORS, error_list)
|
2010-07-23 02:11:02 +01:00
|
|
|
|
2009-11-12 16:48:07 +00:00
|
|
|
/*
|
|
|
|
* GLX events are a bit funky. We don't stuff the X event code into
|
|
|
|
* our user exposed (via XNextEvent) structure. Instead we use the GLX
|
|
|
|
* private event code namespace (and hope it doesn't conflict). Clients
|
|
|
|
* have to know that bit 15 in the event type field means they're getting
|
|
|
|
* a GLX event, and then handle the various sub-event types there, rather
|
|
|
|
* than simply checking the event code and handling it directly.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static Bool
|
|
|
|
__glXWireToEvent(Display *dpy, XEvent *event, xEvent *wire)
|
|
|
|
{
|
2010-07-28 16:16:00 +01:00
|
|
|
struct glx_display *glx_dpy = __glXInitialize(dpy);
|
2009-11-12 16:48:07 +00:00
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
if (glx_dpy == NULL)
|
|
|
|
return False;
|
2009-11-12 16:48:07 +00:00
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
switch ((wire->u.u.type & 0x7f) - glx_dpy->codes->first_event) {
|
2009-11-12 16:48:07 +00:00
|
|
|
case GLX_PbufferClobber:
|
|
|
|
{
|
|
|
|
GLXPbufferClobberEvent *aevent = (GLXPbufferClobberEvent *)event;
|
|
|
|
xGLXPbufferClobberEvent *awire = (xGLXPbufferClobberEvent *)wire;
|
|
|
|
aevent->event_type = awire->type;
|
|
|
|
aevent->serial = awire->sequenceNumber;
|
|
|
|
aevent->event_type = awire->event_type;
|
|
|
|
aevent->draw_type = awire->draw_type;
|
|
|
|
aevent->drawable = awire->drawable;
|
|
|
|
aevent->buffer_mask = awire->buffer_mask;
|
|
|
|
aevent->aux_buffer = awire->aux_buffer;
|
|
|
|
aevent->x = awire->x;
|
|
|
|
aevent->y = awire->y;
|
|
|
|
aevent->width = awire->width;
|
|
|
|
aevent->height = awire->height;
|
|
|
|
aevent->count = awire->count;
|
|
|
|
return True;
|
|
|
|
}
|
|
|
|
case GLX_BufferSwapComplete:
|
|
|
|
{
|
|
|
|
GLXBufferSwapComplete *aevent = (GLXBufferSwapComplete *)event;
|
2011-05-05 21:09:16 +01:00
|
|
|
xGLXBufferSwapComplete2 *awire = (xGLXBufferSwapComplete2 *)wire;
|
2011-05-06 18:31:24 +01:00
|
|
|
struct glx_drawable *glxDraw = GetGLXDrawable(dpy, awire->drawable);
|
2009-11-12 16:48:07 +00:00
|
|
|
aevent->event_type = awire->event_type;
|
|
|
|
aevent->drawable = awire->drawable;
|
|
|
|
aevent->ust = ((CARD64)awire->ust_hi << 32) | awire->ust_lo;
|
|
|
|
aevent->msc = ((CARD64)awire->msc_hi << 32) | awire->msc_lo;
|
2011-05-06 18:31:24 +01:00
|
|
|
|
|
|
|
if (!glxDraw)
|
|
|
|
return False;
|
|
|
|
|
|
|
|
if (awire->sbc < glxDraw->lastEventSbc)
|
|
|
|
glxDraw->eventSbcWrap += 0x100000000;
|
|
|
|
glxDraw->lastEventSbc = awire->sbc;
|
|
|
|
aevent->sbc = awire->sbc + glxDraw->eventSbcWrap;
|
2009-11-12 16:48:07 +00:00
|
|
|
return True;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
/* client doesn't support server event */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return False;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We don't actually support this. It doesn't make sense for clients to
|
|
|
|
* send each other GLX events.
|
|
|
|
*/
|
|
|
|
static Status
|
|
|
|
__glXEventToWire(Display *dpy, XEvent *event, xEvent *wire)
|
|
|
|
{
|
2010-07-28 16:16:00 +01:00
|
|
|
struct glx_display *glx_dpy = __glXInitialize(dpy);
|
2009-11-12 16:48:07 +00:00
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
if (glx_dpy == NULL)
|
|
|
|
return False;
|
2009-11-12 16:48:07 +00:00
|
|
|
|
|
|
|
switch (event->type) {
|
|
|
|
case GLX_DAMAGED:
|
|
|
|
break;
|
|
|
|
case GLX_SAVED:
|
|
|
|
break;
|
2010-01-20 03:01:14 +00:00
|
|
|
case GLX_EXCHANGE_COMPLETE_INTEL:
|
2009-11-12 16:48:07 +00:00
|
|
|
break;
|
2010-04-05 07:06:01 +01:00
|
|
|
case GLX_COPY_COMPLETE_INTEL:
|
2009-11-12 16:48:07 +00:00
|
|
|
break;
|
2010-01-20 03:01:14 +00:00
|
|
|
case GLX_FLIP_COMPLETE_INTEL:
|
2009-11-12 16:48:07 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* client doesn't support server event */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Success;
|
|
|
|
}
|
|
|
|
|
2004-10-25 22:09:16 +01:00
|
|
|
/************************************************************************/
|
|
|
|
/*
|
|
|
|
** Free the per screen configs data as well as the array of
|
|
|
|
** __glXScreenConfigs.
|
|
|
|
*/
|
2008-10-18 16:00:13 +01:00
|
|
|
static void
|
2010-08-02 14:47:44 +01:00
|
|
|
FreeScreenConfigs(struct glx_display * priv)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2010-07-28 15:28:43 +01:00
|
|
|
struct glx_screen *psc;
|
2008-10-13 13:08:45 +01:00
|
|
|
GLint i, screens;
|
|
|
|
|
|
|
|
/* Free screen configuration information */
|
|
|
|
screens = ScreenCount(priv->dpy);
|
2010-07-19 19:57:59 +01:00
|
|
|
for (i = 0; i < screens; i++) {
|
2010-07-28 15:28:43 +01:00
|
|
|
psc = priv->screens[i];
|
2011-01-29 23:00:48 +00:00
|
|
|
glx_screen_cleanup(psc);
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2010-04-02 09:35:19 +01:00
|
|
|
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
|
2008-10-13 13:08:45 +01:00
|
|
|
if (psc->driScreen) {
|
2010-07-19 19:57:59 +01:00
|
|
|
psc->driScreen->destroyScreen(psc);
|
|
|
|
} else {
|
2012-09-05 06:52:36 +01:00
|
|
|
free(psc);
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
2010-07-19 19:57:59 +01:00
|
|
|
#else
|
2012-09-05 06:52:36 +01:00
|
|
|
free(psc);
|
2004-10-25 22:09:16 +01:00
|
|
|
#endif
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
2012-09-05 06:52:36 +01:00
|
|
|
free((char *) priv->screens);
|
2010-07-28 15:28:43 +01:00
|
|
|
priv->screens = NULL;
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
2010-08-02 14:47:44 +01:00
|
|
|
static void
|
|
|
|
glx_display_free(struct glx_display *priv)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2010-08-02 14:47:44 +01:00
|
|
|
struct glx_context *gc;
|
2010-07-23 02:11:02 +01:00
|
|
|
|
|
|
|
gc = __glXGetCurrentContext();
|
2010-08-02 14:47:44 +01:00
|
|
|
if (priv->dpy == gc->currentDpy) {
|
2010-07-23 04:45:18 +01:00
|
|
|
gc->vtable->destroy(gc);
|
2010-07-23 02:11:02 +01:00
|
|
|
__glXSetCurrentContextNull();
|
|
|
|
}
|
2008-10-13 13:08:45 +01:00
|
|
|
|
|
|
|
FreeScreenConfigs(priv);
|
2012-09-04 04:24:35 +01:00
|
|
|
free((char *) priv->serverGLXvendor);
|
|
|
|
free((char *) priv->serverGLXversion);
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2011-05-06 18:31:24 +01:00
|
|
|
__glxHashDestroy(priv->glXDrawHash);
|
|
|
|
|
2010-08-09 14:47:26 +01:00
|
|
|
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
|
2010-07-20 02:15:50 +01:00
|
|
|
__glxHashDestroy(priv->drawHash);
|
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
/* Free the direct rendering per display data */
|
|
|
|
if (priv->driswDisplay)
|
|
|
|
(*priv->driswDisplay->destroyDisplay) (priv->driswDisplay);
|
|
|
|
priv->driswDisplay = NULL;
|
|
|
|
|
|
|
|
if (priv->driDisplay)
|
|
|
|
(*priv->driDisplay->destroyDisplay) (priv->driDisplay);
|
|
|
|
priv->driDisplay = NULL;
|
|
|
|
|
|
|
|
if (priv->dri2Display)
|
|
|
|
(*priv->dri2Display->destroyDisplay) (priv->dri2Display);
|
|
|
|
priv->dri2Display = NULL;
|
2004-10-25 22:09:16 +01:00
|
|
|
#endif
|
|
|
|
|
2012-09-05 06:52:36 +01:00
|
|
|
free((char *) priv);
|
2010-08-02 14:47:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
__glXCloseDisplay(Display * dpy, XExtCodes * codes)
|
|
|
|
{
|
2011-07-17 23:42:27 +01:00
|
|
|
struct glx_display *priv, **prev;
|
2010-08-02 14:47:44 +01:00
|
|
|
|
|
|
|
_XLockMutex(_Xglobal_lock);
|
|
|
|
prev = &glx_displays;
|
|
|
|
for (priv = glx_displays; priv; prev = &priv->next, priv = priv->next) {
|
|
|
|
if (priv->dpy == dpy) {
|
2011-07-17 23:42:27 +01:00
|
|
|
*prev = priv->next;
|
2010-08-02 14:47:44 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-07-17 23:42:27 +01:00
|
|
|
_XUnlockMutex(_Xglobal_lock);
|
2010-08-02 14:47:44 +01:00
|
|
|
|
|
|
|
glx_display_free(priv);
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
return 1;
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Query the version of the GLX extension. This procedure works even if
|
|
|
|
** the client extension is not completely set up.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
static Bool
|
|
|
|
QueryVersion(Display * dpy, int opcode, int *major, int *minor)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-18 16:00:13 +01:00
|
|
|
xcb_connection_t *c = XGetXCBConnection(dpy);
|
2009-08-12 11:41:22 +01:00
|
|
|
xcb_glx_query_version_reply_t *reply = xcb_glx_query_version_reply(c,
|
|
|
|
xcb_glx_query_version
|
|
|
|
(c,
|
|
|
|
GLX_MAJOR_VERSION,
|
|
|
|
GLX_MINOR_VERSION),
|
|
|
|
NULL);
|
|
|
|
|
2012-05-25 01:58:53 +01:00
|
|
|
if (!reply)
|
|
|
|
return GL_FALSE;
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
if (reply->major_version != GLX_MAJOR_VERSION) {
|
2008-10-18 16:00:13 +01:00
|
|
|
free(reply);
|
|
|
|
return GL_FALSE;
|
|
|
|
}
|
|
|
|
*major = reply->major_version;
|
|
|
|
*minor = min(reply->minor_version, GLX_MINOR_VERSION);
|
|
|
|
free(reply);
|
|
|
|
return GL_TRUE;
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
2010-04-01 19:01:31 +01:00
|
|
|
/*
|
|
|
|
* We don't want to enable this GLX_OML_swap_method in glxext.h,
|
|
|
|
* because we can't support it. The X server writes it out though,
|
|
|
|
* so we should handle it somehow, to avoid false warnings.
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
IGNORE_GLX_SWAP_METHOD_OML = 0x8060
|
|
|
|
};
|
|
|
|
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2010-07-28 15:07:52 +01:00
|
|
|
static GLint
|
|
|
|
convert_from_x_visual_type(int visualType)
|
|
|
|
{
|
|
|
|
static const int glx_visual_types[] = {
|
|
|
|
GLX_STATIC_GRAY, GLX_GRAY_SCALE,
|
|
|
|
GLX_STATIC_COLOR, GLX_PSEUDO_COLOR,
|
|
|
|
GLX_TRUE_COLOR, GLX_DIRECT_COLOR
|
|
|
|
};
|
|
|
|
|
|
|
|
if (visualType < ARRAY_SIZE(glx_visual_types))
|
|
|
|
return glx_visual_types[visualType];
|
|
|
|
|
|
|
|
return GLX_NONE;
|
|
|
|
}
|
|
|
|
|
2010-04-01 19:01:31 +01:00
|
|
|
/*
|
|
|
|
* getVisualConfigs uses the !tagged_only path.
|
|
|
|
* getFBConfigs uses the tagged_only path.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
_X_HIDDEN void
|
2010-07-28 15:07:52 +01:00
|
|
|
__glXInitializeVisualConfigFromTags(struct glx_config * config, int count,
|
2008-10-13 13:08:45 +01:00
|
|
|
const INT32 * bp, Bool tagged_only,
|
|
|
|
Bool fbconfig_style_tags)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-13 13:08:45 +01:00
|
|
|
int i;
|
2013-07-17 12:49:16 +01:00
|
|
|
GLint renderType = 0;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
if (!tagged_only) {
|
|
|
|
/* Copy in the first set of properties */
|
|
|
|
config->visualID = *bp++;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2010-07-28 15:07:52 +01:00
|
|
|
config->visualType = convert_from_x_visual_type(*bp++);
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
config->rgbMode = *bp++;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
config->redBits = *bp++;
|
|
|
|
config->greenBits = *bp++;
|
|
|
|
config->blueBits = *bp++;
|
|
|
|
config->alphaBits = *bp++;
|
|
|
|
config->accumRedBits = *bp++;
|
|
|
|
config->accumGreenBits = *bp++;
|
|
|
|
config->accumBlueBits = *bp++;
|
|
|
|
config->accumAlphaBits = *bp++;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
config->doubleBufferMode = *bp++;
|
|
|
|
config->stereoMode = *bp++;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
config->rgbBits = *bp++;
|
|
|
|
config->depthBits = *bp++;
|
|
|
|
config->stencilBits = *bp++;
|
|
|
|
config->numAuxBuffers = *bp++;
|
|
|
|
config->level = *bp++;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2010-04-01 19:01:31 +01:00
|
|
|
#ifdef GLX_USE_APPLEGL
|
|
|
|
/* AppleSGLX supports pixmap and pbuffers with all config. */
|
|
|
|
config->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
|
|
|
|
/* Unfortunately this can create an ABI compatibility problem. */
|
|
|
|
count -= 18;
|
|
|
|
#else
|
2008-10-13 13:08:45 +01:00
|
|
|
count -= __GLX_MIN_CONFIG_PROPS;
|
2010-04-01 19:01:31 +01:00
|
|
|
#endif
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2012-07-12 21:56:32 +01:00
|
|
|
config->sRGBCapable = GL_FALSE;
|
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
/*
|
2004-10-25 22:09:16 +01:00
|
|
|
** Additional properties may be in a list at the end
|
|
|
|
** of the reply. They are in pairs of property type
|
|
|
|
** and property value.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define FETCH_OR_SET(tag) \
|
|
|
|
config-> tag = ( fbconfig_style_tags ) ? *bp++ : 1
|
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
for (i = 0; i < count; i += 2) {
|
2010-04-01 19:01:31 +01:00
|
|
|
long int tag = *bp++;
|
|
|
|
|
|
|
|
switch (tag) {
|
2008-10-13 13:08:45 +01:00
|
|
|
case GLX_RGBA:
|
|
|
|
FETCH_OR_SET(rgbMode);
|
|
|
|
break;
|
|
|
|
case GLX_BUFFER_SIZE:
|
|
|
|
config->rgbBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_LEVEL:
|
|
|
|
config->level = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_DOUBLEBUFFER:
|
|
|
|
FETCH_OR_SET(doubleBufferMode);
|
|
|
|
break;
|
|
|
|
case GLX_STEREO:
|
|
|
|
FETCH_OR_SET(stereoMode);
|
|
|
|
break;
|
|
|
|
case GLX_AUX_BUFFERS:
|
|
|
|
config->numAuxBuffers = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_RED_SIZE:
|
|
|
|
config->redBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_GREEN_SIZE:
|
|
|
|
config->greenBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_BLUE_SIZE:
|
|
|
|
config->blueBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_ALPHA_SIZE:
|
|
|
|
config->alphaBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_DEPTH_SIZE:
|
|
|
|
config->depthBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_STENCIL_SIZE:
|
|
|
|
config->stencilBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_ACCUM_RED_SIZE:
|
|
|
|
config->accumRedBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_ACCUM_GREEN_SIZE:
|
|
|
|
config->accumGreenBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_ACCUM_BLUE_SIZE:
|
|
|
|
config->accumBlueBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_ACCUM_ALPHA_SIZE:
|
|
|
|
config->accumAlphaBits = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_VISUAL_CAVEAT_EXT:
|
|
|
|
config->visualRating = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_X_VISUAL_TYPE:
|
|
|
|
config->visualType = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_TRANSPARENT_TYPE:
|
|
|
|
config->transparentPixel = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_TRANSPARENT_INDEX_VALUE:
|
|
|
|
config->transparentIndex = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_TRANSPARENT_RED_VALUE:
|
|
|
|
config->transparentRed = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_TRANSPARENT_GREEN_VALUE:
|
|
|
|
config->transparentGreen = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_TRANSPARENT_BLUE_VALUE:
|
|
|
|
config->transparentBlue = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_TRANSPARENT_ALPHA_VALUE:
|
|
|
|
config->transparentAlpha = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_VISUAL_ID:
|
|
|
|
config->visualID = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_DRAWABLE_TYPE:
|
|
|
|
config->drawableType = *bp++;
|
2010-04-01 19:01:31 +01:00
|
|
|
#ifdef GLX_USE_APPLEGL
|
|
|
|
/* AppleSGLX supports pixmap and pbuffers with all config. */
|
|
|
|
config->drawableType |= GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
|
|
|
|
#endif
|
2008-10-13 13:08:45 +01:00
|
|
|
break;
|
2013-07-17 12:49:16 +01:00
|
|
|
case GLX_RENDER_TYPE: /* fbconfig render type bits */
|
|
|
|
renderType = *bp++;
|
2008-10-13 13:08:45 +01:00
|
|
|
break;
|
|
|
|
case GLX_X_RENDERABLE:
|
|
|
|
config->xRenderable = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_FBCONFIG_ID:
|
|
|
|
config->fbconfigID = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_MAX_PBUFFER_WIDTH:
|
|
|
|
config->maxPbufferWidth = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_MAX_PBUFFER_HEIGHT:
|
|
|
|
config->maxPbufferHeight = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_MAX_PBUFFER_PIXELS:
|
|
|
|
config->maxPbufferPixels = *bp++;
|
|
|
|
break;
|
2010-04-01 19:01:31 +01:00
|
|
|
#ifndef GLX_USE_APPLEGL
|
2008-10-13 13:08:45 +01:00
|
|
|
case GLX_OPTIMAL_PBUFFER_WIDTH_SGIX:
|
|
|
|
config->optimalPbufferWidth = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX:
|
|
|
|
config->optimalPbufferHeight = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_VISUAL_SELECT_GROUP_SGIX:
|
|
|
|
config->visualSelectGroup = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_SWAP_METHOD_OML:
|
|
|
|
config->swapMethod = *bp++;
|
|
|
|
break;
|
2010-04-01 19:01:31 +01:00
|
|
|
#endif
|
2008-10-13 13:08:45 +01:00
|
|
|
case GLX_SAMPLE_BUFFERS_SGIS:
|
|
|
|
config->sampleBuffers = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_SAMPLES_SGIS:
|
|
|
|
config->samples = *bp++;
|
|
|
|
break;
|
2010-04-01 19:01:31 +01:00
|
|
|
#ifdef GLX_USE_APPLEGL
|
|
|
|
case IGNORE_GLX_SWAP_METHOD_OML:
|
|
|
|
/* We ignore this tag. See the comment above this function. */
|
|
|
|
++bp;
|
|
|
|
break;
|
|
|
|
#else
|
2008-10-13 13:08:45 +01:00
|
|
|
case GLX_BIND_TO_TEXTURE_RGB_EXT:
|
|
|
|
config->bindToTextureRgb = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_BIND_TO_TEXTURE_RGBA_EXT:
|
|
|
|
config->bindToTextureRgba = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
|
|
|
|
config->bindToMipmapTexture = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
|
|
|
|
config->bindToTextureTargets = *bp++;
|
|
|
|
break;
|
|
|
|
case GLX_Y_INVERTED_EXT:
|
|
|
|
config->yInverted = *bp++;
|
|
|
|
break;
|
2010-04-01 19:01:31 +01:00
|
|
|
#endif
|
2011-03-06 09:54:37 +00:00
|
|
|
case GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT:
|
2011-03-06 10:06:42 +00:00
|
|
|
config->sRGBCapable = *bp++;
|
2011-03-06 09:54:37 +00:00
|
|
|
break;
|
|
|
|
|
2010-05-02 10:35:34 +01:00
|
|
|
case GLX_USE_GL:
|
2010-06-02 23:03:22 +01:00
|
|
|
if (fbconfig_style_tags)
|
|
|
|
bp++;
|
2010-05-02 10:35:34 +01:00
|
|
|
break;
|
2008-10-13 13:08:45 +01:00
|
|
|
case None:
|
|
|
|
i = count;
|
|
|
|
break;
|
|
|
|
default:
|
2010-04-01 19:01:31 +01:00
|
|
|
if(getenv("LIBGL_DIAGNOSTIC")) {
|
|
|
|
long int tagvalue = *bp++;
|
|
|
|
fprintf(stderr, "WARNING: unknown GLX tag from server: "
|
|
|
|
"tag 0x%lx value 0x%lx\n", tag, tagvalue);
|
|
|
|
} else {
|
|
|
|
/* Ignore the unrecognized tag's value */
|
|
|
|
bp++;
|
|
|
|
}
|
2010-06-02 23:04:10 +01:00
|
|
|
break;
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-17 12:49:16 +01:00
|
|
|
if (renderType != 0 && renderType != GLX_DONT_CARE) {
|
|
|
|
config->renderType = renderType;
|
|
|
|
config->floatMode = (renderType &
|
|
|
|
(GLX_RGBA_FLOAT_BIT_ARB|GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT)) != 0;
|
|
|
|
} else {
|
|
|
|
/* If there wasn't GLX_RENDER_TYPE property, set it based on
|
|
|
|
* config->rgbMode. The only way to communicate that the config is
|
|
|
|
* floating-point is via GLX_RENDER_TYPE, so this cannot be a float
|
|
|
|
* config.
|
|
|
|
*/
|
|
|
|
config->renderType =
|
|
|
|
(config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The GLX_ARB_fbconfig_float spec says:
|
|
|
|
*
|
|
|
|
* "Note that floating point rendering is only supported for
|
|
|
|
* GLXPbuffer drawables."
|
|
|
|
*/
|
|
|
|
if (config->floatMode)
|
|
|
|
config->drawableType &= ~(GLX_WINDOW_BIT|GLX_PIXMAP_BIT);
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
2010-07-28 15:07:52 +01:00
|
|
|
static struct glx_config *
|
2008-11-27 11:53:43 +00:00
|
|
|
createConfigsFromProperties(Display * dpy, int nvisuals, int nprops,
|
|
|
|
int screen, GLboolean tagged_only)
|
2007-10-16 21:07:47 +01:00
|
|
|
{
|
2008-10-13 13:08:45 +01:00
|
|
|
INT32 buf[__GLX_TOTAL_CONFIG], *props;
|
|
|
|
unsigned prop_size;
|
2010-07-28 15:07:52 +01:00
|
|
|
struct glx_config *modes, *m;
|
2008-10-13 13:08:45 +01:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (nprops == 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for FBconfigs? */
|
|
|
|
|
|
|
|
/* Check number of properties */
|
|
|
|
if (nprops < __GLX_MIN_CONFIG_PROPS || nprops > __GLX_MAX_CONFIG_PROPS)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Allocate memory for our config structure */
|
2010-07-28 15:07:52 +01:00
|
|
|
modes = glx_config_create_list(nvisuals);
|
2008-10-13 13:08:45 +01:00
|
|
|
if (!modes)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
prop_size = nprops * __GLX_SIZE_INT32;
|
|
|
|
if (prop_size <= sizeof(buf))
|
|
|
|
props = buf;
|
|
|
|
else
|
2012-09-05 06:52:36 +01:00
|
|
|
props = malloc(prop_size);
|
2008-10-13 13:08:45 +01:00
|
|
|
|
|
|
|
/* Read each config structure and convert it into our format */
|
|
|
|
m = modes;
|
|
|
|
for (i = 0; i < nvisuals; i++) {
|
|
|
|
_XRead(dpy, (char *) props, prop_size);
|
2010-04-01 19:01:31 +01:00
|
|
|
#ifdef GLX_USE_APPLEGL
|
|
|
|
/* Older X servers don't send this so we default it here. */
|
2008-10-13 13:08:45 +01:00
|
|
|
m->drawableType = GLX_WINDOW_BIT;
|
2010-04-01 19:01:31 +01:00
|
|
|
#else
|
|
|
|
/*
|
|
|
|
* The XQuartz 2.3.2.1 X server doesn't set this properly, so
|
|
|
|
* set the proper bits here.
|
|
|
|
* AppleSGLX supports windows, pixmaps, and pbuffers with all config.
|
|
|
|
*/
|
|
|
|
m->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
|
|
|
|
#endif
|
|
|
|
__glXInitializeVisualConfigFromTags(m, nprops, props,
|
2008-10-13 13:08:45 +01:00
|
|
|
tagged_only, GL_TRUE);
|
|
|
|
m->screen = screen;
|
|
|
|
m = m->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (props != buf)
|
2012-09-05 06:52:36 +01:00
|
|
|
free(props);
|
2008-10-13 13:08:45 +01:00
|
|
|
|
|
|
|
return modes;
|
2007-10-16 21:07:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static GLboolean
|
2010-07-28 15:28:43 +01:00
|
|
|
getVisualConfigs(struct glx_screen *psc,
|
2010-07-28 16:16:00 +01:00
|
|
|
struct glx_display *priv, int screen)
|
2007-10-16 21:07:47 +01:00
|
|
|
{
|
2008-11-04 16:17:18 +00:00
|
|
|
xGLXGetVisualConfigsReq *req;
|
2008-10-13 13:08:45 +01:00
|
|
|
xGLXGetVisualConfigsReply reply;
|
2010-07-19 19:57:59 +01:00
|
|
|
Display *dpy = priv->dpy;
|
2008-10-13 13:08:45 +01:00
|
|
|
|
|
|
|
LockDisplay(dpy);
|
|
|
|
|
|
|
|
psc->visuals = NULL;
|
|
|
|
GetReq(GLXGetVisualConfigs, req);
|
|
|
|
req->reqType = priv->majorOpcode;
|
|
|
|
req->glxCode = X_GLXGetVisualConfigs;
|
|
|
|
req->screen = screen;
|
|
|
|
|
|
|
|
if (!_XReply(dpy, (xReply *) & reply, 0, False))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
psc->visuals = createConfigsFromProperties(dpy,
|
|
|
|
reply.numVisuals,
|
|
|
|
reply.numProps,
|
|
|
|
screen, GL_FALSE);
|
2007-10-16 21:07:47 +01:00
|
|
|
|
|
|
|
out:
|
2008-10-13 13:08:45 +01:00
|
|
|
UnlockDisplay(dpy);
|
|
|
|
return psc->visuals != NULL;
|
2007-10-16 21:07:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static GLboolean
|
2010-07-28 16:16:00 +01:00
|
|
|
getFBConfigs(struct glx_screen *psc, struct glx_display *priv, int screen)
|
2007-10-16 21:07:47 +01:00
|
|
|
{
|
2008-10-13 13:08:45 +01:00
|
|
|
xGLXGetFBConfigsReq *fb_req;
|
|
|
|
xGLXGetFBConfigsSGIXReq *sgi_req;
|
|
|
|
xGLXVendorPrivateWithReplyReq *vpreq;
|
|
|
|
xGLXGetFBConfigsReply reply;
|
2010-07-19 19:57:59 +01:00
|
|
|
Display *dpy = priv->dpy;
|
2008-10-13 13:08:45 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
psc->serverGLXexts =
|
|
|
|
__glXQueryServerString(dpy, priv->majorOpcode, screen, GLX_EXTENSIONS);
|
2008-10-13 13:08:45 +01:00
|
|
|
|
|
|
|
LockDisplay(dpy);
|
|
|
|
|
|
|
|
psc->configs = NULL;
|
|
|
|
if (atof(priv->serverGLXversion) >= 1.3) {
|
|
|
|
GetReq(GLXGetFBConfigs, fb_req);
|
|
|
|
fb_req->reqType = priv->majorOpcode;
|
|
|
|
fb_req->glxCode = X_GLXGetFBConfigs;
|
|
|
|
fb_req->screen = screen;
|
|
|
|
}
|
|
|
|
else if (strstr(psc->serverGLXexts, "GLX_SGIX_fbconfig") != NULL) {
|
|
|
|
GetReqExtra(GLXVendorPrivateWithReply,
|
2011-01-26 12:03:17 +00:00
|
|
|
sz_xGLXGetFBConfigsSGIXReq -
|
2008-10-13 13:08:45 +01:00
|
|
|
sz_xGLXVendorPrivateWithReplyReq, vpreq);
|
|
|
|
sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
|
|
|
|
sgi_req->reqType = priv->majorOpcode;
|
|
|
|
sgi_req->glxCode = X_GLXVendorPrivateWithReply;
|
|
|
|
sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
|
|
|
|
sgi_req->screen = screen;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!_XReply(dpy, (xReply *) & reply, 0, False))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
psc->configs = createConfigsFromProperties(dpy,
|
|
|
|
reply.numFBConfigs,
|
|
|
|
reply.numAttribs * 2,
|
|
|
|
screen, GL_TRUE);
|
2007-10-16 21:07:47 +01:00
|
|
|
|
|
|
|
out:
|
2008-10-13 13:08:45 +01:00
|
|
|
UnlockDisplay(dpy);
|
|
|
|
return psc->configs != NULL;
|
2007-10-16 21:07:47 +01:00
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2010-07-19 19:57:59 +01:00
|
|
|
_X_HIDDEN Bool
|
2010-07-28 15:28:43 +01:00
|
|
|
glx_screen_init(struct glx_screen *psc,
|
2010-07-28 16:16:00 +01:00
|
|
|
int screen, struct glx_display * priv)
|
2010-07-19 19:57:59 +01:00
|
|
|
{
|
|
|
|
/* Initialize per screen dynamic client GLX extensions */
|
|
|
|
psc->ext_list_first_time = GL_TRUE;
|
|
|
|
psc->scr = screen;
|
|
|
|
psc->dpy = priv->dpy;
|
2010-07-20 02:00:09 +01:00
|
|
|
psc->display = priv;
|
2010-07-19 19:57:59 +01:00
|
|
|
|
|
|
|
getVisualConfigs(psc, priv, screen);
|
|
|
|
getFBConfigs(psc, priv, screen);
|
|
|
|
|
|
|
|
return GL_TRUE;
|
|
|
|
}
|
|
|
|
|
2011-01-29 23:00:48 +00:00
|
|
|
_X_HIDDEN void
|
|
|
|
glx_screen_cleanup(struct glx_screen *psc)
|
|
|
|
{
|
|
|
|
if (psc->configs) {
|
|
|
|
glx_config_destroy_list(psc->configs);
|
2012-09-04 04:24:35 +01:00
|
|
|
free(psc->effectiveGLXexts);
|
2011-01-29 23:00:48 +00:00
|
|
|
psc->configs = NULL; /* NOTE: just for paranoia */
|
|
|
|
}
|
|
|
|
if (psc->visuals) {
|
|
|
|
glx_config_destroy_list(psc->visuals);
|
|
|
|
psc->visuals = NULL; /* NOTE: just for paranoia */
|
|
|
|
}
|
2012-09-05 06:52:36 +01:00
|
|
|
free((char *) psc->serverGLXexts);
|
2011-01-29 23:00:48 +00:00
|
|
|
}
|
|
|
|
|
2004-10-25 22:09:16 +01:00
|
|
|
/*
|
|
|
|
** Allocate the memory for the per screen configs for each screen.
|
|
|
|
** If that works then fetch the per screen configs data.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
static Bool
|
2010-07-28 20:33:09 +01:00
|
|
|
AllocAndFetchScreenConfigs(Display * dpy, struct glx_display * priv)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2010-07-28 15:28:43 +01:00
|
|
|
struct glx_screen *psc;
|
2008-10-13 13:08:45 +01:00
|
|
|
GLint i, screens;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
/*
|
2004-10-25 22:09:16 +01:00
|
|
|
** First allocate memory for the array of per screen configs.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
screens = ScreenCount(dpy);
|
2012-09-05 06:52:36 +01:00
|
|
|
priv->screens = malloc(screens * sizeof *priv->screens);
|
2010-07-28 15:28:43 +01:00
|
|
|
if (!priv->screens)
|
2008-10-13 13:08:45 +01:00
|
|
|
return GL_FALSE;
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
priv->serverGLXversion =
|
|
|
|
__glXQueryServerString(dpy, priv->majorOpcode, 0, GLX_VERSION);
|
2008-10-13 13:08:45 +01:00
|
|
|
if (priv->serverGLXversion == NULL) {
|
|
|
|
FreeScreenConfigs(priv);
|
|
|
|
return GL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < screens; i++, psc++) {
|
2010-07-23 13:32:25 +01:00
|
|
|
psc = NULL;
|
2010-04-02 09:35:19 +01:00
|
|
|
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
|
2013-11-05 02:15:51 +00:00
|
|
|
if (priv->dri3Display)
|
|
|
|
psc = (*priv->dri3Display->createScreen) (i, priv);
|
|
|
|
if (psc == NULL && priv->dri2Display)
|
2010-07-19 19:57:59 +01:00
|
|
|
psc = (*priv->dri2Display->createScreen) (i, priv);
|
|
|
|
if (psc == NULL && priv->driDisplay)
|
|
|
|
psc = (*priv->driDisplay->createScreen) (i, priv);
|
|
|
|
if (psc == NULL && priv->driswDisplay)
|
|
|
|
psc = (*priv->driswDisplay->createScreen) (i, priv);
|
2010-07-28 21:40:43 +01:00
|
|
|
#endif
|
|
|
|
#if defined(GLX_USE_APPLEGL)
|
2011-06-05 23:50:55 +01:00
|
|
|
if (psc == NULL)
|
|
|
|
psc = applegl_create_screen(i, priv);
|
|
|
|
#else
|
2010-07-19 19:57:59 +01:00
|
|
|
if (psc == NULL)
|
2010-07-23 21:15:31 +01:00
|
|
|
psc = indirect_create_screen(i, priv);
|
2011-06-05 23:50:55 +01:00
|
|
|
#endif
|
2010-07-28 15:28:43 +01:00
|
|
|
priv->screens[i] = psc;
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
|
|
|
SyncHandle();
|
|
|
|
return GL_TRUE;
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Initialize the client side extension code.
|
|
|
|
*/
|
2010-07-28 16:16:00 +01:00
|
|
|
_X_HIDDEN struct glx_display *
|
2008-10-13 13:08:45 +01:00
|
|
|
__glXInitialize(Display * dpy)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2010-08-02 14:47:44 +01:00
|
|
|
struct glx_display *dpyPriv, *d;
|
2010-04-02 09:35:19 +01:00
|
|
|
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
|
2008-10-13 13:08:45 +01:00
|
|
|
Bool glx_direct, glx_accel;
|
2008-07-07 16:34:17 +01:00
|
|
|
#endif
|
2010-07-23 02:11:02 +01:00
|
|
|
int i;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
_XLockMutex(_Xglobal_lock);
|
2008-10-13 13:08:45 +01:00
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
for (dpyPriv = glx_displays; dpyPriv; dpyPriv = dpyPriv->next) {
|
|
|
|
if (dpyPriv->dpy == dpy) {
|
|
|
|
_XUnlockMutex(_Xglobal_lock);
|
|
|
|
return dpyPriv;
|
|
|
|
}
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
|
|
|
|
2010-08-02 14:47:44 +01:00
|
|
|
/* Drop the lock while we create the display private. */
|
|
|
|
_XUnlockMutex(_Xglobal_lock);
|
|
|
|
|
2012-09-05 06:52:36 +01:00
|
|
|
dpyPriv = calloc(1, sizeof *dpyPriv);
|
2010-07-23 02:11:02 +01:00
|
|
|
if (!dpyPriv)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dpyPriv->codes = XInitExtension(dpy, __glXExtensionName);
|
|
|
|
if (!dpyPriv->codes) {
|
2012-09-05 06:52:36 +01:00
|
|
|
free(dpyPriv);
|
2010-07-23 02:11:02 +01:00
|
|
|
_XUnlockMutex(_Xglobal_lock);
|
|
|
|
return NULL;
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
dpyPriv->dpy = dpy;
|
|
|
|
dpyPriv->majorOpcode = dpyPriv->codes->major_opcode;
|
|
|
|
dpyPriv->serverGLXvendor = 0x0;
|
|
|
|
dpyPriv->serverGLXversion = 0x0;
|
|
|
|
|
2011-11-29 02:31:21 +00:00
|
|
|
/* See if the versions are compatible. This GLX implementation does not
|
|
|
|
* work with servers that only support GLX 1.0.
|
|
|
|
*/
|
2010-07-23 02:11:02 +01:00
|
|
|
if (!QueryVersion(dpy, dpyPriv->majorOpcode,
|
2011-11-29 02:31:21 +00:00
|
|
|
&dpyPriv->majorVersion, &dpyPriv->minorVersion)
|
|
|
|
|| (dpyPriv->majorVersion == 1 && dpyPriv->minorVersion < 1)) {
|
2012-09-05 06:52:36 +01:00
|
|
|
free(dpyPriv);
|
2010-07-23 02:11:02 +01:00
|
|
|
_XUnlockMutex(_Xglobal_lock);
|
|
|
|
return NULL;
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
for (i = 0; i < __GLX_NUMBER_EVENTS; i++) {
|
|
|
|
XESetWireToEvent(dpy, dpyPriv->codes->first_event + i, __glXWireToEvent);
|
|
|
|
XESetEventToWire(dpy, dpyPriv->codes->first_event + i, __glXEventToWire);
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
XESetCloseDisplay(dpy, dpyPriv->codes->extension, __glXCloseDisplay);
|
|
|
|
XESetErrorString (dpy, dpyPriv->codes->extension,__glXErrorString);
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2011-05-06 18:31:24 +01:00
|
|
|
dpyPriv->glXDrawHash = __glxHashCreate();
|
|
|
|
|
2010-04-02 09:35:19 +01:00
|
|
|
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
|
2008-10-13 13:08:45 +01:00
|
|
|
glx_direct = (getenv("LIBGL_ALWAYS_INDIRECT") == NULL);
|
|
|
|
glx_accel = (getenv("LIBGL_ALWAYS_SOFTWARE") == NULL);
|
2008-07-07 16:34:17 +01:00
|
|
|
|
2010-07-20 02:15:50 +01:00
|
|
|
dpyPriv->drawHash = __glxHashCreate();
|
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
/*
|
2004-10-25 22:09:16 +01:00
|
|
|
** Initialize the direct rendering per display data and functions.
|
|
|
|
** Note: This _must_ be done before calling any other DRI routines
|
|
|
|
** (e.g., those called in AllocAndFetchScreenConfigs).
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
if (glx_direct && glx_accel) {
|
2013-11-05 02:15:51 +00:00
|
|
|
if (!getenv("LIBGL_DRI3_DISABLE"))
|
|
|
|
dpyPriv->dri3Display = dri3_create_display(dpy);
|
2008-10-13 13:08:45 +01:00
|
|
|
dpyPriv->dri2Display = dri2CreateDisplay(dpy);
|
|
|
|
dpyPriv->driDisplay = driCreateDisplay(dpy);
|
|
|
|
}
|
|
|
|
if (glx_direct)
|
|
|
|
dpyPriv->driswDisplay = driswCreateDisplay(dpy);
|
2004-10-25 22:09:16 +01:00
|
|
|
#endif
|
2010-07-23 02:11:02 +01:00
|
|
|
|
2010-04-01 19:01:31 +01:00
|
|
|
#ifdef GLX_USE_APPLEGL
|
2010-07-28 21:40:43 +01:00
|
|
|
if (!applegl_create_display(dpyPriv)) {
|
2012-09-05 06:52:36 +01:00
|
|
|
free(dpyPriv);
|
2010-07-23 02:11:02 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-04-01 19:01:31 +01:00
|
|
|
#endif
|
2010-07-23 02:11:02 +01:00
|
|
|
if (!AllocAndFetchScreenConfigs(dpy, dpyPriv)) {
|
2012-09-05 06:52:36 +01:00
|
|
|
free(dpyPriv);
|
2010-07-23 02:11:02 +01:00
|
|
|
return NULL;
|
2008-10-13 13:08:45 +01:00
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2011-11-29 18:57:43 +00:00
|
|
|
__glX_send_client_info(dpyPriv);
|
2010-07-23 02:11:02 +01:00
|
|
|
|
2010-08-02 14:47:44 +01:00
|
|
|
/* Grab the lock again and add the dispay private, unless somebody
|
|
|
|
* beat us to initializing on this display in the meantime. */
|
|
|
|
_XLockMutex(_Xglobal_lock);
|
|
|
|
|
|
|
|
for (d = glx_displays; d; d = d->next) {
|
|
|
|
if (d->dpy == dpy) {
|
|
|
|
_XUnlockMutex(_Xglobal_lock);
|
|
|
|
glx_display_free(dpyPriv);
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-23 02:11:02 +01:00
|
|
|
dpyPriv->next = glx_displays;
|
|
|
|
glx_displays = dpyPriv;
|
|
|
|
|
|
|
|
_XUnlockMutex(_Xglobal_lock);
|
2008-10-13 13:08:45 +01:00
|
|
|
|
|
|
|
return dpyPriv;
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Setup for sending a GLX command on dpy. Make sure the extension is
|
|
|
|
** initialized. Try to avoid calling __glXInitialize as its kinda slow.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
_X_HIDDEN CARD8
|
|
|
|
__glXSetupForCommand(Display * dpy)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2010-07-28 16:16:00 +01:00
|
|
|
struct glx_context *gc;
|
|
|
|
struct glx_display *priv;
|
2008-10-13 13:08:45 +01:00
|
|
|
|
|
|
|
/* If this thread has a current context, flush its rendering commands */
|
|
|
|
gc = __glXGetCurrentContext();
|
|
|
|
if (gc->currentDpy) {
|
|
|
|
/* Flush rendering buffer of the current context, if any */
|
|
|
|
(void) __glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
|
|
|
|
if (gc->currentDpy == dpy) {
|
|
|
|
/* Use opcode from gc because its right */
|
|
|
|
return gc->majorOpcode;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
** Have to get info about argument dpy because it might be to
|
|
|
|
** a different server
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Forced to lookup extension via the slow initialize route */
|
|
|
|
priv = __glXInitialize(dpy);
|
|
|
|
if (!priv) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return priv->majorOpcode;
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
2004-12-21 23:06:02 +00:00
|
|
|
/**
|
|
|
|
* Flush the drawing command transport buffer.
|
2009-08-12 11:41:22 +01:00
|
|
|
*
|
2004-12-21 23:06:02 +00:00
|
|
|
* \param ctx Context whose transport buffer is to be flushed.
|
|
|
|
* \param pc Pointer to first unused buffer location.
|
2009-08-12 11:41:22 +01:00
|
|
|
*
|
2004-12-21 23:06:02 +00:00
|
|
|
* \todo
|
|
|
|
* Modify this function to use \c ctx->pc instead of the explicit
|
|
|
|
* \c pc parameter.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
_X_HIDDEN GLubyte *
|
2010-07-28 16:16:00 +01:00
|
|
|
__glXFlushRenderBuffer(struct glx_context * ctx, GLubyte * pc)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-13 13:08:45 +01:00
|
|
|
Display *const dpy = ctx->currentDpy;
|
|
|
|
xcb_connection_t *c = XGetXCBConnection(dpy);
|
|
|
|
const GLint size = pc - ctx->buf;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
if ((dpy != NULL) && (size > 0)) {
|
|
|
|
xcb_glx_render(c, ctx->currentContextTag, size,
|
|
|
|
(const uint8_t *) ctx->buf);
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
/* Reset pointer and return it */
|
|
|
|
ctx->pc = ctx->buf;
|
|
|
|
return ctx->pc;
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Send a portion of a GLXRenderLarge command to the server. The advantage of
|
|
|
|
* this function over \c __glXSendLargeCommand is that callers can use the
|
|
|
|
* data buffer in the GLX context and may be able to avoid allocating an
|
|
|
|
* extra buffer. The disadvantage is the clients will have to do more
|
|
|
|
* GLX protocol work (i.e., calculating \c totalRequests, etc.).
|
|
|
|
*
|
|
|
|
* \sa __glXSendLargeCommand
|
|
|
|
*
|
|
|
|
* \param gc GLX context
|
|
|
|
* \param requestNumber Which part of the whole command is this? The first
|
|
|
|
* request is 1.
|
|
|
|
* \param totalRequests How many requests will there be?
|
|
|
|
* \param data Command data.
|
|
|
|
* \param dataLen Size, in bytes, of the command data.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
_X_HIDDEN void
|
2010-07-28 16:16:00 +01:00
|
|
|
__glXSendLargeChunk(struct glx_context * gc, GLint requestNumber,
|
2008-10-13 13:08:45 +01:00
|
|
|
GLint totalRequests, const GLvoid * data, GLint dataLen)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-13 13:08:45 +01:00
|
|
|
Display *dpy = gc->currentDpy;
|
|
|
|
xcb_connection_t *c = XGetXCBConnection(dpy);
|
|
|
|
xcb_glx_render_large(c, gc->currentContextTag, requestNumber,
|
|
|
|
totalRequests, dataLen, data);
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Send a command that is too large for the GLXRender protocol request.
|
2009-08-12 11:41:22 +01:00
|
|
|
*
|
2004-10-25 22:09:16 +01:00
|
|
|
* Send a large command, one that is too large for some reason to
|
|
|
|
* send using the GLXRender protocol request. One reason to send
|
|
|
|
* a large command is to avoid copying the data.
|
2009-08-12 11:41:22 +01:00
|
|
|
*
|
2004-10-25 22:09:16 +01:00
|
|
|
* \param ctx GLX context
|
|
|
|
* \param header Header data.
|
|
|
|
* \param headerLen Size, in bytes, of the header data. It is assumed that
|
|
|
|
* the header data will always be small enough to fit in
|
|
|
|
* a single X protocol packet.
|
|
|
|
* \param data Command data.
|
|
|
|
* \param dataLen Size, in bytes, of the command data.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
_X_HIDDEN void
|
2010-07-28 16:16:00 +01:00
|
|
|
__glXSendLargeCommand(struct glx_context * ctx,
|
2008-10-13 13:08:45 +01:00
|
|
|
const GLvoid * header, GLint headerLen,
|
|
|
|
const GLvoid * data, GLint dataLen)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-13 13:08:45 +01:00
|
|
|
GLint maxSize;
|
|
|
|
GLint totalRequests, requestNumber;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
/*
|
2004-10-25 22:09:16 +01:00
|
|
|
** Calculate the maximum amount of data can be stuffed into a single
|
|
|
|
** packet. sz_xGLXRenderReq is added because bufSize is the maximum
|
|
|
|
** packet size minus sz_xGLXRenderReq.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
maxSize = (ctx->bufSize + sz_xGLXRenderReq) - sz_xGLXRenderLargeReq;
|
|
|
|
totalRequests = 1 + (dataLen / maxSize);
|
|
|
|
if (dataLen % maxSize)
|
|
|
|
totalRequests++;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
/*
|
2004-10-25 22:09:16 +01:00
|
|
|
** Send all of the command, except the large array, as one request.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
assert(headerLen <= maxSize);
|
|
|
|
__glXSendLargeChunk(ctx, 1, totalRequests, header, headerLen);
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:08:45 +01:00
|
|
|
/*
|
2004-10-25 22:09:16 +01:00
|
|
|
** Send enough requests until the whole array is sent.
|
|
|
|
*/
|
2008-10-13 13:08:45 +01:00
|
|
|
for (requestNumber = 2; requestNumber <= (totalRequests - 1);
|
|
|
|
requestNumber++) {
|
|
|
|
__glXSendLargeChunk(ctx, requestNumber, totalRequests, data, maxSize);
|
|
|
|
data = (const GLvoid *) (((const GLubyte *) data) + maxSize);
|
|
|
|
dataLen -= maxSize;
|
|
|
|
assert(dataLen > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(dataLen <= maxSize);
|
|
|
|
__glXSendLargeChunk(ctx, requestNumber, totalRequests, data, dataLen);
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2008-10-13 13:08:45 +01:00
|
|
|
_X_HIDDEN void
|
2010-07-28 16:16:00 +01:00
|
|
|
__glXDumpDrawBuffer(struct glx_context * ctx)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-13 13:08:45 +01:00
|
|
|
GLubyte *p = ctx->buf;
|
|
|
|
GLubyte *end = ctx->pc;
|
|
|
|
GLushort opcode, length;
|
|
|
|
|
|
|
|
while (p < end) {
|
|
|
|
/* Fetch opcode */
|
|
|
|
opcode = *((GLushort *) p);
|
|
|
|
length = *((GLushort *) (p + 2));
|
|
|
|
printf("%2x: %5d: ", opcode, length);
|
|
|
|
length -= 4;
|
|
|
|
p += 4;
|
|
|
|
while (length > 0) {
|
|
|
|
printf("%08x ", *((unsigned *) p));
|
|
|
|
p += 4;
|
|
|
|
length -= 4;
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
#endif
|