+if XGL

+XGL_DIR=xgl

+endif

+

+if GLUCOSE

+XGL_DIR=xgl

+GLUCOSE_DIR=glucose

+endif

+

+ $(XGL_DIR) \

+ $(GLUCOSE_DIR) \

+ xgl \

+ glucose \

+PKG_CHECK_MODULES([GLUCOSE], [glitz >= 0.5.7], [GLUCOSE=yes], [GLUCOSE=no])

+AC_SUBST(GLUCOSE_CFLAGS)

+AC_SUBST(GLUCOSE_LIBS)

+AM_CONDITIONAL(GLUCOSE, [test "x$GLUCOSE" = xyes])

+if test "x$GLUCOSE" = xyes; then

+ AC_DEFINE(GLUCOSE, 1, [Build glucose acceleration module])

+fi

+

+ PKG_CHECK_MODULES([XGLMODULES], [glitz-glx >= 0.4.3], [XGL=yes], [XGL=no])

+ AC_SUBST(XGLMODULES_CFLAGS)

+ AC_SUBST(XGLMODULES_LIBS)

+if test "x$XGL" = xyes -o "x$GLUCOSE" = xyes; then

+ XGL_LIBS="$FB_LIB $COMPOSITE_LIB $FIXES_LIB $XEXT_LIB $CONFIG_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $MIEXT_LAYER_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $XPSTUBS_LIB $CWRAP_LIB"

+ AC_SUBST([XGL_LIBS])

+fi

+

+ AC_DEFINE(XGLServer, 1, [Building XGL server])

+ PKG_CHECK_MODULES([XEGLMODULES], [glitz-egl >= 0.4.3], [XEGL=yes], [XEGL=no])

+ AC_SUBST(XEGLMODULES_CFLAGS)

+ AC_SUBST(XEGLMODULES_LIBS)

+ PKG_CHECK_MODULES([XGLXMODULES], [glitz-glx >= 0.4.3 xrender], [XGLX=yes], [XGLX=no])

+ AC_SUBST(XGLXMODULES_CFLAGS)

+ AC_SUBST(XGLXMODULES_LIBS)

+xgl/Makefile

+glucose/Makefile

+hw/xfree86/glucose/Makefile

+#include "mi.h"

+ (stride) = _pPix->devKind / (int) sizeof (FbBits); (void)(stride); \

+ (stride) = _pPix->devKind / (int) sizeof (FbStip); (void)(stride); \

+ bitsRight = (src != srcEnd ? READ(src++) : 0); \

+ bits = (src != srcEnd ? READ(src++) : 0); \

+ bits = (src != srcEnd ? READ(src++) : 0); \

+ (uint32_t *)bits, stride * (int) sizeof (FbStride));

+#if defined(__GNUC__)

+#define INLINE __inline__

+#else

+#define INLINE

+#endif

+

+ if (t == tileEnd) t = tile;

+noinst_LTLIBRARIES = libglucose.la

+

+INCLUDES = -I@MESA_SOURCE@/include \

+ -I$(top_srcdir)/GL/mesa/glapi \

+ -I$(top_srcdir)/GL/glx \

+ -I$(top_srcdir)/GL/include \

+ -I$(top_srcdir)/xgl \

+ -I$(top_srcdir)/hw/xfree86/os-support \

+ -I$(top_srcdir)/hw/xfree86/os-support/bus \

+ -I$(top_srcdir)/hw/xfree86/common

+

+# -DXFree86Server is required because the X11 driver in Mesa thinks that

+# symbol means "being built in the server"

+AM_CFLAGS = \

+ @DIX_CFLAGS@ \

+ @LIBDRM_CFLAGS@ \

+ @DRIPROTO_CFLAGS@ \

+ $(GLUCOSE_CFLAGS) \

+ @GLX_DEFINES@ \

+ -DXFree86Server

+

+libglucose_la_SOURCES = \

+ glucose.c \

+ glucose.h \

+ glucose_context.c \

+ glucose_drawable.c \

+ glucose_format.c \

+ glucose_info.c

+

+libglucose_la_LIBADD = $(GLUCOSE_LIBS)

+/*

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software

+ * and its documentation for any purpose is hereby granted without

+ * fee, provided that the above copyright notice appear in all copies

+ * and that both that copyright notice and this permission notice

+ * appear in supporting documentation, and that the name of

+ * David Reveman not be used in advertising or publicity pertaining to

+ * distribution of the software without specific, written prior permission.

+ * David Reveman makes no representations about the suitability of this

+ * software for any purpose. It is provided "as is" without express or

+ * implied warranty.

+ *

+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN

+ * NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Author: David Reveman <davidr@novell.com>

+ *

+ * This file has been modified from the GLitz GLX code for use with glucose

+ * by: Alan Hourihane <alanh@tungstengraphics.com>

+ *

+ **************************************************************************/

+

+#ifndef GLITZ_GLUCOSE_H_INCLUDED

+#define GLITZ_GLUCOSE_H_INCLUDED

+

+#include "glitzint.h"

+

+typedef glitz_function_pointer_t (* glitz_glucose_get_proc_address_t)

+ (const glitz_gl_ubyte_t *);

+typedef Bool (* glitz_glucose_make_context_current_t)

+ (__GLXcontext *baseContext);

+typedef __GLXcontext (* glitz_glucose_create_new_context_t)

+ (__GLXscreen *display, int config, int render_type,

+ __GLXcontext share_list, Bool direct);

+typedef void *(* glitz_glucose_copy_sub_buffer_t)

+ (__GLXscreen *display, __GLXdrawable *draw, int x, int y, int w, int h);

+

+typedef struct _glitz_glucose_drawable glitz_glucose_drawable_t;

+typedef struct _glitz_glucose_screen_info_t glitz_glucose_screen_info_t;

+typedef struct _glitz_glucose_display_info_t glitz_glucose_display_info_t;

+

+typedef struct _glitz_glucose_static_proc_address_list_t {

+ glitz_glucose_get_proc_address_t get_proc_address;

+ glitz_glucose_make_context_current_t make_context_current;

+ glitz_glucose_create_new_context_t create_new_context;

+ glitz_glucose_copy_sub_buffer_t copy_sub_buffer;

+} glitz_glucose_static_proc_address_list_t;

+

+typedef struct _glitz_glucose_thread_info_t {

+ glitz_glucose_display_info_t **displays;

+ int n_displays;

+ glitz_context_t *cctx;

+} glitz_glucose_thread_info_t;

+

+struct _glitz_glucose_display_info_t {

+ glitz_glucose_thread_info_t *thread_info;

+ __GLXscreen *display;

+ glitz_glucose_screen_info_t **screens;

+ int n_screens;

+};

+

+typedef struct _glitz_glucose_context_info_t {

+ glitz_glucose_drawable_t *drawable;

+ glitz_surface_t *surface;

+ glitz_constraint_t constraint;

+} glitz_glucose_context_info_t;

+

+typedef struct _glitz_glucose_context_t {

+ glitz_context_t base;

+ __GLXcontext *context;

+ glitz_format_id_t id;

+ glitz_backend_t backend;

+ glitz_bool_t initialized;

+} glitz_glucose_context_t;

+

+struct _glitz_glucose_screen_info_t {

+ __GLXscreen *screen;

+ glitz_glucose_display_info_t *display_info;

+ int drawables;

+ glitz_int_drawable_format_t *formats;

+ int n_formats;

+ glitz_glucose_context_t **contexts;

+ int n_contexts;

+ glitz_glucose_context_info_t context_stack[GLITZ_CONTEXT_STACK_SIZE];

+ int context_stack_size;

+ __GLXcontext *root_context;

+ unsigned long glx_feature_mask;

+ glitz_gl_float_t glx_version;

+ glitz_glucose_static_proc_address_list_t glx;

+ glitz_program_map_t program_map;

+};

+

+struct _glitz_glucose_drawable {

+ glitz_drawable_t base;

+

+ glitz_glucose_screen_info_t *screen_info;

+ glitz_glucose_context_t *context;

+ __GLXdrawable *drawable;

+ int width;

+ int height;

+};

+

+extern void

+glitz_glucose_query_extensions (glitz_glucose_screen_info_t *screen_info,

+ glitz_gl_float_t glx_version);

+

+extern glitz_glucose_screen_info_t *

+glitz_glucose_screen_info_get (__GLXscreen *display);

+

+extern glitz_function_pointer_t

+glitz_glucose_get_proc_address (const char *name,

+ void *closure);

+

+extern glitz_glucose_context_t *

+glitz_glucose_context_get (glitz_glucose_screen_info_t *screen_info,

+ glitz_drawable_format_t *format);

+

+extern void

+glitz_glucose_context_destroy (glitz_glucose_screen_info_t *screen_info,

+ glitz_glucose_context_t *context);

+

+extern void

+glitz_glucose_query_formats (glitz_glucose_screen_info_t *screen_info);

+

+extern glitz_bool_t

+_glitz_glucose_drawable_update_size (glitz_glucose_drawable_t *drawable,

+ int width,

+ int height);

+

+extern glitz_bool_t

+glitz_glucose_push_current (void *abstract_drawable,

+ glitz_surface_t *surface,

+ glitz_constraint_t constraint,

+ glitz_bool_t *restore_state);

+

+extern glitz_surface_t *

+glitz_glucose_pop_current (void *abstract_drawable);

+

+void

+glitz_glucose_make_current (void *abstract_drawable,

+ glitz_constraint_t constraint);

+

+extern glitz_status_t

+glitz_glucose_make_current_read (void *abstract_surface);

+

+extern void

+glitz_glucose_destroy (void *abstract_drawable);

+

+extern glitz_bool_t

+glitz_glucose_swap_buffers (void *abstract_drawable);

+

+extern glitz_bool_t

+glitz_glucose_copy_sub_buffer (void *abstract_drawable,

+ int x,

+ int y,

+ int width,

+ int height);

+

+glitz_drawable_format_t *

+glitz_glucose_find_window_format (__GLXscreen *screen,

+ unsigned long mask,

+ const glitz_drawable_format_t *templ,

+ int count);

+

+glitz_drawable_t *

+glitz_glucose_create_drawable_for_window (__GLXscreen *screen,

+ glitz_drawable_format_t *format,

+ __GLXdrawable *window,

+ unsigned int width,

+ unsigned int height);

+

+#endif /* GLITZ_GLUCOSE_H_INCLUDED */

+/*

+ * Copyright 2006 Zack Rusin

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software

+ * and its documentation for any purpose is hereby granted without

+ * fee, provided that the above copyright notice appear in all copies

+ * and that both that copyright notice and this permission notice

+ * appear in supporting documentation, and that the name of

+ * David Reveman not be used in advertising or publicity pertaining to

+ * distribution of the software without specific, written prior permission.

+ * David Reveman makes no representations about the suitability of this

+ * software for any purpose. It is provided "as is" without express or

+ * implied warranty.

+ *

+ * ZACK RUSIN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL ZACK RUSIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

+ * PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Authors: Alan Hourihane <alanh@tungstengraphics.com>

+ *

+ * Re-written from original code by Zack Rusin

+ *

+ **************************************************************************/

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include "glxserver.h"

+#include "glucose.h"

+#include "glitz_glucose.h"

+

+#include "xgl.h"

+

+#include "xf86str.h"

+#include "xf86.h"

+

+#ifdef MITSHM

+#include "shmint.h"

+static ShmFuncs shmFuncs = { NULL, xglShmPutImage };

+#endif

+

+int xglScreenGeneration;

+int xglScreenPrivateIndex;

+int xglGCPrivateIndex;

+int xglPixmapPrivateIndex;

+int xglWinPrivateIndex;

+#ifdef RENDER

+int xglGlyphPrivateIndex;

+#endif

+

+static int glucoseGeneration = -1;

+int glucoseScreenPrivateIndex;

+int glucoseCreateWindowIndex;

+

+xglScreenInfoRec xglScreenInfo = {

+ NULL, 0, 0, 0, 0, 0,

+ DEFAULT_GEOMETRY_DATA_TYPE,

+ DEFAULT_GEOMETRY_USAGE,

+ FALSE,

+ XGL_DEFAULT_PBO_MASK,

+ FALSE,

+ FALSE,

+ FilterBilinear,

+ {

+ { FALSE, FALSE, { 0, 0, 0, 0 } },

+ { FALSE, FALSE, { 0, 0, 0, 0 } },

+ { FALSE, FALSE, { 0, 0, 0, 0 } },

+ { FALSE, FALSE, { 0, 0, 0, 0 } }

+ }

+};

+

+static glitz_drawable_format_t *

+glucoseInitOutput(__GLXscreen *screen);

+

+/* Wrapped for glxext close down */

+static void glucoseDestroyGLXscreen(__GLXscreen *screen)

+{

+ ErrorF("SHUTDOWN EXTENSION\n");

+}

+

+static Bool

+glucoseCreateWindow(WindowPtr pWin)

+{

+ int ret = TRUE;

+ ScreenPtr pScreen = pWin->drawable.pScreen;

+ CreateWindowProcPtr CreateWindow =

+ (CreateWindowProcPtr)(pScreen->devPrivates[glucoseCreateWindowIndex].ptr);

+ GLucoseScreenPrivPtr pScreenPriv = GLucoseGetScreenPriv(pScreen);

+ int err;

+

+ xf86DrvMsg(pScreen->myNum, X_INFO,

+ "GLucose initializing screen %d\n",pScreen->myNum);

+

+ if ( pScreen->CreateWindow != glucoseCreateWindow ) {

+ /* Can't find hook we are hung on */

+ xf86DrvMsg(pScreen->myNum, X_WARNING /* X_ERROR */,

+ "glucoseCreateWindow %p called when not in pScreen->CreateWindow %p n",

+ (void *)glucoseCreateWindow,

+ (void *)pScreen->CreateWindow );

+ }

+

+ /* Unhook this function ... */

+ pScreen->CreateWindow = CreateWindow;

+ pScreen->devPrivates[glucoseCreateWindowIndex].ptr = NULL;

+

+ /* ... and call the previous CreateWindow fuction, if any */

+ if (NULL!=pScreen->CreateWindow) {

+ ret = (*pScreen->CreateWindow)(pWin);

+ }

+

+ xglScreenInfo.width = pScreen->width;

+ xglScreenInfo.height = pScreen->height;

+ xglScreenInfo.widthMm = pScreen->mmWidth;

+ xglScreenInfo.heightMm = pScreen->mmHeight;

+

+ pScreenPriv->screen = glxGetScreen(pScreen);

+

+ /* This stops the driver being unload and prevents a crash.

+ * But should be solved properly.

+ */

+ pScreenPriv->destroyGLXscreen = pScreenPriv->screen->destroy;

+ pScreenPriv->screen->destroy = glucoseDestroyGLXscreen;

+

+ {

+ glitz_drawable_t *drawable;

+ glitz_drawable_format_t *format;

+ __GLcontextModes *fbconfigs = pScreenPriv->screen->fbconfigs;

+ PixmapPtr pPixmap = pScreen->GetScreenPixmap(pScreen);

+ xglScreenPtr xglScreenPriv = XGL_GET_SCREEN_PRIV (pScreen);

+

+ /* track root pixmap */

+ if (pPixmap)

+ {

+ pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;

+ pPixmap->drawable.id = FakeClientID(0);

+ AddResource(pPixmap->drawable.id, RT_PIXMAP, (pointer)pPixmap);

+ }

+

+ xglLeaveServer();

+

+ pScreenPriv->rootDrawable = pScreenPriv->screen->createDrawable(pScreenPriv->screen, (DrawablePtr)pPixmap, GLX_DRAWABLE_PIXMAP, pPixmap->drawable.id, fbconfigs);

+

+ if (!pScreenPriv->rootDrawable) {

+ xglEnterServer();

+ xf86DrvMsg(pScreen->myNum, X_WARNING,

+ "GLucose - creating root drawable failed\n");

+ return FALSE;

+ }

+

+ pScreenPriv->rootContext = pScreenPriv->screen->createContext(pScreenPriv->screen, fbconfigs, NULL);

+

+ if (!pScreenPriv->rootContext) {

+ xglEnterServer();

+ xf86DrvMsg(pScreen->myNum, X_WARNING,

+ "GLucose - creating root context failed\n");

+ pScreenPriv->rootDrawable->destroy(pScreenPriv->rootDrawable);

+ pScreenPriv->rootDrawable = NULL;

+ return FALSE;

+ }

+

+ pScreenPriv->rootContext->drawPriv =

+ pScreenPriv->rootContext->readPriv = pScreenPriv->rootDrawable;

+

+ err = pScreenPriv->rootContext->makeCurrent(pScreenPriv->rootContext);

+ if (!err) {

+ xglEnterServer();

+ xf86DrvMsg(pScreen->myNum, X_WARNING,

+ "GLucose makeCurrent failed, err is %d\n",err);

+ pScreenPriv->rootContext->destroy(pScreenPriv->rootContext);

+ pScreenPriv->rootContext = NULL;

+ pScreenPriv->rootDrawable->destroy(pScreenPriv->rootDrawable);

+ pScreenPriv->rootDrawable = NULL;

+ return FALSE;

+ }

+

+ format = glucoseInitOutput(pScreenPriv->screen);

+

+ drawable = glitz_glucose_create_drawable_for_window(pScreenPriv->screen,

+ format, pScreenPriv->rootDrawable,

+ pScreen->width,

+ pScreen->height);

+

+ if (!drawable) {

+ xglEnterServer();

+ xf86DrvMsg(pScreen->myNum, X_ERROR,

+ "GLucose could not create glitz drawable, not initializing.\n");

+

+ pScreenPriv->rootContext->destroy(pScreenPriv->rootContext);

+ pScreenPriv->rootContext = NULL;

+ pScreenPriv->rootDrawable->destroy(pScreenPriv->rootDrawable);

+ pScreenPriv->rootDrawable = NULL;

+ return FALSE;

+ }

+

+ xglScreenInfo.drawable = xglScreenPriv->drawable = drawable;

+ xglScreenPriv->features =

+ glitz_drawable_get_features (xglScreenInfo.drawable);

+

+ xf86DrvMsg(pScreen->myNum, X_INFO,

+ "GLucose reports GLitz features as 0x%lx\n",xglScreenPriv->features);

+

+ if (!glucoseFinishScreenInit(pScreen)) {

+ xglEnterServer();

+ xf86DrvMsg(pScreen->myNum, X_ERROR,

+ "GLucose could not initialize.\n");

+ pScreenPriv->rootContext->destroy(pScreenPriv->rootContext);

+ pScreenPriv->rootContext = NULL;

+ pScreenPriv->rootDrawable->destroy(pScreenPriv->rootDrawable);

+ pScreenPriv->rootDrawable = NULL;

+ return FALSE;

+ }

+

+ xglEnterServer();

+

+ /* now fixup root pixmap */

+ pPixmap = pScreen->GetScreenPixmap(pScreen);

+ xglPixmapPtr pPixmapPriv = XGL_GET_PIXMAP_PRIV (pPixmap);

+

+ xglPixmapSurfaceInit(pPixmap, xglScreenPriv->features, 0, 0);

+

+ REGION_UNINIT (pPixmap->drawable.pScreen, &pPixmapPriv->bitRegion);

+

+ xglPixmapSurfaceInit(pPixmap, xglScreenPriv->features, pScreen->width, pScreen->height);

+

+ if (pScreen->devPrivate && pPixmapPriv->pDamage) {

+ RegionPtr pRegion = DamageRegion (pPixmapPriv->pDamage);

+

+ REGION_UNINIT (pPixmap->drawable.pScreen, pRegion);

+ REGION_INIT (pPixmap->drawable.pScreen, pRegion, NullBox, 0);

+ REGION_SUBTRACT (pPixmap->drawable.pScreen, pRegion,

+ &pPixmapPriv->bitRegion, pRegion);

+

+ }

+

+ pPixmapPriv->pVisual = xglScreenPriv->rootVisual;

+

+ pPixmapPriv->target = xglPixmapTargetIn;

+

+ xglScreenPriv->pScreenPixmap = pPixmap;

+

+ glitz_drawable_reference (xglScreenPriv->drawable);

+ pPixmapPriv->drawable = xglScreenPriv->drawable;

+

+ glitz_surface_reference (xglScreenPriv->surface);

+ pPixmapPriv->surface = xglScreenPriv->surface;

+ }

+

+ return (ret);

+}

+

+static Bool

+glucoseAllocatePrivates(ScreenPtr pScreen)

+{

+ GLucoseScreenPrivPtr pScreenPriv;

+

+ if (glucoseGeneration != serverGeneration) {

+ glucoseScreenPrivateIndex = AllocateScreenPrivateIndex();

+ if (glucoseScreenPrivateIndex < 0)

+ return FALSE;

+ glucoseCreateWindowIndex = AllocateScreenPrivateIndex();

+ if (glucoseCreateWindowIndex < 0)

+ return FALSE;

+

+ glucoseGeneration = serverGeneration;

+ }

+

+ pScreenPriv = xalloc(sizeof(GLucoseScreenPrivRec));

+ if (!pScreenPriv) {

+ LogMessage(X_WARNING, "GLucose(%d): Failed to allocate screen private\n",

+ pScreen->myNum);

+ return FALSE;

+ }

+

+ pScreen->devPrivates[glucoseScreenPrivateIndex].ptr = (pointer) pScreenPriv;

+

+ pScreen->devPrivates[glucoseCreateWindowIndex].ptr

+ = (void*)(pScreen->CreateWindow);

+ pScreen->CreateWindow = glucoseCreateWindow;

+

+ return TRUE;

+}

+

+static glitz_drawable_format_t *

+glucoseInitOutput(__GLXscreen *screen)

+{

+ glitz_drawable_format_t *format, templ;

+ int i;

+ unsigned long mask;

+ unsigned long extraMask[] = {

+ GLITZ_FORMAT_DOUBLEBUFFER_MASK | GLITZ_FORMAT_ALPHA_SIZE_MASK,

+ GLITZ_FORMAT_DOUBLEBUFFER_MASK,

+ GLITZ_FORMAT_ALPHA_SIZE_MASK,

+ 0

+ };

+

+ templ.samples = 1;

+ templ.doublebuffer = 1;

+ templ.color.fourcc = GLITZ_FOURCC_RGB;

+ templ.color.alpha_size = 8;

+

+ mask = GLITZ_FORMAT_SAMPLES_MASK | GLITZ_FORMAT_FOURCC_MASK;

+

+ for (i = 0; i < sizeof(extraMask) / sizeof(extraMask[0]); i++)

+ {

+ format = glitz_glucose_find_window_format(screen,

+ mask | extraMask[i],

+ &templ, 0);

+ if (format)

+ break;

+ }

+

+ if (!format)

+ FatalError("no visual format found");

+

+ xglScreenInfo.depth =

+ format->color.red_size +

+ format->color.green_size +

+ format->color.blue_size;

+

+ return format;

+}

+

+/* Here to mimick the xgl counterpart */

+static Bool

+xglAllocatePrivates (ScreenPtr pScreen)

+{

+ xglScreenPtr pScreenPriv;

+

+ if (xglScreenGeneration != serverGeneration)

+ {

+ xglScreenPrivateIndex = AllocateScreenPrivateIndex ();

+ if (xglScreenPrivateIndex < 0)

+ return FALSE;

+

+ xglGCPrivateIndex = AllocateGCPrivateIndex ();

+ if (xglGCPrivateIndex < 0)

+ return FALSE;

+

+ xglPixmapPrivateIndex = AllocatePixmapPrivateIndex ();

+ if (xglPixmapPrivateIndex < 0)

+ return FALSE;

+

+ xglWinPrivateIndex = AllocateWindowPrivateIndex ();

+ if (xglWinPrivateIndex < 0)

+ return FALSE;

+

+#ifdef RENDER

+ xglGlyphPrivateIndex = AllocateGlyphPrivateIndex ();

+ if (xglGlyphPrivateIndex < 0)

+ return FALSE;

+#endif

+

+ xglScreenGeneration = serverGeneration;

+ }

+

+ if (!AllocateGCPrivate (pScreen, xglGCPrivateIndex, sizeof (xglGCRec)))

+ return FALSE;

+

+ if (!AllocatePixmapPrivate (pScreen, xglPixmapPrivateIndex,

+ sizeof (xglPixmapRec)))

+ return FALSE;

+

+ if (!AllocateWindowPrivate (pScreen, xglWinPrivateIndex,

+ sizeof (xglWinRec)))

+ return FALSE;

+

+ pScreenPriv = xalloc (sizeof (xglScreenRec));

+ if (!pScreenPriv)

+ return FALSE;

+ memset(pScreenPriv, 0, sizeof(xglScreenRec));

+

+ XGL_SET_SCREEN_PRIV (pScreen, pScreenPriv);

+

+ return TRUE;

+}

+

+static Bool

+glucoseDestroyPixmap (PixmapPtr pPixmap)

+{

+ ScreenPtr pScreen = pPixmap->drawable.pScreen;

+ PixmapPtr pScreenPixmap = pScreen->GetScreenPixmap(pScreen);

+

+ if (pPixmap == pScreenPixmap) {

+ ErrorF("SHUTTING DOWN\n");

+ /* we're shutting down, we'll clean this up later */

+ return TRUE;

+ }

+

+ return xglDestroyPixmap(pPixmap);

+}

+

+Bool

+glucoseScreenInit (ScreenPtr pScreen, int flags)

+{

+ xglScreenPtr pScreenPriv;

+

+#ifdef RENDER

+ PictureScreenPtr pPictureScreen;

+#endif

+

+ if (!glucoseAllocatePrivates(pScreen))

+ return FALSE;

+

+ if (!xglAllocatePrivates (pScreen))

+ return FALSE;

+

+ pScreenPriv = XGL_GET_SCREEN_PRIV (pScreen);

+

+ pScreenPriv->pScreenPixmap = NULL;

+

+ pScreenPriv->pVisual = 0;

+

+ pScreenPriv->rootVisual = 0;

+

+ GEOMETRY_INIT (pScreen, &pScreenPriv->scratchGeometry,

+ GLITZ_GEOMETRY_TYPE_VERTEX,

+ pScreenPriv->geometryUsage, 0);

+

+ pScreenPriv->geometryDataType = xglScreenInfo.geometryDataType;

+ pScreenPriv->geometryUsage = xglScreenInfo.geometryUsage;

+ pScreenPriv->yInverted = xglScreenInfo.yInverted;

+ pScreenPriv->pboMask = xglScreenInfo.pboMask;

+ pScreenPriv->lines = xglScreenInfo.lines;

+ pScreenPriv->noYuv = xglScreenInfo.noYuv;

+ pScreenPriv->xvFilter = xglScreenInfo.xvFilter;

+ pScreenPriv->accel = xglScreenInfo.accel;

+

+#if 0

+ /* add some flags to change the default xgl methods above */

+ if (flags & GLUCOSE_xxx) {

+

+ }

+#endif

+

+

+ pScreen->CreatePixmap = xglCreatePixmap;

+ pScreen->DestroyPixmap = glucoseDestroyPixmap;

+

+#ifdef MITSHM

+ ShmRegisterFuncs (pScreen, &shmFuncs);

+#endif

+

+ XGL_SCREEN_WRAP (GetImage, xglGetImage);

+ XGL_SCREEN_WRAP (GetSpans, xglGetSpans);

+

+ XGL_SCREEN_WRAP (CopyWindow, xglCopyWindow);

+ XGL_SCREEN_WRAP (CreateWindow, xglCreateWindow);

+ XGL_SCREEN_WRAP (DestroyWindow, xglDestroyWindow);

+ XGL_SCREEN_WRAP (ChangeWindowAttributes, xglChangeWindowAttributes);

+

+ XGL_SCREEN_WRAP (CreateGC, xglCreateGC);

+

+#if 0

+#define xglQueryBestSize (void *) NoopDDA

+#define xglSaveScreen (void *) NoopDDA

+

+#define xglConstrainCursor (void *) NoopDDA

+#define xglCursorLimits (void *) NoopDDA

+#define xglDisplayCursor (void *) NoopDDA

+#define xglRealizeCursor (void *) NoopDDA

+#define xglUnrealizeCursor (void *) NoopDDA

+#define xglRecolorCursor (void *) NoopDDA

+#define xglSetCursorPosition (void *) NoopDDA

+

+ /* Might be nice to provide a textured hw cursor at some point */

+ pScreen->ConstrainCursor = xglConstrainCursor;

+ pScreen->CursorLimits = xglCursorLimits;

+ pScreen->DisplayCursor = xglDisplayCursor;

+ pScreen->RealizeCursor = xglRealizeCursor;

+ pScreen->UnrealizeCursor = xglUnrealizeCursor;

+ pScreen->RecolorCursor = xglRecolorCursor;

+ pScreen->SetCursorPosition = xglSetCursorPosition;

+#endif

+

+ pScreen->ModifyPixmapHeader = xglModifyPixmapHeader;

+

+ XGL_SCREEN_WRAP (BitmapToRegion, xglPixmapToRegion);

+

+ pScreen->GetWindowPixmap = xglGetWindowPixmap;

+

+ XGL_SCREEN_WRAP (SetWindowPixmap, xglSetWindowPixmap);

+

+#ifdef RENDER

+ pPictureScreen = GetPictureScreenIfSet (pScreen);

+ if (pPictureScreen)

+ {

+ if (!AllocateGlyphPrivate (pScreen, xglGlyphPrivateIndex,

+ sizeof (xglGlyphRec)))

+ return FALSE;

+

+ XGL_PICTURE_SCREEN_WRAP (Composite, xglComposite);

+ XGL_PICTURE_SCREEN_WRAP (RealizeGlyph, xglRealizeGlyph);

+ XGL_PICTURE_SCREEN_WRAP (UnrealizeGlyph, xglUnrealizeGlyph);

+ XGL_PICTURE_SCREEN_WRAP (Glyphs, xglGlyphs);

+ XGL_PICTURE_SCREEN_WRAP (Trapezoids, xglTrapezoids);

+ XGL_PICTURE_SCREEN_WRAP (AddTraps, xglAddTraps);

+ XGL_PICTURE_SCREEN_WRAP (AddTriangles, xglAddTriangles);

+ XGL_PICTURE_SCREEN_WRAP (ChangePicture, xglChangePicture);

+ XGL_PICTURE_SCREEN_WRAP (ChangePictureTransform,

+ xglChangePictureTransform);

+ XGL_PICTURE_SCREEN_WRAP (ChangePictureFilter, xglChangePictureFilter);

+ }

+#endif

+

+#if 0

+#ifdef COMPOSITE

+#warning "composite building"

+ if (!compScreenInit (pScreen))

+ return FALSE;

+#endif

+#endif

+

+ /* Damage is required */

+ DamageSetup (pScreen);

+

+ XGL_SCREEN_WRAP (CloseScreen, glucoseCloseScreen);

+

+ return TRUE;

+}

+

+static Bool

+glucoseInitVisual (ScreenPtr pScreen,

+ xglVisualPtr pVisual,

+ xglPixelFormatPtr pPixel,

+ VisualID vid)

+{

+ glitz_format_t *format;

+

+ XGL_SCREEN_PRIV (pScreen);

+

+ format = xglFindBestSurfaceFormat (pScreen, pPixel);

+ if (format)

+ {

+ glitz_drawable_format_t templ;

+ unsigned long mask;

+

+ templ.color = format->color;

+ templ.depth_size = 0;

+ templ.stencil_size = 0;

+ templ.doublebuffer = 0;

+ templ.samples = 1;

+

+ mask =

+ GLITZ_FORMAT_FOURCC_MASK |

+ GLITZ_FORMAT_RED_SIZE_MASK |

+ GLITZ_FORMAT_GREEN_SIZE_MASK |

+ GLITZ_FORMAT_BLUE_SIZE_MASK |

+ GLITZ_FORMAT_ALPHA_SIZE_MASK |

+ GLITZ_FORMAT_DEPTH_SIZE_MASK |

+ GLITZ_FORMAT_STENCIL_SIZE_MASK |

+ GLITZ_FORMAT_DOUBLEBUFFER_MASK |

+ GLITZ_FORMAT_SAMPLES_MASK;

+

+ pVisual->next = 0;

+ pVisual->vid = vid;

+ pVisual->pPixel = pPixel;

+ pVisual->pbuffer = FALSE;

+

+ pVisual->format.surface = format;

+ pVisual->format.drawable =

+ glitz_find_drawable_format (pScreenPriv->drawable,

+ mask, &templ, 0);

+

+ return TRUE;

+ }

+

+ return FALSE;

+}

+

+static void

+glucoseInitVisuals (ScreenPtr pScreen)

+{

+ xglVisualPtr v, new, *prev;

+ xglPixelFormatPtr pPixel = NULL;

+ int i,j;

+

+ XGL_SCREEN_PRIV (pScreen);

+

+ for (j = 0; j < pScreen->numVisuals; j++)

+ {

+ pPixel = NULL;

+ for (i = 0; i < xglNumPixelFormats(); i++)

+ {

+ if (pScreen->visuals[j].nplanes == xglPixelFormats[i].depth &&

+ BitsPerPixel(pScreen->visuals[j].nplanes) == xglPixelFormats[i].masks.bpp)

+ pPixel = &xglPixelFormats[i];

+ }

+ if (pPixel) {

+ new = xalloc (sizeof (xglVisualRec));

+ if (new)

+ {

+ if (glucoseInitVisual (pScreen, new, pPixel,

+ pScreen->visuals[j].vid))

+ {

+ new->next = 0;

+

+ prev = &pScreenPriv->pVisual;

+ while ((v = *prev)) {

+ prev = &v->next;

+ }

+

+ *prev = new;

+ }

+ else

+ {

+ xfree (new);

+ }

+ }

+ }

+ }

+}

+

+Bool

+glucoseFinishScreenInit (ScreenPtr pScreen)

+{

+ xglVisualPtr v;

+

+#ifdef RENDER

+ glitz_vertex_format_t *format;

+ static glitz_color_t clearBlack = { 0x0, 0x0, 0x0, 0x0 };

+ static glitz_color_t solidWhite = { 0xffff, 0xffff, 0xffff, 0xffff };

+ int i;

+#endif

+

+ XGL_SCREEN_PRIV (pScreen);

+

+ glucoseInitVisuals (pScreen);

+

+ for (v = pScreenPriv->pVisual; v; v = v->next)

+ {

+ if (v->vid == pScreen->rootVisual)

+ pScreenPriv->rootVisual = v;

+ }

+

+ if (!pScreenPriv->rootVisual || !pScreenPriv->rootVisual->format.surface)

+ return FALSE;

+

+ pScreenPriv->surface =

+ glitz_surface_create (pScreenPriv->drawable,

+ pScreenPriv->rootVisual->format.surface,

+ pScreen->width, pScreen->height,

+ 0, NULL);

+ if (!pScreenPriv->surface)

+ return FALSE;

+

+ glitz_surface_attach (pScreenPriv->surface,

+ pScreenPriv->drawable,

+ GLITZ_DRAWABLE_BUFFER_FRONT_COLOR);

+

+#ifdef RENDER

+ for (i = 0; i < 33; i++)

+ pScreenPriv->glyphCache[i].pScreen = NULL;

+

+ for (v = pScreenPriv->pVisual; v; v = v->next)

+ {

+ if (v->pPixel->depth == 8)

+ break;

+ }

+

+ pScreenPriv->pSolidAlpha = 0;

+ pScreenPriv->trapInfo.pMask = 0;

+

+ /* An accelerated alpha only Xgl visual is required for trapezoid

+ acceleration */

+ if (v && v->format.surface)

+ {

+ glitz_surface_t *mask;

+

+ mask = glitz_surface_create (pScreenPriv->drawable,

+ v->format.surface,

+ 2, 1, 0, NULL);

+ if (mask)

+ {

+ glitz_set_rectangle (mask, &clearBlack, 0, 0, 1, 1);

+ glitz_set_rectangle (mask, &solidWhite, 1, 0, 1, 1);

+

+ glitz_surface_set_fill (mask, GLITZ_FILL_NEAREST);

+ glitz_surface_set_filter (mask, GLITZ_FILTER_BILINEAR, NULL, 0);

+

+ pScreenPriv->trapInfo.pMask = xglCreateDevicePicture (mask);

+ if (!pScreenPriv->trapInfo.pMask)

+ return FALSE;

+ }

+ }

+

+ format = &pScreenPriv->trapInfo.format.vertex;

+ format->primitive = GLITZ_PRIMITIVE_QUADS;

+ format->attributes = GLITZ_VERTEX_ATTRIBUTE_MASK_COORD_MASK;

+

+ format->mask.type = GLITZ_DATA_TYPE_FLOAT;

+ format->mask.size = GLITZ_COORDINATE_SIZE_X;

+ format->bytes_per_vertex = sizeof (glitz_float_t);

+

+ if (pScreenPriv->geometryDataType)

+ {

+ format->type = GLITZ_DATA_TYPE_FLOAT;

+ format->bytes_per_vertex += 2 * sizeof (glitz_float_t);

+ format->mask.offset = 2 * sizeof (glitz_float_t);

+ }

+ else

+ {

+ format->type = GLITZ_DATA_TYPE_SHORT;

+ format->bytes_per_vertex += 2 * sizeof (glitz_short_t);

+ format->mask.offset = 2 * sizeof (glitz_short_t);

+ }

+#endif

+

+#if 0 /* Let the driver do this ! */

+ if (!xglXvScreenInit (pScreen))

+ return FALSE;

+#endif

+

+ return TRUE;

+}

+

+Bool

+glucoseCloseScreen (int index,

+ ScreenPtr pScreen)

+{

+ xglVisualPtr v;

+

+ XGL_SCREEN_PRIV (pScreen);

+ XGL_PIXMAP_PRIV (pScreenPriv->pScreenPixmap);

+ XGL_SCREEN_UNWRAP (CloseScreen);

+ GLucoseScreenPrivPtr pPriv = GLucoseGetScreenPriv(pScreen);

+

+ __pGlxClient = serverClient;

+

+ xglFiniPixmap (pScreenPriv->pScreenPixmap);

+

+ xglLeaveServer();

+

+#ifdef RENDER

+ int i;

+

+ for (i = 0; i < 33; i++)

+ xglFiniGlyphCache (&pScreenPriv->glyphCache[i]);

+

+ if (pScreenPriv->pSolidAlpha)

+ FreePicture ((pointer) pScreenPriv->pSolidAlpha, 0);

+

+ if (pScreenPriv->trapInfo.pMask)

+ FreePicture ((pointer) pScreenPriv->trapInfo.pMask, 0);

+#endif

+

+ if (pScreenPriv->surface)

+ glitz_surface_destroy (pScreenPriv->surface);

+ pPixmapPriv->surface = NULL;

+ pScreenPriv->surface = NULL;

+

+ GEOMETRY_UNINIT (&pScreenPriv->scratchGeometry);

+

+ if (pScreenPriv->drawable)

+ glitz_drawable_destroy(pScreenPriv->drawable);

+ pPixmapPriv->drawable = NULL;

+ pScreenPriv->drawable = NULL;

+ xglScreenInfo.drawable = NULL;

+

+ /* tear down glucose now */

+#if 0

+ /* Unfortunately, this causes some problems in hardware drivers */

+ /* Debug, them and re-enable this */

+ pPriv->rootContext->destroy(pPriv->rootContext);

+#endif

+ pPriv->rootDrawable->destroy(pPriv->rootDrawable);

+

+ xfree(pPriv);

+ pPriv = NULL;

+

+ while (pScreenPriv->pVisual)

+ {

+ v = pScreenPriv->pVisual;

+ pScreenPriv->pVisual = v->next;

+ xfree (v);

+ }

+ xfree(pScreenPriv);

+ pScreenPriv = NULL;

+

+ return (*pScreen->CloseScreen) (index, pScreen);

+}

+

+static ClientPtr pOldGlxClient = NULL;

+

+void xglLeaveServer(void) {

+ assert(pOldGlxClient == NULL);

+ __glXleaveServer(TRUE);

+ pOldGlxClient = __pGlxClient;

+ __pGlxClient = serverClient;

+}

+

+void xglEnterServer(void) {

+ assert(__pGlxClient == serverClient);

+ __pGlxClient = pOldGlxClient;

+ pOldGlxClient = NULL;

+ __glXenterServer(TRUE);

+}

+/*

+ * Copyright 2006 Zack Rusin

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software

+ * and its documentation for any purpose is hereby granted without

+ * fee, provided that the above copyright notice appear in all copies

+ * and that both that copyright notice and this permission notice

+ * appear in supporting documentation, and that the name of

+ * David Reveman not be used in advertising or publicity pertaining to

+ * distribution of the software without specific, written prior permission.

+ * David Reveman makes no representations about the suitability of this

+ * software for any purpose. It is provided "as is" without express or

+ * implied warranty.

+ *

+ * ZACK RUSIN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL ZACK RUSIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

+ * PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Authors: Alan Hourihane <alanh@tungstengraphics.com>

+ *

+ * Re-written from original code by Zack Rusin

+ *

+ **************************************************************************/

+

+#ifndef GLUCOSE_H

+#define GLUCOSE_H

+

+Bool

+glucoseCloseScreen (int index,

+ ScreenPtr pScreen);

+

+Bool

+glucoseFinishScreenInit (ScreenPtr pScreen);

+

+Bool

+glucoseScreenInit (ScreenPtr pScreen, int flags);

+

+typedef void (*destroyGLXscreenProcPtr)(__GLXscreen *screen);

+

+typedef struct {

+ __GLXdrawable *rootDrawable;

+ __GLXcontext *rootContext;

+ CloseScreenProcPtr CloseScreen;

+ DestroyPixmapProcPtr *DestroyPixmap;

+ __GLXscreen *screen;

+ destroyGLXscreenProcPtr destroyGLXscreen;

+} GLucoseScreenPrivRec, *GLucoseScreenPrivPtr;

+

+extern int glucoseScreenPrivateIndex;

+#define GLucoseGetScreenPriv(s) ((GLucoseScreenPrivPtr)(s)->devPrivates[glucoseScreenPrivateIndex].ptr)

+#define GLucoseScreenPriv(s) GLucoseScreenPrivPtr pGLucoseScr = GLucoseGetScreenPriv(s)

+

+#endif /* GLUCOSE_H */

+/*

+ * Copyright © 2004 David Reveman

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software

+ * and its documentation for any purpose is hereby granted without

+ * fee, provided that the above copyright notice appear in all copies

+ * and that both that copyright notice and this permission notice

+ * appear in supporting documentation, and that the name of

+ * David Reveman not be used in advertising or publicity pertaining to

+ * distribution of the software without specific, written prior permission.

+ * David Reveman makes no representations about the suitability of this

+ * software for any purpose. It is provided "as is" without express or

+ * implied warranty.

+ *

+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN

+ * NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Author: David Reveman <davidr@novell.com>

+ *

+ * This file has been modified from the GLitz GLX code for use with glucose

+ * by: Alan Hourihane <alanh@tungstengraphics.com>

+ *

+ **************************************************************************/

+

+#ifdef HAVE_CONFIG_H

+# include "dix-config.h"

+#endif

+

+#include "glxserver.h"

+#include "glxutil.h"

+#include "glcontextmodes.h"

+#include "glitz.h"

+#include "glitz_glucose.h"

+#include "glthread.h"

+#include "dispatch.h"

+#include "glapi.h"

+#include <stdlib.h>

+

+extern __GLXcontext *__glXLastContext;

+extern glitz_gl_proc_address_list_t _glitz_glucose_gl_proc_address;

+

+static void

+_glitz_glucose_context_create (glitz_glucose_screen_info_t *screen_info,

+ int visualid,

+ __GLXcontext *share_list,

+ glitz_glucose_context_t *context)

+{

+ __GLXscreen *screen = screen_info->display_info->display;

+ __GLcontextModes *mode;

+

+ mode = _gl_context_modes_find_visual(screen->fbconfigs, visualid);

+

+ context->context = screen->createContext (screen, mode, share_list);

+ context->id = visualid;

+}

+

+static glitz_context_t *

+_glitz_glucose_create_context (void *abstract_drawable,

+ glitz_drawable_format_t *format)

+{

+ glitz_glucose_drawable_t *drawable = (glitz_glucose_drawable_t *)

+ abstract_drawable;

+ glitz_glucose_screen_info_t *screen_info = drawable->screen_info;

+ unsigned long format_id =

+ screen_info->formats[format->id].u.uval;

+ glitz_glucose_context_t *context;

+

+ context = malloc (sizeof (glitz_glucose_context_t));

+ if (!context)

+ return NULL;

+

+ _glitz_context_init (&context->base, &drawable->base);

+

+ _glitz_glucose_context_create (screen_info,

+ format_id,

+ screen_info->root_context,

+ context);

+

+ return (glitz_context_t *) context;

+}

+

+static void

+_glitz_glucose_context_destroy (void *abstract_context)

+{

+ glitz_glucose_context_t *context = (glitz_glucose_context_t *) abstract_context;

+ glitz_glucose_drawable_t *drawable = (glitz_glucose_drawable_t *)

+ context->base.drawable;

+

+ if (drawable->screen_info->display_info->thread_info->cctx ==

+ &context->base)

+ {

+ __glXDeassociateContext(context->context);

+ __glXLastContext = NULL;

+

+ drawable->screen_info->display_info->thread_info->cctx = NULL;

+ }

+

+ context->context->destroy(context->context);

+

+ _glitz_context_fini (&context->base);

+

+ free (context);

+}

+

+static void

+_glitz_glucose_copy_context (void *abstract_src,

+ void *abstract_dst,

+ unsigned long mask)

+{

+ glitz_glucose_context_t *src = (glitz_glucose_context_t *) abstract_src;

+ glitz_glucose_context_t *dst = (glitz_glucose_context_t *) abstract_dst;

+

+ src->context->copy(dst->context, src->context, mask);

+}

+

+static void

+_glitz_glucose_make_current (void *abstract_drawable,

+ void *abstract_context)

+{

+ glitz_glucose_context_t *context = (glitz_glucose_context_t *) abstract_context;

+ glitz_glucose_drawable_t *drawable = (glitz_glucose_drawable_t *)

+ abstract_drawable;

+ glitz_glucose_display_info_t *display_info =

+ drawable->screen_info->display_info;

+

+ if (drawable->base.width != drawable->width ||

+ drawable->base.height != drawable->height)

+ _glitz_glucose_drawable_update_size (drawable,

+ drawable->base.width,

+ drawable->base.height);

+

+ if ((__glXLastContext != context->context) ||

+ (__glXLastContext->drawPriv != drawable->drawable))

+ {

+ if (display_info->thread_info->cctx)

+ {

+ glitz_context_t *ctx = display_info->thread_info->cctx;

+

+ if (ctx->lose_current)

+ ctx->lose_current (ctx->closure);

+ }

+

+ context->context->drawPriv = drawable->drawable;

+ context->context->readPriv = drawable->drawable;

+ context->context->makeCurrent( context->context );

+ __glXAssociateContext(context->context);

+ __glXLastContext = context->context;

+ context->context->isCurrent = TRUE;

+ }

+

+ display_info->thread_info->cctx = &context->base;

+}

+

+static void

+_glitz_glucose_notify_dummy (void *abstract_drawable,

+ glitz_surface_t *surface) {}

+

+static glitz_function_pointer_t

+_glitz_glucose_context_get_proc_address (void *abstract_context,

+ const char *name)

+{

+ glitz_glucose_context_t *context = (glitz_glucose_context_t *) abstract_context;

+ glitz_glucose_drawable_t *drawable = (glitz_glucose_drawable_t *)

+ context->base.drawable;

+

+ return glitz_glucose_get_proc_address (name, drawable->screen_info);

+}

+

+glitz_glucose_context_t *

+glitz_glucose_context_get (glitz_glucose_screen_info_t *screen_info,

+ glitz_drawable_format_t *format)

+{

+ glitz_glucose_context_t *context;

+ glitz_glucose_context_t **contexts = screen_info->contexts;

+ int index, n_contexts = screen_info->n_contexts;

+ unsigned long format_id;

+

+ for (; n_contexts; n_contexts--, contexts++)

+ if ((*contexts)->id == screen_info->formats[format->id].u.uval)

+ return *contexts;

+

+ index = screen_info->n_contexts++;

+

+ screen_info->contexts =

+ realloc (screen_info->contexts,

+ sizeof (glitz_glucose_context_t *) * screen_info->n_contexts);

+ if (!screen_info->contexts)

+ return NULL;

+

+ context = malloc (sizeof (glitz_glucose_context_t));

+ if (!context)

+ return NULL;

+

+ screen_info->contexts[index] = context;

+

+ format_id = screen_info->formats[format->id].u.uval;

+

+ _glitz_glucose_context_create (screen_info,

+ format_id,

+ screen_info->root_context,

+ context);

+

+ if (!screen_info->root_context)

+ screen_info->root_context = context->context;

+

+ context->backend.gl = &_glitz_glucose_gl_proc_address;

+

+ context->backend.create_pbuffer = NULL;

+ context->backend.destroy = glitz_glucose_destroy;

+ context->backend.push_current = glitz_glucose_push_current;

+ context->backend.pop_current = glitz_glucose_pop_current;

+ context->backend.attach_notify = _glitz_glucose_notify_dummy;

+ context->backend.detach_notify = _glitz_glucose_notify_dummy;

+ context->backend.swap_buffers = glitz_glucose_swap_buffers;

+ context->backend.copy_sub_buffer = glitz_glucose_copy_sub_buffer;

+

+ context->backend.create_context = _glitz_glucose_create_context;

+ context->backend.destroy_context = _glitz_glucose_context_destroy;

+ context->backend.copy_context = _glitz_glucose_copy_context;

+ context->backend.make_current = _glitz_glucose_make_current;

+ context->backend.get_proc_address = _glitz_glucose_context_get_proc_address;

+

+ context->backend.draw_buffer = _glitz_drawable_draw_buffer;

+ context->backend.read_buffer = _glitz_drawable_read_buffer;

+

+ context->backend.drawable_formats = NULL;

+ context->backend.n_drawable_formats = 0;

+

+ if (screen_info->n_formats)

+ {

+ int size;

+

+ size = sizeof (glitz_int_drawable_format_t) * screen_info->n_formats;

+ context->backend.drawable_formats = malloc (size);

+ if (context->backend.drawable_formats)

+ {

+ memcpy (context->backend.drawable_formats, screen_info->formats,

+ size);

+ context->backend.n_drawable_formats = screen_info->n_formats;

+ }

+ }

+

+ context->backend.texture_formats = NULL;

+ context->backend.formats = NULL;

+ context->backend.n_formats = 0;

+

+ context->backend.program_map = &screen_info->program_map;

+ context->backend.feature_mask = 0;

+

+ context->initialized = 0;

+

+ return context;

+}

+

+void

+glitz_glucose_context_destroy (glitz_glucose_screen_info_t *screen_info,

+ glitz_glucose_context_t *context)

+{

+ if (context->backend.drawable_formats)

+ free (context->backend.drawable_formats);

+

+ if (context->backend.formats)

+ free (context->backend.formats);

+

+ if (context->backend.texture_formats)

+ free (context->backend.texture_formats);

+

+ context->context->destroy (context->context);

+

+ free(context);

+}

+

+static void

+_glitz_glucose_context_initialize (glitz_glucose_screen_info_t *screen_info,

+ glitz_glucose_context_t *context)

+{

+ glitz_backend_init (&context->backend,

+ glitz_glucose_get_proc_address,

+ (void *) screen_info);

+

+ glitz_initiate_state (&_glitz_glucose_gl_proc_address);

+

+ context->initialized = 1;

+}

+

+static void

+_glitz_glucose_context_make_current (glitz_glucose_drawable_t *drawable,

+ glitz_bool_t finish)

+{

+ glitz_glucose_display_info_t *display_info =

+ drawable->screen_info->display_info;

+ GLenum err;

+

+ if (finish)

+ {

+ CALL_Finish ( GET_DISPATCH(), () );

+ drawable->base.finished = 1;

+ }

+

+ if (display_info->thread_info->cctx)

+ {

+ glitz_context_t *ctx = display_info->thread_info->cctx;

+

+ if (ctx->lose_current)

+ ctx->lose_current (ctx->closure);

+

+ display_info->thread_info->cctx = NULL;

+ }

+

+ drawable->context->context->drawPriv = drawable->drawable;

+ drawable->context->context->readPriv = drawable->drawable;

+ err = drawable->context->context->makeCurrent(drawable->context->context);

+ __glXAssociateContext(drawable->context->context);

+ __glXLastContext = drawable->context->context;

+ drawable->context->context->isCurrent = TRUE;

+

+ drawable->base.update_all = 1;

+

+ if (!drawable->context->initialized)

+ _glitz_glucose_context_initialize (drawable->screen_info,

+ drawable->context);

+}

+

+static void

+_glitz_glucose_context_update (glitz_glucose_drawable_t *drawable,

+ glitz_constraint_t constraint,

+ glitz_bool_t *restore_state)

+{

+ glitz_glucose_display_info_t *dinfo = drawable->screen_info->display_info;

+ __GLXcontext *context = NULL;

+

+ if (restore_state && constraint == GLITZ_ANY_CONTEXT_CURRENT)

+ {

+ if (dinfo->thread_info->cctx)

+ {

+ *restore_state = 1;

+ return;

+ }

+ }

+

+ drawable->base.flushed = drawable->base.finished = 0;

+

+ switch (constraint) {

+ case GLITZ_NONE:

+ break;

+ case GLITZ_ANY_CONTEXT_CURRENT:

+ if (!dinfo->thread_info->cctx)

+ context = __glXLastContext;

+

+ if (!context)

+ _glitz_glucose_context_make_current (drawable, 0);

+ break;

+ case GLITZ_CONTEXT_CURRENT:

+ if (!dinfo->thread_info->cctx)

+ context = __glXLastContext;

+

+ if (context != drawable->context->context)

+ _glitz_glucose_context_make_current (drawable, (context)? 1: 0);

+ break;

+ case GLITZ_DRAWABLE_CURRENT:

+ if (drawable->base.width != drawable->width ||

+ drawable->base.height != drawable->height)

+ _glitz_glucose_drawable_update_size (drawable,

+ drawable->base.width,

+ drawable->base.height);

+

+ if (!dinfo->thread_info->cctx)

+ context = __glXLastContext;

+

+ if ((context != drawable->context->context) ||

+ (__glXLastContext->drawPriv != drawable->drawable))

+ _glitz_glucose_context_make_current (drawable, (context)? 1: 0);

+ break;

+ }

+}

+

+glitz_bool_t

+glitz_glucose_push_current (void *abstract_drawable,

+ glitz_surface_t *surface,

+ glitz_constraint_t constraint,

+ glitz_bool_t *restore_state)

+{

+ glitz_glucose_drawable_t *drawable = (glitz_glucose_drawable_t *)

+ abstract_drawable;

+ glitz_glucose_context_info_t *context_info;

+ int index;

+

+ if (restore_state)

+ *restore_state = 0;

+

+ index = drawable->screen_info->context_stack_size++;

+

+ if (index > GLITZ_CONTEXT_STACK_SIZE)

+ FatalError("glitz context stack failure\n");

+

+ context_info = &drawable->screen_info->context_stack[index];

+ context_info->drawable = drawable;

+ context_info->surface = surface;

+ context_info->constraint = constraint;

+

+ _glitz_glucose_context_update (context_info->drawable, constraint,

+ restore_state);

+

+ return 1;

+}

+

+glitz_surface_t *

+glitz_glucose_pop_current (void *abstract_drawable)

+{

+ glitz_glucose_drawable_t *drawable = (glitz_glucose_drawable_t *)

+ abstract_drawable;

+ glitz_glucose_context_info_t *context_info = NULL;

+ int index;

+

+ drawable->screen_info->context_stack_size--;

+ index = drawable->screen_info->context_stack_size - 1;

+

+ context_info = &drawable->screen_info->context_stack[index];

+

+ if (context_info->drawable)

+ _glitz_glucose_context_update (context_info->drawable,

+ context_info->constraint,

+ NULL);

+

+ if (context_info->constraint == GLITZ_DRAWABLE_CURRENT)

+ return context_info->surface;

+

+ return NULL;

+}

+/*

+ * Copyright © 2004 David Reveman

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software

+ * and its documentation for any purpose is hereby granted without

+ * fee, provided that the above copyright notice appear in all copies

+ * and that both that copyright notice and this permission notice

+ * appear in supporting documentation, and that the name of

+ * David Reveman not be used in advertising or publicity pertaining to

+ * distribution of the software without specific, written prior permission.

+ * David Reveman makes no representations about the suitability of this

+ * software for any purpose. It is provided "as is" without express or

+ * implied warranty.

+ *

+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN

+ * NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Author: David Reveman <davidr@novell.com>

+ *

+ * This file has been modified from the GLitz GLX code for use with glucose

+ * by: Alan Hourihane <alanh@tungstengraphics.com>

+ *

+ **************************************************************************/

+

+#ifdef HAVE_CONFIG_H

+# include "dix-config.h"

+#endif

+

+#include "glxserver.h"

+#include "glxutil.h"

+#include "glitz_glucose.h"

+

+extern __GLXcontext *__glXLastContext;

+

+static glitz_glucose_drawable_t *

+_glitz_glucose_create_drawable (glitz_glucose_screen_info_t *screen_info,

+ glitz_glucose_context_t *context,

+ glitz_drawable_format_t *format,

+ __GLXdrawable *glx_drawable,

+ int width,

+ int height)

+{

+ glitz_glucose_drawable_t *drawable;

+

+ drawable = (glitz_glucose_drawable_t *) malloc (sizeof (glitz_glucose_drawable_t));

+ if (drawable == NULL)

+ return NULL;

+

+ drawable->screen_info = screen_info;

+ drawable->context = context;

+ drawable->drawable = glx_drawable;

+ drawable->width = width;

+ drawable->height = height;

+

+ _glitz_drawable_init (&drawable->base,

+ &screen_info->formats[format->id],

+ &context->backend,

+ width, height);

+

+ if (!context->initialized) {

+ glitz_glucose_push_current (drawable, NULL, GLITZ_CONTEXT_CURRENT, NULL);

+ glitz_glucose_pop_current (drawable);

+ }

+

+ if (width > context->backend.max_viewport_dims[0] ||

+ height > context->backend.max_viewport_dims[1]) {

+ free (drawable);

+ return NULL;

+ }

+

+ screen_info->drawables++;

+

+ return drawable;

+}

+

+glitz_bool_t

+_glitz_glucose_drawable_update_size (glitz_glucose_drawable_t *drawable,

+ int width,

+ int height)

+{

+ drawable->width = width;

+ drawable->height = height;

+

+ return 1;

+}

+

+glitz_drawable_t *

+glitz_glucose_create_drawable_for_window (__GLXscreen *screen,

+ glitz_drawable_format_t *format,

+ __GLXdrawable *window,

+ unsigned int width,

+ unsigned int height)

+{

+ glitz_glucose_drawable_t *drawable;

+ glitz_glucose_screen_info_t *screen_info;

+ glitz_glucose_context_t *context;

+ glitz_int_drawable_format_t *iformat;

+

+ screen_info = glitz_glucose_screen_info_get (screen);

+ if (!screen_info)

+ return NULL;

+

+ if (format->id >= screen_info->n_formats)

+ return NULL;

+

+ iformat = &screen_info->formats[format->id];

+ if (!(iformat->types & GLITZ_DRAWABLE_TYPE_WINDOW_MASK))

+ return NULL;

+

+ context = glitz_glucose_context_get (screen_info, format);

+ if (!context)

+ return NULL;

+

+ drawable = _glitz_glucose_create_drawable (screen_info, context, format,

+ window,

+ width, height);

+ if (!drawable)

+ return NULL;

+

+ return &drawable->base;

+}

+

+void

+glitz_glucose_destroy (void *abstract_drawable)

+{

+ glitz_glucose_drawable_t *drawable = (glitz_glucose_drawable_t *)

+ abstract_drawable;

+

+ drawable->screen_info->drawables--;

+ if (drawable->screen_info->drawables == 0) {

+ /*

+ * Last drawable? We have to destroy all fragment programs as this may

+ * be our last chance to have a context current.

+ */

+ glitz_glucose_push_current (abstract_drawable, NULL,

+ GLITZ_CONTEXT_CURRENT, NULL);

+ glitz_program_map_fini (drawable->base.backend->gl,

+ &drawable->screen_info->program_map);

+ glitz_program_map_init (&drawable->screen_info->program_map);

+ glitz_glucose_pop_current (abstract_drawable);

+ }

+

+ if (__glXLastContext->drawPriv == drawable->drawable) {

+ __glXDeassociateContext(drawable->context->context);

+ __glXLastContext = NULL;

+ }

+

+ free (drawable);

+}

+

+glitz_bool_t

+glitz_glucose_swap_buffers (void *abstract_drawable)

+{

+ glitz_glucose_drawable_t *drawable = (glitz_glucose_drawable_t *)

+ abstract_drawable;

+

+ drawable->drawable->swapBuffers (drawable->drawable);

+

+ return 1;

+}

+

+glitz_bool_t

+glitz_glucose_copy_sub_buffer (void *abstract_drawable,

+ int x,

+ int y,

+ int width,

+ int height)

+{

+ glitz_glucose_drawable_t *drawable = (glitz_glucose_drawable_t *)

+ abstract_drawable;

+

+ drawable->drawable->copySubBuffer (drawable->drawable, x, y, width, height);

+

+ return 1;

+}

+/*

+ * Copyright © 2004 David Reveman

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software

+ * and its documentation for any purpose is hereby granted without

+ * fee, provided that the above copyright notice appear in all copies

+ * and that both that copyright notice and this permission notice

+ * appear in supporting documentation, and that the name of

+ * David Reveman not be used in advertising or publicity pertaining to

+ * distribution of the software without specific, written prior permission.

+ * David Reveman makes no representations about the suitability of this

+ * software for any purpose. It is provided "as is" without express or

+ * implied warranty.

+ *

+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN

+ * NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Author: David Reveman <davidr@novell.com>

+ *

+ * This file has been modified from the GLitz GLX code for use with glucose

+ * by: Alan Hourihane <alanh@tungstengraphics.com>

+ *

+ **************************************************************************/

+

+#ifdef HAVE_CONFIG_H

+#include "dix-config.h"

+#endif

+

+#if 0

+#include "glxserver.h"

+#else

+#include "scrnintstr.h"

+#include "window.h"

+#include "pixmap.h"

+#include <GL/glx.h>

+#include <GL/glxint.h>

+/* For glxscreens.h */

+typedef struct __GLXdrawable __GLXdrawable;

+typedef struct __GLXcontext __GLXcontext;

+

+#include "glxscreens.h"

+#include "glxdrawable.h"

+#include "glxcontext.h"

+#endif

+#include "glcontextmodes.h"

+#include "glitz_glucose.h"

+

+#include <stdlib.h>

+#include <string.h>

+

+static int

+_glitz_glucose_format_compare (const void *elem1,

+ const void *elem2)

+{

+ glitz_int_drawable_format_t *format[2];

+ int i, score[2];

+

+ format[0] = (glitz_int_drawable_format_t *) elem1;

+ format[1] = (glitz_int_drawable_format_t *) elem2;

+ i = score[0] = score[1] = 0;

+

+ for (; i < 2; i++)

+ {

+ if (format[i]->d.color.fourcc != GLITZ_FOURCC_RGB)

+ score[i] -= 1000;

+

+ if (format[i]->d.color.red_size)

+ {

+ if (format[i]->d.color.red_size >= 8)

+ score[i] += 5;

+

+ score[i] += 10;

+ }

+

+ if (format[i]->d.color.alpha_size)

+ {

+ if (format[i]->d.color.alpha_size >= 8)

+ score[i] += 5;

+

+ score[i] += 10;

+ }

+

+ if (format[i]->d.stencil_size)

+ score[i] += 5;

+

+ if (format[i]->d.depth_size)

+ score[i] += 5;

+

+ if (format[i]->d.doublebuffer)

+ score[i] += 10;

+

+ if (format[i]->d.samples > 1)

+ score[i] -= (20 - format[i]->d.samples);

+

+ if (format[i]->types & GLITZ_DRAWABLE_TYPE_WINDOW_MASK)

+ score[i] += 10;

+

+ if (format[i]->types & GLITZ_DRAWABLE_TYPE_PBUFFER_MASK)

+ score[i] += 10;

+

+ if (format[i]->caveat)

+ score[i] -= 1000;

+ }

+

+ return score[1] - score[0];

+}

+

+static void

+_glitz_add_format (glitz_glucose_screen_info_t *screen_info,

+ glitz_int_drawable_format_t *format)

+{

+ int n = screen_info->n_formats;

+

+ screen_info->formats =

+ realloc (screen_info->formats,

+ sizeof (glitz_int_drawable_format_t) * (n + 1));

+ if (screen_info->formats)

+ {

+ screen_info->formats[n] = *format;

+ screen_info->formats[n].d.id = n;

+ screen_info->n_formats++;

+ }

+}

+

+static void

+_glitz_glucose_query_formats (glitz_glucose_screen_info_t *screen_info)

+{

+ __GLXscreen *screen = screen_info->display_info->display;

+ __GLcontextModes *mode;

+ glitz_int_drawable_format_t format;

+ int i;

+

+ format.types = GLITZ_DRAWABLE_TYPE_WINDOW_MASK;

+ format.d.id = 0;

+ format.d.color.fourcc = GLITZ_FOURCC_RGB;

+

+ mode = screen->fbconfigs;

+

+ for (i = 0; i < screen->numVisuals; i++)

+ {

+ int value;

+

+ if ((_gl_get_context_mode_data(mode, GLX_USE_GL, &value) != 0) ||

+ (value == 0))

+ continue;

+

+ _gl_get_context_mode_data(mode, GLX_RGBA, &value);

+ if (value == 0)

+ continue;

+

+ /* Stereo is not supported yet */

+ _gl_get_context_mode_data(mode, GLX_STEREO, &value);

+ if (value != 0)

+ continue;

+

+ _gl_get_context_mode_data(mode, GLX_RED_SIZE, &value);

+ format.d.color.red_size = (unsigned short) value;

+ _gl_get_context_mode_data(mode, GLX_GREEN_SIZE, &value);

+ format.d.color.green_size = (unsigned short) value;

+ _gl_get_context_mode_data(mode, GLX_BLUE_SIZE, &value);

+ format.d.color.blue_size = (unsigned short) value;

+ _gl_get_context_mode_data(mode, GLX_ALPHA_SIZE, &value);

+ format.d.color.alpha_size = (unsigned short) value;

+ _gl_get_context_mode_data(mode, GLX_DEPTH_SIZE, &value);

+ format.d.depth_size = (unsigned short) value;

+ _gl_get_context_mode_data(mode, GLX_STENCIL_SIZE, &value);

+ format.d.stencil_size = (unsigned short) value;

+ _gl_get_context_mode_data(mode, GLX_DOUBLEBUFFER, &value);

+ format.d.doublebuffer = (value) ? 1: 0;

+

+ _gl_get_context_mode_data(mode, GLX_VISUAL_CAVEAT_EXT, &value);

+ switch (value) {

+ case GLX_SLOW_VISUAL_EXT:

+ case GLX_NON_CONFORMANT_VISUAL_EXT:

+ format.caveat = 1;

+ break;

+ default:

+ format.caveat = 0;

+ break;

+ }

+

+ _gl_get_context_mode_data(mode, GLX_SAMPLE_BUFFERS_ARB, &value);

+ if (value)

+ {

+ _gl_get_context_mode_data(mode, GLX_SAMPLES_ARB, &value);

+ format.d.samples = (unsigned short) (value > 1)? value: 1;

+ }

+ else

+ format.d.samples = 1;

+

+ format.u.uval = mode->visualID;

+

+ _glitz_add_format (screen_info, &format);

+

+ mode = mode->next;

+ }

+}

+

+void

+glitz_glucose_query_formats (glitz_glucose_screen_info_t *screen_info)

+{

+ int i;

+

+ _glitz_glucose_query_formats (screen_info);

+

+ if (!screen_info->n_formats)

+ return;

+

+ qsort (screen_info->formats, screen_info->n_formats,

+ sizeof (glitz_int_drawable_format_t), _glitz_glucose_format_compare);

+

+ for (i = 0; i < screen_info->n_formats; i++)

+ screen_info->formats[i].d.id = i;

+}

+

+glitz_drawable_format_t *

+glitz_glucose_find_window_format (__GLXscreen *screen,

+ unsigned long mask,

+ const glitz_drawable_format_t *templ,

+ int count)

+{

+ glitz_int_drawable_format_t itempl;

+ glitz_glucose_screen_info_t *screen_info =

+ glitz_glucose_screen_info_get (screen);

+

+ glitz_drawable_format_copy (templ, &itempl.d, mask);

+

+ itempl.types = GLITZ_DRAWABLE_TYPE_WINDOW_MASK;

+ mask |= GLITZ_INT_FORMAT_WINDOW_MASK;

+

+ return glitz_drawable_format_find (screen_info->formats,

+ screen_info->n_formats,

+ mask, &itempl, count);

+}

+/*

+ * Copyright © 2004 David Reveman

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software

+ * and its documentation for any purpose is hereby granted without

+ * fee, provided that the above copyright notice appear in all copies

+ * and that both that copyright notice and this permission notice

+ * appear in supporting documentation, and that the name of

+ * David Reveman not be used in advertising or publicity pertaining to

+ * distribution of the software without specific, written prior permission.

+ * David Reveman makes no representations about the suitability of this

+ * software for any purpose. It is provided "as is" without express or

+ * implied warranty.

+ *

+ * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN

+ * NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Author: David Reveman <davidr@novell.com>

+ *

+ * This file has been modified from the GLitz GLX code for use with glucose

+ * by: Alan Hourihane <alanh@tungstengraphics.com>

+ *

+ **************************************************************************/

+

+#ifdef HAVE_CONFIG_H

+# include "dix-config.h"

+#endif

+

+#include "glxserver.h"

+#include "glapi.h"

+#include "glthread.h"

+#include "dispatch.h"

+#include "glitz_glucose.h"

+

+#include <string.h>

+#include <dlfcn.h>

+

+#if DEBUG

+#define glucoseFailure(n) \

+ { \

+ int err = CALL_GetError( GET_DISPATCH(), () ); \

+ if (err) \

+ ErrorF("GL operation (" n ",%d) failed\n",err); \

+ }

+#else

+#define glucoseFailure(n)

+#endif

+

+static void glucoseEnable( GLenum cap )

+{

+ CALL_Enable( GET_DISPATCH(), (cap) );

+ glucoseFailure("Enable");

+}

+

+static void glucoseDisable( GLenum cap )

+{

+ CALL_Disable( GET_DISPATCH(), (cap) );

+ glucoseFailure("Disable");

+}

+

+static GLenum glucoseGetError( void )

+{

+ return CALL_GetError( GET_DISPATCH(), () );

+}

+

+static const GLubyte * glucoseGetString( GLenum name )

+{

+ return CALL_GetString( GET_DISPATCH(), (name) );

+}

+

+static void glucoseEnableClientState( GLenum cap )

+{

+ CALL_EnableClientState( GET_DISPATCH(), (cap) );

+ glucoseFailure("EnableClientState");

+}

+

+static void glucoseDisableClientState( GLenum cap )

+{

+ CALL_DisableClientState( GET_DISPATCH(), (cap) );

+ glucoseFailure("DisableClientState");

+}

+

+static void

+glucoseVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *p)

+{

+ CALL_VertexPointer( GET_DISPATCH(), (size, type, stride, p) );

+ glucoseFailure("VertexPointer");

+}

+

+static void

+glucoseTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *p)

+{

+ CALL_TexCoordPointer( GET_DISPATCH(), (size, type, stride, p) );

+ glucoseFailure("TexCoordPointer");

+}

+

+static void

+glucoseDrawArrays( GLenum mode, GLint first, GLsizei count )

+{

+ CALL_DrawArrays( GET_DISPATCH(), (mode, first, count) );

+ glucoseFailure("DrawArrays");

+}

+

+static void

+glucoseTexEnvf( GLenum target, GLenum pname, GLfloat param )

+{

+ CALL_TexEnvf( GET_DISPATCH(), (target, pname, param) );

+ glucoseFailure("TexEnvf");

+}

+

+static void

+glucoseTexEnvfv( GLenum target, GLenum pname, const GLfloat *params)

+{

+ CALL_TexEnvfv( GET_DISPATCH(), (target, pname, params) );

+ glucoseFailure("TexEnvfv");

+}

+

+static void

+glucoseTexGeni( GLenum coord, GLenum pname, GLint param )

+{

+ CALL_TexGeni( GET_DISPATCH(), (coord, pname, param) );

+ glucoseFailure("TexGeni");

+}

+

+static void

+glucoseTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )

+{

+ CALL_TexGenfv( GET_DISPATCH(), (coord, pname, params) );

+ glucoseFailure("TexGenfv");

+}

+

+static void

+glucoseColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )

+{

+ CALL_Color4us( GET_DISPATCH(), (red, green, blue, alpha) );

+ glucoseFailure("Color4us");

+}

+

+static void

+glucoseColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )

+{

+ CALL_Color4f( GET_DISPATCH(), (red, green, blue, alpha) );

+ glucoseFailure("Color4f");

+}

+

+static void

+glucoseScissor( GLint x, GLint y, GLsizei width, GLsizei height)

+{

+ CALL_Scissor( GET_DISPATCH(), (x, y, width, height) );

+ glucoseFailure("Scissor");

+}

+

+static void

+glucoseBlendFunc( GLenum sfactor, GLenum dfactor )

+{

+ CALL_BlendFunc( GET_DISPATCH(), (sfactor, dfactor) );

+ glucoseFailure("BlendFunc");

+}

+

+static void

+glucoseClear( GLbitfield mask )

+{

+ CALL_Clear( GET_DISPATCH(), (mask) );

+ glucoseFailure("Clear");

+}

+

+static void

+glucoseClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )

+{

+ CALL_ClearColor( GET_DISPATCH(), (red, green, blue, alpha) );

+ glucoseFailure("ClearColor");

+}

+

+static void

+glucoseClearStencil( GLint s )

+{

+ CALL_ClearStencil( GET_DISPATCH(), (s) );

+ glucoseFailure("ClearStencil");

+}

+

+static void

+glucoseStencilFunc( GLenum func, GLint ref, GLuint mask )

+{

+ CALL_StencilFunc( GET_DISPATCH(), (func, ref, mask) );

+ glucoseFailure("StencilFunc");

+}

+

+static void

+glucoseStencilOp( GLenum fail, GLenum zfail, GLenum zpass )

+{

+ CALL_StencilOp( GET_DISPATCH(), (fail, zfail, zpass) );

+ glucoseFailure("StencilOp");

+}

+

+static void

+glucosePushAttrib( GLbitfield mask )

+{

+ CALL_PushAttrib( GET_DISPATCH(), (mask) );

+ glucoseFailure("PushAttrib");

+}

+

+static void

+glucosePopAttrib( void )

+{

+ CALL_PopAttrib( GET_DISPATCH(), () );

+ glucoseFailure("PopAttrib");

+}

+

+static void

+glucoseMatrixMode( GLenum mode )

+{

+ CALL_MatrixMode( GET_DISPATCH(), (mode) );

+ glucoseFailure("MatrixMode");

+}

+

+static void

+glucosePushMatrix( void )

+{

+ CALL_PushMatrix( GET_DISPATCH(), () );

+ glucoseFailure("PushMatrix");

+}

+

+static void

+glucosePopMatrix( void )

+{

+ CALL_PopMatrix( GET_DISPATCH(), () );

+ glucoseFailure("PopMatrix");

+}

+

+static void

+glucoseLoadIdentity( void )

+{

+ CALL_LoadIdentity( GET_DISPATCH(), () );

+ glucoseFailure("LoadIdentity");

+}

+

+static void

+glucoseLoadMatrixf( const GLfloat *m )

+{

+ CALL_LoadMatrixf( GET_DISPATCH(), (m) );

+ glucoseFailure("LoadMatrixf");

+}

+

+static void

+glucoseDepthRange( GLclampd near_val, GLclampd far_val )

+{

+ CALL_DepthRange( GET_DISPATCH(), (near_val, far_val) );

+ glucoseFailure("DepthRange");

+}

+

+static void

+glucoseViewport( GLint x, GLint y, GLsizei width, GLsizei height)

+{

+ CALL_Viewport( GET_DISPATCH(), (x, y, width, height) );

+ glucoseFailure("Viewport");

+}

+

+static void

+glucoseRasterPos2f( GLfloat x, GLfloat y )

+{

+ CALL_RasterPos2f( GET_DISPATCH(), (x, y) );

+ glucoseFailure("RasterPos2f");

+}

+

+static void

+glucoseBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )

+{

+ CALL_Bitmap( GET_DISPATCH(), (width, height, xorig, yorig, xmove, ymove, bitmap) );

+ glucoseFailure("Bitmap");

+}

+

+static void

+glucoseReadBuffer( GLenum mode )

+{

+ CALL_ReadBuffer( GET_DISPATCH(), (mode) );

+ glucoseFailure("ReadBuffer");

+}

+

+static void

+glucoseDrawBuffer( GLenum mode )

+{

+ CALL_DrawBuffer( GET_DISPATCH(), (mode) );

+ glucoseFailure("DrawBuffer");

+}

+

+static void

+glucoseCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )

+{

+ CALL_CopyPixels( GET_DISPATCH(), (x, y, width, height, type) );

+ glucoseFailure("CopyPixels");

+}

+

+static void

+glucoseFlush( void )

+{

+ CALL_Flush( GET_DISPATCH(), () );

+ glucoseFailure("Flush");

+}

+

+static void

+glucoseFinish( void )

+{

+ CALL_Finish( GET_DISPATCH(), () );

+ glucoseFailure("Finish");

+}

+

+static void

+glucosePixelStorei( GLenum pname, GLint param )

+{

+ CALL_PixelStorei( GET_DISPATCH(), (pname, param) );

+ glucoseFailure("PixelStorei");

+}

+

+static void

+glucoseOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val)

+{

+ CALL_Ortho( GET_DISPATCH(), (left, right, bottom, top, near_val, far_val) );

+ glucoseFailure("Ortho");

+}

+

+static void

+glucoseScalef( GLfloat x, GLfloat y, GLfloat z )

+{

+ CALL_Scalef( GET_DISPATCH(), (x, y, z) );

+ glucoseFailure("Scalef");

+}

+

+static void

+glucoseTranslatef( GLfloat x, GLfloat y, GLfloat z )

+{

+ CALL_Translatef( GET_DISPATCH(), (x, y, z) );

+ glucoseFailure("Translatef");

+}

+

+static void

+glucoseHint( GLenum target, GLenum mode )

+{

+ CALL_Hint( GET_DISPATCH(), (target, mode) );

+ glucoseFailure("Hint");

+}

+

+static void

+glucoseDepthMask( GLboolean flag )

+{

+ CALL_DepthMask( GET_DISPATCH(), (flag) );

+ glucoseFailure("DepthMask");

+}

+

+static void

+glucosePolygonMode( GLenum face, GLenum mode )

+{

+ CALL_PolygonMode( GET_DISPATCH(), (face, mode) );

+ glucoseFailure("PolygonMode");

+}

+

+static void

+glucoseShadeModel( GLenum mode )

+{

+ CALL_ShadeModel( GET_DISPATCH(), (mode) );

+ glucoseFailure("ShadeModel");

+}

+

+static void

+glucoseColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )

+{

+ CALL_ColorMask( GET_DISPATCH(), (red, green, blue, alpha) );

+ glucoseFailure("ColorMask");

+}

+

+static void

+glucoseReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )

+{

+ CALL_ReadPixels( GET_DISPATCH(), (x, y, width, height, format, type, pixels) );

+ glucoseFailure("ReadPixels");

+}

+

+static void

+glucoseGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels )

+{

+ CALL_GetTexImage( GET_DISPATCH(), (target, level, format, type, pixels) );

+ glucoseFailure("GetTexImage");

+}

+

+static void

+glucoseTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )

+{

+ CALL_TexSubImage2D( GET_DISPATCH(), (target, level, xoffset, yoffset, width, height, format, type, pixels) );

+ glucoseFailure("TexSubImage2D");

+}

+

+static void

+glucoseGenTextures( GLsizei n, GLuint *textures )

+{

+ CALL_GenTextures( GET_DISPATCH(), (n, textures) );

+ glucoseFailure("GenTextures");

+}

+

+static void

+glucoseDeleteTextures( GLsizei n, const GLuint *textures)

+{

+ CALL_DeleteTextures( GET_DISPATCH(), (n, textures) );

+ glucoseFailure("DeleteTextures");

+}

+

+static void

+glucoseBindTexture( GLenum target, GLuint texture )

+{

+ CALL_BindTexture( GET_DISPATCH(), (target, texture) );

+ glucoseFailure("BindTexture");

+}

+

+static void

+glucoseTexImage2D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels )

+{

+ CALL_TexImage2D( GET_DISPATCH(), (target, level, internalFormat, width, height, border, format, type, pixels) );

+ glucoseFailure("TexImage2D");

+}

+

+static void

+glucoseTexParameteri( GLenum target, GLenum pname, GLint param )

+{

+ CALL_TexParameteri( GET_DISPATCH(), (target, pname, param) );

+ glucoseFailure("TexParameteri");

+}

+

+static void

+glucoseTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )

+{

+ CALL_TexParameterfv( GET_DISPATCH(), (target, pname, params) );

+ glucoseFailure("TexParameterfv");

+}

+

+static void

+glucoseGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )

+{

+ CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, pname, params) );

+ glucoseFailure("GetTexLevelParameteriv");

+}

+

+static void

+glucoseCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )

+{

+ CALL_CopyTexSubImage2D( GET_DISPATCH(), (target, level, xoffset, yoffset, x, y, width, height) );

+ glucoseFailure("CopyTexSubImage2D");

+}

+

+static void

+glucoseGetIntegerv( GLenum pname, GLint *params )

+{

+ CALL_GetIntegerv( GET_DISPATCH(), (pname, params) );

+ glucoseFailure("GetIntegerv");

+}

+

+static void

+glucoseBlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )

+{

+ CALL_BlendColor( GET_DISPATCH(), (red, green, blue, alpha) );

+ glucoseFailure("BlendColor");

+}

+

+static void

+glucoseActiveTexture( GLenum texture )

+{

+ CALL_ActiveTextureARB( GET_DISPATCH(), (texture) );

+ glucoseFailure("ActiveTexture");

+}

+

+static void

+glucoseClientActiveTexture( GLenum texture )

+{

+ CALL_ClientActiveTextureARB( GET_DISPATCH(), (texture) );

+ glucoseFailure("ClientActiveTexture");

+}

+

+static void

+glucoseMultiDrawArrays( GLenum mode, GLint *first, GLsizei *count, GLsizei primcount )

+{

+ CALL_MultiDrawArraysEXT( GET_DISPATCH(), (mode, first, count, primcount) );

+ glucoseFailure("MultiDrawArrays");

+}

+

+static void

+glucoseGenPrograms( GLsizei n, GLuint *ids )

+{

+ CALL_GenProgramsNV( GET_DISPATCH(), (n, ids) );

+ glucoseFailure("GenProgramsNV");

+}

+

+static void

+glucoseDeletePrograms( GLsizei n, const GLuint *ids )

+{

+ CALL_DeleteProgramsNV( GET_DISPATCH(), (n, ids) );

+ glucoseFailure("DeleteProgramsNV");

+}

+

+static void

+glucoseProgramString( GLenum target, GLenum format, GLsizei len, const GLubyte *program )

+{

+ CALL_ProgramStringARB( GET_DISPATCH(), (target, format, len, program) );

+ glucoseFailure("ProgramStringARB");

+}

+

+static void

+glucoseBindProgram( GLenum target, GLuint id )

+{

+ CALL_BindProgramNV( GET_DISPATCH(), (target, id) );

+ glucoseFailure("BindProgramNV");

+}

+

+static void

+glucoseProgramLocalParameter4fv( GLenum target, GLuint id, const GLfloat *params )

+{

+ CALL_ProgramLocalParameter4fvARB( GET_DISPATCH(), (target, id, params) );

+ glucoseFailure("BindProgramNV");

+}

+

+static void

+glucoseGetProgramiv( GLuint program, GLenum pname, GLint *params )

+{

+ CALL_GetProgramiv( GET_DISPATCH(), (program, pname, params) );

+ glucoseFailure("GetProgramiv");

+}

+

+static void

+glucoseGenBuffers( GLsizei n, GLuint *buffers )

+{

+ CALL_GenBuffersARB( GET_DISPATCH(), (n, buffers) );

+ glucoseFailure("GenBuffersARB");

+}

+

+static void

+glucoseDeleteBuffers( GLsizei n, const GLuint *buffers )

+{

+ CALL_DeleteBuffersARB( GET_DISPATCH(), (n, buffers) );

+ glucoseFailure("DeleteBuffersARB");

+}

+

+static void

+glucoseBindBuffer( GLenum target, GLuint buffer )

+{

+ CALL_BindBufferARB( GET_DISPATCH(), (target, buffer) );

+ glucoseFailure("BindBuffer");

+}

+

+static void

+glucoseBufferData( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)

+{

+ CALL_BufferDataARB( GET_DISPATCH(), (target, size, data, usage) );

+ glucoseFailure("BufferDataARB");

+}

+

+static void

+glucoseBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data )

+{

+ CALL_BufferSubDataARB( GET_DISPATCH(), (target, offset, size, data) );

+ glucoseFailure("BufferSubDataARB");

+}

+

+static void

+glucoseGetBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)

+{

+ CALL_GetBufferSubDataARB( GET_DISPATCH(), (target, offset, size, data) );

+ glucoseFailure("GetBufferSubDataARB");

+}

+

+static void

+glucoseMapBuffer(GLenum target, GLenum access)

+{

+ CALL_MapBufferARB( GET_DISPATCH(), (target, access) );

+ glucoseFailure("MapBuffer");

+}

+

+static void

+glucoseUnmapBuffer(GLenum target)

+{

+ CALL_UnmapBufferARB( GET_DISPATCH(), (target) );

+ glucoseFailure("UnmapBuffer");

+}

+

+static void

+glucoseGenFramebuffers(GLsizei n, GLuint *framebuffers)

+{

+ CALL_GenFramebuffersEXT( GET_DISPATCH(), (n, framebuffers) );

+ glucoseFailure("GenFramebuffersEXT");

+}

+

+static void

+glucoseDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)

+{

+ CALL_DeleteFramebuffersEXT( GET_DISPATCH(), (n, framebuffers) );

+ glucoseFailure("DeleteFramebuffersEXT");

+}

+

+static void

+glucoseBindFramebuffer(GLenum target, GLuint framebuffer)

+{

+ CALL_BindFramebufferEXT( GET_DISPATCH(), (target, framebuffer) );

+ glucoseFailure("BindFramebufferEXT");

+}

+

+static void

+glucoseFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)

+{

+ CALL_FramebufferRenderbufferEXT( GET_DISPATCH(), (target, attachment, renderbuffertarget, renderbuffer) );

+ glucoseFailure("FramebufferRenderbufferEXT");

+}

+

+static void

+glucoseFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)

+{

+ CALL_FramebufferTexture2DEXT( GET_DISPATCH(), (target, attachment, textarget, texture, level) );

+ glucoseFailure("FramebufferTexture2DEXT");

+}

+

+static void

+glucoseCheckFramebufferStatus(GLenum target)

+{

+ CALL_CheckFramebufferStatusEXT( GET_DISPATCH(), (target) );

+ glucoseFailure("CheckFramebufferStatusEXT");

+}

+

+static void

+glucoseGenRenderbuffers(GLsizei n, GLuint *renderbuffers)

+{

+ CALL_GenRenderbuffersEXT( GET_DISPATCH(), (n, renderbuffers) );

+ glucoseFailure("GenRenderbuffersEXT");

+}

+

+static void

+glucoseDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)

+{

+ CALL_DeleteRenderbuffersEXT( GET_DISPATCH(), (n, renderbuffers) );

+ glucoseFailure("DeleteRenderbuffersEXT");

+}

+

+static void

+glucoseBindRenderbuffer(GLenum target, GLuint renderbuffer)

+{

+ CALL_BindRenderbufferEXT( GET_DISPATCH(), (target, renderbuffer) );

+ glucoseFailure("BindRenderbufferEXT");

+}

+

+static void

+glucoseRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)

+{

+ CALL_RenderbufferStorageEXT( GET_DISPATCH(), (target, internalformat, width, height) );

+ glucoseFailure("RenderbufferStorageEXT");

+}

+

+static void

+glucoseGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)

+{

+ CALL_GetRenderbufferParameterivEXT( GET_DISPATCH(), (target, pname, params) );

+ glucoseFailure("GetRenderbufferParameterivEXT");

+}

+

+glitz_gl_proc_address_list_t _glitz_glucose_gl_proc_address = {

+

+ /* core */

+ (glitz_gl_enable_t) glucoseEnable,

+ (glitz_gl_disable_t) glucoseDisable,

+ (glitz_gl_get_error_t) glucoseGetError,

+ (glitz_gl_get_string_t) glucoseGetString,

+ (glitz_gl_enable_client_state_t) glucoseEnableClientState,

+ (glitz_gl_disable_client_state_t) glucoseDisableClientState,

+ (glitz_gl_vertex_pointer_t) glucoseVertexPointer,

+ (glitz_gl_tex_coord_pointer_t) glucoseTexCoordPointer,

+ (glitz_gl_draw_arrays_t) glucoseDrawArrays,

+ (glitz_gl_tex_env_f_t) glucoseTexEnvf,

+ (glitz_gl_tex_env_fv_t) glucoseTexEnvfv,

+ (glitz_gl_tex_gen_i_t) glucoseTexGeni,

+ (glitz_gl_tex_gen_fv_t) glucoseTexGenfv,

+ (glitz_gl_color_4us_t) glucoseColor4us,

+ (glitz_gl_color_4f_t) glucoseColor4f,

+ (glitz_gl_scissor_t) glucoseScissor,

+ (glitz_gl_blend_func_t) glucoseBlendFunc,

+ (glitz_gl_clear_t) glucoseClear,

+ (glitz_gl_clear_color_t) glucoseClearColor,

+ (glitz_gl_clear_stencil_t) glucoseClearStencil,

+ (glitz_gl_stencil_func_t) glucoseStencilFunc,

+ (glitz_gl_stencil_op_t) glucoseStencilOp,

+ (glitz_gl_push_attrib_t) glucosePushAttrib,

+ (glitz_gl_pop_attrib_t) glucosePopAttrib,

+ (glitz_gl_matrix_mode_t) glucoseMatrixMode,

+ (glitz_gl_push_matrix_t) glucosePushMatrix,

+ (glitz_gl_pop_matrix_t) glucosePopMatrix,

+ (glitz_gl_load_identity_t) glucoseLoadIdentity,

+ (glitz_gl_load_matrix_f_t) glucoseLoadMatrixf,

+ (glitz_gl_depth_range_t) glucoseDepthRange,

+ (glitz_gl_viewport_t) glucoseViewport,

+ (glitz_gl_raster_pos_2f_t) glucoseRasterPos2f,

+ (glitz_gl_bitmap_t) glucoseBitmap,

+ (glitz_gl_read_buffer_t) glucoseReadBuffer,

+ (glitz_gl_draw_buffer_t) glucoseDrawBuffer,

+ (glitz_gl_copy_pixels_t) glucoseCopyPixels,

+ (glitz_gl_flush_t) glucoseFlush,

+ (glitz_gl_finish_t) glucoseFinish,

+ (glitz_gl_pixel_store_i_t) glucosePixelStorei,

+ (glitz_gl_ortho_t) glucoseOrtho,

+ (glitz_gl_scale_f_t) glucoseScalef,

+ (glitz_gl_translate_f_t) glucoseTranslatef,

+ (glitz_gl_hint_t) glucoseHint,

+ (glitz_gl_depth_mask_t) glucoseDepthMask,

+ (glitz_gl_polygon_mode_t) glucosePolygonMode,

+ (glitz_gl_shade_model_t) glucoseShadeModel,

+ (glitz_gl_color_mask_t) glucoseColorMask,

+ (glitz_gl_read_pixels_t) glucoseReadPixels,

+ (glitz_gl_get_tex_image_t) glucoseGetTexImage,

+ (glitz_gl_tex_sub_image_2d_t) glucoseTexSubImage2D,

+ (glitz_gl_gen_textures_t) glucoseGenTextures,

+ (glitz_gl_delete_textures_t) glucoseDeleteTextures,

+ (glitz_gl_bind_texture_t) glucoseBindTexture,

+ (glitz_gl_tex_image_2d_t) glucoseTexImage2D,

+ (glitz_gl_tex_parameter_i_t) glucoseTexParameteri,

+ (glitz_gl_tex_parameter_fv_t) glucoseTexParameterfv,

+ (glitz_gl_get_tex_level_parameter_iv_t) glucoseGetTexLevelParameteriv,

+ (glitz_gl_copy_tex_sub_image_2d_t) glucoseCopyTexSubImage2D,

+ (glitz_gl_get_integer_v_t) glucoseGetIntegerv,

+

+ /* extensions */

+ (glitz_gl_blend_color_t) 0,

+ (glitz_gl_active_texture_t) 0,

+ (glitz_gl_client_active_texture_t) 0,

+ (glitz_gl_multi_draw_arrays_t) 0,

+ (glitz_gl_gen_programs_t) 0,

+ (glitz_gl_delete_programs_t) 0,

+ (glitz_gl_program_string_t) 0,

+ (glitz_gl_bind_program_t) 0,

+ (glitz_gl_program_local_param_4fv_t) 0,

+ (glitz_gl_get_program_iv_t) 0,

+ (glitz_gl_gen_buffers_t) 0,

+ (glitz_gl_delete_buffers_t) 0,

+ (glitz_gl_bind_buffer_t) 0,

+ (glitz_gl_buffer_data_t) 0,

+ (glitz_gl_buffer_sub_data_t) 0,

+ (glitz_gl_get_buffer_sub_data_t) 0,

+ (glitz_gl_map_buffer_t) 0,

+ (glitz_gl_unmap_buffer_t) 0,

+ (glitz_gl_gen_framebuffers_t) 0,

+ (glitz_gl_delete_framebuffers_t) 0,

+ (glitz_gl_bind_framebuffer_t) 0,

+ (glitz_gl_framebuffer_renderbuffer_t) 0,

+ (glitz_gl_framebuffer_texture_2d_t) 0,

+ (glitz_gl_check_framebuffer_status_t) 0,

+ (glitz_gl_gen_renderbuffers_t) 0,

+ (glitz_gl_delete_renderbuffers_t) 0,

+ (glitz_gl_bind_renderbuffer_t) 0,

+ (glitz_gl_renderbuffer_storage_t) 0,

+ (glitz_gl_get_renderbuffer_parameter_iv_t) 0

+};

+

+

+glitz_function_pointer_t

+glitz_glucose_get_proc_address (const char *name,

+ void *closure)

+{

+ glitz_function_pointer_t address = NULL;

+#if 0

+ /* Unfortunately this doesn't work for us because glapi.c doesn't get

+ * compiled with USE_X86_ASM, or appropriate, so never gets a generated

+ * function pointer. Further investigation required.....

+ */

+ address = _glapi_get_proc_address(name);

+#else

+

+ if (!strncmp(name, "glBlendColor", 12))

+ address = (glitz_function_pointer_t) glucoseBlendColor;

+ else if (!strncmp(name, "glActiveTexture", 15))

+ address = (glitz_function_pointer_t) glucoseActiveTexture;

+ else if (!strncmp(name, "glClientActiveTexture", 21))

+ address = (glitz_function_pointer_t) glucoseClientActiveTexture;

+ else if (!strncmp(name, "glMultiDrawArraysEXT", 20))

+ address = (glitz_function_pointer_t) glucoseMultiDrawArrays;

+ else if (!strncmp(name, "glGenProgramsARB", 16))

+ address = (glitz_function_pointer_t) glucoseGenPrograms;

+ else if (!strncmp(name, "glDeleteProgramsARB", 19))

+ address = (glitz_function_pointer_t) glucoseDeletePrograms;

+ else if (!strncmp(name, "glProgramStringARB", 18))

+ address = (glitz_function_pointer_t) glucoseProgramString;

+ else if (!strncmp(name, "glBindProgramARB", 16))

+ address = (glitz_function_pointer_t) glucoseBindProgram;

+ else if (!strncmp(name, "glProgramLocalParameter4fvARB", 29))

+ address = (glitz_function_pointer_t) glucoseProgramLocalParameter4fv;

+ else if (!strncmp(name, "glGetProgramivARB", 17))

+ address = (glitz_function_pointer_t) glucoseGetProgramiv;

+ else if (!strncmp(name, "glGenBuffers", 12))

+ address = (glitz_function_pointer_t) glucoseGenBuffers;

+ else if (!strncmp(name, "glDeleteBuffers", 15))

+ address = (glitz_function_pointer_t) glucoseDeleteBuffers;

+ else if (!strncmp(name, "glBindBuffer", 12))

+ address = (glitz_function_pointer_t) glucoseBindBuffer;

+ else if (!strncmp(name, "glBufferData", 12))

+ address = (glitz_function_pointer_t) glucoseBufferData;

+ else if (!strncmp(name, "glBufferSubData", 15))

+ address = (glitz_function_pointer_t) glucoseBufferSubData;

+ else if (!strncmp(name, "glGetBufferSubData", 18))

+ address = (glitz_function_pointer_t) glucoseGetBufferSubData;

+ else if (!strncmp(name, "glMapBuffer", 11))

+ address = (glitz_function_pointer_t) glucoseMapBuffer;

+ else if (!strncmp(name, "glUnmapBuffer", 13))

+ address = (glitz_function_pointer_t) glucoseUnmapBuffer;

+ else if (!strncmp(name, "glGenFramebuffersEXT", 20))

+ address = (glitz_function_pointer_t) glucoseGenFramebuffers;

+ else if (!strncmp(name, "glDeleteFramebuffersEXT", 23))

+ address = (glitz_function_pointer_t) glucoseDeleteFramebuffers;

+ else if (!strncmp(name, "glBindFramebufferEXT", 20))

+ address = (glitz_function_pointer_t) glucoseBindFramebuffer;

+ else if (!strncmp(name, "glFramebufferRenderbufferEXT", 28))

+ address = (glitz_function_pointer_t) glucoseFramebufferRenderbuffer;

+ else if (!strncmp(name, "glFramebufferTexture2DEXT", 25))

+ address = (glitz_function_pointer_t) glucoseFramebufferTexture2D;

+ else if (!strncmp(name, "glCheckFramebufferStatusEXT", 27))

+ address = (glitz_function_pointer_t) glucoseCheckFramebufferStatus;

+ else if (!strncmp(name, "glGenRenderbuffersEXT", 21))

+ address = (glitz_function_pointer_t) glucoseGenRenderbuffers;

+ else if (!strncmp(name, "glDeleteRenderbuffersEXT", 24))

+ address = (glitz_function_pointer_t) glucoseDeleteRenderbuffers;

+ else if (!strncmp(name, "glBindRenderbufferEXT", 21))

+ address = (glitz_function_pointer_t) glucoseBindRenderbuffer;

+ else if (!strncmp(name, "glRenderbufferStorageEXT", 24))

+ address = (glitz_function_pointer_t) glucoseRenderbufferStorage;

+ else if (!strncmp(name, "glGetRenderbufferParameterivEXT", 31))

+ address = (glitz_function_pointer_t) glucoseGetRenderbufferParameteriv;

+#endif

+

+#if 0

+ ErrorF("FUNCTION %s = %p\n",name,address);

+#endif

+

+ return address;

+}

+

+static void

+_glitz_glucose_display_destroy (glitz_glucose_display_info_t *display_info);

+

+static void

+_glitz_glucose_screen_destroy (glitz_glucose_screen_info_t *screen_info);

+

+static void

+_glitz_glucose_thread_info_fini (glitz_glucose_thread_info_t *thread_info)

+{

+ int i;

+

+ for (i = 0; i < thread_info->n_displays; i++)

+ _glitz_glucose_display_destroy (thread_info->displays[i]);

+

+ free (thread_info->displays);

+

+ thread_info->displays = NULL;

+ thread_info->n_displays = 0;

+

+ thread_info->cctx = NULL;

+}

+

+static glitz_glucose_thread_info_t thread_info = {

+ NULL,

+ 0,

+ NULL

+};

+

+static glitz_glucose_thread_info_t *

+_glitz_glucose_thread_info_get (const char *gl_library)

+{

+ return &thread_info;

+}

+

+static glitz_glucose_display_info_t *

+_glitz_glucose_display_info_get (__GLXscreen *display)

+{

+ glitz_glucose_display_info_t *display_info;

+ glitz_glucose_thread_info_t *thread_info = _glitz_glucose_thread_info_get (NULL);

+ glitz_glucose_display_info_t **displays = thread_info->displays;

+ int index, n_displays = thread_info->n_displays;

+

+ for (; n_displays; n_displays--, displays++)

+ if ((*displays)->display == display)

+ return *displays;

+

+ index = thread_info->n_displays++;

+

+ thread_info->displays =

+ realloc (thread_info->displays,

+ sizeof (glitz_glucose_display_info_t *) *

+ thread_info->n_displays);

+

+ display_info = malloc (sizeof (glitz_glucose_display_info_t));

+ thread_info->displays[index] = display_info;

+

+ display_info->thread_info = thread_info;

+ display_info->display = display;

+ display_info->screens = NULL;

+ display_info->n_screens = 0;

+

+ return display_info;

+}

+

+static void

+_glitz_glucose_display_destroy (glitz_glucose_display_info_t *display_info)

+{

+ int i;

+

+ for (i = 0; i < display_info->n_screens; i++)

+ _glitz_glucose_screen_destroy (display_info->screens[i]);

+

+ if (display_info->screens)

+ free (display_info->screens);

+

+ free (display_info);

+}

+

+glitz_glucose_screen_info_t *

+glitz_glucose_screen_info_get (__GLXscreen *display)

+{

+ glitz_glucose_screen_info_t *screen_info;

+ glitz_glucose_display_info_t *display_info =

+ _glitz_glucose_display_info_get (display);

+ glitz_glucose_screen_info_t **screens = display_info->screens;

+ int index, n_screens = display_info->n_screens;

+

+ for (; n_screens; n_screens--, screens++)

+ if ((*screens)->screen == display)

+ return *screens;

+

+ index = display_info->n_screens++;

+

+ display_info->screens =

+ realloc (display_info->screens,

+ sizeof (glitz_glucose_screen_info_t *) * display_info->n_screens);

+

+ screen_info = malloc (sizeof (glitz_glucose_screen_info_t));

+ display_info->screens[index] = screen_info;

+

+ screen_info->display_info = display_info;

+ screen_info->drawables = 0;

+ screen_info->formats = NULL;

+ screen_info->n_formats = 0;

+

+ screen_info->contexts = NULL;

+ screen_info->n_contexts = 0;

+

+ glitz_program_map_init (&screen_info->program_map);

+

+ screen_info->root_context = (__GLXcontext *)NULL;

+ screen_info->glx_feature_mask = 0;

+

+ glitz_glucose_query_formats (screen_info);

+

+ screen_info->context_stack_size = 1;

+ screen_info->context_stack->drawable = NULL;

+ screen_info->context_stack->surface = NULL;

+ screen_info->context_stack->constraint = GLITZ_NONE;

+

+ return screen_info;

+}

+

+static void

+_glitz_glucose_screen_destroy (glitz_glucose_screen_info_t *screen_info)

+{

+ int i;

+

+ if (screen_info->root_context)

+ screen_info->root_context->makeCurrent (NULL);

+

+ for (i = 0; i < screen_info->n_contexts; i++)

+ glitz_glucose_context_destroy (screen_info, screen_info->contexts[i]);

+

+ if (screen_info->contexts)

+ free (screen_info->contexts);

+

+ if (screen_info->formats)

+ free (screen_info->formats);

+

+ free (screen_info);

+}

+if GLUCOSE

+GLUCOSE_DIR=glucose

+endif

+

+<<<<<<< HEAD:hw/xfree86/Makefile.am

+ $(DRI_SUBDIR) $(XF86UTILS_SUBDIR) $(DOC_SUBDIR) $(GLUCOSE_DIR)

+=======

+>>>>>>> 41aea6194bd29ab34cc166b3fd90eee64299ddf8:hw/xfree86/Makefile.am

+<<<<<<< HEAD:hw/xfree86/Makefile.am

+ xf8_16bpp xf8_32bpp loader dixmods dri exa modes \

+ utils doc glucose

+=======

+>>>>>>> 41aea6194bd29ab34cc166b3fd90eee64299ddf8:hw/xfree86/Makefile.am

+static DevPrivateKey DRIPixmapPrivKey = &DRIPixmapPrivKey;

+ WindowPtr pWin = (WindowPtr)pDrawable;

+ else if (pDrawable->type == DRAWABLE_PIXMAP) {

+ PixmapPtr pPixmap = (PixmapPtr)pDrawable;

+ if ((pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_PIXMAP(pPixmap))) {

+ pDRIDrawablePriv->refCount++;

+

+ if (!pDRIDrawablePriv->hwDrawable) {

+ drmCreateDrawable(pDRIPriv->drmFD, &pDRIDrawablePriv->hwDrawable);

+ }

+ }

+ else {

+ /* allocate a DRI Window Private record */

+ if (!(pDRIDrawablePriv = xalloc(sizeof(DRIDrawablePrivRec)))) {

+ return FALSE;

+ }

+

+ /* Only create a drm_drawable_t once */

+ if (drmCreateDrawable(pDRIPriv->drmFD,

+ &pDRIDrawablePriv->hwDrawable)) {

+ xfree(pDRIDrawablePriv);

+ return FALSE;

+ }

+

+ /* add it to the list of DRI drawables for this screen */

+ pDRIDrawablePriv->pScreen = pScreen;

+ pDRIDrawablePriv->refCount = 1;

+ pDRIDrawablePriv->drawableIndex = -1;

+ pDRIDrawablePriv->nrects = 1;

+

+ /* save private off of preallocated index */

+ pPixmap->devPrivates[DRIPixmapPrivIndex].ptr =

+ (pointer)pDRIDrawablePriv;

+ }

+

+ /* track this in case the client dies */

+ AddResource(FakeClientID(client->index), DRIDrawablePrivResType,

+ (pointer)pDrawable->id);

+

+ if (pDRIDrawablePriv->hwDrawable)

+ *hHWDrawable = pDRIDrawablePriv->hwDrawable;

+ }

+ else { /* for GLX 1.3, a PBuffer */

+ return FALSE;

+ else if (pDrawable->type == DRAWABLE_PIXMAP) {

+ LookupClientResourceComplex(client, DRIDrawablePrivResType,

+ DRIDestroyDrawableCB,

+ (pointer)pDrawable->id);

+ }

+ else { /* for GLX 1.3, a PBuffer */

+ PixmapPtr pPixmap;

+

+ pPixmap = LookupIDByType(id, RT_PIXMAP);

+

+ if (pPixmap) {

+ DRIDrawablePrivPtr pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_PIXMAP(pPixmap);

+ ScreenPtr pScreen;

+ DRIScreenPrivPtr pDRIPriv;

+

+ if (!pDRIDrawablePriv)

+ return FALSE;

+

+ pScreen = pPixmap->drawable.pScreen;

+ pDRIPriv = DRI_SCREEN_PRIV(pScreen);

+

+ if (--pDRIDrawablePriv->refCount == 0) {

+ if (pDRIDrawablePriv->drawableIndex != -1) {

+ /* bump stamp to force outstanding 3D requests to resync */

+ pDRIPriv->pSAREA->drawableTable[pDRIDrawablePriv->drawableIndex].stamp

+ = DRIDrawableValidationStamp++;

+

+ /* release drawable table entry */

+ pDRIPriv->DRIDrawables[pDRIDrawablePriv->drawableIndex] = NULL;

+ }

+

+ drmDestroyDrawable(pDRIPriv->drmFD, pDRIDrawablePriv->hwDrawable);

+

+ xfree(pDRIDrawablePriv);

+ pPixmap->devPrivates[DRIPixmapPrivIndex].ptr = NULL;

+ }

+

+ return TRUE;

+ }

+ else { /* or for GLX 1.3, a PBuffer */

+ WindowPtr pOldWin;

+ WindowPtr pWin = (WindowPtr)pDrawable;

+ else if (pDrawable->type == DRAWABLE_PIXMAP) {

+ PixmapPtr pOldPixmap;

+ PixmapPtr pPixmap = (PixmapPtr)pDrawable;

+ if ((pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_PIXMAP(pPixmap))) {

+

+ /* Manage drawable table */

+ if (pDRIDrawablePriv->drawableIndex == -1) { /* load SAREA table */

+

+ /* Search table for empty entry */

+ i = 0;

+ while (i < pDRIPriv->pDriverInfo->maxDrawableTableEntry) {

+ if (!(pDRIPriv->DRIDrawables[i])) {

+ pDRIPriv->DRIDrawables[i] = pDrawable;

+ pDRIDrawablePriv->drawableIndex = i;

+ pDRIPriv->pSAREA->drawableTable[i].stamp =

+ DRIDrawableValidationStamp++;

+ break;

+ }

+ i++;

+ }

+

+ /* Search table for oldest entry */

+ if (i == pDRIPriv->pDriverInfo->maxDrawableTableEntry) {

+ unsigned int oldestStamp = ~0;

+ int oldestIndex = 0;

+ i = pDRIPriv->pDriverInfo->maxDrawableTableEntry;

+ while (i--) {

+ if (pDRIPriv->pSAREA->drawableTable[i].stamp <

+ oldestStamp) {

+ oldestIndex = i;

+ oldestStamp =

+ pDRIPriv->pSAREA->drawableTable[i].stamp;

+ }

+ }

+ pDRIDrawablePriv->drawableIndex = oldestIndex;

+

+ /* release oldest drawable table entry */

+ pOldPixmap = (PixmapPtr)pDRIPriv->DRIDrawables[oldestIndex];

+ pOldDrawPriv = DRI_DRAWABLE_PRIV_FROM_PIXMAP(pOldPixmap);

+ pOldDrawPriv->drawableIndex = -1;

+

+ /* claim drawable table entry */

+ pDRIPriv->DRIDrawables[oldestIndex] = pDrawable;

+

+ /* validate SAREA entry */

+ pDRIPriv->pSAREA->drawableTable[oldestIndex].stamp =

+ DRIDrawableValidationStamp++;

+

+ /* check for stamp wrap around */

+ if (oldestStamp > DRIDrawableValidationStamp) {

+

+ /* walk SAREA table and invalidate all drawables */

+ for( i=0;

+ i < pDRIPriv->pDriverInfo->maxDrawableTableEntry;

+ i++) {

+ pDRIPriv->pSAREA->drawableTable[i].stamp =

+ DRIDrawableValidationStamp++;

+ }

+ }

+ }

+ }

+

+ *index = pDRIDrawablePriv->drawableIndex;

+ *stamp = pDRIPriv->pSAREA->drawableTable[*index].stamp;

+ *X = (int)(pPixmap->drawable.x);

+ *Y = (int)(pPixmap->drawable.y);

+ *W = (int)(pPixmap->drawable.width);

+ *H = (int)(pPixmap->drawable.height);

+ /* use pixmap clip rect */

+ pDRIPriv->fullscreen_rect.x1 = *X;

+ pDRIPriv->fullscreen_rect.y1 = *Y;

+ pDRIPriv->fullscreen_rect.x2 = *X + *W;

+ pDRIPriv->fullscreen_rect.y2 = *Y + *H;

+ *numClipRects = 1;

+ *pClipRects = &pDRIPriv->fullscreen_rect;

+

+ /* Use the frontbuffer cliprects for back buffers. */

+ *numBackClipRects = 0;

+ *pBackClipRects = NULL;

+ }

+ else {

+ /* Not a DRIDrawable */

+ return FALSE;

+ }

+ }

+ else { /* (or for GLX 1.3, a PBuffer) */

+void*

+ REGION_TRANSLATE(pScreen, &reg, ptOldOrg.x - pWin->drawable.x,

+/*

+ * need to use the region again for anything you have to call

+ ScreenPtr pScreen,

+ int *xdir,

+ int *ydir,

+ dixLookupPrivate(&(pPix)->devPrivates, DRIPixmapPrivKey))

+module_LTLIBRARIES = libglucose.la

+

+libglucose_la_LDFLAGS = -avoid-version

+

+INCLUDES = \

+ $(XORG_INCS) \

+ -I$(srcdir)/../../../glucose \

+ -I$(srcdir)/../../../miext/cw

+

+AM_CFLAGS = $(DIX_CFLAGS) $(XORG_CFLAGS)

+

+libglucose_la_SOURCES = \

+ glucosemodule.c

+

+libglucose_la_LIBADD = \

+ ../../../glucose/libglucose.la \

+ ../../../xgl/libxgl.la

+

+

+include $(top_srcdir)/cpprules.in

+/*

+ * Copyright 2006 Zack Rusin

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ *

+ * Permission to use, copy, modify, distribute, and sell this software

+ * and its documentation for any purpose is hereby granted without

+ * fee, provided that the above copyright notice appear in all copies

+ * and that both that copyright notice and this permission notice

+ * appear in supporting documentation, and that the name of

+ * David Reveman not be used in advertising or publicity pertaining to

+ * distribution of the software without specific, written prior permission.

+ * David Reveman makes no representations about the suitability of this

+ * software for any purpose. It is provided "as is" without express or

+ * implied warranty.

+ *

+ * ZACK RUSIN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL ZACK RUSIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

+ * PERFORMANCE OF THIS SOFTWARE.

+ *

+ * Authors: Alan Hourihane <alanh@tungstengraphics.com>

+ *

+ * Re-written from original code by Zack Rusin

+ *

+ **************************************************************************/

+

+#ifdef HAVE_DIX_CONFIG_H

+#include <dix-config.h>

+#endif

+

+#include "xf86str.h"

+#include "xf86.h"

+

+#define GLUCOSE_VERSION_MAJOR 1

+#define GLUCOSE_VERSION_MINOR 0

+#define GLUCOSE_VERSION_RELEASE 0

+

+static MODULESETUPPROTO(glucoseSetup);

+

+static const OptionInfoRec GlucoseOptions[] = {

+ { -1, NULL,

+ OPTV_NONE, {0}, FALSE }

+};

+

+/*ARGSUSED*/

+static const OptionInfoRec *

+GlucoseAvailableOptions(void *unused)

+{

+ return (GlucoseOptions);

+}

+

+static XF86ModuleVersionInfo glucoseVersRec =

+{

+ "glucose",

+ MODULEVENDORSTRING,

+ MODINFOSTRING1,

+ MODINFOSTRING2,

+ XORG_VERSION_CURRENT,

+ GLUCOSE_VERSION_MAJOR, GLUCOSE_VERSION_MINOR, GLUCOSE_VERSION_RELEASE,

+ ABI_CLASS_VIDEODRV, /* requires the video driver ABI */

+ ABI_VIDEODRV_VERSION,

+ MOD_CLASS_NONE,

+ {0,0,0,0}

+};

+

+XF86ModuleData glucoseModuleData = { &glucoseVersRec, glucoseSetup, NULL };

+

+ModuleInfoRec Glucose = {

+ 1,

+ "Glucose",

+ NULL,

+ 0,

+ GlucoseAvailableOptions,

+};

+

+/*ARGSUSED*/

+static pointer

+glucoseSetup(pointer Module, pointer Options, int *ErrorMajor, int *ErrorMinor)

+{

+ static Bool Initialised = FALSE;

+

+ if (!Initialised) {

+ Initialised = TRUE;

+#ifndef REMOVE_LOADER_CHECK_MODULE_INFO

+ if (xf86LoaderCheckSymbol("xf86AddModuleInfo"))

+#endif

+ xf86AddModuleInfo(&Glucose, Module);

+ }

+

+ return (pointer)TRUE;

+}

+ @DIX_CFLAGS@ \

+ @LIBDRM_CFLAGS@ \

+ @DRIPROTO_CFLAGS@ \

+ -I$(top_srcdir)/xgl \

+ xglmodule.h \

+ xglglx.h \

+ xglinput.c \

+ xgloutput.c \

+ xglparse.c \

+ xglscreen.c \

+ xglloader.c \

+ xglhash.c \

+ xglglx.c \

+ $(top_builddir)/xgl/libxgl.la \

+ FALSE,

+ FilterBilinear,

+ {

+ { FALSE, FALSE, { 0, 0, 0, 0 } },

+ { FALSE, FALSE, { 0, 0, 0, 0 } },

+ { FALSE, FALSE, { 0, 0, 0, 0 } },

+ { FALSE, FALSE, { 0, 0, 0, 0 } }

+ }

+ @DIX_CFLAGS@ \

+ @LIBDRM_CFLAGS@ \

+ @DRIPROTO_CFLAGS@ \

+ -DHAVE_XGL_CONFIG_H \

+ -DHAVE_DIX_CONFIG_H \

+ -I$(srcdir)/.. \

+ -I$(srcdir)/../glxext \

+ -I$(top_srcdir)/xgl \

+AM_CFLAGS = \

+ @DIX_CFLAGS@ \

+ @LIBDRM_CFLAGS@ \

+ @DRIPROTO_CFLAGS@ \

+ -I$(top_srcdir)/GL/glx \

+ -I$(top_srcdir)/GL/include \

+ -I@MESA_SOURCE@/include \

+ -I@MESA_SOURCE@/src/mesa/glapi \

+ -I$(top_srcdir)/xgl \

+static DeviceIntPtr xglxKeyboardDevice = NULL;

+static DeviceIntPtr xglxPointerDevice = NULL;

+

+static xEvent *xglxEvents = NULL;

+

+static void

+xglxQueueKeyEvent(int type, unsigned int keycode)

+{

+ int i, n;

+

+ lastEventTime = GetTimeInMillis();

+ n = GetKeyboardEvents(xglxEvents, xglxKeyboardDevice, type, keycode);

+ for (i = 0; i < n; i++)

+ mieqEnqueue(xglxKeyboardDevice, xglxEvents + i);

+}

+

+ xglxQueueKeyEvent(KeyPress, X.xkey.keycode);

+ xglxQueueKeyEvent(KeyRelease, X.xkey.keycode);

+ mieqEnqueue (xglxPointerDevice, &x);

+ mieqEnqueue (xglxPointerDevice, &x);

+ mieqEnqueue (xglxPointerDevice, &x);

+ mieqEnqueue (xglxPointerDevice, &x);

+ XBell (xdisplay, volume);

+xglxKeybdProc (DeviceIntPtr pDev,

+ CARD8 xglxModMap[MAP_LENGTH];

+ for (i = 0; i < MAP_LENGTH; i++)

+ xglxModMap[i] = 0;

+ ret = InitKeyboardDeviceStruct (&pDev->public,

+ xglxPointerDevice = AddInputDevice (xglMouseProc, TRUE);

+ xglxKeyboardDevice = AddInputDevice (xglxKeybdProc, TRUE);

+ RegisterPointerDevice (xglxPointerDevice);

+ RegisterKeyboardDevice (xglxKeyboardDevice);

+ if (!xglxEvents)

+ xglxEvents = (xEvent *) xcalloc(sizeof(xEvent), GetMaximumEventsNum());

+ if (!xglxEvents)

+ FatalError("couldn't allocate room for events\n");

+ mieqInit ();

+ FALSE,

+ FilterBilinear,

+ @DIX_CFLAGS@ \

+ @LIBDRM_CFLAGS@ \

+ @DRIPROTO_CFLAGS@ \

+ -I$(top_srcdir)/xgl \

+ xglglxext.c \

+ -I$(top_srcdir)/xgl \

+libglxext_la_LDFLAGS = -avoid-version

+libglxext_la_SOURCES = glxmodule.c

+libglxext_la_LIBADD = $(top_builddir)/GL/glx/libglx.la \

+ $(top_builddir)/GL/mesa/libGLcore.la

+libglxext_modules = libglxext.la

+module_LTLIBRARIES = $(libglxext_modules)

+#include <GL/glxtokens.h>

+#ifdef COMPOSITE

+#include "compint.h"

+#endif

+extern void GlxWrapInitVisuals(miInitVisualsProcPtr *);

+

+extern __GLXprovider *__xglMesaProvider;

+

+typedef struct _xglGLScreen {

+ __GLXscreen base;

+ __GLXscreen *mesaScreen;

+ char *GLXextensions;

+} xglGLScreenRec, *xglGLScreenPtr;

+ __GLXdrawable base;

+ __GLXdrawable *mesaDrawable;

+

+ ScreenPtr pScreen;

+ DrawablePtr pDrawable;

+ xglVisualPtr pVisual;

+ glitz_drawable_t *drawable;

+ glitz_surface_t *backSurface;

+ PixmapPtr pPixmap;

+ GCPtr pGC;

+ RegionRec damage;

+ int screenX, screenY;

+ int xOff, yOff;

+ int yFlip;

+ GLuint object;

+ } bind_object;

+ __GLXcontext base;

+ __GLXcontext *mesaContext;

+

+ int refcnt;

+ struct _xglGLContext *shared;

+ glitz_context_t *context;

+ struct _glapi_table glRenderTable;

+

+ PFNGLWINDOWPOS3FMESAPROC WindowPos3fMESA;

+ PFNGLISPROGRAMARBPROC IsProgramARB;

+ PFNGLGENPROGRAMSARBPROC GenProgramsARB;

+ PFNGLBINDPROGRAMARBPROC BindProgramARB;

+ PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB;

+ PFNGLISRENDERBUFFEREXTPROC IsRenderbufferEXT;

+ PFNGLBINDRENDERBUFFEREXTPROC BindRenderbufferEXT;

+ PFNGLDELETERENDERBUFFERSEXTPROC DeleteRenderbuffersEXT;

+ PFNGLGENRENDERBUFFERSEXTPROC GenRenderbuffersEXT;

+ PFNGLISFRAMEBUFFEREXTPROC IsFramebufferEXT;

+ PFNGLBINDFRAMEBUFFEREXTPROC BindFramebufferEXT;

+ PFNGLDELETEFRAMEBUFFERSEXTPROC DeleteFramebuffersEXT;

+ PFNGLGENFRAMEBUFFERSEXTPROC GenFramebuffersEXT;

+ PFNGLFRAMEBUFFERTEXTURE1DEXTPROC FramebufferTexture1DEXT;

+ PFNGLFRAMEBUFFERTEXTURE2DEXTPROC FramebufferTexture2DEXT;

+ PFNGLFRAMEBUFFERTEXTURE3DEXTPROC FramebufferTexture3DEXT;

+ PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC FramebufferRenderbufferEXT;

+ PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC

+ GetFramebufferAttachmentParameterivEXT;

+ PFNGLGENERATEMIPMAPEXTPROC GenerateMipmapEXT;

+

+ Bool needInit;

+ xglGLBufferPtr pDrawBuffer;

+ xglGLBufferPtr pReadBuffer;

+ int drawXoff, drawYoff;

+ int readXoff, readYoff;

+ char *versionString;

+ GLenum errorValue;

+ GLboolean doubleBuffer;

+ GLint depthBits;

+ GLint stencilBits;

+ xglHashTablePtr texObjects;

+ xglHashTablePtr programObjects;

+ xglHashTablePtr renderbufferObjects;

+ xglHashTablePtr framebufferObjects;

+ GLuint framebuffer;

+ xglHashTablePtr displayLists;

+ GLuint list;

+ GLenum listMode;

+ GLuint beginCnt;

+ xglDisplayListPtr pList;

+ GLuint groupList;

+ xglGLAttributesRec attrib;

+ xglGLAttributesRec attribStack[XGL_MAX_ATTRIB_STACK_DEPTH];

+ int nAttribStack;

+ int activeTexUnit;

+ GLint maxTexUnits;

+ GLint maxListNesting;

+ GLint maxAttribStackDepth;

+static BoxRec _largeBox = { SHRT_MIN, SHRT_MIN, SHRT_MAX, SHRT_MAX };

+

+#define XGL_GLX_DRAW_PROLOGUE_WITHOUT_TEXTURES(pBox, nBox, pScissorBox) \

+ if (cctx->framebuffer) \

+ { \

+ (pBox) = &_largeBox; \

+ (nBox) = 1; \

+ } \

+ else \

+ { \

+ (pBox) = REGION_RECTS (cctx->pDrawBuffer->pGC->pCompositeClip); \

+ (nBox) = REGION_NUM_RECTS (cctx->pDrawBuffer->pGC->pCompositeClip); \

+ (pScissorBox)->x1 = cctx->attrib.scissor.x + cctx->pDrawBuffer->xOff; \

+ (pScissorBox)->x2 = (pScissorBox)->x1 + cctx->attrib.scissor.width; \

+ (pScissorBox)->y2 = cctx->attrib.scissor.y + cctx->pDrawBuffer->yOff; \

+ (pScissorBox)->y2 = cctx->pDrawBuffer->yFlip - (pScissorBox)->y2; \

+ (pScissorBox)->y1 = (pScissorBox)->y2 - cctx->attrib.scissor.height; \

+ }

+#define XGL_GLX_SET_SCISSOR_BOX(pBox) \

+ if (cctx->framebuffer) \

+ { \

+ if (cctx->attrib.scissorTest) \

+ glScissor (cctx->attrib.scissor.x, \

+ cctx->attrib.scissor.y, \

+ cctx->attrib.scissor.width, \

+ cctx->attrib.scissor.height); \

+ else \

+ glScissor (0, 0, SHRT_MAX, SHRT_MAX); \

+ } \

+ else \

+ { \

+ glScissor ((pBox)->x1, \

+ cctx->pDrawBuffer->yFlip - (pBox)->y2, \

+ (pBox)->x2 - (pBox)->x1, \

+ (pBox)->y2 - (pBox)->y1); \

+ }

+ if (!cctx->framebuffer && cctx->attrib.drawBuffer != GL_BACK) \

+

+static void

+xglSetDrawOffset (int xOff,

+ int yOff)

+{

+ /* update viewport and raster position */

+ if (xOff != cctx->drawXoff || yOff != cctx->drawYoff)

+ {

+ glViewport (cctx->attrib.viewport.x + xOff,

+ cctx->attrib.viewport.y + yOff,

+ cctx->attrib.viewport.width,

+ cctx->attrib.viewport.height);

+

+ glBitmap (0, 0, 0, 0,

+ xOff - cctx->drawXoff,

+ yOff - cctx->drawYoff,

+ NULL);

+

+ cctx->drawXoff = xOff;

+ cctx->drawYoff = yOff;

+ }

+}

+

+ glViewport (pOp->u.rect.x + cctx->drawXoff,

+ pOp->u.rect.y + cctx->drawYoff,

+ if (cctx->framebuffer)

+ {

+ glDrawBuffer (pOp->u.enumeration);

+ return;

+ }

+

+ if (cctx->framebuffer)

+ {

+ glReadBuffer (pOp->u.enumeration);

+ return;

+ }

+

+ switch (pOp->u.bind_object.target) {

+ if (pOp->u.bind_object.object)

+ if (!*ppTexObj || pOp->u.bind_object.object != (*ppTexObj)->key)

+ pOp->u.bind_object.object);

+ pTexObj->key = pOp->u.bind_object.object;

+ pOp->u.bind_object.object,

+ glBindTexture (pOp->u.bind_object.target, pTexObj->name);

+ glBindTexture (pOp->u.bind_object.target, 0);

+ gl.u.bind_object.target = target;

+ gl.u.bind_object.object = texture;

+ (*cctx->ActiveTextureARB) (GL_TEXTURE0_ARB + i);

+ (*cctx->ActiveTextureARB) (cctx->activeTexUnit);

+xglTextureMinFilter (GLenum param)

+{

+ switch (param) {

+ case GL_LINEAR:

+ return GLITZ_TEXTURE_FILTER_LINEAR;

+ case GL_NEAREST_MIPMAP_NEAREST:

+ return GLITZ_TEXTURE_FILTER_NEAREST_MIPMAP_NEAREST;

+ case GL_LINEAR_MIPMAP_NEAREST:

+ return GLITZ_TEXTURE_FILTER_LINEAR_MIPMAP_NEAREST;

+ case GL_NEAREST_MIPMAP_LINEAR:

+ return GLITZ_TEXTURE_FILTER_NEAREST_MIPMAP_LINEAR;

+ case GL_LINEAR_MIPMAP_LINEAR:

+ return GLITZ_TEXTURE_FILTER_LINEAR_MIPMAP_LINEAR;

+ case GL_NEAREST:

+ default:

+ return GLITZ_TEXTURE_FILTER_NEAREST;

+ }

+}

+

+static glitz_texture_filter_t

+xglTextureMagFilter (GLenum param)

+ xglTextureMinFilter (params[0]));

+ xglTextureMagFilter (params[0]));

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ list = (GLuint) *(((GLbyte *) lists) + i);

+ list = (GLuint) *(((GLubyte *) lists) + i);

+ list = (GLuint) *(((GLshort *) lists) + i);

+ list = (GLuint) *(((GLushort *) lists) + i);

+ list = (GLuint) *(((GLint *) lists) + i);

+ list = (GLuint) *(((GLuint *) lists) + i);

+ list = (GLuint) *(((GLfloat *) lists) + i);

+ GLubyte *ubptr = ((GLubyte *) lists) + 2 * i;

+ GLubyte *ubptr = ((GLubyte *) lists) + 3 * i;

+ GLubyte *ubptr = ((GLubyte *) lists) + 4 * i;

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ if (cctx->framebuffer ||

+ REGION_NUM_RECTS (cctx->pDrawBuffer->pGC->pCompositeClip) == 1)

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ if (cctx->framebuffer ||

+ REGION_NUM_RECTS (cctx->pDrawBuffer->pGC->pCompositeClip) == 1)

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ if (!cctx->framebuffer && cctx->attrib.scissorTest)

+ glReadPixels (x + cctx->readXoff,

+ y + cctx->readYoff,

+ pOp->u.copy_tex_image_1d.x + cctx->readXoff,

+ pOp->u.copy_tex_image_1d.y + cctx->readYoff,

+ pOp->u.copy_tex_image_2d.x + cctx->readXoff,

+ pOp->u.copy_tex_image_2d.y + cctx->readYoff,

+ pOp->u.copy_tex_sub_image_1d.x + cctx->readXoff,

+ pOp->u.copy_tex_sub_image_1d.y + cctx->readYoff,

+ pOp->u.copy_tex_sub_image_2d.x + cctx->readXoff,

+ pOp->u.copy_tex_sub_image_2d.y + cctx->readYoff,

+ pOp->u.copy_color_table.x + cctx->readXoff,

+ pOp->u.copy_color_table.y + cctx->readYoff,

+ pOp->u.copy_color_sub_table.x + cctx->readXoff,

+ pOp->u.copy_color_sub_table.y + cctx->readYoff,

+ cctx->readXoff,

+ cctx->readYoff,

+ cctx->readXoff,

+ cctx->readYoff,

+ pOp->u.copy_tex_sub_image_3d.x + cctx->readXoff,

+ pOp->u.copy_tex_sub_image_3d.y + cctx->readYoff,

+xglNoOpWindowPos3fvMESA (const GLfloat *v) {}

+xglWindowPos3fvMESA (const GLfloat *v)

+ gl.u.window_pos_3f.x = v[0];

+ gl.u.window_pos_3f.y = v[1];

+ gl.u.window_pos_3f.z = v[2];

+/* GL_ARB_vertex_program */

+static void

+xglNoOpVertexAttrib1svARB (GLuint index, const GLshort *v) {}

+static void

+xglNoOpVertexAttrib1fvARB (GLuint index, const GLfloat *v) {}

+static void

+xglNoOpVertexAttrib1dvARB (GLuint index, const GLdouble *v) {}

+static void

+xglNoOpVertexAttrib2svARB (GLuint index, const GLshort *v) {}

+static void

+xglNoOpVertexAttrib2fvARB (GLuint index, const GLfloat *v) {}

+static void

+xglNoOpVertexAttrib2dvARB (GLuint index, const GLdouble *v) {}

+static void

+xglNoOpVertexAttrib3svARB (GLuint index, const GLshort *v) {}

+static void

+xglNoOpVertexAttrib3fvARB (GLuint index, const GLfloat *v) {}

+static void

+xglNoOpVertexAttrib3dvARB (GLuint index, const GLdouble *v) {}

+static void

+xglNoOpVertexAttrib4bvARB (GLuint index, const GLbyte *v) {}

+static void

+xglNoOpVertexAttrib4svARB (GLuint index, const GLshort *v) {}

+static void

+xglNoOpVertexAttrib4ivARB (GLuint index, const GLint *v) {}

+static void

+xglNoOpVertexAttrib4ubvARB (GLuint index, const GLubyte *v) {}

+static void

+xglNoOpVertexAttrib4usvARB (GLuint index, const GLushort *v) {}

+static void

+xglNoOpVertexAttrib4uivARB (GLuint index, const GLuint *v) {}

+static void

+xglNoOpVertexAttrib4fvARB (GLuint index, const GLfloat *v) {}

+static void

+xglNoOpVertexAttrib4dvARB (GLuint index, const GLdouble *v) {}

+static void

+xglNoOpVertexAttrib4NbvARB (GLuint index, const GLbyte *v) {}

+static void

+xglNoOpVertexAttrib4NsvARB (GLuint index, const GLshort *v) {}

+static void

+xglNoOpVertexAttrib4NivARB (GLuint index, const GLint *v) {}

+static void

+xglNoOpVertexAttrib4NubvARB (GLuint index, const GLubyte *v) {}

+static void

+xglNoOpVertexAttrib4NusvARB (GLuint index, const GLushort *v) {}

+static void

+xglNoOpVertexAttrib4NuivARB (GLuint index, const GLuint *v) {}

+static void

+xglNoOpProgramStringARB (GLenum target, GLenum format, GLsizei len,

+ const void *string) {}

+static void

+xglNoOpBindProgramARB (GLenum target, GLuint program) {}

+static void

+xglBindProgramARBProc (xglGLOpPtr pOp)

+{

+ if (pOp->u.bind_object.object)

+ {

+ GLuint po;

+

+ po = (GLuint) xglHashLookup (cctx->shared->programObjects,

+ pOp->u.bind_object.object);

+ if (!po)

+ {

+ (*cctx->GenProgramsARB) (1, &po);

+

+ xglHashInsert (cctx->shared->programObjects,

+ pOp->u.bind_object.object,

+ (void *) po);

+ }

+

+ (*cctx->BindProgramARB) (pOp->u.bind_object.target, po);

+ }

+ else

+ {

+ (*cctx->BindProgramARB) (pOp->u.bind_object.target, 0);

+ }

+}

+static void

+xglBindProgramARB (GLenum target, GLuint program)

+{

+ xglGLOpRec gl;

+

+ gl.glProc = xglBindProgramARBProc;

+

+ gl.u.bind_object.target = target;

+ gl.u.bind_object.object = program;

+

+ xglGLOp (&gl);

+}

+static void

+xglNoOpDeleteProgramsARB (GLsizei n, const GLuint *programs) {}

+static void

+xglDeleteProgramsARB (GLsizei n, const GLuint *programs)

+{

+ GLuint po;

+

+ while (n--)

+ {

+ if (!*programs)

+ continue;

+

+ po = (GLuint) xglHashLookup (cctx->shared->programObjects,

+ *programs);

+ if (po)

+ {

+ (*cctx->DeleteProgramsARB) (1, &po);

+ xglHashRemove (cctx->shared->programObjects, *programs);

+ }

+ programs++;

+ }

+}

+static void

+xglNoOpGenProgramsARB (GLsizei n, GLuint *programs) {}

+static void

+xglGenProgramsARB (GLsizei n, GLuint *programs)

+{

+ GLuint name;

+

+ name = xglHashFindFreeKeyBlock (cctx->shared->programObjects, n);

+

+ (cctx->GenProgramsARB) (n, programs);

+

+ while (n--)

+ {

+ xglHashInsert (cctx->shared->programObjects, name,

+ (void *) *programs);

+

+ *programs++ = name++;

+ }

+}

+static void

+xglNoOpProgramEnvParameter4dvARB (GLenum target, GLuint index,

+ const GLdouble *params) {}

+static void

+xglNoOpProgramEnvParameter4fvARB (GLenum target, GLuint index,

+ const GLfloat *params) {}

+static void

+xglNoOpProgramLocalParameter4dvARB (GLenum target, GLuint index,

+ const GLdouble *params) {}

+static void

+xglNoOpProgramLocalParameter4fvARB (GLenum target, GLuint index,

+ const GLfloat *params) {}

+static void

+xglNoOpGetProgramEnvParameterdvARB (GLenum target, GLuint index,

+ GLdouble *params) {}

+static void

+xglNoOpGetProgramEnvParameterfvARB (GLenum target, GLuint index,

+ GLfloat *params) {}

+static void

+xglNoOpGetProgramLocalParameterdvARB (GLenum target, GLuint index,

+ GLdouble *params) {}

+static void

+xglNoOpGetProgramLocalParameterfvARB (GLenum target, GLuint index,

+ GLfloat *params) {}

+static void

+xglNoOpGetProgramivARB (GLenum target, GLenum pname, GLint *params) {}

+static void

+xglNoOpGetProgramStringARB (GLenum target, GLenum pname, void *string) {}

+static void

+xglNoOpGetVertexAttribdvARB (GLuint index, GLenum pname, GLdouble *params) {}

+static void

+xglNoOpGetVertexAttribfvARB (GLuint index,GLenum pname, GLfloat *params) {}

+static void

+xglNoOpGetVertexAttribivARB (GLuint index, GLenum pname, GLint *params) {}

+static GLboolean

+xglNoOpIsProgramARB (GLuint program)

+{

+ return GL_FALSE;

+}

+static GLboolean

+xglIsProgramARB (GLuint program)

+{

+ if (!program)

+ return GL_FALSE;

+

+ if (xglHashLookup (cctx->shared->programObjects, program))

+ return GL_TRUE;

+

+ return GL_FALSE;

+}

+

+static GLboolean

+xglIsRenderbufferEXT (GLuint renderbuffer)

+{

+ if (!renderbuffer)

+ return GL_FALSE;

+

+ if (xglHashLookup (cctx->shared->renderbufferObjects, renderbuffer))

+ return GL_TRUE;

+

+ return GL_FALSE;

+}

+xglBindRenderbufferEXTProc (xglGLOpPtr pOp)

+{

+ if (pOp->u.bind_object.object)

+ {

+ GLuint rbo;

+

+ rbo = (GLuint) xglHashLookup (cctx->shared->renderbufferObjects,

+ pOp->u.bind_object.object);

+ if (!rbo)

+ {

+ (*cctx->GenRenderbuffersEXT) (1, &rbo);

+

+ xglHashInsert (cctx->shared->renderbufferObjects,

+ pOp->u.bind_object.object,

+ (void *) rbo);

+ }

+

+ (*cctx->BindRenderbufferEXT) (pOp->u.bind_object.target, rbo);

+ }

+ else

+ {

+ (*cctx->BindRenderbufferEXT) (pOp->u.bind_object.target, 0);

+ }

+}

+static void

+xglBindRenderbufferEXT (GLenum target,

+ GLuint renderbuffer)

+{

+ xglGLOpRec gl;

+

+ gl.glProc = xglBindRenderbufferEXTProc;

+

+ gl.u.bind_object.target = target;

+ gl.u.bind_object.object = renderbuffer;

+

+ xglGLOp (&gl);

+}

+static void

+xglDeleteRenderbuffersEXT (GLsizei n, const GLuint *renderbuffers)

+{

+ GLuint rbo;

+

+ while (n--)

+ {

+ if (!*renderbuffers)

+ continue;

+

+ rbo = (GLuint) xglHashLookup (cctx->shared->renderbufferObjects,

+ *renderbuffers);

+ if (rbo)

+ {

+ (*cctx->DeleteRenderbuffersEXT) (1, &rbo);

+ xglHashRemove (cctx->shared->renderbufferObjects, *renderbuffers);

+ }

+ renderbuffers++;

+ }

+}

+static void

+xglGenRenderbuffersEXT (GLsizei n, GLuint *renderbuffers)

+{

+ GLuint name;

+

+ name = xglHashFindFreeKeyBlock (cctx->shared->renderbufferObjects, n);

+

+ (cctx->GenRenderbuffersEXT) (n, renderbuffers);

+

+ while (n--)

+ {

+ xglHashInsert (cctx->shared->renderbufferObjects, name,

+ (void *) *renderbuffers);

+

+ *renderbuffers++ = name++;

+ }

+}

+static void

+static GLboolean

+xglIsFramebufferEXT (GLuint framebuffer)

+{

+ if (!framebuffer)

+ return GL_FALSE;

+

+ if (xglHashLookup (cctx->shared->framebufferObjects, framebuffer))

+ return GL_TRUE;

+

+ return GL_FALSE;

+}

+xglBindFramebufferEXTProc (xglGLOpPtr pOp)

+{

+ GLuint fbo;

+

+ switch (pOp->u.bind_object.target) {

+ case GL_FRAMEBUFFER_EXT:

+ fbo = cctx->framebuffer;

+ break;

+ default:

+ xglRecordError (GL_INVALID_ENUM);

+ return;

+ }

+

+ if (pOp->u.bind_object.object)

+ {

+ if (pOp->u.bind_object.object != fbo)

+ {

+ fbo = (GLuint)

+ xglHashLookup (cctx->shared->framebufferObjects,

+ pOp->u.bind_object.object);

+ if (!fbo)

+ {

+ (*cctx->GenFramebuffersEXT) (1, &fbo);

+

+ xglHashInsert (cctx->shared->framebufferObjects,

+ pOp->u.bind_object.object,

+ (void *) fbo);

+ }

+

+ if (!cctx->framebuffer)

+ {

+ xglSetDrawOffset (0, 0);

+

+ cctx->readXoff = 0;

+ cctx->readYoff = 0;

+ }

+

+ (*cctx->BindFramebufferEXT) (GL_FRAMEBUFFER_EXT, fbo);

+ }

+ }

+ else

+ {

+ (*cctx->BindFramebufferEXT) (GL_FRAMEBUFFER_EXT, 0);

+

+ /* window-system drawable */

+ glitz_context_make_current (cctx->context, cctx->pDrawBuffer->drawable);

+

+ xglSetDrawOffset (cctx->pDrawBuffer->xOff, cctx->pDrawBuffer->yOff);

+

+ cctx->readXoff = cctx->pReadBuffer->xOff;

+ cctx->readYoff = cctx->pReadBuffer->yOff;

+ }

+

+ cctx->framebuffer = pOp->u.bind_object.object;

+}

+static void

+xglBindFramebufferEXT (GLenum target,

+ GLuint framebuffer)

+{

+ xglGLOpRec gl;

+

+ gl.glProc = xglBindFramebufferEXTProc;

+

+ gl.u.bind_object.target = target;

+ gl.u.bind_object.object = framebuffer;

+

+ xglGLOp (&gl);

+}

+static void

+xglDeleteFramebuffersEXT (GLsizei n, const GLuint *framebuffers)

+{

+ GLuint fbo;

+

+ while (n--)

+ {

+ if (!*framebuffers)

+ continue;

+

+ fbo = (GLuint) xglHashLookup (cctx->shared->framebufferObjects,

+ *framebuffers);

+ if (fbo)

+ {

+ (*cctx->DeleteFramebuffersEXT) (1, &fbo);

+ xglHashRemove (cctx->shared->framebufferObjects, *framebuffers);

+ }

+ framebuffers++;

+ }

+}

+static void

+static void

+xglGenFramebuffersEXT (GLsizei n, GLuint *framebuffers)

+{

+ GLuint name;

+

+ name = xglHashFindFreeKeyBlock (cctx->shared->framebufferObjects, n);

+

+ (cctx->GenFramebuffersEXT) (n, framebuffers);

+

+ while (n--)

+ {

+ xglHashInsert (cctx->shared->framebufferObjects, name,

+ (void *) *framebuffers);

+

+ *framebuffers++ = name++;

+ }

+}

+xglNoOpFramebufferTexture1DEXT (GLenum target,

+ GLenum attachment,

+ GLenum textarget,

+ GLuint texture,

+ GLint level) {}

+static void

+xglFramebufferTexture1DEXT (GLenum target,

+ GLenum attachment,

+ GLenum textarget,

+ GLuint texture,

+ GLint level)

+{

+ if (!cctx->framebuffer)

+ {

+ xglRecordError (GL_INVALID_OPERATION);

+ return;

+ }

+

+ if (texture)

+ {

+ xglTexObjPtr pTexObj;

+

+ pTexObj = (xglTexObjPtr) xglHashLookup (cctx->shared->texObjects,

+ texture);

+ if (!pTexObj)

+ {

+ xglRecordError (GL_INVALID_OPERATION);

+ return;

+ }

+

+ texture = pTexObj->name;

+ }

+

+ (*cctx->FramebufferTexture1DEXT) (target,

+ attachment,

+ textarget,

+ texture,

+ level);

+}

+static void

+xglNoOpFramebufferTexture2DEXT (GLenum target,

+ GLenum attachment,

+ GLenum textarget,

+ GLuint texture,

+ GLint level) {}

+static void

+xglFramebufferTexture2DEXT (GLenum target,

+ GLenum attachment,

+ GLenum textarget,

+ GLuint texture,

+ GLint level)

+{

+ if (!cctx->framebuffer)

+ {

+ xglRecordError (GL_INVALID_OPERATION);

+ return;

+ }

+

+ if (texture)

+ {

+ xglTexObjPtr pTexObj;

+

+ pTexObj = (xglTexObjPtr) xglHashLookup (cctx->shared->texObjects,

+ texture);

+ if (!pTexObj)

+ {

+ xglRecordError (GL_INVALID_OPERATION);

+ return;

+ }

+

+ texture = pTexObj->name;

+ }

+

+ (*cctx->FramebufferTexture2DEXT) (target,

+ attachment,

+ textarget,

+ texture,

+ level);

+}

+xglNoOpFramebufferTexture3DEXT (GLenum target,

+ GLenum attachment,

+ GLenum textarget,

+ GLuint texture,

+ GLint level,

+ GLint zoffset) {}

+xglFramebufferTexture3DEXT (GLenum target,

+ GLenum attachment,

+ GLenum textarget,

+ GLuint texture,

+ GLint level,

+ GLint zoffset)

+{

+ if (!cctx->framebuffer)

+ {

+ xglRecordError (GL_INVALID_OPERATION);

+ return;

+ }

+

+ if (texture)

+ {

+ xglTexObjPtr pTexObj;

+

+ pTexObj = (xglTexObjPtr) xglHashLookup (cctx->shared->texObjects,

+ texture);

+ if (!pTexObj)

+ {

+ xglRecordError (GL_INVALID_OPERATION);

+ return;

+ }

+

+ texture = pTexObj->name;

+ }

+

+ (*cctx->FramebufferTexture3DEXT) (target,

+ attachment,

+ textarget,

+ texture,

+ level,

+ zoffset);

+}

+xglNoOpFramebufferRenderbufferEXT (GLenum target,

+ GLenum attachment,

+xglFramebufferRenderbufferEXT (GLenum target,

+ GLenum attachment,

+ GLenum renderbuffertarget,

+ GLuint renderbuffer)

+{

+ if (!cctx->framebuffer)

+ {

+ xglRecordError (GL_INVALID_OPERATION);

+ return;

+ }

+

+ if (renderbuffer)

+ {

+ renderbuffer = (GLuint)

+ xglHashLookup (cctx->shared->renderbufferObjects,

+ renderbuffer);

+ if (!renderbuffer)

+ {

+ xglRecordError (GL_INVALID_OPERATION);

+ return;

+ }

+ }

+

+ (*cctx->FramebufferRenderbufferEXT) (target,

+ attachment,

+ renderbuffertarget,

+ renderbuffer);

+}

+static void

+xglGetFramebufferAttachmentParameterivEXT (GLenum target,

+ GLenum attachment,

+ GLenum pname,

+ GLint *params)

+{

+ if (!cctx->framebuffer)

+ {

+ xglRecordError (GL_INVALID_OPERATION);

+ return;

+ }

+

+ (*cctx->GetFramebufferAttachmentParameterivEXT) (target,

+ attachment,

+ pname,

+ params);

+

+ if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT)

+ {

+ GLint type;

+

+ pname = GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT;

+

+ (*cctx->GetFramebufferAttachmentParameterivEXT) (target,

+ attachment,

+ pname,

+ &type);

+

+ switch (type) {

+ case GL_RENDERBUFFER_EXT:

+ *params = (GLint) xglHashLookup (cctx->shared->renderbufferObjects,

+ *params);

+ break;

+ case GL_TEXTURE:

+ *params = (GLint) xglHashLookup (cctx->shared->texObjects,

+ *params);

+ break;

+ }

+ }

+}

+static void

+static void

+xglGenerateMipmapEXT (GLenum target)

+{

+ xglTexObjPtr pTexObj = NULL;

+

+ switch (target) {

+ case GL_TEXTURE_2D:

+ pTexObj = cctx->attrib.texUnits[cctx->activeTexUnit].p2D;

+ default:

+ break;

+ }

+

+ if (pTexObj)

+ {

+ if (pTexObj->pPixmap)

+ {

+ xglGLContextPtr pContext = cctx;

+

+ if (xglSyncSurface (&pTexObj->pPixmap->drawable))

+ {

+ if (pContext != cctx)

+ {

+ XGL_SCREEN_PRIV (pContext->pDrawBuffer->pGC->pScreen);

+

+ glitz_drawable_finish (pScreenPriv->drawable);

+

+ xglSetCurrentContext (pContext);

+ }

+

+ glitz_context_bind_texture (cctx->context, pTexObj->object);

+ }

+ else

+ pTexObj = NULL;

+ }

+

+ if (pTexObj)

+ (*cctx->GenerateMipmapEXT) (target);

+ }

+}

+

+ 0, /* glAttachShader */

+ 0, /* glCreateProgram */

+ 0, /* glCreateShader */

+ 0, /* glDeleteProgram */

+ 0, /* glDeleteShader */

+ 0, /* glDetachShader */

+ 0, /* glGetAttachedShaders */

+ 0, /* glGetProgramInfoLog */

+ 0, /* glGetProgramiv */

+ 0, /* glGetShaderInfoLog */

+ 0, /* glGetShaderiv */

+ 0, /* glIsProgram */

+ 0, /* glIsShader */

+ 0, /* glStencilFuncSeparate */

+ 0, /* glStencilMaskSeparate */

+ 0, /* glStencilOpSeparate */

+ 0, /* glUniformMatrix2x3fv */

+ 0, /* glUniformMatrix2x4fv */

+ 0, /* glUniformMatrix3x2fv */

+ 0, /* glUniformMatrix3x4fv */

+ 0, /* glUniformMatrix4x2fv */

+ 0, /* glUniformMatrix4x3fv */

+ 0, /* glCompressedTexImage1DARB */

+ 0, /* glCompressedTexImage2DARB */

+ 0, /* glCompressedTexImage3DARB */

+ 0, /* glCompressedTexSubImage1DARB */

+ 0, /* glCompressedTexSubImage2DARB */

+ 0, /* glCompressedTexSubImage3DARB */

+ 0, /* glGetCompressedTexImageARB */

+ 0, /* glDisableVertexAttribArrayARB */

+ 0, /* glEnableVertexAttribArrayARB */

+ xglNoOpGetProgramEnvParameterdvARB,

+ xglNoOpGetProgramEnvParameterfvARB,

+ xglNoOpGetProgramLocalParameterdvARB,

+ xglNoOpGetProgramLocalParameterfvARB,

+ xglNoOpGetProgramStringARB,

+ xglNoOpGetProgramivARB,

+ xglNoOpGetVertexAttribdvARB,

+ xglNoOpGetVertexAttribfvARB,

+ xglNoOpGetVertexAttribivARB,

+ 0, /* glProgramEnvParameter4dARB */

+ xglNoOpProgramEnvParameter4dvARB,

+ 0, /* glProgramEnvParameter4fARB */

+ xglNoOpProgramEnvParameter4fvARB,

+ 0, /* glProgramLocalParameter4dARB */

+ xglNoOpProgramLocalParameter4dvARB,

+ 0, /* glProgramLocalParameter4fARB */

+ xglNoOpProgramLocalParameter4fvARB,

+ xglNoOpProgramStringARB,

+ 0, /* glVertexAttrib1dARB */

+ xglNoOpVertexAttrib1dvARB,

+ 0, /* glVertexAttrib1fARB */

+ xglNoOpVertexAttrib1fvARB,

+ 0, /* glVertexAttrib1sARB */

+ xglNoOpVertexAttrib1svARB,

+ 0, /* glVertexAttrib2dARB */

+ xglNoOpVertexAttrib2dvARB,

+ 0, /* glVertexAttrib2fARB */

+ xglNoOpVertexAttrib2fvARB,

+ 0, /* glVertexAttrib2sARB */

+ xglNoOpVertexAttrib2svARB,

+ 0, /* glVertexAttrib3dARB */

+ xglNoOpVertexAttrib3dvARB,

+ 0, /* glVertexAttrib3fARB */

+ xglNoOpVertexAttrib3fvARB,

+ 0, /* glVertexAttrib3sARB */

+ xglNoOpVertexAttrib3svARB,

+ xglNoOpVertexAttrib4NbvARB,

+ xglNoOpVertexAttrib4NivARB,

+ xglNoOpVertexAttrib4NsvARB,

+ 0, /* glVertexAttrib4NubARB */

+ xglNoOpVertexAttrib4NubvARB,

+ xglNoOpVertexAttrib4NuivARB,

+ xglNoOpVertexAttrib4NusvARB,

+ xglNoOpVertexAttrib4bvARB,

+ 0, /* glVertexAttrib4dARB */

+ xglNoOpVertexAttrib4dvARB,

+ 0, /* glVertexAttrib4fARB */

+ xglNoOpVertexAttrib4fvARB,

+ xglNoOpVertexAttrib4ivARB,

+ 0, /* glVertexAttrib4sARB */

+ xglNoOpVertexAttrib4svARB,

+ xglNoOpVertexAttrib4ubvARB,

+ xglNoOpVertexAttrib4uivARB,

+ xglNoOpVertexAttrib4usvARB,

+ 0, /* glVertexAttribPointerARB */

+ 0, /* glBindBufferARB */

+ 0, /* glBufferDataARB */

+ 0, /* glBufferSubDataARB */

+ 0, /* glDeleteBuffersARB */

+ 0, /* glGenBuffersARB */

+ 0, /* glGetBufferParameterivARB */

+ 0, /* glGetBufferPointervARB */

+ 0, /* glGetBufferSubDataARB */

+ 0, /* glIsBufferARB */

+ 0, /* glMapBufferARB */

+ 0, /* glUnmapBufferARB */

+ 0, /* glBeginQueryARB */

+ 0, /* glDeleteQueriesARB */

+ 0, /* glEndQueryARB */

+ 0, /* glGenQueriesARB */

+ 0, /* glGetQueryObjectivARB */

+ 0, /* glGetQueryObjectuivARB */

+ 0, /* glGetQueryivARB */

+ 0, /* IsQueryARB */

+ 0, /* glAttachObjectARB */

+ 0, /* glCompileShaderARB */

+ 0, /* CreateProgramObjectARB */

+ 0, /* CreateShaderObjectARB */

+ 0, /* glDeleteObjectARB */

+ 0, /* glDetachObjectARB */

+ 0, /* glGetActiveUniformARB */

+ 0, /* glGetAttachedObjectsARB */

+ 0, /* GetHandleARB */

+ 0, /* glGetInfoLogARB */

+ 0, /* glGetObjectParameterfvARB */

+ 0, /* glGetObjectParameterivARB */

+ 0, /* glGetShaderSourceARB */

+ 0, /* GetUniformLocationARB */

+ 0, /* glGetUniformfvARB */

+ 0, /* glGetUniformivARB */

+ 0, /* glLinkProgramARB */

+ 0, /* glShaderSourceARB */

+ 0, /* glUniform1fARB */

+ 0, /* glUniform1fvARB */

+ 0, /* glUniform1iARB */

+ 0, /* glUniform1ivARB */

+ 0, /* glUniform2fARB */

+ 0, /* glUniform2fvARB */

+ 0, /* glUniform2iARB */

+ 0, /* glUniform2ivARB */

+ 0, /* glUniform3fARB */

+ 0, /* glUniform3fvARB */

+ 0, /* glUniform3iARB */

+ 0, /* glUniform3ivARB */

+ 0, /* glUniform4fARB */

+ 0, /* glUniform4fvARB */

+ 0, /* glUniform4iARB */

+ 0, /* glUniform4ivARB */

+ 0, /* glUniformMatrix2fvARB */

+ 0, /* glUniformMatrix3fvARB */

+ 0, /* glUniformMatrix4fvARB */

+ 0, /* glUseProgramObjectARB */

+ 0, /* glValidateProgramARB */

+ 0, /* glBindAttribLocationARB */

+ 0, /* glGetActiveAttribARB */

+ 0, /* GetAttribLocationARB */

+ 0, /* glGetPixelTexGenParameterfvSGIS */

+ 0, /* glGetPixelTexGenParameterivSGIS */

+ 0, /* glPixelTexGenParameteriSGIS */

+ 0, /* glPixelTexGenParameterivSGIS */

+ 0, /* glLockArraysEXT */

+ 0, /* glUnlockArraysEXT */

+ 0, /* glCullParameterdvEXT */

+ 0, /* glCullParameterfvEXT */

+ 0, /* glSecondaryColor3bEXT */

+ xglNoOpSecondaryColor3bvEXT,

+ 0, /* glSecondaryColor3dEXT */

+ xglNoOpSecondaryColor3dvEXT,

+ 0, /* glSecondaryColor3fEXT */

+ xglNoOpSecondaryColor3fvEXT,

+ 0, /* glSecondaryColor3iEXT */

+ xglNoOpSecondaryColor3ivEXT,

+ 0, /* glSecondaryColor3sEXT */

+ xglNoOpSecondaryColor3svEXT,

+ 0, /* glSecondaryColor3ubEXT */

+ xglNoOpSecondaryColor3ubvEXT,

+ 0, /* glSecondaryColor3uiEXT */

+ xglNoOpSecondaryColor3uivEXT,

+ 0, /* glSecondaryColor3usEXT */

+ xglNoOpSecondaryColor3usvEXT,

+ xglNoOpSecondaryColorPointerEXT,

+ 0, /* glMultiDrawArraysEXT */

+ 0, /* glMultiDrawElementsEXT */

+ xglNoOpFogCoordPointerEXT,

+ 0, /* glFogCoorddEXT */

+ xglNoOpFogCoorddvEXT,

+ 0, /* glFogCoordfEXT */

+ xglNoOpFogCoordfvEXT,

+ 0, /* glPixelTexGenSGIX */

+ xglNoOpBlendFuncSeparateEXT,

+ 0, /* glCombinerParameterfNV */

+ 0, /* glCombinerParameterfvNV */

+ 0, /* glCombinerParameteriNV */

+ 0, /* glCombinerParameterivNV */

+ 0, /* glWindowPos3fMESA */

+ xglNoOpWindowPos3fvMESA,

+ 0, /* glMultiModeDrawArraysIBM */

+ 0, /* glMultiModeDrawElementsIBM */

+ 0, /* glDeleteFencesNV */

+ 0, /* glFinishFenceNV */

+ 0, /* glGenFencesNV */

+ 0, /* glGetFenceivNV */

+ 0, /* glIsFenceNV */

+ 0, /* glSetFenceNV */

+ 0, /* glTestFenceNV */

+ xglNoOpBindProgramARB,

+ xglNoOpDeleteProgramsARB,

+ xglNoOpGenProgramsARB,

+ 0, /* glGetProgramivNV */

+ 0, /* glGetVertexAttribdvNV */

+ 0, /* glGetVertexAttribfvNV */

+ 0, /* glGetVertexAttribivNV */

+ xglNoOpIsProgramARB,

+ 0, /* glVertexAttribPointerNV */

+ 0, /* glVertexAttribs1dvNV */

+ 0, /* glVertexAttribs1fvNV */

+ 0, /* glVertexAttribs1svNV */

+ 0, /* glVertexAttribs2dvNV */

+ 0, /* glVertexAttribs2fvNV */

+ 0, /* glVertexAttribs2svNV */

+ 0, /* glVertexAttribs3dvNV */

+ 0, /* glVertexAttribs3fvNV */

+ 0, /* glVertexAttribs3svNV */

+ 0, /* glVertexAttribs4dvNV */

+ 0, /* glVertexAttribs4fvNV */

+ 0, /* glVertexAttribs4svNV */

+ 0, /* glVertexAttribs4ubvNV */

+ 0, /* glAlphaFragmentOp1ATI */

+ 0, /* glAlphaFragmentOp2ATI */

+ 0, /* glAlphaFragmentOp3ATI */

+ 0, /* glBeginFragmentShaderATI */

+ 0, /* glColorFragmentOp1ATI */

+ 0, /* glColorFragmentOp2ATI */

+ 0, /* glColorFragmentOp3ATI */

+ 0, /* glGenFragmentShadersATI */

+ xglNoOpPointParameteriNV,

+ xglNoOpPointParameterivNV,

+ xglNoOpActiveStencilFaceEXT,

+ 0, /* glBindVertexArrayAPPLE */

+ 0, /* glDeleteVertexArraysAPPLE */

+ 0, /* glGenVertexArraysAPPLE */

+ 0, /* glIsVertexArrayAPPLE */

+ 0, /* glGetProgramNamedParameterdvNV */

+ 0, /* glGetProgramNamedParameterfvNV */

+ 0, /* glProgramNamedParameter4dNV */

+ 0, /* glProgramNamedParameter4fNV */

+ 0, /* glProgramNamedParameter4dvNV */

+ 0, /* glProgramNamedParameter4fvNV */

+ 0, /* glDepthBoundsEXT */

+ 0, /* glBlendEquationSeparateEXT */

+ xglNoOpBindRenderbufferEXT,

+ xglNoOpDeleteFramebuffersEXT,

+ xglNoOpDeleteRenderbuffersEXT,

+ xglNoOpFramebufferRenderbufferEXT,

+ xglNoOpGenFramebuffersEXT,

+ xglNoOpGenRenderbuffersEXT,

+ xglNoOpGetFramebufferAttachmentParameterivEXT,

+ xglNoOpGetRenderbufferParameterivEXT,

+ xglNoOpIsFramebufferEXT,

+ xglNoOpIsRenderbufferEXT,

+ xglNoOpRenderbufferStorageEXT,

+ 0, /* glBlitFramebufferEXT */

+ 0, /* glProgramEnvParameters4fvEXT */

+ 0, /* glProgramLocalParameters4fvEXT */

+ if (strstr (extensions, "GL_ARB_window_pos"))

+ {

+ pContext->WindowPos3fMESA =

+ (PFNGLWINDOWPOS3FMESAPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glWindowPos3fARB");

+

+ pContext->glRenderTable.WindowPos3fvMESA = xglWindowPos3fvMESA;

+ }

+ else if (strstr (extensions, "GL_MESA_window_pos"))

+ pContext->glRenderTable.WindowPos3fvMESA = xglWindowPos3fvMESA;

+ if (strstr (extensions, "GL_ARB_vertex_program"))

+ {

+ pContext->BindProgramARB =

+ (PFNGLBINDPROGRAMARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glBindProgramARB");

+ pContext->DeleteProgramsARB =

+ (PFNGLDELETEPROGRAMSARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glDeleteProgramsARB");

+ pContext->GenProgramsARB =

+ (PFNGLGENPROGRAMSARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGenProgramsARB");

+ pContext->glRenderTable.GetProgramivARB =

+ (PFNGLGETPROGRAMIVPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGetProgramivARB");

+ pContext->glRenderTable.GetVertexAttribdvARB =

+ (PFNGLGETVERTEXATTRIBDVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGetVertexAttribdvARB");

+ pContext->glRenderTable.GetVertexAttribfvARB =

+ (PFNGLGETVERTEXATTRIBFVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGetVertexAttribfvARB");

+ pContext->glRenderTable.GetVertexAttribivARB =

+ (PFNGLGETVERTEXATTRIBIVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGetVertexAttribivARB");

+ pContext->IsProgramARB =

+ (PFNGLISPROGRAMARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glIsProgramARB");

+ pContext->glRenderTable.ProgramEnvParameter4fvARB =

+ (PFNGLPROGRAMENVPARAMETER4FVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glProgramEnvParameter4fvARB");

+ pContext->glRenderTable.ProgramEnvParameter4dvARB =

+ (PFNGLPROGRAMENVPARAMETER4DVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glProgramEnvParameter4dvARB");

+ pContext->glRenderTable.VertexAttrib1svARB =

+ (PFNGLVERTEXATTRIB1SVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib1svARB");

+ pContext->glRenderTable.VertexAttrib2svARB =

+ (PFNGLVERTEXATTRIB2SVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib2svARB");

+ pContext->glRenderTable.VertexAttrib3svARB =

+ (PFNGLVERTEXATTRIB3SVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib3svARB");

+ pContext->glRenderTable.VertexAttrib4svARB =

+ (PFNGLVERTEXATTRIB4SVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4svARB");

+ pContext->glRenderTable.VertexAttrib1fvARB =

+ (PFNGLVERTEXATTRIB1FVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib1fvARB");

+ pContext->glRenderTable.VertexAttrib2fvARB =

+ (PFNGLVERTEXATTRIB2FVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib2fvARB");

+ pContext->glRenderTable.VertexAttrib3fvARB =

+ (PFNGLVERTEXATTRIB3FVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib3fvARB");

+ pContext->glRenderTable.VertexAttrib4fvARB =

+ (PFNGLVERTEXATTRIB4FVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4fvARB");

+ pContext->glRenderTable.VertexAttrib1dvARB =

+ (PFNGLVERTEXATTRIB1DVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib1dvARB");

+ pContext->glRenderTable.VertexAttrib2dvARB =

+ (PFNGLVERTEXATTRIB2DVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib2dvARB");

+ pContext->glRenderTable.VertexAttrib3dvARB =

+ (PFNGLVERTEXATTRIB3DVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib3dvARB");

+ pContext->glRenderTable.VertexAttrib4dvARB =

+ (PFNGLVERTEXATTRIB4DVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4dvARB");

+ pContext->glRenderTable.VertexAttrib4NubvARB =

+ (PFNGLVERTEXATTRIB4NUBVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4NubvARB");

+ pContext->glRenderTable.ProgramLocalParameter4fvARB =

+ (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glProgramLocalParameter4fvARB");

+ pContext->glRenderTable.ProgramLocalParameter4dvARB =

+ (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glProgramLocalParameter4dvARB");

+ pContext->glRenderTable.GetProgramEnvParameterdvARB =

+ (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGetProgramEnvParameterdvARB");

+ pContext->glRenderTable.GetProgramEnvParameterfvARB =

+ (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGetProgramEnvParameterfvARB");

+ pContext->glRenderTable.GetProgramLocalParameterdvARB =

+ (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGetProgramLocalParameterdvARB");

+ pContext->glRenderTable.GetProgramLocalParameterfvARB =

+ (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGetProgramLocalParameterfvARB");

+ pContext->glRenderTable.ProgramStringARB =

+ (PFNGLPROGRAMSTRINGARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glProgramStringARB");

+ pContext->glRenderTable.GetProgramStringARB =

+ (PFNGLGETPROGRAMSTRINGARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glGetProgramStringARB");

+ pContext->glRenderTable.VertexAttrib4bvARB =

+ (PFNGLVERTEXATTRIB4BVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4bvARB");

+ pContext->glRenderTable.VertexAttrib4ivARB =

+ (PFNGLVERTEXATTRIB4IVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4ivARB");

+ pContext->glRenderTable.VertexAttrib4ubvARB =

+ (PFNGLVERTEXATTRIB4UBVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4ubvARB");

+ pContext->glRenderTable.VertexAttrib4usvARB =

+ (PFNGLVERTEXATTRIB4USVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4usvARB");

+ pContext->glRenderTable.VertexAttrib4uivARB =

+ (PFNGLVERTEXATTRIB4UIVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4uivARB");

+ pContext->glRenderTable.VertexAttrib4NbvARB =

+ (PFNGLVERTEXATTRIB4NBVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4NbvARB");

+ pContext->glRenderTable.VertexAttrib4NsvARB =

+ (PFNGLVERTEXATTRIB4NSVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4NsvARB");

+ pContext->glRenderTable.VertexAttrib4NivARB =

+ (PFNGLVERTEXATTRIB4NIVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4NivARB");

+ pContext->glRenderTable.VertexAttrib4NusvARB =

+ (PFNGLVERTEXATTRIB4NUSVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4NusvARB");

+ pContext->glRenderTable.VertexAttrib4NuivARB =

+ (PFNGLVERTEXATTRIB4NUIVARBPROC)

+ glitz_context_get_proc_address (pContext->context,

+ "glVertexAttrib4NuivARB");

+

+ pContext->glRenderTable.IsProgramNV = xglIsProgramARB;

+ pContext->glRenderTable.BindProgramNV = xglBindProgramARB;

+ pContext->glRenderTable.DeleteProgramsNV = xglDeleteProgramsARB;

+ pContext->glRenderTable.GenProgramsNV = xglGenProgramsARB;

+ }

+

+ pContext->IsRenderbufferEXT =

+ pContext->BindRenderbufferEXT =

+ pContext->DeleteRenderbuffersEXT =

+ pContext->GenRenderbuffersEXT =

+ pContext->IsFramebufferEXT =

+ pContext->BindFramebufferEXT =

+ pContext->DeleteFramebuffersEXT =

+ pContext->GenFramebuffersEXT =

+ pContext->FramebufferTexture1DEXT =

+ pContext->FramebufferTexture2DEXT =

+ pContext->FramebufferTexture3DEXT =

+ pContext->FramebufferRenderbufferEXT =

+ pContext->GetFramebufferAttachmentParameterivEXT =

+ pContext->GenerateMipmapEXT =

+

+ pContext->glRenderTable.IsRenderbufferEXT = xglIsRenderbufferEXT;

+ pContext->glRenderTable.BindRenderbufferEXT = xglBindRenderbufferEXT;

+ pContext->glRenderTable.DeleteRenderbuffersEXT =

+ xglDeleteRenderbuffersEXT;

+ pContext->glRenderTable.GenRenderbuffersEXT = xglGenRenderbuffersEXT;

+ pContext->glRenderTable.IsFramebufferEXT = xglIsFramebufferEXT;

+ pContext->glRenderTable.BindFramebufferEXT = xglBindFramebufferEXT;

+ pContext->glRenderTable.DeleteFramebuffersEXT = xglDeleteFramebuffersEXT;

+ pContext->glRenderTable.GenFramebuffersEXT = xglGenFramebuffersEXT;

+ pContext->glRenderTable.FramebufferTexture1DEXT =

+ xglFramebufferTexture1DEXT;

+ pContext->glRenderTable.FramebufferTexture2DEXT =

+ xglFramebufferTexture2DEXT;

+ pContext->glRenderTable.FramebufferTexture3DEXT =

+ xglFramebufferTexture3DEXT;

+ pContext->glRenderTable.FramebufferRenderbufferEXT =

+ xglFramebufferRenderbufferEXT;

+ pContext->glRenderTable.GetFramebufferAttachmentParameterivEXT =

+ xglGetFramebufferAttachmentParameterivEXT;

+ pContext->glRenderTable.GenerateMipmapEXT = xglGenerateMipmapEXT;

+ }

+}

+

+static GLboolean

+xglResizeBuffer (xglGLBufferPtr pBufferPriv)

+{

+ DrawablePtr pDrawable = pBufferPriv->pDrawable;

+

+ XGL_SCREEN_PRIV (pDrawable->pScreen);

+ XGL_DRAWABLE_PIXMAP (pBufferPriv->pDrawable);

+

+ if (pPixmap != pScreenPriv->pScreenPixmap)

+ {

+ if (!xglCreatePixmapSurface (pPixmap))

+ return FALSE;

+

+ if (pBufferPriv->drawable == pScreenPriv->drawable)

+ {

+ if (pBufferPriv->backSurface)

+ glitz_surface_destroy (pBufferPriv->backSurface);

+

+ glitz_drawable_destroy (pBufferPriv->drawable);

+

+ pBufferPriv->drawable = NULL;

+ pBufferPriv->backSurface = NULL;

+ }

+

+ if (pBufferPriv->drawable)

+ {

+ glitz_drawable_update_size (pBufferPriv->drawable,

+ pPixmap->drawable.width,

+ pPixmap->drawable.height);

+ }

+ else

+ {

+ glitz_drawable_format_t *format;

+

+ format = pBufferPriv->pVisual->format.drawable;

+ if (pBufferPriv->pVisual->pbuffer)

+ {

+ pBufferPriv->drawable =

+ glitz_create_pbuffer_drawable (pScreenPriv->drawable,

+ format,

+ pPixmap->drawable.width,

+ pPixmap->drawable.height);

+ }

+ else

+ {

+ pBufferPriv->drawable =

+ glitz_create_drawable (pScreenPriv->drawable, format,

+ pPixmap->drawable.width,

+ pPixmap->drawable.height);

+

+ if (!pBufferPriv->drawable)

+ return FALSE;

+

+ if (format->doublebuffer)

+ {

+ glitz_format_t *backFormat;

+

+ backFormat = pBufferPriv->pVisual->format.surface;

+

+ pBufferPriv->backSurface =

+ glitz_surface_create (pScreenPriv->drawable, backFormat,

+ pPixmap->drawable.width,

+ pPixmap->drawable.height,

+ 0, NULL);

+ if (pBufferPriv->backSurface)

+ glitz_surface_attach (pBufferPriv->backSurface,

+ pBufferPriv->drawable,

+ GLITZ_DRAWABLE_BUFFER_BACK_COLOR);

+ }

+ }

+ }

+ }

+ else

+ {

+ glitz_drawable_reference (pScreenPriv->drawable);

+

+ if (pBufferPriv->backSurface)

+ glitz_surface_destroy (pBufferPriv->backSurface);

+

+ if (pBufferPriv->drawable)

+ glitz_drawable_destroy (pBufferPriv->drawable);

+

+ pBufferPriv->drawable = pScreenPriv->drawable;

+ pBufferPriv->backSurface = NULL;

+ }

+

+ ValidateGC (pDrawable, pBufferPriv->pGC);

+

+ return TRUE;

+}

+

+static GLboolean

+xglSwapBuffers (__GLXdrawable *drawable)

+{

+ xglGLBufferPtr pBufferPriv = (xglGLBufferPtr) drawable;

+ __GLXdrawable *mesaDrawable = pBufferPriv->mesaDrawable;

+ DrawablePtr pDrawable = pBufferPriv->pDrawable;

+ GLboolean status = GL_TRUE;

+

+ if (pDrawable)

+ {

+ glitz_surface_t *surface;

+ int xOff, yOff;

+ GCPtr pGC = pBufferPriv->pGC;

+ BoxPtr pBox = REGION_RECTS (pGC->pCompositeClip);

+ int nBox = REGION_NUM_RECTS (pGC->pCompositeClip);

+

+ XGL_GET_DRAWABLE (pDrawable, surface, xOff, yOff);

+

+ glitz_drawable_swap_buffer_region (pBufferPriv->drawable,

+ xOff, yOff,

+ (glitz_box_t *) pBox, nBox);

+

+ xglAddBitDamage (pDrawable, pGC->pCompositeClip);

+ DamageDamageRegion (pDrawable, pGC->pCompositeClip);

+ REGION_EMPTY (pGC->pScreen, &pBufferPriv->damage);

+ }

+ else if (mesaDrawable)

+ {

+ status = (*mesaDrawable->swapBuffers) (mesaDrawable);

+ }

+

+ return status;

+}

+

+static void

+xglCopySubBuffer (__GLXdrawable *drawable,

+ int x,

+ int y,

+ int width,

+ int height)

+{

+ xglGLBufferPtr pBufferPriv = (xglGLBufferPtr) drawable;

+ __GLXdrawable *mesaDrawable = pBufferPriv->mesaDrawable;

+ DrawablePtr pDrawable = pBufferPriv->pDrawable;

+

+ if (pDrawable)

+ {

+ glitz_surface_t *surface;

+ int xOff, yOff;

+ GCPtr pGC = pBufferPriv->pGC;

+ RegionRec region;

+ BoxRec box;

+

+ XGL_GET_DRAWABLE (pDrawable, surface, xOff, yOff);

+

+ box.x1 = pDrawable->x + x;

+ box.y2 = pDrawable->height - y;

+ box.x2 = box.x1 + width;

+ box.y1 = box.y2 - height;

+

+ REGION_INIT (pGC->pScreen, &region, &box, 1);

+ REGION_INTERSECT (pDrawable->pScreen, &region,

+ pGC->pCompositeClip, &region);

+

+ glitz_drawable_swap_buffer_region (pBufferPriv->drawable,

+ xOff, yOff, (glitz_box_t *)

+ REGION_RECTS (&region),

+ REGION_NUM_RECTS (&region));

+

+ xglAddBitDamage (pDrawable, &region);

+ DamageDamageRegion (pDrawable, &region);

+ REGION_SUBTRACT (pGC->pScreen, &pBufferPriv->damage,

+ &pBufferPriv->damage, &region);

+

+ REGION_UNINIT (pGC->pScreen, &region);

+ }

+ else if (mesaDrawable)

+ {

+ (*mesaDrawable->copySubBuffer) (mesaDrawable,

+ x, y, width, height);

+ }

+}

+

+static GLboolean

+xglResizeDrawable (__GLXdrawable *drawable)

+{

+ xglGLBufferPtr pBufferPriv = (xglGLBufferPtr) drawable;

+ __GLXdrawable *mesaDrawable = pBufferPriv->mesaDrawable;

+ DrawablePtr pDrawable = pBufferPriv->pDrawable;

+ GLboolean status = GL_TRUE;

+

+ if (pDrawable)

+ {

+ if (!xglResizeBuffer (pBufferPriv))

+ return GL_FALSE;

+ }

+ else if (mesaDrawable)

+ {

+ status = (*mesaDrawable->resize) (mesaDrawable);

+ }

+

+ return status;

+}

+

+static int

+xglBindTexImage (__GLXcontext *context,

+ int buffer,

+ __GLXdrawable *pixmap)

+{

+ xglGLContextPtr pContext = (xglGLContextPtr) context;

+ __GLXcontext *mesaContext = pContext->mesaContext;

+

+ if (cctx)

+ {

+ xglTexUnitPtr pTexUnit = &cctx->attrib.texUnits[cctx->activeTexUnit];

+ ScreenPtr pScreen = pixmap->pDraw->pScreen;

+

+ XGL_SCREEN_PRIV (pScreen);

+ XGL_DRAWABLE_PIXMAP (pixmap->pDraw);

+

+ /* XXX: front left buffer is only supported so far */

+ if (buffer != GLX_FRONT_LEFT_EXT)

+ return BadMatch;

+

+ if (xglCreatePixmapSurface (pPixmap))

+ {

+ glitz_texture_object_t *texture;

+

+ XGL_PIXMAP_PRIV (pPixmap);

+

+ texture = glitz_texture_object_create (pPixmapPriv->surface);

+ if (texture)

+ {

+ xglTexObjPtr pTexObj;

+

+ switch (glitz_texture_object_get_target (texture)) {

+ case GLITZ_TEXTURE_TARGET_2D:

+ pTexObj = pTexUnit->p2D;

+ break;

+ case GLITZ_TEXTURE_TARGET_RECT:

+ pTexObj = pTexUnit->pRect;

+ break;

+ default:

+ pTexObj = NULL;

+ break;

+ }

+

+ if (pTexObj)

+ {

+ pPixmap->refcnt++;

+

+ if (pTexObj->pPixmap)

+ (*pScreen->DestroyPixmap) (pTexObj->pPixmap);

+

+ if (pTexObj->object)

+ glitz_texture_object_destroy (pTexObj->object);

+

+ pTexObj->pPixmap = pPixmap;

+ pTexObj->object = texture;

+ }

+ else

+ glitz_texture_object_destroy (texture);

+

+ return Success;

+ }

+ }

+ }

+ else

+ {

+ return (*mesaContext->textureFromPixmap->bindTexImage) (mesaContext,

+ buffer,

+ pixmap);

+ }

+

+ return BadDrawable;

+}

+

+static int

+xglReleaseTexImage (__GLXcontext *context,

+ int buffer,

+ __GLXdrawable *pixmap)

+{

+ xglGLContextPtr pContext = (xglGLContextPtr) context;

+ __GLXcontext *mesaContext = pContext->mesaContext;

+

+ if (cctx)

+ {

+ DrawablePtr pDrawable = pixmap->pDraw;

+ xglTexObjPtr pTexObj;

+

+ XGL_DRAWABLE_PIXMAP (pDrawable);

+

+ /* XXX: front left buffer is only supported so far */

+ if (buffer != GLX_FRONT_LEFT_EXT)

+ return BadMatch;

+

+ pTexObj = cctx->attrib.texUnits[cctx->activeTexUnit].p2D;

+ if (pTexObj && pTexObj->pPixmap == pPixmap)

+ {

+ (*pDrawable->pScreen->DestroyPixmap) (pTexObj->pPixmap);

+ pTexObj->pPixmap = NULL;

+ glitz_texture_object_destroy (pTexObj->object);

+ pTexObj->object = NULL;

+

+ return Success;

+ }

+ else

+ {

+ pTexObj = cctx->attrib.texUnits[cctx->activeTexUnit].pRect;

+ if (pTexObj && pTexObj->pPixmap == pPixmap)

+ {

+ (*pDrawable->pScreen->DestroyPixmap) (pTexObj->pPixmap);

+ pTexObj->pPixmap = NULL;

+ glitz_texture_object_destroy (pTexObj->object);

+ pTexObj->object = NULL;

+

+ return Success;

+ }

+ }

+ }

+ else

+ {

+ return (*mesaContext->textureFromPixmap->releaseTexImage) (mesaContext,

+ buffer,

+ pixmap);

+ }

+

+ return BadDrawable;

+}

+

+static __GLXtextureFromPixmap __xglTextureFromPixmapContext = {

+ xglBindTexImage,

+ xglReleaseTexImage

+};

+

+static void

+xglDestroyDrawable (__GLXdrawable *drawable)

+{

+ xglGLBufferPtr pBufferPriv = (xglGLBufferPtr) drawable;

+ __GLXdrawable *mesaDrawable = pBufferPriv->mesaDrawable;

+

+ if (mesaDrawable)

+ {

+ mesaDrawable->refCount--;

+ if (!mesaDrawable->refCount)

+ (*mesaDrawable->destroy) (mesaDrawable);

+ }

+

+ if (pBufferPriv->pGC)

+ FreeGC (pBufferPriv->pGC, (GContext) 0);

+

+ if (pBufferPriv->backSurface)

+ glitz_surface_destroy (pBufferPriv->backSurface);

+

+ if (pBufferPriv->drawable)

+ glitz_drawable_destroy (pBufferPriv->drawable);

+

+ xfree (pBufferPriv);

+}

+

+static __GLXdrawable *

+xglCreateDrawable (__GLXscreen *screen,

+ DrawablePtr pDrawable,

+ int type,

+ XID drawId,

+ __GLcontextModes *modes)

+{

+ ScreenPtr pScreen = pDrawable->pScreen;

+ xglGLScreenPtr pGLScreen = (xglGLScreenPtr) screen;

+ __GLXscreen *mesaScreen = pGLScreen->mesaScreen;

+ xglGLBufferPtr pBufferPriv;

+ xglVisualPtr v;

+ Bool useMesa;

+

+ XGL_SCREEN_PRIV (pScreen);

+ XGL_DRAWABLE_PIXMAP (pDrawable);

+

+ pBufferPriv = xalloc (sizeof (xglGLBufferRec));

+ if (!pBufferPriv)

+ return NULL;

+

+ memset (pBufferPriv, 0, sizeof (xglGLBufferRec));

+

+ if (!__glXDrawableInit (&pBufferPriv->base, screen, pDrawable, type, drawId, modes))

+ {

+ xfree (pBufferPriv);

+ return NULL;

+ }

+

+ pBufferPriv->mesaDrawable = NULL;

+

+ pBufferPriv->pScreen = pScreen;

+ pBufferPriv->pDrawable = NULL;

+ pBufferPriv->pPixmap = NULL;