Import the GLX client side library, formerly from xc/lib/GL/glx. Build it

by adding 'glx/x11' to SRC_DIRS in your build config.

src/glx/x11/Makefile

@@ -0,0 +1,115 @@
+TOP = ../../..
+include $(TOP)/configs/current
+
+# This is a bit messy.  We want this libGL to be capable of loading old
+# interface drivers, so we have to turn off DRI_NEW_INTERFACE_ONLY.  However,
+# glcontextmodes.c is built elsewhere with DNIO on, so we symlink it across.
+# 
+# Furthermore, context creation has evolved over the years, such that this
+# code will not build with DNIO defined.  When we finally drop old interface
+# support in libGL, we need to clean up both glxcmds.c and dri_interface.h.
+
+DEFINES += -DGLX_DIRECT_RENDERING -DGLXEXT -DXF86DRI -DGLX_USE_DLOPEN \
+	-DGLX_USE_MESA -DXF86VIDMODE -D_REENTRANT -UDRI_NEW_INTERFACE_ONLY \
+	-Werror
+
+C_SOURCES = \
+	  $(TOP)/src/mesa/glapi/glapi.c \
+	  $(TOP)/src/mesa/glapi/glthread.c \
+	  glcontextmodes.c \
+	  $(DRM_SOURCE_PATH)/libdrm/xf86drm.c \
+	  $(DRM_SOURCE_PATH)/libdrm/xf86drmHash.c \
+	  $(DRM_SOURCE_PATH)/libdrm/xf86drmRandom.c \
+	  $(DRM_SOURCE_PATH)/libdrm/xf86drmSL.c \
+	  clientattrib.c \
+	  compsize.c \
+	  dispatch.c \
+	  eval.c \
+	  g_render.c \
+	  g_single.c \
+	  g_vendpriv.c \
+	  glxcmds.c \
+	  glxext.c \
+	  glxextensions.c \
+	  indirect_init.c \
+	  pixel.c \
+	  pixelstore.c \
+	  render2.c \
+	  renderpix.c \
+	  single2.c \
+	  singlepix.c \
+	  vertarr.c \
+	  xfont.c \
+	  glx_pbuffer.c \
+	  glx_query.c \
+	  glx_texture_compression.c \
+	  dri_glx.c \
+	  XF86dri.c \
+
+X86_SOURCES = $(TOP)/src/mesa/x86/glapi_x86.S
+
+# ASM_SOURCES = $(X86_SOURCES)
+
+OBJECTS = $(C_SOURCES:.c=.o) \
+	  $(ASM_SOURCES:.S=.o)
+
+INCLUDES = -I. $(INCLUDE_DIRS)
+
+INCLUDE_DIRS = \
+	-I$(TOP)/include \
+	-I$(TOP)/include/GL/internal \
+	-I$(TOP)/src/mesa \
+	-I$(TOP)/src/mesa/main \
+	-I$(TOP)/src/mesa/glapi \
+	-I$(TOP)/src/mesa/math \
+	-I$(TOP)/src/mesa/transform \
+	-I$(TOP)/src/mesa/swrast \
+	-I$(TOP)/src/mesa/swrast_setup \
+	-I$(TOP)/src/mesa/drivers/dri/common \
+	-I$(DRM_SOURCE_PATH)/libdrm \
+	-I$(DRM_SOURCE_PATH)/shared
+
+
+##### RULES #####
+
+.c.o:
+	$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@
+
+.S.o:
+	$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES)  $< -o $@
+
+##### TARGETS #####
+
+default: depend $(LIB_DIR)/$(GL_LIB_NAME)
+
+glcontextmodes.c:
+	ln -s $(TOP)/src/mesa/drivers/dri/common/glcontextmodes.c .
+
+# Make libGL
+$(LIB_DIR)/$(GL_LIB_NAME):  $(OBJECTS) Makefile
+	CC=$(CC) CXX=$(CXX) $(TOP)/bin/mklib -o $(GL_LIB) -major 1 -minor 2 $(MKLIB_OPTIONS) \
+		-install $(LIB_DIR) $(GL_LIB_DEPS) $(OBJECTS)
+
+
+drmtest: xf86drm.o drmtest.o
+	rm -f drmtest && $(CC) -o drmtest xf86drm.o drmtest.o
+
+
+depend: $(C_SOURCES) $(ASM_SOURCES)
+	touch depend
+	$(MKDEP) $(MKDEP_OPTIONS) $(INCLUDES) $(C_SOURCES) $(ASM_SOURCES) \
+		> /dev/null 2>&1
+
+
+# Emacs tags
+tags:
+	etags `find . -name \*.[ch]` `find ../include`
+
+
+# Remove .o and backup files
+clean:
+	-rm -f $(LIB_DIR)/libGL.so*
+	-rm -f *.o *~
+	-rm -f depend
+
+include depend

src/glx/x11/XF86dri.c

@@ -0,0 +1,615 @@
+/* $XFree86: xc/lib/GL/dri/XF86dri.c,v 1.13 2002/10/30 12:51:25 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <martin@valinux.com>
+ *   Jens Owen <jens@tungstengraphics.com>
+ *   Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+#include "xf86dristr.h"
+#include <X11/extensions/Xext.h>
+#include "extutil.h"
+
+static XExtensionInfo _xf86dri_info_data;
+static XExtensionInfo *xf86dri_info = &_xf86dri_info_data;
+static char *xf86dri_extension_name = XF86DRINAME;
+
+#define XF86DRICheckExtension(dpy,i,val) \
+  XextCheckExtension (dpy, i, xf86dri_extension_name, val)
+
+/*****************************************************************************
+ *                                                                           *
+ *			   private utility routines                          *
+ *                                                                           *
+ *****************************************************************************/
+
+static int close_display(Display *dpy, XExtCodes *extCodes);
+static /* const */ XExtensionHooks xf86dri_extension_hooks = {
+    NULL,				/* create_gc */
+    NULL,				/* copy_gc */
+    NULL,				/* flush_gc */
+    NULL,				/* free_gc */
+    NULL,				/* create_font */
+    NULL,				/* free_font */
+    close_display,			/* close_display */
+    NULL,				/* wire_to_event */
+    NULL,				/* event_to_wire */
+    NULL,				/* error */
+    NULL,				/* error_string */
+};
+
+static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86dri_info, 
+				   xf86dri_extension_name, 
+				   &xf86dri_extension_hooks, 
+				   0, NULL)
+
+static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86dri_info)
+
+
+/*****************************************************************************
+ *                                                                           *
+ *		    public XFree86-DRI Extension routines                    *
+ *                                                                           *
+ *****************************************************************************/
+
+#if 0
+#include <stdio.h>
+#define TRACE(msg)  fprintf(stderr,"XF86DRI%s\n", msg);
+#else
+#define TRACE(msg)
+#endif
+
+
+Bool XF86DRIQueryExtension (dpy, event_basep, error_basep)
+    Display *dpy;
+    int *event_basep, *error_basep;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+
+    TRACE("QueryExtension...");
+    if (XextHasExtension(info)) {
+	*event_basep = info->codes->first_event;
+	*error_basep = info->codes->first_error;
+        TRACE("QueryExtension... return True");
+	return True;
+    } else {
+        TRACE("QueryExtension... return False");
+	return False;
+    }
+}
+
+Bool XF86DRIQueryVersion(dpy, majorVersion, minorVersion, patchVersion)
+    Display* dpy;
+    int* majorVersion; 
+    int* minorVersion;
+    int* patchVersion;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIQueryVersionReply rep;
+    xXF86DRIQueryVersionReq *req;
+
+    TRACE("QueryVersion...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIQueryVersion, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIQueryVersion;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("QueryVersion... return False");
+	return False;
+    }
+    *majorVersion = rep.majorVersion;
+    *minorVersion = rep.minorVersion;
+    *patchVersion = rep.patchVersion;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("QueryVersion... return True");
+    return True;
+}
+
+Bool XF86DRIQueryDirectRenderingCapable(dpy, screen, isCapable)
+    Display* dpy;
+    int screen;
+    Bool* isCapable;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIQueryDirectRenderingCapableReply rep;
+    xXF86DRIQueryDirectRenderingCapableReq *req;
+
+    TRACE("QueryDirectRenderingCapable...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIQueryDirectRenderingCapable, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIQueryDirectRenderingCapable;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("QueryDirectRenderingCapable... return False");
+	return False;
+    }
+    *isCapable = rep.isCapable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("QueryDirectRenderingCapable... return True");
+    return True;
+}
+
+Bool XF86DRIOpenConnection(dpy, screen, hSAREA, busIdString)
+    Display* dpy;
+    int screen;
+    drm_handle_t * hSAREA;
+    char **busIdString;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIOpenConnectionReply rep;
+    xXF86DRIOpenConnectionReq *req;
+
+    TRACE("OpenConnection...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIOpenConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIOpenConnection;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("OpenConnection... return False");
+	return False;
+    }
+
+    *hSAREA = rep.hSAREALow;
+#ifdef LONG64
+    *hSAREA |= ((drm_handle_t)rep.hSAREAHigh) << 32;
+#endif
+
+    if (rep.length) {
+        if (!(*busIdString = (char *)Xcalloc(rep.busIdStringLength + 1, 1))) {
+            _XEatData(dpy, ((rep.busIdStringLength+3) & ~3));
+            UnlockDisplay(dpy);
+            SyncHandle();
+            TRACE("OpenConnection... return False");
+            return False;
+        }
+	_XReadPad(dpy, *busIdString, rep.busIdStringLength);
+    } else {
+        *busIdString = NULL;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("OpenConnection... return True");
+    return True;
+}
+
+Bool XF86DRIAuthConnection(dpy, screen, magic)
+    Display* dpy;
+    int screen;
+    drm_magic_t magic;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIAuthConnectionReq *req;
+    xXF86DRIAuthConnectionReply rep;
+
+    TRACE("AuthConnection...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIAuthConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIAuthConnection;
+    req->screen = screen;
+    req->magic = magic;
+    rep.authenticated = 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("AuthConnection... return False");
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("AuthConnection... return True");
+    return True;
+}
+
+Bool XF86DRICloseConnection(dpy, screen)
+    Display* dpy;
+    int screen;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRICloseConnectionReq *req;
+
+    TRACE("CloseConnection...");
+
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRICloseConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRICloseConnection;
+    req->screen = screen;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("CloseConnection... return True");
+    return True;
+}
+
+Bool XF86DRIGetClientDriverName(dpy, screen, ddxDriverMajorVersion, 
+	ddxDriverMinorVersion, ddxDriverPatchVersion, clientDriverName)
+    Display* dpy;
+    int screen;
+    int* ddxDriverMajorVersion;
+    int* ddxDriverMinorVersion;
+    int* ddxDriverPatchVersion;
+    char** clientDriverName;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIGetClientDriverNameReply rep;
+    xXF86DRIGetClientDriverNameReq *req;
+
+    TRACE("GetClientDriverName...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIGetClientDriverName, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIGetClientDriverName;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("GetClientDriverName... return False");
+	return False;
+    }
+
+    *ddxDriverMajorVersion = rep.ddxDriverMajorVersion;
+    *ddxDriverMinorVersion = rep.ddxDriverMinorVersion;
+    *ddxDriverPatchVersion = rep.ddxDriverPatchVersion;
+
+    if (rep.length) {
+        if (!(*clientDriverName = (char *)Xcalloc(rep.clientDriverNameLength + 1, 1))) {
+            _XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));
+            UnlockDisplay(dpy);
+            SyncHandle();
+            TRACE("GetClientDriverName... return False");
+            return False;
+        }
+	_XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
+    } else {
+        *clientDriverName = NULL;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("GetClientDriverName... return True");
+    return True;
+}
+
+Bool XF86DRICreateContextWithConfig(dpy, screen, configID, context, hHWContext)
+    Display* dpy;
+    int screen;
+    int configID;
+    XID* context;
+    drm_context_t * hHWContext;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRICreateContextReply rep;
+    xXF86DRICreateContextReq *req;
+
+    TRACE("CreateContext...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRICreateContext, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRICreateContext;
+    req->visual = configID;
+    req->screen = screen;
+    *context = XAllocID(dpy);
+    req->context = *context;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("CreateContext... return False");
+	return False;
+    }
+    *hHWContext = rep.hHWContext;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("CreateContext... return True");
+    return True;
+}
+
+Bool XF86DRICreateContext(dpy, screen, visual, context, hHWContext)
+    Display* dpy;
+    int screen;
+    Visual* visual;
+    XID* context;
+    drm_context_t * hHWContext;
+{
+    return XF86DRICreateContextWithConfig( dpy, screen, visual->visualid,
+					   context, hHWContext );
+}
+
+GLboolean XF86DRIDestroyContext( __DRInativeDisplay * ndpy, int screen, 
+    __DRIid context )
+{
+    Display * const dpy = (Display *) ndpy;
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIDestroyContextReq *req;
+
+    TRACE("DestroyContext...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIDestroyContext, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIDestroyContext;
+    req->screen = screen;
+    req->context = context;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("DestroyContext... return True");
+    return True;
+}
+
+GLboolean XF86DRICreateDrawable( __DRInativeDisplay * ndpy, int screen, 
+    __DRIid drawable, drm_drawable_t * hHWDrawable )
+{
+    Display * const dpy = (Display *) ndpy;
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRICreateDrawableReply rep;
+    xXF86DRICreateDrawableReq *req;
+
+    TRACE("CreateDrawable...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRICreateDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRICreateDrawable;
+    req->screen = screen;
+    req->drawable = drawable;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("CreateDrawable... return False");
+	return False;
+    }
+    *hHWDrawable = rep.hHWDrawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("CreateDrawable... return True");
+    return True;
+}
+
+GLboolean XF86DRIDestroyDrawable( __DRInativeDisplay * ndpy, int screen,
+    __DRIid drawable )
+{
+    Display * const dpy = (Display *) ndpy;
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIDestroyDrawableReq *req;
+
+    TRACE("DestroyDrawable...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIDestroyDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIDestroyDrawable;
+    req->screen = screen;
+    req->drawable = drawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("DestroyDrawable... return True");
+    return True;
+}
+
+Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
+    unsigned int* index, unsigned int* stamp,
+    int* X, int* Y, int* W, int* H,
+    int* numClipRects, drm_clip_rect_t ** pClipRects,
+    int* backX, int* backY,
+    int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIGetDrawableInfoReply rep;
+    xXF86DRIGetDrawableInfoReq *req;
+    int total_rects;
+
+    TRACE("GetDrawableInfo...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIGetDrawableInfo, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIGetDrawableInfo;
+    req->screen = screen;
+    req->drawable = drawable;
+
+    if (!_XReply(dpy, (xReply *)&rep, 1, xFalse)) 
+    {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("GetDrawableInfo... return False");
+	return False;
+    }
+    *index = rep.drawableTableIndex;
+    *stamp = rep.drawableTableStamp;
+    *X = (int)rep.drawableX;
+    *Y = (int)rep.drawableY;
+    *W = (int)rep.drawableWidth;
+    *H = (int)rep.drawableHeight;
+    *numClipRects = rep.numClipRects;
+    total_rects = *numClipRects;
+
+    *backX = rep.backX;
+    *backY = rep.backY;
+    *numBackClipRects = rep.numBackClipRects;
+    total_rects += *numBackClipRects;
+
+#if 0
+    /* Because of the fix in Xserver/GL/dri/xf86dri.c, this check breaks
+     * backwards compatibility (Because of the >> 2 shift) but the fix
+     * enables multi-threaded apps to work.
+     */
+    if (rep.length !=  ((((SIZEOF(xXF86DRIGetDrawableInfoReply) - 
+		       SIZEOF(xGenericReply) + 
+		       total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {
+        _XEatData(dpy, rep.length);
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("GetDrawableInfo... return False");
+        return False;
+    }
+#endif
+
+    if (*numClipRects) {
+       int len = sizeof(drm_clip_rect_t) * (*numClipRects);
+
+       *pClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
+       if (*pClipRects) 
+	  _XRead(dpy, (char*)*pClipRects, len);
+    } else {
+        *pClipRects = NULL;
+    }
+
+    if (*numBackClipRects) {
+       int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
+
+       *pBackClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
+       if (*pBackClipRects) 
+	  _XRead(dpy, (char*)*pBackClipRects, len);
+    } else {
+        *pBackClipRects = NULL;
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("GetDrawableInfo... return True");
+    return True;
+}
+
+Bool XF86DRIGetDeviceInfo(dpy, screen, hFrameBuffer, 
+	fbOrigin, fbSize, fbStride, devPrivateSize, pDevPrivate)
+    Display* dpy;
+    int screen;
+    drm_handle_t * hFrameBuffer;
+    int* fbOrigin;
+    int* fbSize;
+    int* fbStride;
+    int* devPrivateSize;
+    void** pDevPrivate;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIGetDeviceInfoReply rep;
+    xXF86DRIGetDeviceInfoReq *req;
+
+    TRACE("GetDeviceInfo...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIGetDeviceInfo, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIGetDeviceInfo;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("GetDeviceInfo... return False");
+	return False;
+    }
+
+    *hFrameBuffer = rep.hFrameBufferLow;
+#ifdef LONG64
+    *hFrameBuffer |= ((drm_handle_t)rep.hFrameBufferHigh) << 32;
+#endif
+
+    *fbOrigin = rep.framebufferOrigin;
+    *fbSize = rep.framebufferSize;
+    *fbStride = rep.framebufferStride;
+    *devPrivateSize = rep.devPrivateSize;
+
+    if (rep.length) {
+        if (!(*pDevPrivate = (void *)Xcalloc(rep.devPrivateSize, 1))) {
+            _XEatData(dpy, ((rep.devPrivateSize+3) & ~3));
+            UnlockDisplay(dpy);
+            SyncHandle();
+            TRACE("GetDeviceInfo... return False");
+            return False;
+        }
+	_XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);
+    } else {
+        *pDevPrivate = NULL;
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("GetDeviceInfo... return True");
+    return True;
+}
+
+Bool XF86DRIOpenFullScreen(dpy, screen, drawable)
+    Display* dpy;
+    int screen;
+    Drawable drawable;
+{
+    /* This function and the underlying X protocol are deprecated.
+     */
+    (void) dpy;
+    (void) screen;
+    (void) drawable;
+    return False;
+}
+
+Bool XF86DRICloseFullScreen(dpy, screen, drawable)
+    Display* dpy;
+    int screen;
+    Drawable drawable;
+{
+    /* This function and the underlying X protocol are deprecated.
+     */
+    (void) dpy;
+    (void) screen;
+    (void) drawable;
+    return True;
+}

src/glx/x11/clientattrib.c

@@ -0,0 +1,186 @@
+/* $XFree86: xc/lib/GL/glx/clientattrib.c,v 1.5 2001/03/21 16:04:39 dawes Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include <assert.h>
+#define NEED_GL_FUNCS_WRAPPED
+#include "glxclient.h"
+
+/*****************************************************************************/
+
+void glEnableClientState(GLenum array)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+
+    switch (array) {
+	case GL_COLOR_ARRAY:
+	    ENABLE_ARRAY(state, color);
+	    break;
+	case GL_EDGE_FLAG_ARRAY:
+	    ENABLE_ARRAY(state, edgeFlag);
+	    break;
+	case GL_INDEX_ARRAY:
+	    ENABLE_ARRAY(state, index);
+	    break;
+	case GL_NORMAL_ARRAY:
+	    ENABLE_ARRAY(state, normal);
+	    break;
+	case GL_TEXTURE_COORD_ARRAY:
+	    ENABLE_TEXARRAY(state, state->vertArray.activeTexture);
+	    break;
+	case GL_VERTEX_ARRAY:
+	    ENABLE_ARRAY(state, vertex);
+	    break;
+	case GL_SECONDARY_COLOR_ARRAY:
+	    ENABLE_ARRAY(state, secondaryColor);
+	    break;
+	case GL_FOG_COORD_ARRAY:
+	    ENABLE_ARRAY(state, fogCoord);
+	    break;
+	default:
+	    __glXSetError(gc, GL_INVALID_ENUM);
+    }
+}
+
+void glDisableClientState(GLenum array)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+
+    switch (array) {
+	case GL_COLOR_ARRAY:
+	    DISABLE_ARRAY(state, color);
+	    break;
+	case GL_EDGE_FLAG_ARRAY:
+	    DISABLE_ARRAY(state, edgeFlag);
+	    break;
+	case GL_INDEX_ARRAY:
+	    DISABLE_ARRAY(state, index);
+	    break;
+	case GL_NORMAL_ARRAY:
+	    DISABLE_ARRAY(state, normal);
+	    break;
+	case GL_TEXTURE_COORD_ARRAY:
+	    DISABLE_TEXARRAY(state, state->vertArray.activeTexture);
+	    break;
+	case GL_VERTEX_ARRAY:
+	    DISABLE_ARRAY(state, vertex);
+	    break;
+	case GL_SECONDARY_COLOR_ARRAY:
+	    DISABLE_ARRAY(state, secondaryColor);
+	    break;
+	case GL_FOG_COORD_ARRAY:
+	    DISABLE_ARRAY(state, fogCoord);
+	    break;
+	default:
+	    __glXSetError(gc, GL_INVALID_ENUM);
+    }
+}
+
+/************************************************************************/
+
+void glPushClientAttrib(GLuint mask)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    __GLXattribute **spp = gc->attributes.stackPointer, *sp;
+
+    if (spp < &gc->attributes.stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]) {
+	if (!(sp = *spp)) {
+	    sp = (__GLXattribute *)Xmalloc(sizeof(__GLXattribute));
+	    *spp = sp;
+	}
+	sp->mask = mask;
+	gc->attributes.stackPointer = spp + 1;
+	if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
+	    sp->storePack = state->storePack;
+	    sp->storeUnpack = state->storeUnpack;
+	}
+	if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
+	    sp->vertArray = state->vertArray;
+	}
+    } else {
+	__glXSetError(gc, GL_STACK_OVERFLOW);
+	return;
+    }
+}
+
+void glPopClientAttrib(void)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    __GLXattribute **spp = gc->attributes.stackPointer, *sp;
+    GLuint mask;
+
+    if (spp > &gc->attributes.stack[0]) {
+	--spp;
+	sp = *spp;
+	assert(sp != 0);
+	mask = sp->mask;
+	gc->attributes.stackPointer = spp;
+
+	if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
+	    state->storePack = sp->storePack;
+	    state->storeUnpack = sp->storeUnpack;
+	}
+	if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
+	    state->vertArray = sp->vertArray;
+	}
+
+	sp->mask = 0;
+    } else {
+	__glXSetError(gc, GL_STACK_UNDERFLOW);
+	return;
+    }
+}
+
+void __glFreeAttributeState(__GLXcontext *gc)
+{
+    __GLXattribute *sp, **spp;
+
+    for (spp = &gc->attributes.stack[0];
+         spp < &gc->attributes.stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
+	 spp++) {
+	sp = *spp;
+        if (sp) {
+            XFree((char *)sp);
+        } else {
+            break;
+	}
+    }
+}
+
+

src/glx/x11/compsize.c

@@ -0,0 +1,522 @@
+/* $XFree86: xc/lib/GL/glx/compsize.c,v 1.6 2004/01/28 18:11:38 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include <GL/gl.h>
+#include "glxclient.h"
+#include "size.h"
+
+/*
+** Return the number of elements per group of a specified format
+*/
+GLint __glElementsPerGroup(GLenum format, GLenum type) 
+{
+    /*
+    ** To make row length computation valid for image extraction,
+    ** packed pixel types assume elements per group equals one.
+    */
+    switch(type) {
+    case GL_UNSIGNED_BYTE_3_3_2:
+    case GL_UNSIGNED_BYTE_2_3_3_REV:
+    case GL_UNSIGNED_SHORT_5_6_5:
+    case GL_UNSIGNED_SHORT_5_6_5_REV:
+    case GL_UNSIGNED_SHORT_4_4_4_4:
+    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+    case GL_UNSIGNED_SHORT_5_5_5_1:
+    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+    case GL_UNSIGNED_SHORT_8_8_APPLE:
+    case GL_UNSIGNED_SHORT_8_8_REV_APPLE:
+    case GL_UNSIGNED_SHORT_15_1_MESA:
+    case GL_UNSIGNED_SHORT_1_15_REV_MESA:
+    case GL_UNSIGNED_INT_8_8_8_8:
+    case GL_UNSIGNED_INT_8_8_8_8_REV:
+    case GL_UNSIGNED_INT_10_10_10_2:
+    case GL_UNSIGNED_INT_2_10_10_10_REV:
+    case GL_UNSIGNED_INT_24_8_NV:
+    case GL_UNSIGNED_INT_24_8_MESA:
+    case GL_UNSIGNED_INT_8_24_REV_MESA:
+      return 1;
+    default:
+      break;
+    }
+
+    switch(format) {
+      case GL_RGB:
+      case GL_BGR:
+	return 3;
+      case GL_422_EXT:
+      case GL_422_REV_EXT:
+      case GL_422_AVERAGE_EXT:
+      case GL_422_REV_AVERAGE_EXT:
+      case GL_YCBCR_422_APPLE:
+      case GL_LUMINANCE_ALPHA:
+	return 2;
+      case GL_RGBA:
+      case GL_BGRA:
+      case GL_ABGR_EXT:
+	return 4;
+      case GL_COLOR_INDEX:
+      case GL_STENCIL_INDEX:
+      case GL_DEPTH_COMPONENT:
+      case GL_RED:
+      case GL_GREEN:
+      case GL_BLUE:
+      case GL_ALPHA:
+      case GL_LUMINANCE:
+      case GL_INTENSITY:
+	return 1;
+      default:
+	return 0;
+    }
+}
+
+/*
+** Return the number of bytes per element, based on the element type (other
+** than GL_BITMAP).
+*/
+GLint __glBytesPerElement(GLenum type) 
+{
+    switch(type) {
+      case GL_UNSIGNED_SHORT:
+      case GL_SHORT:
+      case GL_UNSIGNED_SHORT_5_6_5:
+      case GL_UNSIGNED_SHORT_5_6_5_REV:
+      case GL_UNSIGNED_SHORT_4_4_4_4:
+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+      case GL_UNSIGNED_SHORT_5_5_5_1:
+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+      case GL_UNSIGNED_SHORT_8_8_APPLE:
+      case GL_UNSIGNED_SHORT_8_8_REV_APPLE:
+      case GL_UNSIGNED_SHORT_15_1_MESA:
+      case GL_UNSIGNED_SHORT_1_15_REV_MESA:
+	return 2;
+      case GL_UNSIGNED_BYTE:
+      case GL_BYTE:
+      case GL_UNSIGNED_BYTE_3_3_2:
+      case GL_UNSIGNED_BYTE_2_3_3_REV:
+	return 1;
+      case GL_INT:
+      case GL_UNSIGNED_INT:
+      case GL_FLOAT:
+      case GL_UNSIGNED_INT_8_8_8_8:
+      case GL_UNSIGNED_INT_8_8_8_8_REV:
+      case GL_UNSIGNED_INT_10_10_10_2:
+      case GL_UNSIGNED_INT_2_10_10_10_REV:
+      case GL_UNSIGNED_INT_24_8_NV:
+      case GL_UNSIGNED_INT_24_8_MESA:
+      case GL_UNSIGNED_INT_8_24_REV_MESA:
+	return 4;
+      default:
+	return 0;
+    }
+}
+
+/*
+** Compute memory required for internal packed array of data of given type
+** and format.
+*/
+GLint __glImageSize(GLsizei width, GLsizei height, GLsizei depth,
+		    GLenum format, GLenum type) 
+{
+    int bytes_per_row;
+    int components;
+
+    if (width < 0 || height < 0 || depth < 0) {
+	return 0;
+    }
+    /*
+    ** Zero is returned if either format or type are invalid.
+    */
+    components = __glElementsPerGroup(format,type);
+    if (type == GL_BITMAP) {
+	if (format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX) {
+	    bytes_per_row = (width + 7) >> 3;
+	} else {
+	    return 0;
+	}
+    } else {
+	bytes_per_row = __glBytesPerElement(type) * width;
+    }
+    return bytes_per_row * height * depth * components;
+}
+
+GLint __glFogiv_size(GLenum pname)
+{
+    switch (pname) {
+      case GL_FOG_COLOR:	return 4;
+      case GL_FOG_DENSITY:	return 1;
+      case GL_FOG_END:		return 1;
+      case GL_FOG_MODE:		return 1;
+      case GL_FOG_INDEX:	return 1;
+      case GL_FOG_START:	return 1;
+      case GL_FOG_DISTANCE_MODE_NV: return 1;
+      case GL_FOG_OFFSET_VALUE_SGIX: return 1;
+      default:
+	return 0;
+    }
+}
+
+GLint __glFogfv_size(GLenum pname)
+{
+    return __glFogiv_size(pname);
+}
+
+GLint __glCallLists_size(GLsizei n, GLenum type)
+{
+    GLint size;
+
+    if (n < 0) return 0;
+    switch (type) {
+      case GL_BYTE:		size = 1; break;
+      case GL_UNSIGNED_BYTE:	size = 1; break;
+      case GL_SHORT:		size = 2; break;
+      case GL_UNSIGNED_SHORT:	size = 2; break;
+      case GL_INT:		size = 4; break;
+      case GL_UNSIGNED_INT:	size = 4; break;
+      case GL_FLOAT:		size = 4; break;
+      case GL_2_BYTES:		size = 2; break;
+      case GL_3_BYTES:		size = 3; break;
+      case GL_4_BYTES:		size = 4; break;
+      default:
+	return 0;
+    }
+    return n * size;
+}
+
+GLint __glDrawPixels_size(GLenum format, GLenum type, GLsizei w, GLsizei h)
+{
+    return __glImageSize( w, h, 1, format, type );
+}
+
+GLint __glBitmap_size(GLsizei w, GLsizei h)
+{
+    return __glDrawPixels_size(GL_COLOR_INDEX, GL_BITMAP, w, h);
+}
+
+GLint __glTexGendv_size(GLenum e)
+{
+    switch (e) {
+      case GL_TEXTURE_GEN_MODE:
+	return 1;
+      case GL_OBJECT_PLANE:
+      case GL_EYE_PLANE:
+	return 4;
+      default:
+	return 0;
+    }
+}
+
+GLint __glTexGenfv_size(GLenum e)
+{
+    return __glTexGendv_size(e);
+}
+
+GLint __glTexGeniv_size(GLenum e)
+{
+    return __glTexGendv_size(e);
+}
+
+GLint __glTexParameterfv_size(GLenum e)
+{
+    switch (e) {
+      case GL_TEXTURE_WRAP_S:
+      case GL_TEXTURE_WRAP_T:
+      case GL_TEXTURE_WRAP_R:
+      case GL_TEXTURE_MIN_FILTER:
+      case GL_TEXTURE_MAG_FILTER:
+      case GL_TEXTURE_PRIORITY:
+      case GL_TEXTURE_RESIDENT:
+       
+      /* GL_SGIS_texture_lod / GL_EXT_texture_lod / GL 1.2 */
+      case GL_TEXTURE_MIN_LOD:
+      case GL_TEXTURE_MAX_LOD:
+      case GL_TEXTURE_BASE_LEVEL:
+      case GL_TEXTURE_MAX_LEVEL:
+
+      /* GL_SGIX_texture_lod_bias */
+      case GL_TEXTURE_LOD_BIAS_S_SGIX:
+      case GL_TEXTURE_LOD_BIAS_T_SGIX:
+      case GL_TEXTURE_LOD_BIAS_R_SGIX:
+
+      /* GL_ARB_shadow / GL 1.4 */
+      case GL_TEXTURE_COMPARE_MODE:
+      case GL_TEXTURE_COMPARE_FUNC:
+
+      /* GL_SGIS_generate_mipmap / GL 1.4 */
+      case GL_GENERATE_MIPMAP:
+
+      /* GL_ARB_depth_texture / GL 1.4 */
+      case GL_DEPTH_TEXTURE_MODE:
+
+      /* GL_EXT_texture_lod_bias / GL 1.4 */
+      case GL_TEXTURE_LOD_BIAS:
+
+      /* GL_SGIX_shadow_ambient / GL_ARB_shadow_ambient */
+      case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+
+      /* GL_SGIX_shadow */
+      case GL_TEXTURE_COMPARE_SGIX:
+      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
+
+      /* GL_SGIX_texture_coordinate_clamp */
+      case GL_TEXTURE_MAX_CLAMP_S_SGIX:
+      case GL_TEXTURE_MAX_CLAMP_T_SGIX:
+      case GL_TEXTURE_MAX_CLAMP_R_SGIX:
+
+      /* GL_EXT_texture_filter_anisotropic */
+      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+
+      /* GL_NV_texture_expand_normal */
+      case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
+	return 1;
+
+      /* GL_SGIX_clipmap */
+      case GL_TEXTURE_CLIPMAP_CENTER_SGIX:
+      case GL_TEXTURE_CLIPMAP_OFFSET_SGIX:
+	return 2;
+
+      /* GL_SGIX_clipmap */
+      case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX:
+	return 3;
+
+      case GL_TEXTURE_BORDER_COLOR:
+
+      /* GL_SGIX_texture_scale_bias */
+      case GL_POST_TEXTURE_FILTER_BIAS_SGIX:
+      case GL_POST_TEXTURE_FILTER_SCALE_SGIX:
+	return 4;
+
+      default:
+	return 0;
+    }
+}
+
+GLint __glTexParameteriv_size(GLenum e)
+{
+    return __glTexParameterfv_size(e);
+}
+
+GLint __glTexEnvfv_size(GLenum e)
+{
+    switch (e) {
+      case GL_TEXTURE_ENV_MODE:
+
+      /* GL_ARB_texture_env_combine / GL_EXT_texture_env_combine / GL 1.3 */
+      case GL_COMBINE_RGB:
+      case GL_COMBINE_ALPHA:
+      case GL_SOURCE0_RGB:
+      case GL_SOURCE1_RGB:
+      case GL_SOURCE2_RGB:
+      case GL_SOURCE0_ALPHA:
+      case GL_SOURCE1_ALPHA:
+      case GL_SOURCE2_ALPHA:
+      case GL_OPERAND0_RGB:
+      case GL_OPERAND1_RGB:
+      case GL_OPERAND0_ALPHA:
+      case GL_OPERAND1_ALPHA:
+      case GL_OPERAND2_RGB:
+      case GL_OPERAND2_ALPHA:
+      case GL_RGB_SCALE:
+      case GL_ALPHA_SCALE:
+
+      /* GL_EXT_texture_lod_bias / GL 1.4 */
+      case GL_TEXTURE_LOD_BIAS:
+
+      /* GL_ARB_point_sprite / GL_NV_point_sprite */
+      case GL_COORD_REPLACE_ARB:
+
+      /* GL_NV_texture_env_combine4 */
+      case GL_SOURCE3_RGB_NV:
+      case GL_SOURCE3_ALPHA_NV:
+      case GL_OPERAND3_RGB_NV:
+      case GL_OPERAND3_ALPHA_NV:
+        return 1;
+
+      case GL_TEXTURE_ENV_COLOR:
+	return 4;
+
+      default:
+	return 0;
+    }
+}
+
+GLint __glTexEnviv_size(GLenum e)
+{
+    return __glTexEnvfv_size(e);
+}
+
+GLint __glTexImage1D_size(GLenum format, GLenum type, GLsizei w)
+{
+    return __glImageSize( w, 1, 1, format, type );
+}
+
+GLint __glTexImage2D_size(GLenum format, GLenum type, GLsizei w, GLsizei h)
+{
+    return __glImageSize( w, h, 1, format, type );
+}
+
+GLint __glTexImage3D_size(GLenum format, GLenum type, GLsizei w, GLsizei h,
+			  GLsizei d)
+{
+    return __glImageSize( w, h, d, format, type );
+}
+
+GLint __glLightfv_size(GLenum pname)
+{
+    switch (pname) {
+      case GL_SPOT_EXPONENT:		return 1;
+      case GL_SPOT_CUTOFF:		return 1;
+      case GL_AMBIENT:			return 4;
+      case GL_DIFFUSE:			return 4;
+      case GL_SPECULAR:			return 4;
+      case GL_POSITION:			return 4;
+      case GL_SPOT_DIRECTION:		return 3;
+      case GL_CONSTANT_ATTENUATION:	return 1;
+      case GL_LINEAR_ATTENUATION:	return 1;
+      case GL_QUADRATIC_ATTENUATION:	return 1;
+      default:
+	return 0;
+    }
+}
+
+GLint __glLightiv_size(GLenum pname)
+{
+    return __glLightfv_size(pname);
+}
+
+GLint __glLightModelfv_size(GLenum pname)
+{
+    switch (pname) {
+      case GL_LIGHT_MODEL_AMBIENT:		return 4;
+      case GL_LIGHT_MODEL_LOCAL_VIEWER:		return 1;
+      case GL_LIGHT_MODEL_TWO_SIDE:		return 1;
+      case GL_LIGHT_MODEL_COLOR_CONTROL:	return 1;
+      default:
+	return 0;
+    }
+}
+
+GLint __glLightModeliv_size(GLenum pname)
+{
+    return __glLightModelfv_size(pname);
+}
+
+GLint __glMaterialfv_size(GLenum pname)
+{
+    switch (pname) {
+      case GL_SHININESS:		return 1;
+      case GL_EMISSION:			return 4;
+      case GL_AMBIENT:			return 4;
+      case GL_DIFFUSE:			return 4;
+      case GL_SPECULAR:			return 4;
+      case GL_AMBIENT_AND_DIFFUSE:	return 4;
+      case GL_COLOR_INDEXES:		return 3;
+      default:
+	return 0;
+    }
+}
+
+GLint __glMaterialiv_size(GLenum pname)
+{
+    return __glMaterialfv_size(pname);
+}
+
+GLint __glColorTableParameterfv_size(GLenum pname)
+{
+    switch (pname) {
+      case GL_COLOR_TABLE_FORMAT:
+      case GL_COLOR_TABLE_WIDTH:
+      case GL_COLOR_TABLE_RED_SIZE:
+      case GL_COLOR_TABLE_GREEN_SIZE:
+      case GL_COLOR_TABLE_BLUE_SIZE:
+      case GL_COLOR_TABLE_ALPHA_SIZE:
+      case GL_COLOR_TABLE_LUMINANCE_SIZE:
+      case GL_COLOR_TABLE_INTENSITY_SIZE:
+	return 1;
+      case GL_COLOR_TABLE_SCALE:
+      case GL_COLOR_TABLE_BIAS:
+	return 4;
+      default:
+	return -1;
+    }
+}
+
+GLint __glColorTableParameteriv_size(GLenum pname)
+{
+    return __glColorTableParameterfv_size(pname);
+}
+
+GLint __glConvolutionParameterfv_size(GLenum pname)
+{
+    switch(pname) {
+      case GL_CONVOLUTION_BORDER_MODE:
+	return 1;
+      case GL_CONVOLUTION_BORDER_COLOR:
+      case GL_CONVOLUTION_FILTER_SCALE:
+      case GL_CONVOLUTION_FILTER_BIAS:
+	return 4;
+      default: /* error: bad enum value */
+	return -1;
+    }
+}
+
+GLint __glConvolutionParameteriv_size(GLenum pname)
+{
+    return __glConvolutionParameterfv_size(pname);
+}
+
+GLint __glPointParameterfvARB_size(GLenum e)
+{
+    switch (e) {
+      case GL_POINT_SIZE_MIN:
+      case GL_POINT_SIZE_MAX:
+      case GL_POINT_FADE_THRESHOLD_SIZE:
+
+      /* GL_NV_point_sprite */
+      case GL_POINT_SPRITE_R_MODE_NV:
+        return 1;
+
+      case GL_POINT_DISTANCE_ATTENUATION:
+	return 3;
+
+      default:
+        return -1;
+    }
+}
+
+GLint __glPointParameteriv_size(GLenum e)
+{
+    return __glPointParameterfvARB_size(e);
+}

src/glx/x11/dispatch.c

@@ -0,0 +1,73 @@
+/* $XFree86: xc/lib/GL/glx/dispatch.c,v 1.5 2003/06/30 01:45:10 torrey Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Brian Paul <brian@precisioninsight.com>
+ *
+ */
+
+#ifndef GLX_USE_APPLEGL
+
+#include <GL/gl.h>
+#include "glapi.h"
+#include "glapitable.h"
+
+
+/*
+ * NOTE: this file implements C-based dispatch of the OpenGL entrypoints
+ * (glAccum, glBegin, etc).
+ * This code IS NOT USED if we're compiling on an x86 system and using
+ * the glapi_x86.S assembly code.
+ */
+
+
+#if !(defined(USE_X86_ASM) || defined(USE_SPARC_ASM))
+
+#define KEYWORD1
+
+#define KEYWORD2
+
+#define NAME(func) gl##func
+
+#define DISPATCH(func, args, msg)					\
+   const struct _glapi_table *dispatch;					\
+   dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
+   (dispatch->func) args
+
+#define RETURN_DISPATCH(func, args, msg) 				\
+   const struct _glapi_table *dispatch;					\
+   dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
+   return (dispatch->func) args
+
+
+#include "glapitemp.h"
+
+#endif /* USE_X86_ASM */
+
+#endif /* !GLX_USE_APPLEGL */

src/glx/x11/dri_glx.c

@@ -0,0 +1,475 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+/* $XFree86: xc/lib/GL/dri/dri_glx.c,v 1.14 2003/07/16 00:54:00 dawes Exp $ */
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *   Brian Paul <brian@precisioninsight.com>
+ *
+ */
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <unistd.h>
+#include <X11/Xlibint.h>
+#include <X11/extensions/Xext.h>
+#include "extutil.h"
+#include "glxclient.h"
+#include "xf86dri.h"
+#include "sarea.h"
+#include <stdio.h>
+#include <dlfcn.h>
+#include "dri_glx.h"
+#include <sys/types.h>
+#include <stdarg.h>
+
+#ifndef RTLD_NOW
+#define RTLD_NOW 0
+#endif
+#ifndef RTLD_GLOBAL
+#define RTLD_GLOBAL 0
+#endif
+
+#ifdef BUILT_IN_DRI_DRIVER
+
+extern void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
+                               int numConfigs, __GLXvisualConfig *config);
+
+
+#else /* BUILT_IN_DRI_DRIVER */
+
+
+#ifndef DEFAULT_DRIVER_DIR
+/* this is normally defined in the Imakefile */
+#define DEFAULT_DRIVER_DIR "/usr/X11R6/lib/modules/dri"
+#endif
+
+static __DRIdriver *Drivers = NULL;
+
+
+/*
+ * printf wrappers
+ */
+
+static void InfoMessageF(const char *f, ...)
+{
+    va_list args;
+    const char *env;
+
+    if ((env = getenv("LIBGL_DEBUG")) && strstr(env, "verbose")) {
+	fprintf(stderr, "libGL: ");
+	va_start(args, f);
+	vfprintf(stderr, f, args);
+	va_end(args);
+    }
+}
+
+static void ErrorMessageF(const char *f, ...)
+{
+    va_list args;
+
+    if (getenv("LIBGL_DEBUG")) {
+	fprintf(stderr, "libGL error: ");
+	va_start(args, f);
+	vfprintf(stderr, f, args);
+	va_end(args);
+    }
+}
+
+
+/*
+ * We'll save a pointer to this function when we couldn't find a
+ * direct rendering driver for a given screen.
+ */
+static void *DummyCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
+                               int numConfigs, __GLXvisualConfig *config)
+{
+    (void) dpy;
+    (void) scrn;
+    (void) psc;
+    (void) numConfigs;
+    (void) config;
+    return NULL;
+}
+
+
+
+/*
+ * Extract the ith directory path out of a colon-separated list of
+ * paths.
+ * Input:
+ *   index - index of path to extract (starting at zero)
+ *   paths - the colon-separated list of paths
+ *   dirLen - max length of result to store in <dir>
+ * Output:
+ *   dir - the extracted directory path, dir[0] will be zero when
+ *         extraction fails.
+ */
+static void ExtractDir(int index, const char *paths, int dirLen, char *dir)
+{
+   int i, len;
+   const char *start, *end;
+
+   /* find ith colon */
+   start = paths;
+   i = 0;
+   while (i < index) {
+      if (*start == ':') {
+         i++;
+         start++;
+      }
+      else if (*start == 0) {
+         /* end of string and couldn't find ith colon */
+         dir[0] = 0;
+         return;
+      }
+      else {
+         start++;
+      }
+   }
+
+   while (*start == ':')
+      start++;
+
+   /* find next colon, or end of string */
+   end = start + 1;
+   while (*end != ':' && *end != 0) {
+      end++;
+   }
+
+   /* copy string between <start> and <end> into result string */
+   len = end - start;
+   if (len > dirLen - 1)
+      len = dirLen - 1;
+   strncpy(dir, start, len);
+   dir[len] = 0;
+}
+
+
+/*
+ * Try to dlopen() the named driver.  This function adds the
+ * "_dri.so" suffix to the driver name and searches the
+ * directories specified by the LIBGL_DRIVERS_PATH env var
+ * in order to find the driver.
+ * Input:
+ *   driverName - a name like "tdfx", "i810", "mga", etc.
+ * Return:
+ *   handle from dlopen, or NULL if driver file not found.
+ */
+static __DRIdriver *OpenDriver(const char *driverName)
+{
+   char *libPaths = NULL;
+   int i;
+   __DRIdriver *driver;
+
+   /* First, search Drivers list to see if we've already opened this driver */
+   for (driver = Drivers; driver; driver = driver->next) {
+      if (strcmp(driver->name, driverName) == 0) {
+         /* found it */
+         return driver;
+      }
+   }
+
+   if (geteuid() == getuid()) {
+      /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
+      libPaths = getenv("LIBGL_DRIVERS_PATH");
+      if (!libPaths)
+         libPaths = getenv("LIBGL_DRIVERS_DIR"); /* deprecated */
+   }
+   if (!libPaths)
+      libPaths = DEFAULT_DRIVER_DIR;
+
+   for (i = 0; ; i++) {
+      char libDir[1000], realDriverName[200];
+      void *handle;
+      ExtractDir(i, libPaths, 1000, libDir);
+      if (!libDir[0])
+         break; /* ran out of paths to search */
+      snprintf(realDriverName, 200, "%s/%s_dri.so", libDir, driverName);
+      InfoMessageF("OpenDriver: trying %s\n", realDriverName);
+      handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
+      if (handle) {
+         /* allocate __DRIdriver struct */
+         driver = (__DRIdriver *) Xmalloc(sizeof(__DRIdriver));
+         if (!driver)
+            return NULL; /* out of memory! */
+         /* init the struct */
+         driver->name = __glXstrdup(driverName);
+         if (!driver->name) {
+            Xfree(driver);
+            return NULL; /* out of memory! */
+         }
+
+         driver->createScreenFunc = (CreateScreenFunc)
+            dlsym(handle, "__driCreateScreen");
+         driver->createNewScreenFunc = (CreateNewScreenFunc)
+            dlsym(handle, "__driCreateNewScreen");
+
+         if ( (driver->createScreenFunc == NULL) 
+	      && (driver->createNewScreenFunc == NULL) ) {
+            /* If the driver doesn't have this symbol then something's
+             * really, really wrong.
+             */
+            ErrorMessageF("Neither __driCreateScreen or __driCreateNewScreen "
+			  "are defined in %s_dri.so!\n", driverName);
+            Xfree(driver);
+            dlclose(handle);
+            continue;
+         }
+         driver->handle = handle;
+         /* put at head of linked list */
+         driver->next = Drivers;
+         Drivers = driver;
+         return driver;
+      }
+      else {
+	 ErrorMessageF("dlopen %s failed (%s)\n", realDriverName, dlerror());
+      }
+   }
+
+   ErrorMessageF("unable to find driver: %s_dri.so\n", driverName);
+   return NULL;
+}
+
+
+/*
+ * Given a display pointer and screen number, determine the name of
+ * the DRI driver for the screen. (I.e. "r128", "tdfx", etc).
+ * Return True for success, False for failure.
+ */
+static Bool GetDriverName(Display *dpy, int scrNum, char **driverName)
+{
+   int directCapable;
+   Bool b;
+   int driverMajor, driverMinor, driverPatch;
+
+   *driverName = NULL;
+
+   if (!XF86DRIQueryDirectRenderingCapable(dpy, scrNum, &directCapable)) {
+      ErrorMessageF("XF86DRIQueryDirectRenderingCapable failed\n");
+      return False;
+   }
+   if (!directCapable) {
+      ErrorMessageF("XF86DRIQueryDirectRenderingCapable returned false\n");
+      return False;
+   }
+
+   b = XF86DRIGetClientDriverName(dpy, scrNum, &driverMajor, &driverMinor,
+                                  &driverPatch, driverName);
+   if (!b) {
+      ErrorMessageF("Cannot determine driver name for screen %d\n", scrNum);
+      return False;
+   }
+
+   InfoMessageF("XF86DRIGetClientDriverName: %d.%d.%d %s (screen %d)\n",
+	     driverMajor, driverMinor, driverPatch, *driverName, scrNum);
+
+   return True;
+}
+
+
+/*
+ * Given a display pointer and screen number, return a __DRIdriver handle.
+ * Return NULL if anything goes wrong.
+ */
+__DRIdriver *driGetDriver(Display *dpy, int scrNum)
+{
+   char *driverName;
+   if (GetDriverName(dpy, scrNum, &driverName)) {
+      __DRIdriver *ret;
+      ret = OpenDriver(driverName);
+      if (driverName)
+     	 Xfree(driverName);
+      return ret;
+   }
+   return NULL;
+}
+
+
+/*
+ * Exported function for querying the DRI driver for a given screen.
+ *
+ * The returned char pointer points to a static array that will be
+ * overwritten by subsequent calls.
+ */
+const char *glXGetScreenDriver (Display *dpy, int scrNum) {
+   static char ret[32];
+   char *driverName;
+   if (GetDriverName(dpy, scrNum, &driverName)) {
+      int len;
+      if (!driverName)
+	 return NULL;
+      len = strlen (driverName);
+      if (len >= 31)
+	 return NULL;
+      memcpy (ret, driverName, len+1);
+      Xfree(driverName);
+      return ret;
+   }
+   return NULL;
+}
+
+
+/*
+ * Exported function for obtaining a driver's option list (UTF-8 encoded XML).
+ *
+ * The returned char pointer points directly into the driver. Therefore
+ * it should be treated as a constant.
+ *
+ * If the driver was not found or does not support configuration NULL is
+ * returned.
+ *
+ * Note: The driver remains opened after this function returns.
+ */
+const char *glXGetDriverConfig (const char *driverName) {
+   __DRIdriver *driver = OpenDriver (driverName);
+   if (driver)
+      return dlsym (driver->handle, "__driConfigOptions");
+   else
+      return NULL;
+}
+
+
+#endif /* BUILT_IN_DRI_DRIVER */
+
+
+/* This function isn't currently used.
+ */
+static void driDestroyDisplay(Display *dpy, void *private)
+{
+    __DRIdisplayPrivate *pdpyp = (__DRIdisplayPrivate *)private;
+
+    if (pdpyp) {
+        const int numScreens = ScreenCount(dpy);
+        int i;
+        for (i = 0; i < numScreens; i++) {
+            if (pdpyp->libraryHandles[i])
+                dlclose(pdpyp->libraryHandles[i]);
+        }
+        Xfree(pdpyp->libraryHandles);
+	Xfree(pdpyp);
+    }
+}
+
+
+/*
+ * Allocate, initialize and return a __DRIdisplayPrivate object.
+ * This is called from __glXInitialize() when we are given a new
+ * display pointer.
+ */
+void *driCreateDisplay(Display *dpy, __DRIdisplay *pdisp)
+{
+    const int numScreens = ScreenCount(dpy);
+    __DRIdisplayPrivate *pdpyp;
+    int eventBase, errorBase;
+    int major, minor, patch;
+    int scrn;
+
+    /* Initialize these fields to NULL in case we fail.
+     * If we don't do this we may later get segfaults trying to free random
+     * addresses when the display is closed.
+     */
+    pdisp->private = NULL;
+    pdisp->destroyDisplay = NULL;
+    pdisp->createScreen = NULL;
+
+    if (!XF86DRIQueryExtension(dpy, &eventBase, &errorBase)) {
+	return NULL;
+    }
+
+    if (!XF86DRIQueryVersion(dpy, &major, &minor, &patch)) {
+	return NULL;
+    }
+
+    pdpyp = (__DRIdisplayPrivate *)Xmalloc(sizeof(__DRIdisplayPrivate));
+    if (!pdpyp) {
+	return NULL;
+    }
+
+    pdpyp->driMajor = major;
+    pdpyp->driMinor = minor;
+    pdpyp->driPatch = patch;
+
+    pdisp->destroyDisplay = driDestroyDisplay;
+
+    /* allocate array of pointers to createScreen funcs */
+    pdisp->createScreen = (CreateScreenFunc *) Xmalloc(numScreens * sizeof(void *));
+    if (!pdisp->createScreen) {
+       Xfree(pdpyp);
+       return NULL;
+    }
+
+    /* allocate array of pointers to createScreen funcs */
+    pdisp->createNewScreen = (CreateNewScreenFunc *) Xmalloc(numScreens * sizeof(void *));
+    if (!pdisp->createNewScreen) {
+       Xfree(pdisp->createScreen);
+       Xfree(pdpyp);
+       return NULL;
+    }
+
+    /* allocate array of library handles */
+    pdpyp->libraryHandles = (void **) Xmalloc(numScreens * sizeof(void*));
+    if (!pdpyp->libraryHandles) {
+       Xfree(pdisp->createNewScreen);
+       Xfree(pdisp->createScreen);
+       Xfree(pdpyp);
+       return NULL;
+    }
+
+#ifdef BUILT_IN_DRI_DRIVER
+    /* we'll statically bind to the built-in __driCreateScreen function */
+    for (scrn = 0; scrn < numScreens; scrn++) {
+       pdisp->createScreen[scrn] = __driCreateScreen;
+       pdisp->createNewScreen[scrn] = NULL;
+       pdpyp->libraryHandles[scrn] = NULL;
+    }
+
+#else
+    /* dynamically discover DRI drivers for all screens, saving each
+     * driver's "__driCreateScreen" function pointer.  That's the bootstrap
+     * entrypoint for all DRI drivers.
+     */
+    for (scrn = 0; scrn < numScreens; scrn++) {
+        __DRIdriver *driver = driGetDriver(dpy, scrn);
+        if (driver) {
+           pdisp->createScreen[scrn] = driver->createScreenFunc;
+           pdisp->createNewScreen[scrn] = driver->createNewScreenFunc;
+           pdpyp->libraryHandles[scrn] = driver->handle;
+        }
+        else {
+           pdisp->createScreen[scrn] = DummyCreateScreen;
+           pdisp->createNewScreen[scrn] = NULL;
+           pdpyp->libraryHandles[scrn] = NULL;
+        }
+    }
+#endif
+
+    return (void *)pdpyp;
+}
+
+#endif /* GLX_DIRECT_RENDERING */

src/glx/x11/dri_glx.h

@@ -0,0 +1,61 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *   Brian Paul <brian@precisioninsight.com>
+ *
+ */
+
+#ifndef _DRI_GLX_H_
+#define _DRI_GLX_H_
+
+#ifdef GLX_DIRECT_RENDERING
+
+struct __DRIdisplayPrivateRec {
+    /*
+    ** XFree86-DRI version information
+    */
+    int driMajor;
+    int driMinor;
+    int driPatch;
+
+    /*
+    ** Array of library handles [indexed by screen number]
+    */
+    void **libraryHandles;
+};
+
+typedef struct __DRIdisplayPrivateRec  __DRIdisplayPrivate;
+typedef struct __DRIscreenPrivateRec   __DRIscreenPrivate;
+typedef struct __DRIvisualPrivateRec   __DRIvisualPrivate;
+typedef struct __DRIcontextPrivateRec  __DRIcontextPrivate;
+typedef struct __DRIdrawablePrivateRec __DRIdrawablePrivate;
+
+#endif
+#endif /* _DRI_GLX_H_ */

src/glx/x11/eval.c

@@ -0,0 +1,162 @@
+/* $XFree86$ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+
+/*
+** Routines to pack evaluator maps into the transport buffer.  Maps are
+** allowed to have extra arbitrary data, so these routines extract just
+** the information that the GL needs.
+*/
+
+void __glFillMap1f(GLint k, GLint order, GLint stride, 
+		   const GLfloat *points, GLubyte *pc)
+{
+    if (stride == k) {
+	/* Just copy the data */
+	__GLX_PUT_FLOAT_ARRAY(0, points, order * k);
+    } else {
+	GLint i;
+
+	for (i = 0; i < order; i++) {
+	    __GLX_PUT_FLOAT_ARRAY(0, points, k);
+	    points += stride;
+	    pc += k * __GLX_SIZE_FLOAT32;
+	}
+    }
+}
+
+void __glFillMap1d(GLint k, GLint order, GLint stride, 
+		   const GLdouble *points, GLubyte *pc)
+{
+    if (stride == k) {
+	/* Just copy the data */
+	__GLX_PUT_DOUBLE_ARRAY(0, points, order * k);
+    } else {
+	GLint i;
+	for (i = 0; i < order; i++) {
+            __GLX_PUT_DOUBLE_ARRAY(0, points, k);
+	    points += stride;
+	    pc += k * __GLX_SIZE_FLOAT64;
+	}
+    }
+}
+
+void __glFillMap2f(GLint k, GLint majorOrder, GLint minorOrder, 
+		   GLint majorStride, GLint minorStride,
+		   const GLfloat *points, GLfloat *data)
+{
+    GLint i, j, x;
+
+    if ((minorStride == k) && (majorStride == minorOrder*k)) {
+	/* Just copy the data */
+	__GLX_MEM_COPY(data, points, majorOrder * majorStride *
+		       __GLX_SIZE_FLOAT32);
+	return;
+    }
+    for (i = 0; i < majorOrder; i++) {
+	for (j = 0; j < minorOrder; j++) {
+	    for (x = 0; x < k; x++) {
+		data[x] = points[x];
+	    }
+	    points += minorStride;
+	    data += k;
+	}
+	points += majorStride - minorStride * minorOrder;
+    }
+}
+
+void __glFillMap2d(GLint k, GLint majorOrder, GLint minorOrder, 
+		   GLint majorStride, GLint minorStride,
+		   const GLdouble *points, GLdouble *data)
+{
+    int i,j,x;
+
+    if ((minorStride == k) && (majorStride == minorOrder*k)) {
+	/* Just copy the data */
+	__GLX_MEM_COPY(data, points, majorOrder * majorStride *
+		       __GLX_SIZE_FLOAT64);
+	return;
+    }
+
+#ifdef __GLX_ALIGN64
+    x = k * __GLX_SIZE_FLOAT64;
+#endif
+    for (i = 0; i<majorOrder; i++) {
+	for (j = 0; j<minorOrder; j++) {
+#ifdef __GLX_ALIGN64
+	    __GLX_MEM_COPY(data, points, x);
+#else
+	    for (x = 0; x<k; x++) {
+		data[x] = points[x];
+	    }
+#endif
+	    points += minorStride;
+	    data += k;
+	}
+	points += majorStride - minorStride * minorOrder;
+    }
+}
+
+GLint __glEvalComputeK(GLenum target)
+{
+    switch(target) {
+      case GL_MAP1_VERTEX_4:
+      case GL_MAP1_COLOR_4:
+      case GL_MAP1_TEXTURE_COORD_4:
+      case GL_MAP2_VERTEX_4:
+      case GL_MAP2_COLOR_4:
+      case GL_MAP2_TEXTURE_COORD_4:
+	return 4;
+      case GL_MAP1_VERTEX_3:
+      case GL_MAP1_TEXTURE_COORD_3:
+      case GL_MAP1_NORMAL:
+      case GL_MAP2_VERTEX_3:
+      case GL_MAP2_TEXTURE_COORD_3:
+      case GL_MAP2_NORMAL:
+	return 3;
+      case GL_MAP1_TEXTURE_COORD_2:
+      case GL_MAP2_TEXTURE_COORD_2:
+	return 2;
+      case GL_MAP1_TEXTURE_COORD_1:
+      case GL_MAP2_TEXTURE_COORD_1:
+      case GL_MAP1_INDEX:
+      case GL_MAP2_INDEX:
+	return 1;
+      default:
+	return 0;
+    }
+}

src/glx/x11/g_render.c

@@ -0,0 +1,819 @@
+/* $XFree86: xc/lib/GL/glx/g_render.c,v 1.8 2004/01/28 18:11:38 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#include "packrender.h"
+#include "size.h"
+
+#define GLdouble_SIZE   8
+#define GLclampd_SIZE   8
+#define GLfloat_SIZE    4
+#define GLclampf_SIZE   4
+#define GLint_SIZE      4
+#define GLuint_SIZE     4
+#define GLenum_SIZE     4
+#define GLbitfield_SIZE 4
+#define GLshort_SIZE    2
+#define GLushort_SIZE   2
+#define GLbyte_SIZE     1
+#define GLubyte_SIZE    1
+#define GLboolean_SIZE  1
+
+#define __GLX_PUT_GLdouble(offset,value)   __GLX_PUT_DOUBLE(offset,value)
+#define __GLX_PUT_GLclampd(offset,value)   __GLX_PUT_DOUBLE(offset,value)
+#define __GLX_PUT_GLfloat(offset,value)    __GLX_PUT_FLOAT(offset,value)
+#define __GLX_PUT_GLclampf(offset,value)   __GLX_PUT_FLOAT(offset,value)
+#define __GLX_PUT_GLint(offset,value)      __GLX_PUT_LONG(offset,value)
+#define __GLX_PUT_GLuint(offset,value)     __GLX_PUT_LONG(offset,value)
+#define __GLX_PUT_GLenum(offset,value)     __GLX_PUT_LONG(offset,value)
+#define __GLX_PUT_GLbitfield(offset,value) __GLX_PUT_LONG(offset,value)
+#define __GLX_PUT_GLshort(offset,value)    __GLX_PUT_SHORT(offset,value)
+#define __GLX_PUT_GLushort(offset,value)   __GLX_PUT_SHORT(offset,value)
+#define __GLX_PUT_GLbyte(offset,value)     __GLX_PUT_CHAR(offset,value)
+#define __GLX_PUT_GLubyte(offset,value)    __GLX_PUT_CHAR(offset,value)
+#define __GLX_PUT_GLboolean(offset,value)  __GLX_PUT_CHAR(offset,value)
+
+#define __GLX_PUT_GLdouble_ARRAY(offset,ptr,count)   __GLX_PUT_DOUBLE_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLclampd_ARRAY(offset,ptr,count)   __GLX_PUT_DOUBLE_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLfloat_ARRAY(offset,ptr,count)    __GLX_PUT_FLOAT_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLclampf_ARRAY(offset,ptr,count)   __GLX_PUT_FLOAT_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLint_ARRAY(offset,ptr,count)      __GLX_PUT_LONG_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLuint_ARRAY(offset,ptr,count)     __GLX_PUT_LONG_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLenum_ARRAY(offset,ptr,count)     __GLX_PUT_LONG_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLshort_ARRAY(offset,ptr,count)    __GLX_PUT_SHORT_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLushort_ARRAY(offset,ptr,count)   __GLX_PUT_SHORT_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLbyte_ARRAY(offset,ptr,count)     __GLX_PUT_CHAR_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLubyte_ARRAY(offset,ptr,count)    __GLX_PUT_CHAR_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLboolean_ARRAY(offset,ptr,count)  __GLX_PUT_CHAR_ARRAY(offset,ptr,count)
+
+#define RENDER_SIZE(t,c)  (__GLX_PAD(4 + (t ## _SIZE * c)))
+
+/* GLX protocol templates are named in the following manner.  All templates
+ * begin with the string 'glxproto_'.  Following is an optional list of
+ * scalar parameters.  The scalars are listed as type and number.  The most
+ * common being \c enum1 (one scalar enum) and \c enum2 (two scalar enums).
+ *
+ * The final part of the name describes the number of named-type parameters
+ * and how they are passed.
+ * - One or more digits followed by the letter s means
+ *   that the specified number of parameters are passed as scalars.  The macro
+ *   \c glxproto_3s generates a function that takes 3 scalars, such as
+ *   \c glVertex3f.
+ * - A capital C follwed by a lower-case v means that a constant
+ *   sized vector is passed.  Macros of this type take an extra parameter,
+ *   which is the size of the vector.  The invocation
+ *   'glxproto_Cv(Vertex3fv, X_GLrop_Vertexfv, GLfloat, 3)' would generate the
+ *   correct protocol for the \c glVertex3fv function.
+ * - A capital V followed by a lower-case v means that a variable sized
+ *   vector is passed.  The function generated by these macros will call
+ *   a co-function to determine the size of the vector.  The name of the
+ *   co-function is generated by prepending \c __gl and appending \c _size
+ *   to the base name of the function.  The invocation
+ *   'glxproto_enum1_Vv(Fogiv, X_GLrop_Fogiv, GLint)' would generate the
+ *   correct protocol for the \c glFogiv function.
+ * - One or more digits without a following letter means that a function
+ *   taking the specified number of scalar parameters and a function with a
+ *   vector parameter of the specified size should be generated.  The letter
+ *   v is automatically appended to the name of the vector-based function in
+ *   this case.  The invocation
+ *   'glxproto_3(Vertex3f, X_GLrop_Vertex3fv, GLfloat)' would generate the
+ *   correct protocol for both \c glVertex3f and \c glVertex3fv.
+ *
+ * glxproto_void is a special case for functions that take no parameters
+ * (i.e., glEnd).
+ *
+ * An addition form is 'glxvendr_'.  This is identical to the other forms
+ * with the exception of taking an additional parameter (to the macro) which
+ * is a vendor string to append to the function name.  The invocation
+ * 'glxproto_3(Foo3f, X_GLrop_Foo3fv, GLfloat)' would generate the functions
+ * 'glFoo3fv' and 'glFoo3f', and the invocation
+ * 'glxvendr_3(Foo3f, X_GLrop_Foo3fv, GLfloat, EXT)' would generate the
+ * functions 'glFoo3fvEXT' and 'glFoo3fEXT'.
+ */
+
+#define glxproto_void(name, rop) \
+   void __indirect_gl ## name (void) \
+   { \
+	__GLX_DECLARE_VARIABLES(); \
+	__GLX_LOAD_VARIABLES(); \
+	__GLX_BEGIN(rop, 4); \
+	__GLX_END(4); \
+   }
+
+#define glxproto_Cv(name, rop, type, count) \
+   void __indirect_gl ## name (const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, count); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (count <= 4) { \
+	                  __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 if (count > 1) { __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v[1]); } \
+	 if (count > 2) { __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v[2]); } \
+	 if (count > 3) { __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v[3]); } \
+      } else { \
+	 __GLX_PUT_ ## type ## _ARRAY(4, v, count); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_Cv_transpose(name, rop, type, w) \
+   void __indirect_gl ## name (const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      type t[ w * w ]; unsigned i, j; \
+      for (i = 0; i < w; i++) { \
+	 for (j = 0; j < w; j++) { \
+	    t[i*w+j] = v[j*w+i]; \
+	 } \
+      } \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, (w * w)); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type ## _ARRAY(4, t, (w * w)); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_1s(name, rop, type) \
+   void __indirect_gl ## name (type v1) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 1); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_2s(name, rop, type) \
+   void __indirect_gl ## name (type v1, type v2) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 2); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_3s(name, rop, type) \
+   void __indirect_gl ## name (type v1, type v2, type v3) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 3); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+      __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_4s(name, rop, type) \
+   void __indirect_gl ## name (type v1, type v2, type v3, type v4) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 4); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+      __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+      __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v4); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_6s(name, rop, type) \
+   void __indirect_gl ## name (type v1, type v2, type v3, type v4, type v5, type v6) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 6); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+      __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+      __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v4); \
+      __GLX_PUT_ ## type (4 + (4 * type ## _SIZE), v5); \
+      __GLX_PUT_ ## type (4 + (5 * type ## _SIZE), v6); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_1s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 1); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_LONG     (4 + (1 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v1); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_1v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 1); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_LONG     (4 + (1 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v[0]); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_2s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1, type v2) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 2); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_LONG     (4 + (2 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v2); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_2v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 2); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_LONG     (4 + (2 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v[1]); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_3s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1, type v2, type v3) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 3); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+	 __GLX_PUT_LONG     (4 + (3 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_ ## type (8 + (2 * type ## _SIZE), v3); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_3v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 3); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v[2]); \
+	 __GLX_PUT_LONG     (4 + (3 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_ ## type (8 + (2 * type ## _SIZE), v[2]); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_4s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1, type v2, type v3, type v4) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 4); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+	 __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v4); \
+	 __GLX_PUT_LONG     (4 + (4 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_ ## type (8 + (2 * type ## _SIZE), v3); \
+	 __GLX_PUT_ ## type (8 + (3 * type ## _SIZE), v4); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_4v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 4); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v[2]); \
+	 __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v[3]); \
+	 __GLX_PUT_LONG     (4 + (4 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_ ## type (8 + (2 * type ## _SIZE), v[2]); \
+	 __GLX_PUT_ ## type (8 + (3 * type ## _SIZE), v[3]); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_Vv(name, rop, type) \
+   void __indirect_gl ## name (GLenum pname, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      compsize = __gl ## name ## _size(pname); \
+      cmdlen = 4 + RENDER_SIZE(type, compsize); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_LONG(4, pname); \
+      __GLX_PUT_ ## type ## _ARRAY(8, v, compsize); \
+      __GLX_END(cmdlen); \
+   }
+    
+#define glxproto_enum2_1s(name, rop, type) \
+   void __indirect_gl ## name (GLenum target, GLenum pname, type v1) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 8 + RENDER_SIZE(type, 1); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_LONG     (4 + (1 * type ## _SIZE), target); \
+	 __GLX_PUT_LONG     (8 + (1 * type ## _SIZE), pname); \
+      } else { \
+	 __GLX_PUT_LONG(4, target); \
+	 __GLX_PUT_LONG(8, pname); \
+	 __GLX_PUT_ ## type (12 + (0 * type ## _SIZE), v1); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum2_Vv(name, rop, type) \
+   void __indirect_gl ## name (GLenum target, GLenum pname, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      compsize = __gl ## name ## _size(pname); \
+      cmdlen =  8 + RENDER_SIZE(type, compsize); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_LONG(4, target); \
+      __GLX_PUT_LONG(8, pname); \
+      __GLX_PUT_ ## type ## _ARRAY(12, v, compsize); \
+      __GLX_END(cmdlen); \
+   }
+
+#define GENERATE_GLX_PROTOCOL_FUNCTIONS
+#include "indirect.h"
+
+void __indirect_glRectdv(const GLdouble *v1, const GLdouble *v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Rectdv,36);
+	__GLX_PUT_DOUBLE(4,v1[0]);
+	__GLX_PUT_DOUBLE(12,v1[1]);
+	__GLX_PUT_DOUBLE(20,v2[0]);
+	__GLX_PUT_DOUBLE(28,v2[1]);
+	__GLX_END(36);
+}
+
+void __indirect_glRectfv(const GLfloat *v1, const GLfloat *v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Rectfv,20);
+	__GLX_PUT_FLOAT(4,v1[0]);
+	__GLX_PUT_FLOAT(8,v1[1]);
+	__GLX_PUT_FLOAT(12,v2[0]);
+	__GLX_PUT_FLOAT(16,v2[1]);
+	__GLX_END(20);
+}
+
+void __indirect_glRectiv(const GLint *v1, const GLint *v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Rectiv,20);
+	__GLX_PUT_LONG(4,v1[0]);
+	__GLX_PUT_LONG(8,v1[1]);
+	__GLX_PUT_LONG(12,v2[0]);
+	__GLX_PUT_LONG(16,v2[1]);
+	__GLX_END(20);
+}
+
+void __indirect_glRectsv(const GLshort *v1, const GLshort *v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Rectsv,12);
+	__GLX_PUT_SHORT(4,v1[0]);
+	__GLX_PUT_SHORT(6,v1[1]);
+	__GLX_PUT_SHORT(8,v2[0]);
+	__GLX_PUT_SHORT(10,v2[1]);
+	__GLX_END(12);
+}
+
+void __indirect_glLineStipple(GLint factor, GLushort pattern)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_LineStipple,12);
+	__GLX_PUT_LONG(4,factor);
+	__GLX_PUT_SHORT(8,pattern);
+	__GLX_END(12);
+}
+
+void __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Scissor,20);
+	__GLX_PUT_LONG(4,x);
+	__GLX_PUT_LONG(8,y);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_END(20);
+}
+
+void __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_MapGrid1d,24);
+	__GLX_PUT_DOUBLE(4,u1);
+	__GLX_PUT_DOUBLE(12,u2);
+	__GLX_PUT_LONG(20,un);
+	__GLX_END(24);
+}
+
+void __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_MapGrid1f,16);
+	__GLX_PUT_LONG(4,un);
+	__GLX_PUT_FLOAT(8,u1);
+	__GLX_PUT_FLOAT(12,u2);
+	__GLX_END(16);
+}
+
+void __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_MapGrid2d,44);
+	__GLX_PUT_DOUBLE(4,u1);
+	__GLX_PUT_DOUBLE(12,u2);
+	__GLX_PUT_DOUBLE(20,v1);
+	__GLX_PUT_DOUBLE(28,v2);
+	__GLX_PUT_LONG(36,un);
+	__GLX_PUT_LONG(40,vn);
+	__GLX_END(44);
+}
+
+void __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_MapGrid2f,28);
+	__GLX_PUT_LONG(4,un);
+	__GLX_PUT_FLOAT(8,u1);
+	__GLX_PUT_FLOAT(12,u2);
+	__GLX_PUT_LONG(16,vn);
+	__GLX_PUT_FLOAT(20,v1);
+	__GLX_PUT_FLOAT(24,v2);
+	__GLX_END(28);
+}
+
+void __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_StencilFunc,16);
+	__GLX_PUT_LONG(4,func);
+	__GLX_PUT_LONG(8,ref);
+	__GLX_PUT_LONG(12,mask);
+	__GLX_END(16);
+}
+
+void __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyPixels,24);
+	__GLX_PUT_LONG(4,x);
+	__GLX_PUT_LONG(8,y);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,type);
+	__GLX_END(24);
+}
+
+void __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Viewport,20);
+	__GLX_PUT_LONG(4,x);
+	__GLX_PUT_LONG(8,y);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_END(20);
+}
+
+void __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexImage1D,32);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,internalformat);
+	__GLX_PUT_LONG(16,x);
+	__GLX_PUT_LONG(20,y);
+	__GLX_PUT_LONG(24,width);
+	__GLX_PUT_LONG(28,border);
+	__GLX_END(32);
+}
+
+void __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexImage2D,36);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,internalformat);
+	__GLX_PUT_LONG(16,x);
+	__GLX_PUT_LONG(20,y);
+	__GLX_PUT_LONG(24,width);
+	__GLX_PUT_LONG(28,height);
+	__GLX_PUT_LONG(32,border);
+	__GLX_END(36);
+}
+
+void __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexSubImage1D,28);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,xoffset);
+	__GLX_PUT_LONG(16,x);
+	__GLX_PUT_LONG(20,y);
+	__GLX_PUT_LONG(24,width);
+	__GLX_END(28);
+}
+
+void __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexSubImage2D,36);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,xoffset);
+	__GLX_PUT_LONG(16,yoffset);
+	__GLX_PUT_LONG(20,x);
+	__GLX_PUT_LONG(24,y);
+	__GLX_PUT_LONG(28,width);
+	__GLX_PUT_LONG(32,height);
+	__GLX_END(36);
+}
+
+void __indirect_glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	if (n < 0) return;
+	cmdlen = 8+n*4+n*4;
+	__GLX_BEGIN(X_GLrop_PrioritizeTextures,cmdlen);
+	__GLX_PUT_LONG(4,n);
+	__GLX_PUT_LONG_ARRAY(8,textures,n);
+	__GLX_PUT_FLOAT_ARRAY(8+n*4,priorities,n);
+	__GLX_END(cmdlen);
+}
+
+void __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyColorTable,24);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,x);
+	__GLX_PUT_LONG(16,y);
+	__GLX_PUT_LONG(20,width);
+	__GLX_END(24);
+}
+
+void __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyColorSubTable,24);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,start);
+	__GLX_PUT_LONG(12,x);
+	__GLX_PUT_LONG(16,y);
+	__GLX_PUT_LONG(20,width);
+	__GLX_END(24);
+}
+
+void __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyConvolutionFilter1D,24);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,x);
+	__GLX_PUT_LONG(16,y);
+	__GLX_PUT_LONG(20,width);
+	__GLX_END(24);
+}
+
+void __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyConvolutionFilter2D,28);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,x);
+	__GLX_PUT_LONG(16,y);
+	__GLX_PUT_LONG(20,width);
+	__GLX_PUT_LONG(24,height);
+	__GLX_END(28);
+}
+
+void __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Histogram,20);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,internalformat);
+	__GLX_PUT_CHAR(16,sink);
+	__GLX_END(20);
+}
+
+void __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexSubImage3D,40);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,xoffset);
+	__GLX_PUT_LONG(16,yoffset);
+	__GLX_PUT_LONG(20,zoffset);
+	__GLX_PUT_LONG(24,x);
+	__GLX_PUT_LONG(28,y);
+	__GLX_PUT_LONG(32,width);
+	__GLX_PUT_LONG(36,height);
+	__GLX_END(40);
+}
+
+void __indirect_glWindowPos2dARB(GLdouble x, GLdouble y)
+{
+	__indirect_glWindowPos3fARB(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2iARB(GLint x, GLint y)
+{
+	__indirect_glWindowPos3fARB(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2fARB(GLfloat x, GLfloat y)
+{
+	__indirect_glWindowPos3fARB(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2sARB(GLshort x, GLshort y)
+{
+	__indirect_glWindowPos3fARB(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2dvARB(const GLdouble * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos2fvARB(const GLfloat * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos2ivARB(const GLint * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos2svARB(const GLshort * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z)
+{
+	__indirect_glWindowPos3fARB(x, y, z);
+}
+
+void __indirect_glWindowPos3iARB(GLint x, GLint y, GLint z)
+{
+	__indirect_glWindowPos3fARB(x, y, z);
+}
+
+void __indirect_glWindowPos3sARB(GLshort x, GLshort y, GLshort z)
+{
+	__indirect_glWindowPos3fARB(x, y, z);
+}
+
+void __indirect_glWindowPos3dvARB(const GLdouble * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], p[2]);
+}
+
+void __indirect_glWindowPos3ivARB(const GLint * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], p[2]);
+}
+
+void __indirect_glWindowPos3svARB(const GLshort * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], p[2]);
+}

src/glx/x11/g_single.c

@@ -0,0 +1,663 @@
+/* $XFree86$ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#include "packsingle.h"
+
+void glNewList(GLuint list, GLenum mode)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_NewList,8);
+	__GLX_SINGLE_PUT_LONG(0,list);
+	__GLX_SINGLE_PUT_LONG(4,mode);
+	__GLX_SINGLE_END();
+}
+
+void glEndList(void)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_EndList,0);
+	__GLX_SINGLE_END();
+}
+
+void glDeleteLists(GLuint list, GLsizei range)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_DeleteLists,8);
+	__GLX_SINGLE_PUT_LONG(0,list);
+	__GLX_SINGLE_PUT_LONG(4,range);
+	__GLX_SINGLE_END();
+}
+
+GLuint glGenLists(GLsizei range)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	GLuint    retval = 0;
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GenLists,4);
+	__GLX_SINGLE_PUT_LONG(0,range);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_RETVAL(retval, GLuint);
+	__GLX_SINGLE_END();
+	return retval;
+}
+
+void glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetLightfv,8);
+	__GLX_SINGLE_PUT_LONG(0,light);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetLightiv(GLenum light, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetLightiv,8);
+	__GLX_SINGLE_PUT_LONG(0,light);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetMapdv(GLenum target, GLenum query, GLdouble *v)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetMapdv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,query);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_DOUBLE(v);
+	} else {
+	    __GLX_SINGLE_GET_DOUBLE_ARRAY(v,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetMapfv(GLenum target, GLenum query, GLfloat *v)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetMapfv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,query);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(v);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(v,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetMapiv(GLenum target, GLenum query, GLint *v)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetMapiv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,query);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(v);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(v,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetMaterialfv,8);
+	__GLX_SINGLE_PUT_LONG(0,face);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetMaterialiv,8);
+	__GLX_SINGLE_PUT_LONG(0,face);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetPixelMapfv(GLenum map, GLfloat *values)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetPixelMapfv,4);
+	__GLX_SINGLE_PUT_LONG(0,map);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(values);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(values,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetPixelMapuiv(GLenum map, GLuint *values)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetPixelMapuiv,4);
+	__GLX_SINGLE_PUT_LONG(0,map);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(values);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(values,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetPixelMapusv(GLenum map, GLushort *values)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetPixelMapusv,4);
+	__GLX_SINGLE_PUT_LONG(0,map);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_SHORT(values);
+	} else {
+	    __GLX_SINGLE_GET_SHORT_ARRAY(values,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetTexEnvfv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetTexEnviv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetTexGendv,8);
+	__GLX_SINGLE_PUT_LONG(0,coord);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_DOUBLE(params);
+	} else {
+	    __GLX_SINGLE_GET_DOUBLE_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetTexGenfv,8);
+	__GLX_SINGLE_PUT_LONG(0,coord);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetTexGeniv,8);
+	__GLX_SINGLE_PUT_LONG(0,coord);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetTexParameterfv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetTexParameteriv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetTexLevelParameterfv,12);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,level);
+	__GLX_SINGLE_PUT_LONG(8,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetTexLevelParameteriv,12);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,level);
+	__GLX_SINGLE_PUT_LONG(8,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+GLboolean glIsList(GLuint list)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	GLboolean    retval = 0;
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_IsList,4);
+	__GLX_SINGLE_PUT_LONG(0,list);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_RETVAL(retval, GLboolean);
+	__GLX_SINGLE_END();
+	return retval;
+}
+
+/*
+ * Somewhere between GLX 1.2 and 1.3 (in SGI's code anyway) the
+ * protocol for glAreTexturesResident, glDeleteTextures, glGenTextures,
+ * and glIsTexture() was changed.  Before, calls to these functions
+ * generated protocol for the old GL_EXT_texture_object versions of those
+ * calls.  In the newer code, this is actually corrected; calls to the
+ * 1.1 functions generate 1.1 protocol and calls to the EXT functions
+ * generate EXT protocol.
+ * Unfortunately, this correction causes an incompatibility.  Specifically,
+ * an updated libGL.so will send protocol requests that the server won't
+ * be able to handle.  For example, calling glGenTextures will generate a
+ * BadRequest error.
+ * For now, we'll keep generating EXT protocol from libGL.  We'll update
+ * the server to understand both the 1.1 and EXT protocol ASAP.  At some point
+ * in the future we'll correct libGL.so as well.  That should be a smoother
+ * transition path.
+ */
+
+GLboolean glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
+{
+#if 0 /* see comments above */
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	GLboolean    retval = 0;
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	if (n < 0) return retval;
+	cmdlen = 4+n*4;
+	__GLX_SINGLE_BEGIN(X_GLsop_AreTexturesResident,cmdlen);
+	__GLX_SINGLE_PUT_LONG(0,n);
+	__GLX_PUT_LONG_ARRAY(4,textures,n);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_RETVAL(retval, GLboolean);
+	__GLX_SINGLE_GET_CHAR_ARRAY(residences,n);
+	__GLX_SINGLE_END();
+	return retval;
+#else
+        return glAreTexturesResidentEXT(n, textures, residences);
+#endif
+}
+
+void glDeleteTextures(GLsizei n, const GLuint *textures)
+{
+#if 0 /* see comments above */
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	__GLX_SINGLE_LOAD_VARIABLES();
+	if (n < 0) return;
+	cmdlen = 4+n*4;
+	__GLX_SINGLE_BEGIN(X_GLsop_DeleteTextures,cmdlen);
+	__GLX_SINGLE_PUT_LONG(0,n);
+	__GLX_PUT_LONG_ARRAY(4,textures,n);
+	__GLX_SINGLE_END();
+#else
+        glDeleteTexturesEXT(n, textures);
+#endif
+}
+
+void glGenTextures(GLsizei n, GLuint *textures)
+{
+#if 0 /* see comments above */
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GenTextures,4);
+	__GLX_SINGLE_PUT_LONG(0,n);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_LONG_ARRAY(textures,n);
+	__GLX_SINGLE_END();
+#else
+        glGenTexturesEXT(n, textures);
+#endif
+}
+
+GLboolean glIsTexture(GLuint texture)
+{
+#if 0 /* see comments above */
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	GLboolean    retval = 0;
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_IsTexture,4);
+	__GLX_SINGLE_PUT_LONG(0,texture);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_RETVAL(retval, GLboolean);
+	__GLX_SINGLE_END();
+	return retval;
+#else
+        return glIsTextureEXT(texture);
+#endif
+}
+
+void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetColorTableParameterfv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetColorTableParameteriv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetConvolutionParameterfv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetConvolutionParameteriv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetHistogramParameterfv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetHistogramParameteriv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetMinmaxParameterfv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_FLOAT(params);
+	} else {
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+
+void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	__GLX_SINGLE_DECLARE_VARIABLES();
+	xGLXSingleReply reply;
+	__GLX_SINGLE_LOAD_VARIABLES();
+	__GLX_SINGLE_BEGIN(X_GLsop_GetMinmaxParameteriv,8);
+	__GLX_SINGLE_PUT_LONG(0,target);
+	__GLX_SINGLE_PUT_LONG(4,pname);
+	__GLX_SINGLE_READ_XREPLY();
+	__GLX_SINGLE_GET_SIZE(compsize);
+	if (compsize == 1) {
+	    __GLX_SINGLE_GET_LONG(params);
+	} else {
+	    __GLX_SINGLE_GET_LONG_ARRAY(params,compsize);
+	}
+	__GLX_SINGLE_END();
+}
+

src/glx/x11/g_vendpriv.c

@@ -0,0 +1,88 @@
+/* $XFree86$ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#include "packvendpriv.h"
+
+GLboolean glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences)
+{
+	__GLX_VENDPRIV_DECLARE_VARIABLES();
+	GLboolean    retval = 0;
+	xGLXVendorPrivReply reply;
+	__GLX_VENDPRIV_LOAD_VARIABLES();
+	if (n < 0) return retval;
+	cmdlen = 4+n*4;
+	__GLX_VENDPRIV_BEGIN(X_GLXVendorPrivateWithReply,X_GLvop_AreTexturesResidentEXT,cmdlen);
+	__GLX_VENDPRIV_PUT_LONG(0,n);
+	__GLX_PUT_LONG_ARRAY(4,textures,n);
+	__GLX_VENDPRIV_READ_XREPLY();
+	__GLX_VENDPRIV_GET_RETVAL(retval, GLboolean);
+	__GLX_VENDPRIV_GET_CHAR_ARRAY(residences,n);
+	__GLX_VENDPRIV_END();
+	return retval;
+}
+
+void glDeleteTexturesEXT(GLsizei n, const GLuint *textures)
+{
+	__GLX_VENDPRIV_DECLARE_VARIABLES();
+	__GLX_VENDPRIV_LOAD_VARIABLES();
+	if (n < 0) return;
+	cmdlen = 4+n*4;
+	__GLX_VENDPRIV_BEGIN(X_GLXVendorPrivate,X_GLvop_DeleteTexturesEXT,cmdlen);
+	__GLX_VENDPRIV_PUT_LONG(0,n);
+	__GLX_PUT_LONG_ARRAY(4,textures,n);
+	__GLX_VENDPRIV_END();
+}
+
+void glGenTexturesEXT(GLsizei n, GLuint *textures)
+{
+	__GLX_VENDPRIV_DECLARE_VARIABLES();
+	xGLXVendorPrivReply reply;
+	__GLX_VENDPRIV_LOAD_VARIABLES();
+	__GLX_VENDPRIV_BEGIN(X_GLXVendorPrivateWithReply,X_GLvop_GenTexturesEXT,4);
+	__GLX_VENDPRIV_PUT_LONG(0,n);
+	__GLX_VENDPRIV_READ_XREPLY();
+	__GLX_VENDPRIV_GET_LONG_ARRAY(textures,n);
+	__GLX_VENDPRIV_END();
+}
+
+GLboolean glIsTextureEXT(GLuint texture)
+{
+	__GLX_VENDPRIV_DECLARE_VARIABLES();
+	GLboolean    retval = 0;
+	xGLXVendorPrivReply reply;
+	__GLX_VENDPRIV_LOAD_VARIABLES();
+	__GLX_VENDPRIV_BEGIN(X_GLXVendorPrivateWithReply,X_GLvop_IsTextureEXT,4);
+	__GLX_VENDPRIV_PUT_LONG(0,texture);
+	__GLX_VENDPRIV_READ_XREPLY();
+	__GLX_VENDPRIV_GET_RETVAL(retval, GLboolean);
+	__GLX_VENDPRIV_END();
+	return retval;
+}
+

src/glx/x11/glx_pbuffer.c

@@ -0,0 +1,556 @@
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file glx_pbuffer.c
+ * Implementation of pbuffer related functions.
+ * 
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+
+#include <inttypes.h>
+#include "glxclient.h"
+#include <extutil.h>
+#include <Xext.h>
+#include <assert.h>
+#include <string.h>
+#include "glapi.h"
+#include "glxextensions.h"
+#include "glcontextmodes.h"
+
+#ifdef IN_DOXYGEN
+#define GLX_PREFIX(x) x
+#endif /* IN_DOXYGEN */
+
+static void ChangeDrawableAttribute( Display * dpy, GLXDrawable drawable,
+    const CARD32 * attribs, size_t num_attribs );
+
+static void DestroyPbuffer( Display * dpy, GLXDrawable drawable );
+
+static GLXDrawable CreatePbuffer( Display *dpy,
+    const __GLcontextModes * fbconfig, unsigned int width, unsigned int height,
+    const int *attrib_list, GLboolean size_in_attribs );
+
+static int GetDrawableAttribute( Display *dpy, GLXDrawable drawable,
+    int attribute, unsigned int *value );
+
+
+/**
+ * Change a drawable's attribute.
+ *
+ * This function is used to implement \c glXSelectEvent and
+ * \c glXSelectEventSGIX.
+ *
+ * \note
+ * This function dynamically determines whether to use the SGIX_pbuffer
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static void
+ChangeDrawableAttribute( Display * dpy, GLXDrawable drawable,
+			 const CARD32 * attribs, size_t num_attribs )
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+   CARD32 * output;
+
+
+   if ( (dpy == NULL) || (drawable == 0) ) {
+      return;
+   }
+
+
+   LockDisplay(dpy);
+
+   if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) {
+      xGLXChangeDrawableAttributesReq *req;
+
+      GetReqExtra( GLXChangeDrawableAttributes, 8 + (8 * num_attribs), req );
+      output = (CARD32 *) (req + 1);
+
+      req->reqType = __glXSetupForCommand(dpy);
+      req->glxCode = X_GLXChangeDrawableAttributes;
+      req->drawable = drawable;
+      req->numAttribs = (CARD32) num_attribs;
+   }
+   else {
+      xGLXVendorPrivateWithReplyReq *vpreq;
+
+      GetReqExtra( GLXVendorPrivateWithReply, 4 + (8 * num_attribs), vpreq );
+      output = (CARD32 *) (vpreq + 1);
+
+      vpreq->reqType = __glXSetupForCommand(dpy);
+      vpreq->glxCode = X_GLXVendorPrivateWithReply;
+      vpreq->vendorCode = X_GLXvop_ChangeDrawableAttributesSGIX;
+
+      output[0] = (CARD32) drawable;
+      output++;
+   }
+
+   (void) memcpy( output, attribs, sizeof( CARD32 ) * 2 * num_attribs );
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return;
+}
+
+
+/**
+ * Destroy a pbuffer.
+ *
+ * This function is used to implement \c glXDestroyPbuffer and
+ * \c glXDestroyGLXPbufferSGIX.
+ *
+ * \note
+ * This function dynamically determines whether to use the SGIX_pbuffer
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ * 
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static void
+DestroyPbuffer( Display * dpy, GLXDrawable drawable )
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+
+   if ( (dpy == NULL) || (drawable == 0) ) {
+      return;
+   }
+
+
+   LockDisplay(dpy);
+
+   if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) {
+      xGLXDestroyPbufferReq * req;
+
+      GetReqExtra( GLXDestroyPbuffer, 4, req );
+      req->reqType = __glXSetupForCommand(dpy);
+      req->glxCode = X_GLXDestroyPbuffer;
+      req->pbuffer = (GLXPbuffer) drawable;
+   }
+   else {
+      xGLXVendorPrivateWithReplyReq *vpreq;
+      CARD32 * data;
+
+      GetReqExtra( GLXVendorPrivateWithReply, 4, vpreq );
+      data = (CARD32 *) (vpreq + 1);
+
+      data[0] = (CARD32) drawable;
+
+      vpreq->reqType = __glXSetupForCommand(dpy);
+      vpreq->glxCode = X_GLXVendorPrivateWithReply;
+      vpreq->vendorCode = X_GLXvop_DestroyGLXPbufferSGIX;
+   }
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return;
+}
+
+
+/**
+ * Get a drawable's attribute.
+ *
+ * This function is used to implement \c glXGetSelectedEvent and
+ * \c glXGetSelectedEventSGIX.
+ *
+ * \note
+ * This function dynamically determines whether to use the SGIX_pbuffer
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ *
+ * \todo
+ * The number of attributes returned is likely to be small, probably less than
+ * 10.  Given that, this routine should try to use an array on the stack to
+ * capture the reply rather than always calling Xmalloc.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static int
+GetDrawableAttribute( Display *dpy, GLXDrawable drawable,
+		      int attribute, unsigned int *value )
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+   xGLXGetDrawableAttributesReply reply;
+   CARD32 * data;
+   unsigned int length;
+   unsigned int i;
+   unsigned int num_attributes;
+   GLboolean use_glx_1_3 = ((priv->majorVersion > 1)
+			    || (priv->minorVersion >= 3));
+
+
+   if ( (dpy == NULL) || (drawable == 0) ) {
+      return 0;
+   }
+
+   
+   LockDisplay(dpy);
+
+   if ( use_glx_1_3 ) {
+      xGLXGetDrawableAttributesReq *req;
+
+      GetReqExtra( GLXGetDrawableAttributes, 4, req );
+      req->reqType = __glXSetupForCommand(dpy);
+      req->glxCode = X_GLXGetDrawableAttributes;
+      req->drawable = drawable;
+   }
+   else {
+      xGLXVendorPrivateWithReplyReq *vpreq;
+
+      GetReqExtra( GLXVendorPrivateWithReply, 4, vpreq );
+      data = (CARD32 *) (vpreq + 1);
+      data[0] = (CARD32) drawable;
+
+      vpreq->reqType = __glXSetupForCommand(dpy);
+      vpreq->glxCode = X_GLXVendorPrivateWithReply;
+      vpreq->vendorCode = X_GLXvop_GetDrawableAttributesSGIX;
+   }
+
+   _XReply(dpy, (xReply*) &reply, 0, False);
+
+   length = reply.length;
+   num_attributes = (use_glx_1_3) ? reply.numAttribs : length / 2;
+   data = (CARD32 *) Xmalloc( length * sizeof(CARD32) );
+   if ( data == NULL ) {
+      /* Throw data on the floor */
+      _XEatData(dpy, length);
+   } else {
+      _XRead(dpy, (char *)data, length * sizeof(CARD32) );
+   }
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+
+   /* Search the set of returned attributes for the attribute requested by
+    * the caller.
+    */
+
+   for ( i = 0 ; i < num_attributes ; i++ ) {
+      if ( data[i*2] == attribute ) {
+	 *value = data[ (i*2) + 1 ];
+	 break;
+      }
+   }
+
+   Xfree( data );
+
+   return 0;
+}
+
+
+/**
+ * Create a non-pbuffer GLX drawable.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static GLXDrawable
+CreateDrawable( Display *dpy, const __GLcontextModes * fbconfig,
+		Drawable drawable, const int *attrib_list,
+		CARD8 glxCode )
+{
+   xGLXCreateWindowReq * req;
+   CARD32 * data;
+   unsigned int  i;
+
+
+   for ( i = 0 ; attrib_list[i * 2] != None ; i++ )
+      /* empty */ ;
+
+   LockDisplay(dpy);
+   GetReqExtra( GLXCreateWindow, 20 + (8 * i), req );
+   data = (CARD32 *) (req + 1);
+
+   req->reqType = __glXSetupForCommand(dpy);
+   req->glxCode = glxCode;
+   req->screen = (CARD32) fbconfig->screen;
+   req->fbconfig = fbconfig->fbconfigID;
+   req->window = (GLXPbuffer) drawable;
+   req->numAttribs = (CARD32) i;
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+   
+   return drawable;
+}
+
+
+/**
+ * Destroy a non-pbuffer GLX drawable.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static void
+DestroyDrawable( Display * dpy, GLXDrawable drawable, CARD32 glxCode )
+{
+   xGLXDestroyPbufferReq * req;
+
+   if ( (dpy == NULL) || (drawable == 0) ) {
+      return;
+   }
+
+
+   LockDisplay(dpy);
+
+   GetReqExtra( GLXDestroyPbuffer, 4, req );
+   req->reqType = __glXSetupForCommand(dpy);
+   req->glxCode = glxCode;
+   req->pbuffer = (GLXPbuffer) drawable;
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return;
+}
+
+
+/**
+ * Create a pbuffer.
+ *
+ * This function is used to implement \c glXCreatePbuffer and
+ * \c glXCreateGLXPbufferSGIX.
+ *
+ * \note
+ * This function dynamically determines whether to use the SGIX_pbuffer
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static GLXDrawable
+CreatePbuffer( Display *dpy, const __GLcontextModes * fbconfig,
+	       unsigned int width, unsigned int height, 
+	       const int *attrib_list, GLboolean size_in_attribs )
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+   GLXDrawable id = 0;
+   CARD32 * data;
+   unsigned int  i;
+
+
+   for ( i = 0 ; attrib_list[i * 2] != None ; i++ )
+      /* empty */ ;
+
+
+   LockDisplay(dpy);
+   id = XAllocID(dpy);
+
+   if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) {
+      xGLXCreatePbufferReq * req;
+      unsigned int extra = (size_in_attribs) ? 0 : 2;
+
+      GetReqExtra( GLXCreatePbuffer, (8 * (i + extra)), req );
+      data = (CARD32 *) (req + 1);
+
+      req->reqType = __glXSetupForCommand(dpy);
+      req->glxCode = X_GLXCreatePbuffer;
+      req->screen = (CARD32) fbconfig->screen;
+      req->fbconfig = fbconfig->fbconfigID;
+      req->pbuffer = (GLXPbuffer) id;
+      req->numAttribs = (CARD32) (i + extra);
+
+      if ( ! size_in_attribs ) {
+	 data[(2 * i) + 0] = GLX_PBUFFER_WIDTH;
+	 data[(2 * i) + 1] = width;
+	 data[(2 * i) + 2] = GLX_PBUFFER_HEIGHT;
+	 data[(2 * i) + 3] = height;
+	 data += 4;
+      }
+   }
+   else {
+      xGLXVendorPrivateReq *vpreq;
+
+      GetReqExtra( GLXVendorPrivate, 20 + (8 * i), vpreq );
+      data = (CARD32 *) (vpreq + 1);
+
+      vpreq->reqType = __glXSetupForCommand(dpy);
+      vpreq->glxCode = X_GLXVendorPrivate;
+      vpreq->vendorCode = X_GLXvop_CreateGLXPbufferSGIX;
+
+      data[0] = (CARD32) fbconfig->screen;
+      data[1] = (CARD32) fbconfig->fbconfigID;
+      data[2] = (CARD32) id;
+      data[3] = (CARD32) width;
+      data[4] = (CARD32) height;
+      data += 5;
+   }
+
+   (void) memcpy( data, attrib_list, sizeof(CARD32) * 2 * i );
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return id;
+}
+
+
+/**
+ * Create a new pbuffer.
+ */
+GLXPbufferSGIX
+GLX_PREFIX(glXCreateGLXPbufferSGIX)(Display *dpy, GLXFBConfigSGIX config,
+				    unsigned int width, unsigned int height,
+				    int *attrib_list)
+{
+   return (GLXPbufferSGIX) CreatePbuffer( dpy, (__GLcontextModes *) config,
+					  width, height,
+					  attrib_list, GL_FALSE );
+}
+
+
+/**
+ * Create a new pbuffer.
+ */
+GLXPbuffer
+GLX_PREFIX(glXCreatePbuffer)(Display *dpy, GLXFBConfig config,
+			     const int *attrib_list)
+{
+   return (GLXPbuffer) CreatePbuffer( dpy, (__GLcontextModes *) config,
+				      0, 0,
+				      attrib_list, GL_TRUE );
+}
+
+
+/**
+ * Destroy an existing pbuffer.
+ */
+void
+GLX_PREFIX(glXDestroyPbuffer)(Display *dpy, GLXPbuffer pbuf)
+{
+   DestroyPbuffer( dpy, pbuf );
+}
+
+
+/**
+ * Query an attribute of a drawable.
+ */
+void
+GLX_PREFIX(glXQueryDrawable)(Display *dpy, GLXDrawable drawable,
+				   int attribute, unsigned int *value)
+{
+   GetDrawableAttribute( dpy, drawable, attribute, value );
+}
+
+
+/**
+ * Query an attribute of a pbuffer.
+ */
+int
+GLX_PREFIX(glXQueryGLXPbufferSGIX)(Display *dpy, GLXPbufferSGIX drawable,
+				   int attribute, unsigned int *value)
+{
+   return GetDrawableAttribute( dpy, drawable, attribute, value );
+}
+
+
+/**
+ * Select the event mask for a drawable.
+ */
+void
+GLX_PREFIX(glXSelectEvent)(Display *dpy, GLXDrawable drawable,
+			   unsigned long mask)
+{
+   CARD32 attribs[2];
+
+   attribs[0] = (CARD32) GLX_EVENT_MASK;
+   attribs[1] = (CARD32) mask;
+
+   ChangeDrawableAttribute( dpy, drawable, attribs, 1 );
+}
+
+
+/**
+ * Get the selected event mask for a drawable.
+ */
+void
+GLX_PREFIX(glXGetSelectedEvent)(Display *dpy, GLXDrawable drawable,
+				unsigned long *mask)
+{
+   unsigned int value;
+
+
+   /* The non-sense with value is required because on LP64 platforms
+    * sizeof(unsigned int) != sizeof(unsigned long).  On little-endian
+    * we could just type-cast the pointer, but why?
+    */
+
+   GetDrawableAttribute( dpy, drawable, GLX_EVENT_MASK_SGIX, & value );
+   *mask = value;
+}
+
+
+GLXPixmap
+GLX_PREFIX(glXCreatePixmap)( Display *dpy, GLXFBConfig config, Pixmap pixmap,
+			     const int *attrib_list )
+{
+   return CreateDrawable( dpy, (__GLcontextModes *) config,
+			  (Drawable) pixmap, attrib_list,
+			  X_GLXCreatePixmap );
+}
+
+
+GLXWindow
+GLX_PREFIX(glXCreateWindow)( Display *dpy, GLXFBConfig config, Window win,
+			     const int *attrib_list )
+{
+   return CreateDrawable( dpy, (__GLcontextModes *) config,
+			  (Drawable) win, attrib_list,
+			  X_GLXCreateWindow );
+}
+
+
+void
+GLX_PREFIX(glXDestroyPixmap)(Display *dpy, GLXPixmap pixmap)
+{
+   DestroyDrawable( dpy, (GLXDrawable) pixmap, X_GLXDestroyPixmap );
+}
+
+
+void
+GLX_PREFIX(glXDestroyWindow)(Display *dpy, GLXWindow win)
+{
+   DestroyDrawable( dpy, (GLXDrawable) win, X_GLXDestroyWindow );
+}
+
+
+GLX_ALIAS_VOID(glXDestroyGLXPbufferSGIX,
+	  (Display *dpy, GLXPbufferSGIX pbuf),
+	  (dpy, pbuf),
+	  glXDestroyPbuffer)
+
+GLX_ALIAS_VOID(glXSelectEventSGIX,
+	  (Display *dpy, GLXDrawable drawable, unsigned long mask),
+	  (dpy, drawable, mask),
+	  glXSelectEvent)
+
+GLX_ALIAS_VOID(glXGetSelectedEventSGIX,
+	  (Display *dpy, GLXDrawable drawable, unsigned long *mask),
+	  (dpy, drawable, mask),
+	  glXGetSelectedEvent)

src/glx/x11/glx_query.c

@@ -0,0 +1,102 @@
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file glx_query.c
+ * Generic utility functions to query internal data from the server.
+ * 
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+
+#include "glxclient.h"
+
+/**
+ * GLX protocol structure for the ficticious "GXLGenericGetString" request.
+ * 
+ * This is a non-existant protocol packet.  It just so happens that all of
+ * the real protocol packets used to request a string from the server have
+ * an identical binary layout.  The only difference between them is the
+ * meaning of the \c for_whom field and the value of the \c glxCode.
+ */
+typedef struct GLXGenericGetString {
+    CARD8 reqType;
+    CARD8 glxCode;
+    CARD16 length B16;
+    CARD32 for_whom B32;
+    CARD32 name B32;
+} xGLXGenericGetStringReq;
+
+/* These defines are only needed to make the GetReq macro happy.
+ */
+#define sz_xGLXGenericGetStringReq 12
+#define X_GLXGenericGetString 0
+
+/**
+ * Query the Server GLX string and cache it in the display private.
+ * This routine will allocate the necessay space for the string.
+ */
+char *
+__glXGetStringFromServer( Display * dpy, int opcode, CARD32 glxCode,
+			  CARD32 for_whom, CARD32 name )
+{
+    xGLXGenericGetStringReq *req;
+    xGLXSingleReply reply;
+    int length;
+    int numbytes;
+    char * buf;
+
+
+    LockDisplay( dpy );
+
+
+    /* All of the GLX protocol requests for getting a string from the server
+     * look the same.  The exact meaning of the for_whom field is usually
+     * either the screen number (for glXQueryServerString) or the context tag
+     * (for GLXSingle).
+     */
+
+    GetReq( GLXGenericGetString, req );
+    req->reqType = opcode;
+    req->glxCode = glxCode;
+    req->for_whom = for_whom;
+    req->name = name;
+
+    _XReply( dpy, (xReply *) & reply, 0, False );
+
+    length = reply.length * 4;
+    numbytes = reply.size;
+
+    buf = (char *) Xmalloc( numbytes );
+    if ( buf != NULL ) {
+        _XRead( dpy, buf, numbytes );
+	length -= numbytes;
+    }
+
+    _XEatData( dpy, length );
+
+    UnlockDisplay( dpy );
+    SyncHandle();
+
+    return buf;
+}

src/glx/x11/glx_texture_compression.c

@@ -0,0 +1,346 @@
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file glx_texture_compression.c
+ * Contains the routines required to implement GLX protocol for
+ * ARB_texture_compression and related extensions.
+ *
+ * \sa http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_compression.txt
+ *
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+
+#include "packrender.h"
+#include "packsingle.h"
+
+#include <assert.h>
+
+
+void
+__indirect_glGetCompressedTexImage( GLenum target, GLint level, 
+				    GLvoid * img )
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    xGLXGetTexImageReply reply;
+    size_t image_bytes;
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN( X_GLsop_GetCompressedTexImage, 8 );
+    __GLX_SINGLE_PUT_LONG( 0, target );
+    __GLX_SINGLE_PUT_LONG( 4, level );
+    __GLX_SINGLE_READ_XREPLY();
+
+    image_bytes = reply.width;
+    assert( image_bytes <= ((4 * reply.length) - 0) );
+    assert( image_bytes >= ((4 * reply.length) - 3) );
+    
+    if ( image_bytes != 0 ) {
+	_XRead( dpy, (char *) img, image_bytes );
+	if ( image_bytes < (4 * reply.length) ) {
+	    _XEatData( dpy, (4 * reply.length) - image_bytes );
+	}
+    }
+
+    __GLX_SINGLE_END();
+}
+
+
+/**
+ * Internal function used for \c glCompressedTexImage1D and
+ * \c glCompressedTexImage2D.
+ */
+static void
+CompressedTexImage1D2D( GLenum target, GLint level,
+			GLenum internal_format, 
+			GLsizei width, GLsizei height,
+			GLint border, GLsizei image_size,
+			const GLvoid *data, CARD32 rop )
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    if ( (target == GL_PROXY_TEXTURE_1D)
+	 || (target == GL_PROXY_TEXTURE_2D)
+	 || (target == GL_PROXY_TEXTURE_CUBE_MAP) ) {
+	compsize = 0;
+    }
+    else {
+	compsize = image_size;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE 
+			+ compsize );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( rop, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, internal_format );
+	__GLX_PUT_LONG( 16, width );
+	__GLX_PUT_LONG( 20, height );
+	__GLX_PUT_LONG( 24, border );
+	__GLX_PUT_LONG( 28, image_size );
+	if ( compsize != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE,
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	assert( compsize != 0 );
+
+	__GLX_BEGIN_VARIABLE_LARGE( rop, cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, internal_format );
+	__GLX_PUT_LONG( 20, width );
+	__GLX_PUT_LONG( 24, height );
+	__GLX_PUT_LONG( 28, border );
+	__GLX_PUT_LONG( 32, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
+
+
+/**
+ * Internal function used for \c glCompressedTexSubImage1D and
+ * \c glCompressedTexSubImage2D.
+ */
+static void
+CompressedTexSubImage1D2D( GLenum target, GLint level,
+			   GLsizei xoffset, GLsizei yoffset,
+			   GLsizei width, GLsizei height,
+			   GLenum format, GLsizei image_size,
+			   const GLvoid *data, CARD32 rop )
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    if ( target == GL_PROXY_TEXTURE_3D ) {
+	compsize = 0;
+    }
+    else {
+	compsize = image_size;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE
+			+ compsize );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( rop, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, xoffset );
+	__GLX_PUT_LONG( 16, yoffset );
+	__GLX_PUT_LONG( 20, width );
+	__GLX_PUT_LONG( 24, height );
+	__GLX_PUT_LONG( 28, format );
+	__GLX_PUT_LONG( 32, image_size );
+	if ( compsize != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE, 
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	assert( compsize != 0 );
+
+	__GLX_BEGIN_VARIABLE_LARGE( rop, cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, xoffset );
+	__GLX_PUT_LONG( 20, yoffset );
+	__GLX_PUT_LONG( 24, width );
+	__GLX_PUT_LONG( 28, height );
+	__GLX_PUT_LONG( 32, format );
+	__GLX_PUT_LONG( 36, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
+
+
+void
+__indirect_glCompressedTexImage1D( GLenum target, GLint level,
+				   GLenum internal_format, GLsizei width,
+				   GLint border, GLsizei image_size,
+				   const GLvoid *data )
+{
+    CompressedTexImage1D2D( target, level, internal_format, width, 0,
+			    border, image_size, data,
+			    X_GLrop_CompressedTexImage1D );
+}
+
+
+void
+__indirect_glCompressedTexImage2D( GLenum target, GLint level,
+				   GLenum internal_format,
+				   GLsizei width, GLsizei height,
+				   GLint border, GLsizei image_size,
+				   const GLvoid *data )
+{
+    CompressedTexImage1D2D( target, level, internal_format, width, height,
+			    border, image_size, data,
+			    X_GLrop_CompressedTexImage2D );
+}
+
+
+void
+__indirect_glCompressedTexImage3D( GLenum target, GLint level,
+				   GLenum internal_format,
+				   GLsizei width, GLsizei height, GLsizei depth,
+				   GLint border, GLsizei image_size,
+				   const GLvoid *data )
+{
+    __GLX_DECLARE_VARIABLES();
+    
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE
+			+ image_size );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( X_GLrop_CompressedTexImage3D, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, internal_format );
+	__GLX_PUT_LONG( 16, width );
+	__GLX_PUT_LONG( 20, height );
+	__GLX_PUT_LONG( 24, depth );
+	__GLX_PUT_LONG( 28, border );
+	__GLX_PUT_LONG( 32, image_size );
+	if ( image_size != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE,
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	__GLX_BEGIN_VARIABLE_LARGE( X_GLrop_CompressedTexImage3D,
+				    cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, internal_format );
+	__GLX_PUT_LONG( 20, width );
+	__GLX_PUT_LONG( 24, height );
+	__GLX_PUT_LONG( 28, depth );
+	__GLX_PUT_LONG( 32, border );
+	__GLX_PUT_LONG( 36, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
+
+
+void
+__indirect_glCompressedTexSubImage1D( GLenum target, GLint level,
+				      GLint xoffset,
+				      GLsizei width,
+				      GLenum format, GLsizei image_size,
+				      const GLvoid *data )
+{
+    CompressedTexSubImage1D2D( target, level, xoffset, 0, width, 0,
+			       format, image_size, data,
+			       X_GLrop_CompressedTexSubImage1D );
+}
+
+
+void
+__indirect_glCompressedTexSubImage2D( GLenum target, GLint level,
+				      GLint xoffset, GLint yoffset,
+				      GLsizei width, GLsizei height,
+				      GLenum format, GLsizei image_size,
+				      const GLvoid *data )
+{
+    CompressedTexSubImage1D2D( target, level, xoffset, yoffset, width, height,
+			       format, image_size, data,
+			       X_GLrop_CompressedTexSubImage2D );
+}
+
+
+void
+__indirect_glCompressedTexSubImage3D( GLenum target, GLint level,
+				      GLint xoffset, GLint yoffset, GLint zoffset,
+				      GLsizei width, GLsizei height, GLsizei depth,
+				      GLenum format, GLsizei image_size,
+				      const GLvoid *data )
+{
+    __GLX_DECLARE_VARIABLES();
+    
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE
+			+ image_size );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( X_GLrop_CompressedTexSubImage3D, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, xoffset );
+	__GLX_PUT_LONG( 16, yoffset );
+	__GLX_PUT_LONG( 20, zoffset );
+	__GLX_PUT_LONG( 24, width );
+	__GLX_PUT_LONG( 28, height );
+	__GLX_PUT_LONG( 32, depth );
+	__GLX_PUT_LONG( 36, format );
+	__GLX_PUT_LONG( 40, image_size );
+	if ( image_size != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE,
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	__GLX_BEGIN_VARIABLE_LARGE( X_GLrop_CompressedTexSubImage3D,
+				    cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, xoffset );
+	__GLX_PUT_LONG( 20, yoffset );
+	__GLX_PUT_LONG( 24, zoffset );
+	__GLX_PUT_LONG( 28, width );
+	__GLX_PUT_LONG( 32, height );
+	__GLX_PUT_LONG( 36, depth );
+	__GLX_PUT_LONG( 40, format );
+	__GLX_PUT_LONG( 44, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}

src/glx/x11/glxclient.h

@@ -0,0 +1,833 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+*/
+/* $XFree86: xc/lib/GL/glx/glxclient.h,v 1.21 2004/02/09 23:46:31 alanh Exp $ */
+
+/**
+ * \file glxclient.h
+ * Direct rendering support added by Precision Insight, Inc.
+ *
+ * \author Kevin E. Martin <kevin@precisioninsight.com>
+ */
+
+#ifndef _GLX_client_h_
+#define _GLX_client_h_
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include <X11/Xproto.h>
+#include <X11/Xlibint.h>
+#define GLX_GLXEXT_PROTOTYPES
+#include <GL/glx.h>
+#include <GL/glxext.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "GL/glxint.h"
+#include "GL/glxproto.h"
+#include "GL/internal/glcore.h"
+#include "glapitable.h"
+#ifdef NEED_GL_FUNCS_WRAPPED
+#include "indirect.h"
+#endif
+#ifdef XTHREADS
+#include "Xthreads.h"
+#endif
+#ifdef GLX_BUILT_IN_XMESA
+#include "realglx.h"  /* just silences prototype warnings */
+#endif
+
+#define GLX_MAJOR_VERSION	1	/* current version numbers */
+#define GLX_MINOR_VERSION	4
+
+#define __GLX_MAX_TEXTURE_UNITS 32
+
+typedef struct __GLXcontextRec __GLXcontext;
+typedef struct __GLXdisplayPrivateRec __GLXdisplayPrivate;
+typedef struct _glapi_table __GLapi;
+
+/************************************************************************/
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <GL/internal/dri_interface.h>
+
+typedef void *(*CreateScreenFunc)(Display *dpy, int scrn, __DRIscreen *psc,
+                                  int numConfigs, __GLXvisualConfig *config);
+
+typedef void *(*CreateNewScreenFunc)(Display *dpy, int scrn, __DRIscreen *psc,
+    const __GLcontextModes * modes, const __DRIversion * ddx_version,
+    const __DRIversion * dri_version, const __DRIversion * drm_version,
+    const __DRIframebuffer * frame_buffer, void * pSAREA,
+    int fd, int internal_api_version, __GLcontextModes ** driver_modes);
+
+
+/**
+ * Display dependent methods.  This structure is initialized during the
+ * \c driCreateDisplay call.
+ */
+struct __DRIdisplayRec {
+    /**
+     * Method to destroy the private DRI display data.
+     */
+    void (*destroyDisplay)(Display *dpy, void *displayPrivate);
+
+    /**
+     * Methods to create the private DRI screen data and initialize the
+     * screen dependent methods.
+     * This is an array [indexed by screen number] of function pointers.
+     * 
+     * \deprecated  This array of function pointers has been replaced by
+     *              \c __DRIdisplayRec::createNewScreen.
+     * \sa __DRIdisplayRec::createNewScreen
+     */
+    CreateScreenFunc * createScreen;
+
+    /**
+     * Opaque pointer to private per display direct rendering data.
+     * \c NULL if direct rendering is not supported on this display.
+     */
+    struct __DRIdisplayPrivateRec *private;
+
+    /**
+     * Array of pointers to methods to create and initialize the private DRI
+     * screen data.
+     *
+     * \sa __DRIdisplayRec::createScreen
+     */
+    CreateNewScreenFunc * createNewScreen;
+};
+
+
+/*
+** We keep a linked list of these structures, one per DRI device driver.
+*/
+struct __DRIdriverRec {
+   const char *name;
+   void *handle;
+   CreateScreenFunc createScreenFunc;
+   CreateNewScreenFunc createNewScreenFunc;
+   struct __DRIdriverRec *next;
+};
+
+/*
+** Function to create and DRI display data and initialize the display
+** dependent methods.
+*/
+extern void *driCreateDisplay(Display *dpy, __DRIdisplay *pdisp);
+
+extern  __DRIdriver *driGetDriver(Display *dpy, int scrNum);
+
+extern void DRI_glXUseXFont( Font font, int first, int count, int listbase );
+
+/*
+** Functions to obtain driver configuration information from a direct
+** rendering client application
+*/
+extern const char *glXGetScreenDriver (Display *dpy, int scrNum);
+
+extern const char *glXGetDriverConfig (const char *driverName);
+
+#endif
+
+/************************************************************************/
+
+#define __GL_CLIENT_ATTRIB_STACK_DEPTH 16
+
+typedef struct __GLXpixelStoreModeRec {
+    GLboolean swapEndian;
+    GLboolean lsbFirst;
+    GLuint rowLength;
+    GLuint imageHeight;
+    GLuint imageDepth;
+    GLuint skipRows;
+    GLuint skipPixels;
+    GLuint skipImages;
+    GLuint alignment;
+} __GLXpixelStoreMode;
+
+/* The next 3 structures are deprecated.  Client state is no longer tracked
+ * using them.  They only remain to maintain the layout / structure offset of
+ * __GLXcontextRec.  In XFree86 5.0 they will be removed altogether.
+ */
+
+typedef struct __GLXvertexArrayPointerStateRecDEPRECATED {
+    GLboolean enable;
+    void (*proc)(const void *);
+    const GLubyte *ptr;
+    GLsizei skip;
+    GLint size;
+    GLenum type;
+    GLsizei stride;
+} __GLXvertexArrayPointerStateDEPRECATED;
+
+typedef struct __GLXvertArrayStateRecDEPRECATED {
+    __GLXvertexArrayPointerStateDEPRECATED vertex;
+    __GLXvertexArrayPointerStateDEPRECATED normal;
+    __GLXvertexArrayPointerStateDEPRECATED color;
+    __GLXvertexArrayPointerStateDEPRECATED index;
+    __GLXvertexArrayPointerStateDEPRECATED texCoord[__GLX_MAX_TEXTURE_UNITS];
+    __GLXvertexArrayPointerStateDEPRECATED edgeFlag;
+    GLint maxElementsVertices;
+    GLint maxElementsIndices;
+    GLint activeTexture;
+} __GLXvertArrayStateDEPRECATED;
+
+typedef struct __GLXattributeRecDEPRECATED {
+	GLuint mask;
+
+	/*
+	** Pixel storage state.  Most of the pixel store mode state is kept
+	** here and used by the client code to manage the packing and
+	** unpacking of data sent to/received from the server.
+	*/
+	__GLXpixelStoreMode storePack, storeUnpack;
+
+	/*
+	** Vertex Array storage state.  The vertex array component
+	** state is stored here and is used to manage the packing of
+	** DrawArrays data sent to the server.
+	*/
+	__GLXvertArrayStateDEPRECATED vertArray;
+} __GLXattributeDEPRECATED;
+
+typedef struct __GLXvertexArrayPointerStateRec {
+    void (*proc)(const void *);
+    void (*mtex_proc)(GLenum, const void *);
+    const GLubyte *ptr;
+    GLsizei skip;
+    GLint size;
+    GLenum type;
+    GLsizei stride;
+} __GLXvertexArrayPointerState;
+
+/**
+ * Define which entries of \c __GLXvertArrayState::arrays match which
+ * vertex arrays in the client-state vector.  These are only the one-of
+ * arrays.  See the \c __GLXvertArrayState::arrays documentation for more
+ * details.
+ * 
+ * \sa __GLXvertArrayState
+ */
+enum {
+    edgeFlag_ARRAY,       /**< \c GL_EDGE_FLAG_ARRAY */
+    index_ARRAY,          /**< \c GL_INDEX_ARRAY */
+    fogCoord_ARRAY,       /**< \c GL_FOG_COORD_ARRAY */
+    secondaryColor_ARRAY, /**< \c GL_SECONDARY_COLOR_ARRAY */
+    color_ARRAY,          /**< \c GL_COLOR_ARRAY */
+    normal_ARRAY,         /**< \c GL_NORMAL_ARRAY */
+       
+    /**
+     * \c GL_VERTEX_ARRAY \b must be last!  All of the code for emitting arrays
+     * and array elements is written based on the assumption that the vertex
+     * array is last.
+     */
+    vertex_ARRAY,
+
+    __GLX_MAX_ARRAYS      /**< Place holder entry. */
+};
+
+#define ENABLE_ARRAY(state,a) \
+    do { (state)->vertArray.enables |=  (1U << (a ## _ARRAY)); } while( 0 )
+#define DISABLE_ARRAY(state,a) \
+    do { (state)->vertArray.enables &= ~(1U << (a ## _ARRAY)); } while( 0 )
+#define IS_ARRAY_ENABLED_BY_INDEX(state, i) \
+    (((state)->vertArray.enables & (1U << (i))) != 0)
+#define IS_ARRAY_ENABLED(state, a) \
+    IS_ARRAY_ENABLED_BY_INDEX(state, a ## _ARRAY)
+
+#define ENABLE_TEXARRAY(state,a) \
+    do { (state)->vertArray.texture_enables |=  (1U << a); } while( 0 )
+#define DISABLE_TEXARRAY(state,a) \
+    do { (state)->vertArray.texture_enables &= ~(1U << a); } while( 0 )
+#define IS_TEXARRAY_ENABLED(state, a) \
+    (((state)->vertArray.texture_enables & (1U << a)) != 0)
+
+/**
+ * Client-side vertex array state.
+ */
+typedef struct __GLXvertArrayStateRec {
+    /**
+     * Which client-side arrays are enabled?  These are the flag bits for
+     * all of the non-texture coordinate arrays.
+     */
+    GLuint enables;
+
+    /**
+     * Which of the texture coordinate arrays are enabled?
+     */
+    GLuint texture_enables;
+
+    /**
+     * State for "one-of" arrays.  These are the arrays, such as
+     * GL_COLOR_ARRAY or GL_FOG_COORD_ARRAY for which there is only one
+     * array.  There are also "many-of" arrays, such as
+     * GL_TEXTURE_COORD_ARRAY.
+     */
+    __GLXvertexArrayPointerState arrays[__GLX_MAX_ARRAYS];
+
+    __GLXvertexArrayPointerState texCoord[__GLX_MAX_TEXTURE_UNITS];
+
+    GLint maxElementsVertices;
+    GLint maxElementsIndices;
+    GLint activeTexture;
+} __GLXvertArrayState;
+
+typedef struct __GLXattributeRec {
+	GLuint mask;
+
+	/*
+	** Pixel storage state.  Most of the pixel store mode state is kept
+	** here and used by the client code to manage the packing and
+	** unpacking of data sent to/received from the server.
+	*/
+	__GLXpixelStoreMode storePack, storeUnpack;
+
+	/*
+	** Vertex Array storage state.  The vertex array component
+	** state is stored here and is used to manage the packing of
+	** DrawArrays data sent to the server.
+	*/
+	__GLXvertArrayState vertArray;
+
+	/**
+	 * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically
+	 * disabled?
+	 */
+	GLboolean NoDrawArraysProtocol;
+} __GLXattribute;
+
+typedef struct __GLXattributeMachineRec {
+	__GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
+	__GLXattribute **stackPointer;
+} __GLXattributeMachine;
+
+/**
+ * GLX state that needs to be kept on the client.  One of these records
+ * exist for each context that has been made current by this client.
+ */
+struct __GLXcontextRec {
+    /**
+     * \name Drawing command buffer.
+     *
+     * Drawing commands are packed into this buffer before being sent as a
+     * single GLX protocol request.  The buffer is sent when it overflows or
+     * is flushed by \c __glXFlushRenderBuffer.  \c pc is the next location
+     * in the buffer to be filled.  \c limit is described above in the buffer
+     * slop discussion.
+     *
+     * Commands that require large amounts of data to be transfered will
+     * also use this buffer to hold a header that describes the large
+     * command.
+     *
+     * These must be the first 6 fields since they are static initialized
+     * in the dummy context in glxext.c
+     */
+    /*@{*/
+    GLubyte *buf;
+    GLubyte *pc;
+    GLubyte *limit;
+    GLubyte *bufEnd;
+    GLint bufSize;
+    /*@}*/
+
+    /**
+     * The XID of this rendering context.  When the context is created a
+     * new XID is allocated.  This is set to None when the context is
+     * destroyed but is still current to some thread. In this case the
+     * context will be freed on next MakeCurrent.
+     */
+    XID xid;
+
+    /**
+     * The XID of the \c shareList context.
+     */
+    XID share_xid;
+
+    /**
+     * Visual id.
+     * 
+     * \deprecated
+     * This filed has been largely been replaced by the \c mode field, but
+     * the work is not quite done.
+     */
+    VisualID vid;
+
+    /**
+     * Screen number.
+     */
+    GLint screen;
+
+    /**
+     * \c GL_TRUE if the context was created with ImportContext, which
+     * means the server-side context was created by another X client.
+     */
+    GLboolean imported;
+
+    /**
+     * The context tag returned by MakeCurrent when this context is made
+     * current. This tag is used to identify the context that a thread has
+     * current so that proper server context management can be done.  It is
+     * used for all context specific commands (i.e., \c Render, \c RenderLarge,
+     * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old
+     * context)).
+     */
+    GLXContextTag currentContextTag;
+
+    /**
+     * \name Rendering mode
+     *
+     * The rendering mode is kept on the client as well as the server.
+     * When \c glRenderMode is called, the buffer associated with the
+     * previous rendering mode (feedback or select) is filled.
+     */
+    /*@{*/
+    GLenum renderMode;
+    GLfloat *feedbackBuf;
+    GLuint *selectBuf;
+    /*@}*/
+
+    /**
+     * This is \c GL_TRUE if the pixel unpack modes are such that an image
+     * can be unpacked from the clients memory by just copying.  It may
+     * still be true that the server will have to do some work.  This
+     * just promises that a straight copy will fetch the correct bytes.
+     */
+    GLboolean fastImageUnpack;
+
+    /**
+     * Fill newImage with the unpacked form of \c oldImage getting it
+     * ready for transport to the server.
+     */
+    void (*fillImage)(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+		      GLenum, const GLvoid*, GLubyte*, GLubyte*);
+
+    /**
+     * \name Client side attribs.
+     */
+    /*@{*/
+    __GLXattributeDEPRECATED stateDEPRECATED;
+    __GLXattributeMachine attributes;
+    /*@}*/
+
+    /**
+     * Client side error code.  This is set when client side gl API
+     * routines need to set an error because of a bad enumerant or
+     * running out of memory, etc.
+     */
+    GLenum error;
+
+    /**
+     * Whether this context does direct rendering.
+     */
+    Bool isDirect;
+
+    /**
+     * \c dpy of current display for this context.  Will be \c NULL if not
+     * current to any display, or if this is the "dummy context".
+     */
+    Display *currentDpy;
+
+    /**
+     * The current drawable for this context.  Will be None if this
+     * context is not current to any drawable.  currentReadable is below.
+     */
+    GLXDrawable currentDrawable;
+
+    /**
+     * \name GL Constant Strings
+     *
+     * Constant strings that describe the server implementation
+     * These pertain to GL attributes, not to be confused with
+     * GLX versioning attributes.
+     */
+    /*@{*/
+    GLubyte *vendor;
+    GLubyte *renderer;
+    GLubyte *version;
+    GLubyte *extensions;
+    /*@}*/
+
+    /**
+     * Record the dpy this context was created on for later freeing
+     */
+    Display *createDpy;
+
+    /**
+     * Maximum small render command size.  This is the smaller of 64k and
+     * the size of the above buffer.
+     */
+    GLint maxSmallRenderCommandSize;
+
+    /**
+     * Major opcode for the extension.  Copied here so a lookup isn't
+     * needed.
+     */
+    GLint majorOpcode;
+
+#ifdef GLX_DIRECT_RENDERING
+    /**
+     * Per context direct rendering interface functions and data.
+     */
+    __DRIcontext driContext;
+#endif
+    
+    /**
+     * \c GLXFBConfigID used to create this context.  May be \c None.  This
+     * field has been replaced by the \c mode field.
+     *
+     * \since Internal API version 20030317.
+     *
+     * \deprecated
+     * This filed has been largely been replaced by the \c mode field, but
+     * the work is not quite done.
+     */
+    GLXFBConfigID  fbconfigID;
+
+    /**
+     * The current read-drawable for this context.  Will be None if this
+     * context is not current to any drawable.
+     *
+     * \since Internal API version 20030606.
+     */
+    GLXDrawable currentReadable;
+
+   /** 
+    * Pointer to client-state data that is private to libGL.  This is only
+    * used for indirect rendering contexts.
+    *
+    * No internal API version change was made for this change.  Client-side
+    * drivers should NEVER use this data or even care that it exists.
+    */
+   void * client_state_private;
+   
+   /**
+    * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE.
+    */
+   int renderType;
+    
+   /**
+    * \name Raw server GL version
+    *
+    * True core GL version supported by the server.  This is the raw value
+    * returned by the server, and it may not reflect what is actually
+    * supported (or reported) by the client-side library.
+    */
+    /*@{*/
+   int server_major;        /**< Major version number. */
+   int server_minor;        /**< Minor version number. */
+    /*@}*/
+};
+
+#define __glXSetError(gc,code) \
+    if (!(gc)->error) {	       \
+	(gc)->error = code;    \
+    }
+
+extern void __glFreeAttributeState(__GLXcontext *);
+
+/************************************************************************/
+
+/**
+ * The size of the largest drawing command known to the implementation
+ * that will use the GLXRender GLX command.  In this case it is
+ * \c glPolygonStipple.
+ */
+#define __GLX_MAX_SMALL_RENDER_CMD_SIZE	156
+
+/**
+ * To keep the implementation fast, the code uses a "limit" pointer
+ * to determine when the drawing command buffer is too full to hold
+ * another fixed size command.  This constant defines the amount of
+ * space that must always be available in the drawing command buffer
+ * at all times for the implementation to work.  It is important that
+ * the number be just large enough, but not so large as to reduce the
+ * efficacy of the buffer.  The "+32" is just to keep the code working
+ * in case somebody counts wrong.
+ */
+#define __GLX_BUFFER_LIMIT_SIZE	(__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32)
+
+/**
+ * This implementation uses a smaller threshold for switching
+ * to the RenderLarge protocol than the protcol requires so that
+ * large copies don't occur.
+ */
+#define __GLX_RENDER_CMD_SIZE_LIMIT	4096
+
+/**
+ * One of these records exists per screen of the display.  It contains
+ * a pointer to the config data for that screen (if the screen supports GL).
+ */
+typedef struct __GLXscreenConfigsRec {
+    /**
+     * GLX visuals formated as \c __GLXvisualConfig structures.
+     */
+    /*@{*/
+    __GLXvisualConfig * old_configs;
+    int numOldConfigs;
+    /*@}*/
+
+    /**
+     * GLX extension string reported by the X-server.
+     */
+    const char *serverGLXexts;
+
+    /**
+     * GLX extension string to be reported to applications.  This is the
+     * set of extensions that the application can actually use.
+     */
+    char *effectiveGLXexts;
+
+#ifdef GLX_DIRECT_RENDERING
+    /**
+     * Per screen direct rendering interface functions and data.
+     */
+    __DRIscreen driScreen;
+#endif
+
+    /**
+     * Linked list of configurations for this screen.  This is intended to
+     * be a superset of \c old_configs.
+     */
+    __GLcontextModes *configs;
+    /**
+     * Per-screen dynamic GLX extension tracking.  The \c direct_support
+     * field only contains enough bits for 64 extensions.  Should libGL
+     * ever need to track more than 64 GLX extensions, we can safely grow
+     * this field.  The \c __GLXscreenConfigs structure is not used outside
+     * libGL.
+     */
+    /*@{*/
+    unsigned char direct_support[8];
+    GLboolean ext_list_first_time;
+    /*@}*/
+
+} __GLXscreenConfigs;
+
+/**
+ * Per display private data.  One of these records exists for each display
+ * that is using the OpenGL (GLX) extension.
+ */
+struct __GLXdisplayPrivateRec {
+    /**
+     * Back pointer to the display
+     */
+    Display *dpy;
+
+    /**
+     * The \c majorOpcode is common to all connections to the same server.
+     * It is also copied into the context structure.
+     */
+    int majorOpcode;
+
+    /**
+     * \name Server Version
+     *
+     * Major and minor version returned by the server during initialization.
+     */
+    /*@{*/
+    int majorVersion, minorVersion;
+    /*@}*/
+
+    /**
+     * \name Storage for the servers GLX vendor and versions strings.
+     * 
+     * These are the same for all screens on this display. These fields will
+     * be filled in on demand.
+     */
+    /*@{*/
+    const char *serverGLXvendor;
+    const char *serverGLXversion;
+    /*@}*/
+
+    /**
+     * Configurations of visuals for all screens on this display.
+     * Also, per screen data which now includes the server \c GLX_EXTENSION
+     * string.
+     */
+    __GLXscreenConfigs *screenConfigs;
+
+#ifdef GLX_DIRECT_RENDERING
+    /**
+     * Per display direct rendering interface functions and data.
+     */
+    __DRIdisplay driDisplay;
+#endif
+};
+
+void __glXFreeContext(__GLXcontext*);
+
+extern GLubyte *__glXFlushRenderBuffer(__GLXcontext*, GLubyte*);
+
+extern void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber, 
+				GLint totalRequests,
+				const GLvoid * data, GLint dataLen);
+
+extern void __glXSendLargeCommand(__GLXcontext *, const GLvoid *, GLint,
+				  const GLvoid *, GLint);
+
+/* Initialize the GLX extension for dpy */
+extern __GLXdisplayPrivate *__glXInitialize(Display*);
+
+/************************************************************************/
+
+extern int __glXDebug;
+
+/* This is per-thread storage in an MT environment */
+#if defined(GLX_DIRECT_RENDERING) && defined(XTHREADS)
+extern __GLXcontext *__glXGetCurrentContext(void);
+extern void __glXSetCurrentContext(__GLXcontext *c);
+#else
+extern __GLXcontext *__glXcurrentContext;
+#define __glXGetCurrentContext()	__glXcurrentContext
+#define __glXSetCurrentContext(gc)	__glXcurrentContext = gc
+#endif
+
+
+/*
+** Global lock for all threads in this address space using the GLX
+** extension
+*/
+#if defined(GLX_DIRECT_RENDERING) && defined(XTHREADS)
+extern xmutex_rec __glXmutex;
+#define __glXLock()    xmutex_lock(&__glXmutex)
+#define __glXUnlock()  xmutex_unlock(&__glXmutex)
+#else
+#define __glXLock()
+#define __glXUnlock()
+#endif
+
+/*
+** Setup for a command.  Initialize the extension for dpy if necessary.
+*/
+extern CARD8 __glXSetupForCommand(Display *dpy);
+
+/************************************************************************/
+
+/*
+** Data conversion and packing support.
+*/
+
+/* Return the size, in bytes, of some pixel data */
+extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum);
+
+/* Return the number of elements per group of a specified format*/
+extern GLint __glElementsPerGroup(GLenum format, GLenum type);
+
+/* Return the number of bytes per element, based on the element type (other
+** than GL_BITMAP).
+*/
+extern GLint __glBytesPerElement(GLenum type);
+
+/* Return the k value for a given map target */
+extern GLint __glEvalComputeK(GLenum);
+
+/*
+** Fill the transport buffer with the data from the users buffer,
+** applying some of the pixel store modes (unpack modes) to the data
+** first.  As a side effect of this call, the "modes" field is
+** updated to contain the modes needed by the server to decode the
+** sent data.
+*/
+extern void __glFillImage(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+			  GLenum, const GLvoid*, GLubyte*, GLubyte*);
+
+/* Copy map data with a stride into a packed buffer */
+extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *);
+extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *);
+extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint,
+			  const GLfloat *, GLfloat *);
+extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint,
+			  const GLdouble *, GLdouble *);
+
+/*
+** Empty an image out of the reply buffer into the clients memory applying
+** the pack modes to pack back into the clients requested format.
+*/
+extern void __glEmptyImage(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+		           GLenum, const GLubyte *, GLvoid *);
+
+
+/*
+** Allocate and Initialize Vertex Array client state 
+*/
+extern void __glXInitVertexArrayState(__GLXcontext*);
+
+/*
+** Inform the Server of the major and minor numbers and of the client
+** libraries extension string.
+*/
+extern void __glXClientInfo (  Display *dpy, int opcode );
+
+/************************************************************************/
+
+/*
+** Declarations that should be in Xlib
+*/
+#ifdef __GL_USE_OUR_PROTOTYPES
+extern void _XFlush(Display*);
+extern Status _XReply(Display*, xReply*, int, Bool);
+extern void _XRead(Display*, void*, long);
+extern void _XSend(Display*, const void*, long);
+#endif
+
+
+/*
+** GLX_BUILT_IN_XMESA controls whether libGL has a built-in verions of
+** Mesa that can render to non-GLX displays.
+*/
+#ifdef GLX_BUILT_IN_XMESA
+#define GLX_PREFIX(function)  _real_##function
+#else
+#define GLX_PREFIX(function)  function
+#endif
+
+
+extern void __glXInitializeVisualConfigFromTags( __GLcontextModes *config,
+    int count, const INT32 *bp, Bool tagged_only, Bool fbconfig_style_tags );
+
+extern char * __glXGetStringFromServer( Display * dpy, int opcode,
+    CARD32 glxCode, CARD32 for_whom, CARD32 name );
+
+extern char *__glXstrdup(const char *str);
+
+
+extern const char __glXGLClientVersion[];
+extern const char __glXGLClientExtensions[];
+
+/* Determine the internal API version */
+extern int __glXGetInternalVersion(void);
+
+/* Get the unadjusted system time */
+extern int __glXGetUST( int64_t * ust );
+
+#endif /* !__GLX_client_h__ */

src/glx/x11/glxextensions.c

@@ -0,0 +1,710 @@
+/*
+ * (C) Copyright IBM Corporation 2002, 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file glxextensions.c
+ *
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+/* $XFree86: xc/lib/GL/glx/glxextensions.c,v 1.1 2003/09/28 20:15:03 alanh Exp $ */
+
+#include "glxclient.h"
+#include <extutil.h>
+#include <Xext.h>
+#include <string.h>
+#include "glapi.h"
+#include "glxextensions.h"
+#include "simple_list.h"
+
+#define SET_BIT(m,b)   (m[ (b) / 8 ] |=  (1U << ((b) % 8)))
+#define CLR_BIT(m,b)   (m[ (b) / 8 ] &= ~(1U << ((b) % 8)))
+#define IS_SET(m,b)    ((m[ (b) / 8 ] & (1U << ((b) % 8))) != 0)
+#define CONCAT(a,b) a ## b
+#define GLX(n) "GLX_" # n, 4 + sizeof( # n ) - 1, CONCAT(n,_bit)
+#define GL(n)  "GL_" # n,  3 + sizeof( # n ) - 1, GL_ ## n ## _bit
+#define VER(a,b)  a, b
+#define Y  1
+#define N  0
+#define EXT_ENABLED(bit,supported) (IS_SET( supported, bit ))
+
+
+struct extension_info {
+   const char * const name;
+   unsigned   name_len;
+
+   unsigned char  bit;
+
+   /* This is the lowest version of GLX that "requires" this extension.
+    * For example, GLX 1.3 requires SGIX_fbconfig, SGIX_pbuffer, and
+    * SGI_make_current_read.  If the extension is not required by any known
+    * version of GLX, use 0, 0.
+    */
+   unsigned char  version_major;
+   unsigned char  version_minor;
+   unsigned char  client_support;
+   unsigned char  direct_support;
+   unsigned char  client_only;       /** Is the extension client-side only? */
+   unsigned char  direct_only;       /** Is the extension for direct
+				      * contexts only?
+				      */
+};
+
+static const struct extension_info known_glx_extensions[] = {
+   { GLX(ARB_get_proc_address),        VER(1,4), Y, N, Y, N },
+   { GLX(ARB_multisample),             VER(1,4), Y, Y, N, N },
+   { GLX(ARB_render_texture),          VER(0,0), N, N, N, N },
+   { GLX(ATI_pixel_format_float),      VER(0,0), N, N, N, N },
+   { GLX(EXT_import_context),          VER(0,0), Y, Y, N, N },
+   { GLX(EXT_visual_info),             VER(0,0), Y, Y, N, N },
+   { GLX(EXT_visual_rating),           VER(0,0), Y, Y, N, N },
+   { GLX(MESA_agp_offset),             VER(0,0), N, N, N, Y }, /* Deprecated */
+   { GLX(MESA_allocate_memory),        VER(0,0), Y, N, N, Y },
+   { GLX(MESA_copy_sub_buffer),        VER(0,0), N, N, N, N }, /* Deprecated? */
+   { GLX(MESA_pixmap_colormap),        VER(0,0), N, N, N, N }, /* Deprecated */
+   { GLX(MESA_release_buffers),        VER(0,0), N, N, N, N }, /* Deprecated */
+   { GLX(MESA_set_3dfx_mode),          VER(0,0), N, N, N, N }, /* Deprecated */
+   { GLX(MESA_swap_control),           VER(0,0), Y, N, N, Y },
+   { GLX(MESA_swap_frame_usage),       VER(0,0), Y, N, N, Y },
+   { GLX(NV_float_buffer),             VER(0,0), N, N, N, N },
+   { GLX(NV_render_depth_texture),     VER(0,0), N, N, N, N },
+   { GLX(NV_render_texture_rectangle), VER(0,0), N, N, N, N },
+   { GLX(NV_vertex_array_range),       VER(0,0), N, N, N, Y }, /* Deprecated */
+   { GLX(OML_swap_method),             VER(0,0), Y, N, N, N },
+   { GLX(OML_sync_control),            VER(0,0), Y, N, N, Y },
+   { GLX(SGI_cushion),                 VER(0,0), N, N, N, N },
+   { GLX(SGI_make_current_read),       VER(1,3), Y, N, N, N },
+   { GLX(SGI_swap_control),            VER(0,0), Y, N, N, N },
+   { GLX(SGI_video_sync),              VER(0,0), Y, N, N, Y },
+   { GLX(SGIS_blended_overlay),        VER(0,0), N, N, N, N },
+   { GLX(SGIS_color_range),            VER(0,0), N, N, N, N },
+   { GLX(SGIS_multisample),            VER(0,0), Y, Y, N, N },
+   { GLX(SGIX_dm_buffer),              VER(0,0), N, N, N, N },
+   { GLX(SGIX_fbconfig),               VER(1,3), Y, N, N, N },
+   { GLX(SGIX_pbuffer),                VER(1,3), Y, N, N, N },
+   { GLX(SGIX_swap_barrier),           VER(0,0), N, N, N, N },
+   { GLX(SGIX_swap_group),             VER(0,0), N, N, N, N },
+   { GLX(SGIX_video_resize),           VER(0,0), N, N, N, N },
+   { GLX(SGIX_video_source),           VER(0,0), N, N, N, N },
+   { GLX(SGIX_visual_select_group),    VER(0,0), Y, Y, N, N },
+   { GLX(SUN_get_transparent_index),   VER(0,0), N, N, N, N },
+   { NULL }
+};
+
+static const struct extension_info known_gl_extensions[] = {
+   { GL(ARB_depth_texture),              VER(1,4), Y, N, N, N },
+   { GL(ARB_fragment_program),           VER(0,0), N, N, N, N },
+   { GL(ARB_imaging),                    VER(0,0), Y, N, N, N },
+   { GL(ARB_multisample),                VER(1,3), Y, N, N, N },
+   { GL(ARB_multitexture),               VER(1,3), Y, N, N, N },
+   { GL(ARB_occlusion_query),            VER(1,5), N, N, N, N },
+   { GL(ARB_point_parameters),           VER(1,4), Y, N, N, N },
+   { GL(ARB_point_sprite),               VER(0,0), Y, N, N, N },
+   { GL(ARB_shadow),                     VER(1,4), Y, N, N, N },
+   { GL(ARB_shadow_ambient),             VER(0,0), Y, N, N, N },
+   { GL(ARB_texture_border_clamp),       VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_compression),        VER(1,3), N, N, N, N },
+   { GL(ARB_texture_cube_map),           VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_env_add),            VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_env_combine),        VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_env_crossbar),       VER(1,4), Y, N, N, N },
+   { GL(ARB_texture_env_dot3),           VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_mirrored_repeat),    VER(1,4), Y, N, N, N },
+   { GL(ARB_texture_non_power_of_two),   VER(1,5), Y, N, N, N },
+   { GL(ARB_transpose_matrix),           VER(1,3), Y, N, Y, N },
+   { GL(ARB_vertex_buffer_object),       VER(1,5), N, N, N, N },
+   { GL(ARB_window_pos),                 VER(1,4), Y, N, N, N },
+   { GL(EXT_abgr),                       VER(0,0), Y, N, N, N },
+   { GL(EXT_bgra),                       VER(1,2), Y, N, N, N },
+   { GL(EXT_blend_color),                VER(1,4), Y, N, N, N },
+   { GL(EXT_blend_equation_separate),    VER(0,0), N, N, N, N },
+   { GL(EXT_blend_func_separate),        VER(1,4), Y, N, N, N },
+   { GL(EXT_blend_logic_op),             VER(1,4), Y, N, N, N },
+   { GL(EXT_blend_minmax),               VER(1,4), Y, N, N, N },
+   { GL(EXT_blend_subtract),             VER(1,4), Y, N, N, N },
+   { GL(EXT_clip_volume_hint),           VER(0,0), Y, N, N, N },
+   { GL(EXT_compiled_vertex_array),      VER(0,0), N, N, N, N },
+   { GL(EXT_convolution),                VER(0,0), N, N, N, N },
+   { GL(EXT_copy_texture),               VER(1,1), Y, N, N, N },
+   { GL(EXT_cull_vertex),                VER(0,0), N, N, N, N },
+   { GL(EXT_depth_bounds_test),          VER(0,0), N, N, N, N },
+   { GL(EXT_draw_range_elements),        VER(1,2), Y, N, Y, N },
+   { GL(EXT_fog_coord),                  VER(1,4), Y, N, N, N },
+   { GL(EXT_multi_draw_arrays),          VER(1,4), Y, N, Y, N },
+   { GL(EXT_packed_pixels),              VER(1,2), Y, N, N, N },
+   { GL(EXT_paletted_texture),           VER(0,0), Y, N, N, N },
+   { GL(EXT_pixel_buffer_object),        VER(0,0), N, N, N, N },
+   { GL(EXT_point_parameters),           VER(1,4), Y, N, N, N },
+   { GL(EXT_polygon_offset),             VER(1,1), Y, N, N, N },
+   { GL(EXT_rescale_normal),             VER(1,2), Y, N, N, N },
+   { GL(EXT_secondary_color),            VER(1,4), Y, N, N, N },
+   { GL(EXT_separate_specular_color),    VER(1,2), Y, N, N, N },
+   { GL(EXT_shadow_funcs),               VER(1,5), Y, N, N, N },
+   { GL(EXT_shared_texture_palette),     VER(0,0), Y, N, N, N },
+   { GL(EXT_stencil_two_side),           VER(0,0), Y, N, N, N },
+   { GL(EXT_stencil_wrap),               VER(1,4), Y, N, N, N },
+   { GL(EXT_subtexture),                 VER(1,1), Y, N, N, N },
+   { GL(EXT_texture),                    VER(1,1), Y, N, N, N },
+   { GL(EXT_texture3D),                  VER(1,2), Y, N, N, N },
+   { GL(EXT_texture_compression_s3tc),   VER(0,0), N, N, N, N },
+   { GL(EXT_texture_edge_clamp),         VER(1,2), Y, N, N, N },
+   { GL(EXT_texture_env_add),            VER(1,3), Y, N, N, N },
+   { GL(EXT_texture_env_combine),        VER(1,3), Y, N, N, N },
+   { GL(EXT_texture_env_dot3),           VER(0,0), Y, N, N, N },
+   { GL(EXT_texture_filter_anisotropic), VER(0,0), Y, N, N, N },
+   { GL(EXT_texture_lod),                VER(1,2), Y, N, N, N },
+   { GL(EXT_texture_lod_bias),           VER(1,4), Y, N, N, N },
+   { GL(EXT_texture_mirror_clamp),       VER(0,0), Y, N, N, N },
+   { GL(EXT_texture_object),             VER(1,1), Y, N, N, N },
+   { GL(EXT_texture_rectangle),          VER(0,0), Y, N, N, N },
+   { GL(EXT_vertex_array),               VER(0,0), Y, N, N, N },
+   { GL(3DFX_texture_compression_FXT1),  VER(0,0), N, N, N, N },
+   { GL(APPLE_packed_pixels),            VER(1,2), Y, N, N, N },
+   { GL(APPLE_ycbcr_422),                VER(0,0), Y, N, N, N },
+   { GL(ATI_texture_env_combine3),       VER(0,0), Y, N, N, N },
+   { GL(ATI_texture_float),              VER(0,0), Y, N, N, N },
+   { GL(ATI_texture_mirror_once),        VER(0,0), Y, N, N, N },
+   { GL(ATIX_texture_env_combine3),      VER(0,0), Y, N, N, N },
+   { GL(HP_convolution_border_modes),    VER(0,0), Y, N, N, N },
+
+    /* This is currently removed because there seem to be some problems with
+     * it and the software-only indirect rendering path.  At this point, I'm
+     * not sure which side (client or server) has the problem. - idr
+     */
+   { GL(HP_occlusion_test),              VER(0,0), N, N, N, N },
+
+   { GL(IBM_cull_vertex),                VER(0,0), Y, N, N, N },
+   { GL(IBM_pixel_filter_hint),          VER(0,0), Y, N, N, N },
+   { GL(IBM_rasterpos_clip),             VER(0,0), Y, N, N, N },
+   { GL(IBM_texture_clamp_nodraw),       VER(0,0), Y, N, N, N },
+   { GL(IBM_texture_mirrored_repeat),    VER(0,0), Y, N, N, N },
+   { GL(INGR_blend_func_separate),       VER(0,0), Y, N, N, N },
+   { GL(INGR_interlace_read),            VER(0,0), Y, N, N, N },
+   { GL(MESA_pack_invert),               VER(0,0), Y, N, N, N },
+   { GL(MESA_ycbcr_texture),             VER(0,0), Y, N, N, N },
+   { GL(NV_blend_square),                VER(1,4), Y, N, N, N },
+   { GL(NV_copy_depth_to_color),         VER(0,0), Y, N, N, N },
+   { GL(NV_depth_clamp),                 VER(0,0), Y, N, N, N },
+   { GL(NV_fog_distance),                VER(0,0), Y, N, N, N },
+   { GL(NV_light_max_exponent),          VER(0,0), Y, N, N, N },
+   { GL(NV_multisample_filter_hint),     VER(0,0), Y, N, N, N },
+   { GL(NV_point_sprite),                VER(0,0), Y, N, N, N },
+   { GL(NV_texgen_reflection),           VER(0,0), Y, N, N, N },
+   { GL(NV_texture_compression_vtc),     VER(0,0), N, N, N, N },
+   { GL(NV_texture_env_combine4),        VER(0,0), Y, N, N, N },
+   { GL(NV_texture_rectangle),           VER(0,0), Y, N, N, N },
+   { GL(SGIS_generate_mipmap),           VER(1,4), Y, N, N, N },
+   { GL(SGIS_multisample),               VER(0,0), Y, N, N, N },
+   { GL(SGIS_texture_border_clamp),      VER(1,3), Y, N, N, N },
+   { GL(SGIS_texture_edge_clamp),        VER(1,2), Y, N, N, N },
+   { GL(SGIS_texture_lod),               VER(1,2), Y, N, N, N },
+   { GL(SGIX_blend_alpha_minmax),        VER(0,0), Y, N, N, N },
+   { GL(SGIX_clipmap),                   VER(0,0), Y, N, N, N },
+   { GL(SGIX_depth_texture),             VER(0,0), Y, N, N, N },
+   { GL(SGIX_fog_offset),                VER(0,0), Y, N, N, N },
+   { GL(SGIX_shadow),                    VER(0,0), Y, N, N, N },
+   { GL(SGIX_shadow_ambient),            VER(0,0), Y, N, N, N },
+   { GL(SGIX_texture_coordinate_clamp),  VER(0,0), Y, N, N, N },
+   { GL(SGIX_texture_lod_bias),          VER(0,0), Y, N, N, N },
+   { GL(SGIX_texture_range),             VER(0,0), Y, N, N, N },
+   { GL(SGIX_texture_scale_bias),        VER(0,0), Y, N, N, N },
+   { GL(SGIX_vertex_preclip),            VER(0,0), Y, N, N, N },
+   { GL(SGIX_vertex_preclip_hint),       VER(0,0), Y, N, N, N },
+   { GL(SGIX_ycrcb),                     VER(0,0), Y, N, N, N },
+   { GL(SUN_convolution_border_modes),   VER(0,0), Y, N, N, N },
+   { GL(SUN_multi_draw_arrays),          VER(0,0), Y, N, Y, N },
+   { GL(SUN_slice_accum),                VER(0,0), Y, N, N, N },
+   { NULL }
+};
+
+
+#define __GL_EXT_BYTES   ((__NUM_GL_EXTS + 7) / 8)
+
+/* global bit-fields of available extensions and their characteristics */
+static unsigned char client_glx_support[8];
+static unsigned char client_glx_only[8];
+static unsigned char direct_glx_only[8];
+static unsigned char client_gl_support[ __GL_EXT_BYTES ];
+static unsigned char client_gl_only[ __GL_EXT_BYTES ];
+
+/**
+ * Bits representing the set of extensions that are enabled by default in all
+ * direct rendering drivers.
+ */
+static unsigned char direct_glx_support[8];
+
+/**
+ * Highest core GL version that can be supported for indirect rendering.
+ */
+static unsigned gl_major = 0;
+static unsigned gl_minor = 0;
+
+/* client extensions string */
+static const char * __glXGLXClientExtensions = NULL;
+
+static void __glXExtensionsCtr( void );
+static void __glXExtensionsCtrScreen( __GLXscreenConfigs *psc );
+static void __glXProcessServerString( const struct extension_info * ext,
+    const char * server_string, unsigned char * server_support );
+
+/**
+ * Set the state of a GLX extension.
+ *
+ * \param name      Name of the extension.
+ * \param name_len  Length, in characters, of the extension name.
+ * \param state     New state (either enabled or disabled) of the extension.
+ * \param supported Table in which the state of the extension is to be set.
+ */
+static void
+set_glx_extension( const struct extension_info * ext,
+		   const char * name, unsigned name_len, GLboolean state,
+		   unsigned char * supported )
+{
+   unsigned   i;
+
+
+   for ( i = 0 ; ext[i].name != NULL ; i++ ) {
+      if ( (name_len == ext[i].name_len)
+	   && (strncmp( ext[i].name, name, name_len ) == 0) ) {
+	 if ( state ) {
+	    SET_BIT( supported, ext[i].bit );
+	 }
+	 else {
+	    CLR_BIT( supported, ext[i].bit );
+	 }
+
+	 return;
+      }
+   }
+}
+
+
+#define NUL '\0'
+#define SEPARATOR ' '
+
+/**
+ * Convert the server's extension string to a bit-field.
+ * 
+ * \param server_string   GLX extension string from the server.
+ * \param server_support  Bit-field of supported extensions.
+ */
+static void
+__glXProcessServerString( const struct extension_info * ext,
+			  const char * server_string,
+			  unsigned char * server_support )
+{
+   unsigned  base;
+   unsigned  len;
+
+   (void) memset( server_support, 0, sizeof( server_support ) );
+   
+   for ( base = 0 ; server_string[ base ] != NUL ; /* empty */ ) {
+      /* Determine the length of the next extension name.
+       */
+      for ( len = 0
+	    ; (server_string[ base + len ] != SEPARATOR)
+	    && (server_string[ base + len ] != NUL)
+	    ; len++ ) {
+	 /* empty */
+      }
+
+      /* Set the bit for the extension in the server_support table.
+       */
+      set_glx_extension( ext, & server_string[ base ], len, GL_TRUE,
+			 server_support );
+
+ 
+      /* Advance to the next extension string.  This means that we skip
+       * over the previous string and any trialing white-space.
+       */
+      for ( base += len ;
+	    (server_string[ base ] == SEPARATOR)
+	    && (server_string[ base ] != NUL)
+	    ; base++ ) {
+	 /* empty */
+      }
+   }
+}
+
+
+/**
+ * Enable a named GLX extension on a given screen.
+ * Drivers should not call this function directly.  They should instead use
+ * \c glXGetProcAddress to obtain a pointer to the function.
+ *
+ * \param psc   Pointer to GLX per-screen record.
+ * \param name  Name of the extension to enable.
+ *
+ * \sa glXGetProcAddress
+ *
+ * \since Internal API version 20030813.
+ */
+void
+__glXScrEnableExtension( __GLXscreenConfigs *psc, const char * name )
+{
+   __glXExtensionsCtr();
+   __glXExtensionsCtrScreen(psc);
+   set_glx_extension( known_glx_extensions, name, strlen( name ), GL_TRUE,
+		      psc->direct_support );
+}
+
+
+/**
+ * Initialize global extension support tables.
+ */
+
+static void
+__glXExtensionsCtr( void )
+{
+   static const char major_table[32] = { 1, 1, 1, 1, 1, 1, 2, };
+   static const char minor_table[32] = { 0, 1, 2, 3, 4, 5, 0, };
+   unsigned   i;
+   static GLboolean ext_list_first_time = GL_TRUE;
+   unsigned   full_support = ~0;
+
+
+   if ( ext_list_first_time ) {
+      ext_list_first_time = GL_FALSE;
+
+      (void) memset( client_glx_support, 0, sizeof( client_glx_support ) );
+      (void) memset( direct_glx_support, 0, sizeof( direct_glx_support ) );
+      (void) memset( client_glx_only,    0, sizeof( client_glx_only ) );
+      (void) memset( direct_glx_only,    0, sizeof( direct_glx_only ) );
+
+      (void) memset( client_gl_support,  0, sizeof( client_gl_support ) );
+      (void) memset( client_gl_only,     0, sizeof( client_gl_only ) );
+
+      for ( i = 0 ; known_glx_extensions[i].name != NULL ; i++ ) {
+	 const unsigned  bit = known_glx_extensions[i].bit;
+
+	 if ( known_glx_extensions[i].client_support ) {
+	    SET_BIT( client_glx_support, bit );
+	 }
+
+	 if ( known_glx_extensions[i].direct_support ) {
+	    SET_BIT( direct_glx_support, bit );
+	 }
+
+	 if ( known_glx_extensions[i].client_only ) {
+	    SET_BIT( client_glx_only, bit );
+	 }
+
+	 if ( known_glx_extensions[i].direct_only ) {
+	    SET_BIT( direct_glx_only, bit );
+	 }
+      }
+
+      for ( i = 0 ; known_gl_extensions[i].name != NULL ; i++ ) {
+	 const unsigned  bit = known_gl_extensions[i].bit;
+
+	 if ( known_gl_extensions[i].client_support ) {
+	    SET_BIT( client_gl_support, bit );
+	 }
+	 else if ( known_gl_extensions[i].version_major != 0 ) {
+	    /* If an extension that is required for some core GL version is
+	     * not supported, clear the bit for that core GL version as well.
+	     */
+
+	    unsigned ver_bit = (6 * (known_gl_extensions[i].version_major - 1))
+	      + (known_gl_extensions[i].version_minor);
+
+	    full_support &= ~(1U << ver_bit);
+	 }
+
+	 if ( known_gl_extensions[i].client_only ) {
+	    SET_BIT( client_gl_only, bit );
+	 }
+      }
+      
+      /* Determine the lowest unsupported core GL version.  The version before
+       * that is, therefore, the highest supported core GL version.
+       */
+      for ( i = 0 ; (full_support & (1 << i)) != 0 ; i++ )
+	 /* empty */ ;
+
+      i--;
+      gl_major = major_table[i];
+      gl_minor = minor_table[i];
+#if 0
+      fprintf( stderr, "[%s:%u] Maximum client library version: %u.%u\n",
+	       __func__, __LINE__, gl_major, gl_minor );
+#endif
+   }
+}
+
+
+/**
+ * Make sure that per-screen direct-support table is initialized.
+ *
+ * \param psc  Pointer to GLX per-screen record.
+ */
+
+static void
+__glXExtensionsCtrScreen( __GLXscreenConfigs *psc )
+{
+    if (psc->ext_list_first_time) {
+	psc->ext_list_first_time = GL_FALSE;
+	(void) memcpy( psc->direct_support, direct_glx_support,
+		       sizeof( direct_glx_support ) );
+    }
+}
+
+
+/**
+ * Check if a certain extension is enabled on a given screen.
+ *
+ * \param psc  Pointer to GLX per-screen record.
+ * \param bit  Bit index in the direct-support table.
+ * \returns If the extension bit is enabled for the screen, \c GL_TRUE is
+ *          returned.  If the extension bit is not enabled or if \c psc is
+ *          \c NULL, then \c GL_FALSE is returned.
+ */
+GLboolean
+__glXExtensionBitIsEnabled( __GLXscreenConfigs *psc, unsigned bit )
+{
+   GLboolean enabled = GL_FALSE;
+
+   if ( psc != NULL ) {
+      __glXExtensionsCtr();
+      __glXExtensionsCtrScreen( psc );
+      enabled = EXT_ENABLED( bit, psc->direct_support );
+   }
+
+   return enabled;
+}
+
+
+/**
+ * Convert a bit-field to a string of supported extensions.
+ */
+static char *
+__glXGetStringFromTable( const struct extension_info * ext,
+			 const unsigned char * supported )
+{
+   unsigned   i;
+   unsigned   ext_str_len;
+   char * ext_str;
+   char * point;
+
+
+   ext_str_len = 0;
+   for ( i = 0 ; ext[i].name != NULL ; i++ ) {
+      if ( EXT_ENABLED( ext[i].bit, supported ) ) {
+	 ext_str_len += ext[i].name_len + 1;
+      }
+   }
+
+   ext_str = Xmalloc( ext_str_len + 1 );
+   if ( ext_str != NULL ) {
+      point = ext_str;
+
+      for ( i = 0 ; ext[i].name != NULL ; i++ ) {
+	 if ( EXT_ENABLED( ext[i].bit, supported ) ) {
+	    (void) memcpy( point, ext[i].name, ext[i].name_len );
+	    point += ext[i].name_len;
+
+	    *point = ' ';
+	    point++;
+	 }
+      }
+
+      *point = '\0';
+   }
+
+   return ext_str;
+}
+
+
+/**
+ * Get the string of client library supported extensions.
+ */
+const char *
+__glXGetClientExtensions( void )
+{
+   if ( __glXGLXClientExtensions == NULL ) {
+      __glXExtensionsCtr();
+      __glXGLXClientExtensions = __glXGetStringFromTable( known_glx_extensions,
+							  client_glx_support );
+   }
+
+   return __glXGLXClientExtensions;
+}
+
+
+/**
+ * Calculate the list of application usable extensions.  The resulting
+ * string is stored in \c psc->effectiveGLXexts.
+ * 
+ * \param psc                        Pointer to GLX per-screen record.
+ * \param display_is_direct_capable  True if the display is capable of
+ *                                   direct rendering.
+ * \param minor_version              GLX minor version from the server.
+ */
+
+void
+__glXCalculateUsableExtensions( __GLXscreenConfigs *psc,
+				GLboolean display_is_direct_capable,
+				int minor_version )
+{
+   unsigned char server_support[8];
+   unsigned char usable[8];
+   unsigned      i;
+
+   __glXExtensionsCtr();
+   __glXExtensionsCtrScreen( psc );
+   __glXProcessServerString( known_glx_extensions,
+			     psc->serverGLXexts, server_support );
+
+
+   /* This is a hack.  Some servers support GLX 1.3 but don't export
+    * all of the extensions implied by GLX 1.3.  If the server claims
+    * support for GLX 1.3, enable support for the extensions that can be
+    * "emulated" as well.
+    */
+
+   if ( minor_version >= 3 ) {
+      SET_BIT( server_support, EXT_visual_info_bit );
+      SET_BIT( server_support, EXT_visual_rating_bit );
+      SET_BIT( server_support, SGI_make_current_read_bit );
+      SET_BIT( server_support, SGIX_fbconfig_bit );
+      SET_BIT( server_support, SGIX_pbuffer_bit );
+       
+      /* This one is a little iffy.  GLX 1.3 doesn't incorporate all of this
+       * extension.  However, the only part that is not strictly client-side
+       * is shared.  That's the glXQueryContext / glXQueryContextInfoEXT
+       * function.
+       */
+
+      SET_BIT( server_support, EXT_import_context_bit );
+   }
+
+
+   /* An extension is supported if the client-side (i.e., libGL) supports
+    * it and the "server" supports it.  In this case that means that either
+    * the true server supports it or it is only for direct-rendering and
+    * the direct rendering driver supports it.
+    * 
+    * If the display is not capable of direct rendering, then the extension
+    * is enabled if and only if the client-side library and the server
+    * support it.
+    */
+
+   if ( display_is_direct_capable ) {
+      for ( i = 0 ; i < 8 ; i++ ) {
+	 usable[i] = (client_glx_support[i] & client_glx_only[i])
+	     | (client_glx_support[i] & psc->direct_support[i] & server_support[i])
+	     | (client_glx_support[i] & psc->direct_support[i] & direct_glx_only[i]);
+      }
+   }
+   else {
+      for ( i = 0 ; i < 8 ; i++ ) {
+	 usable[i] = (client_glx_support[i] & client_glx_only[i])
+	     | (client_glx_support[i] & server_support[i]);
+      }
+   }
+
+   psc->effectiveGLXexts = __glXGetStringFromTable( known_glx_extensions,
+						    usable );
+}
+
+
+/**
+ * Calculate the list of application usable extensions.  The resulting
+ * string is stored in \c gc->extensions.
+ * 
+ * \param gc             Pointer to GLX context.
+ * \param server_string  Extension string from the server.
+ * \param major_version  GL major version from the server.
+ * \param minor_version  GL minor version from the server.
+ */
+
+void
+__glXCalculateUsableGLExtensions( __GLXcontext * gc,
+				  const char * server_string,
+				  int major_version, int minor_version )
+{
+   unsigned char server_support[ __GL_EXT_BYTES ];
+   unsigned char usable[ __GL_EXT_BYTES ];
+   unsigned      i;
+
+
+   __glXExtensionsCtr();
+
+   (void) memset( server_support, 0, sizeof( server_support ) );
+   __glXProcessServerString( known_gl_extensions, server_string,
+			     server_support );
+
+
+   /* Handle lazy servers that don't export all the extensions strings that
+    * are part of the GL core version that they support.
+    */
+
+   for ( i = 0 ; i < __GL_EXT_BYTES ; i++ ) {
+      if ( (known_gl_extensions[i].version_major != 0)
+	   && ((major_version > known_gl_extensions[i].version_major)
+	       || ((major_version == known_gl_extensions[i].version_major)
+		   && (minor_version >= known_gl_extensions[i].version_minor))) ) {
+	 SET_BIT( server_support, known_gl_extensions[i].bit );
+      }
+   }
+
+
+   /* An extension is supported if the client-side (i.e., libGL) supports
+    * it and the server supports it or the client-side library supports it
+    * and it only needs client-side support.
+    */
+
+   for ( i = 0 ; i < __GL_EXT_BYTES ; i++ ) {
+      usable[i] = (client_gl_support[i] & client_gl_only[i])
+	| (client_gl_support[i] & server_support[i]);
+   }
+
+   gc->extensions = (unsigned char *) 
+     __glXGetStringFromTable( known_gl_extensions, usable );
+}
+
+
+/**
+ * Calculates the maximum core GL version that can be supported for indirect
+ * rendering.
+ */
+void
+__glXGetGLVersion( int * major_version, int * minor_version )
+{		   
+    __glXExtensionsCtr();
+    *major_version = gl_major;
+    *minor_version = gl_minor;
+}
+
+
+/**
+ * Get a string representing the set of extensions supported by the client
+ * library.  This is currently only used to send the list of extensions
+ * supported by the client to the server.
+ */
+char *
+__glXGetClientGLExtensionString( void )
+{
+    __glXExtensionsCtr();
+    return __glXGetStringFromTable( known_gl_extensions, client_gl_support );
+}

src/glx/x11/glxextensions.h

@@ -0,0 +1,253 @@
+/*
+ * (C) Copyright IBM Corporation 2002, 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file glxextensions.h
+ *
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+/* $XFree86: xc/lib/GL/glx/glxextensions.h,v 1.2tsi Exp $ */
+
+#ifndef GLX_GLXEXTENSIONS_H
+#define GLX_GLXEXTENSIONS_H
+
+enum {
+   ARB_get_proc_address_bit = 0,
+   ARB_multisample_bit,
+   ARB_render_texture_bit,
+   ATI_pixel_format_float_bit,
+   EXT_visual_info_bit,
+   EXT_visual_rating_bit,
+   EXT_import_context_bit,
+   MESA_agp_offset_bit,
+   MESA_allocate_memory_bit, /* Replaces MESA_agp_offset & NV_vertex_array_range */
+   MESA_copy_sub_buffer_bit,
+   MESA_depth_float_bit,
+   MESA_pixmap_colormap_bit,
+   MESA_release_buffers_bit,
+   MESA_set_3dfx_mode_bit,
+   MESA_swap_control_bit,
+   MESA_swap_frame_usage_bit,
+   NV_float_buffer_bit,
+   NV_render_depth_texture_bit,
+   NV_render_texture_rectangle_bit,
+   NV_vertex_array_range_bit,
+   OML_swap_method_bit,
+   OML_sync_control_bit,
+   SGI_cushion_bit,
+   SGI_make_current_read_bit,
+   SGI_swap_control_bit,
+   SGI_video_sync_bit,
+   SGIS_blended_overlay_bit,
+   SGIS_color_range_bit,
+   SGIS_multisample_bit,
+   SGIX_dm_buffer_bit,
+   SGIX_fbconfig_bit,
+   SGIX_pbuffer_bit,
+   SGIX_swap_barrier_bit,
+   SGIX_swap_group_bit,
+   SGIX_video_resize_bit,
+   SGIX_video_source_bit,
+   SGIX_visual_select_group_bit,
+   SUN_get_transparent_index_bit
+};
+
+enum {
+   GL_ARB_depth_texture_bit = 0,
+   GL_ARB_fragment_program_bit,
+   GL_ARB_imaging_bit,
+   GL_ARB_multisample_bit,
+   GL_ARB_multitexture_bit,
+   GL_ARB_occlusion_query_bit,
+   GL_ARB_point_parameters_bit,
+   GL_ARB_point_sprite_bit,
+   GL_ARB_shadow_bit,
+   GL_ARB_shadow_ambient_bit,
+   GL_ARB_texture_border_clamp_bit,
+   GL_ARB_texture_cube_map_bit,
+   GL_ARB_texture_compression_bit,
+   GL_ARB_texture_env_add_bit,
+   GL_ARB_texture_env_combine_bit,
+   GL_ARB_texture_env_crossbar_bit,
+   GL_ARB_texture_env_dot3_bit,
+   GL_ARB_texture_mirrored_repeat_bit,
+   GL_ARB_texture_non_power_of_two_bit,
+   GL_ARB_transpose_matrix_bit,
+   GL_ARB_vertex_buffer_object_bit,
+   GL_ARB_vertex_program_bit,
+   GL_ARB_window_pos_bit,
+   GL_EXT_abgr_bit,
+   GL_EXT_bgra_bit,
+   GL_EXT_blend_color_bit,
+   GL_EXT_blend_equation_separate_bit,
+   GL_EXT_blend_func_separate_bit,
+   GL_EXT_blend_logic_op_bit,
+   GL_EXT_blend_minmax_bit,
+   GL_EXT_blend_subtract_bit,
+   GL_EXT_clip_volume_hint_bit,
+   GL_EXT_compiled_vertex_array_bit,
+   GL_EXT_convolution_bit,
+   GL_EXT_copy_texture_bit,
+   GL_EXT_cull_vertex_bit,
+   GL_EXT_depth_bounds_test_bit,
+   GL_EXT_draw_range_elements_bit,
+   GL_EXT_fog_coord_bit,
+   GL_EXT_multi_draw_arrays_bit,
+   GL_EXT_packed_pixels_bit,
+   GL_EXT_paletted_texture_bit,
+   GL_EXT_pixel_buffer_object_bit,
+   GL_EXT_polygon_offset_bit,
+   GL_EXT_rescale_normal_bit,
+   GL_EXT_secondary_color_bit,
+   GL_EXT_separate_specular_color_bit,
+   GL_EXT_shadow_funcs_bit,
+   GL_EXT_shared_texture_palette_bit,
+   GL_EXT_stencil_two_side_bit,
+   GL_EXT_stencil_wrap_bit,
+   GL_EXT_subtexture_bit,
+   GL_EXT_texture_bit,
+   GL_EXT_texture3D_bit,
+   GL_EXT_texture_compression_s3tc_bit,
+   GL_EXT_texture_edge_clamp_bit,
+   GL_EXT_texture_env_combine_bit,
+   GL_EXT_texture_env_dot3_bit,
+   GL_EXT_texture_filter_anisotropic_bit,
+   GL_EXT_texture_lod_bit,
+   GL_EXT_texture_lod_bias_bit,
+   GL_EXT_texture_mirror_clamp_bit,
+   GL_EXT_texture_object_bit,
+   GL_EXT_texture_rectangle_bit,
+   GL_EXT_vertex_array_bit,
+   GL_3DFX_texture_compression_FXT1_bit,
+   GL_APPLE_packed_pixels_bit,
+   GL_APPLE_ycbcr_422_bit,
+   GL_ATI_texture_env_combine3_bit,
+   GL_ATI_texture_float_bit,
+   GL_ATI_texture_mirror_once_bit,
+   GL_HP_convolution_border_modes_bit,
+   GL_HP_occlusion_test_bit,
+   GL_IBM_cull_vertex_bit,
+   GL_IBM_pixel_filter_hint_bit,
+   GL_IBM_rasterpos_clip_bit,
+   GL_IBM_texture_clamp_nodraw_bit,
+   GL_INGR_interlace_read_bit,
+   GL_MESA_pack_invert_bit,
+   GL_MESA_ycbcr_texture_bit,
+   GL_NV_blend_square_bit,
+   GL_NV_copy_depth_to_color_bit,
+   GL_NV_depth_clamp_bit,
+   GL_NV_fog_distance_bit,
+   GL_NV_light_max_exponent_bit,
+   GL_NV_multisample_filter_hint_bit,
+   GL_NV_point_sprite_bit,
+   GL_NV_texgen_reflection_bit,
+   GL_NV_texture_compression_vtc_bit,
+   GL_NV_texture_env_combine4_bit,
+   GL_SGIS_generate_mipmap_bit,
+   GL_SGIS_multisample_bit,
+   GL_SGIS_texture_lod_bit,
+   GL_SGIX_blend_alpha_minmax_bit,
+   GL_SGIX_clipmap_bit,
+   GL_SGIX_depth_texture_bit,
+   GL_SGIX_fog_offset_bit,
+   GL_SGIX_shadow_bit,
+   GL_SGIX_texture_coordinate_clamp_bit,
+   GL_SGIX_texture_lod_bias_bit,
+   GL_SGIX_texture_range_bit,
+   GL_SGIX_texture_scale_bias_bit,
+   GL_SGIX_vertex_preclip_bit,
+   GL_SGIX_vertex_preclip_hint_bit,
+   GL_SGIX_ycrcb_bit,
+   GL_SUN_convolution_border_modes_bit,
+   GL_SUN_slice_accum_bit,
+
+   /* This *MUST* go here.  If it gets put after the duplicate values it will
+    * get the value after the last duplicate.
+    */
+   __NUM_GL_EXTS,
+
+
+   /* Alias extension bits.  These extensions exist in either vendor-specific
+    * or EXT form and were later promoted to either EXT or ARB form.  In all
+    * cases, the meaning is *exactly* the same.  That's why
+    * EXT_texture_env_combine is *NOT* an alias of ARB_texture_env_combine and
+    * EXT_texture_env_dot3 is *NOT* an alias of ARB_texture_env_dot3.  Be
+    * careful!  When in doubt, src/mesa/main/extensions.c in the Mesa tree
+    * is a great reference.
+    */
+
+   GL_ATI_blend_equation_separate_bit = GL_EXT_blend_equation_separate_bit,
+   GL_ATIX_texture_env_combine3_bit = GL_ATI_texture_env_combine3_bit,
+   GL_EXT_point_parameters_bit = GL_ARB_point_parameters_bit,
+   GL_EXT_texture_env_add_bit = GL_ARB_texture_env_add_bit,
+   GL_IBM_texture_mirrored_repeat_bit = GL_ARB_texture_mirrored_repeat_bit,
+   GL_INGR_blend_func_separate_bit = GL_EXT_blend_func_separate_bit,
+   GL_MESA_window_pos_bit = GL_ARB_window_pos_bit,
+   GL_NV_texture_rectangle_bit = GL_EXT_texture_rectangle_bit,
+   GL_SGIS_texture_border_clamp_bit = GL_ARB_texture_border_clamp_bit,
+   GL_SGIS_texture_edge_clamp_bit = GL_EXT_texture_edge_clamp_bit,
+   GL_SGIX_shadow_ambient_bit = GL_ARB_shadow_ambient_bit,
+   GL_SUN_multi_draw_arrays_bit = GL_EXT_multi_draw_arrays_bit
+};
+
+extern GLboolean __glXExtensionBitIsEnabled( __GLXscreenConfigs *psc, unsigned bit );
+extern const char * __glXGetClientExtensions( void );
+extern void __glXCalculateUsableExtensions( __GLXscreenConfigs *psc,
+    GLboolean display_is_direct_capable, int server_minor_version );
+extern void __glXScrEnableExtension( __GLXscreenConfigs *psc, const char * name );
+extern void __glXCalculateUsableGLExtensions( __GLXcontext * gc,
+    const char * server_string, int major_version, int minor_version );
+extern void __glXGetGLVersion( int * major_version, int * minor_version );
+extern char * __glXGetClientGLExtensionString( void );
+
+/* Source-level backwards compatibility with old drivers. They won't
+ * find the respective functions, though. 
+ */
+typedef void (* PFNGLXENABLEEXTENSIONPROC) ( const char * name,
+    GLboolean force_client );
+typedef void (* PFNGLXDISABLEEXTENSIONPROC) ( const char * name );
+
+/* GLX_ALIAS should be used for functions with a non-void return type.
+   GLX_ALIAS_VOID is for functions with a void return type. */
+#ifdef GLX_NO_STATIC_EXTENSION_FUNCTIONS
+# define GLX_ALIAS(return_type, real_func, proto_args, args, aliased_func)
+# define GLX_ALIAS_VOID(real_func, proto_args, args, aliased_func)
+#else
+# if defined(__GNUC__) && !defined(GLX_ALIAS_UNSUPPORTED)
+#  define GLX_ALIAS(return_type, real_func, proto_args, args, aliased_func) \
+	return_type GLX_PREFIX( real_func ) proto_args \
+	__attribute__ ((alias( # aliased_func ) ));
+#  define GLX_ALIAS_VOID(real_func, proto_args, args, aliased_func) \
+	GLX_ALIAS(void, real_func, proto_args, args, aliased_func)
+# else
+#  define GLX_ALIAS(return_type, real_func, proto_args, args, aliased_func) \
+	return_type GLX_PREFIX( real_func ) proto_args \
+	{ return aliased_func args ; }
+#  define GLX_ALIAS_VOID(real_func, proto_args, args, aliased_func) \
+	void GLX_PREFIX( real_func ) proto_args \
+	{ aliased_func args ; }
+# endif /* __GNUC__ */
+#endif /* GLX_NO_STATIC_EXTENSION_FUNCTIONS */
+
+#endif /* GLX_GLXEXTENSIONS_H */

src/glx/x11/indirect.h

@@ -0,0 +1,647 @@
+/* $XFree86: xc/lib/GL/glx/indirect.h,v 1.5 2003/09/28 20:15:03 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *
+ */
+
+#if !defined( _INDIRECT_H_ ) || defined( GENERATE_GLX_PROTOCOL_FUNCTIONS )
+
+# if !defined( _INDIRECT_H_ ) 
+#  if defined( GENERATE_GLX_PROTOCOL_FUNCTIONS )
+#   error "indirect.h must be included once without GENERATE_GLX_PROTOCOL_FUNCTIONS defined!"
+#  endif
+
+#  define _INDIRECT_H_
+#  include "indirect_wrap.h"
+
+#  define glxproto_void(name, rop) \
+   extern void __indirect_gl ## name ( void );
+#  define glxproto_Cv(name, rop, type, count) \
+   extern void __indirect_gl ## name (const type * v);
+#  define glxproto_Cv_transpose(name, rop, type, w) \
+   extern void __indirect_gl ## name (const type * v);
+#  define glxproto_1s(name, rop, type) \
+   extern void __indirect_gl ## name (type v1);
+#  define glxproto_2s(name, rop, type) \
+   extern void __indirect_gl ## name (type v1, type v2);
+#  define glxproto_3s(name, rop, type) \
+   extern void __indirect_gl ## name (type v1, type v2, type v3);
+#  define glxproto_4s(name, rop, type) \
+   extern void __indirect_gl ## name (type v1, type v2, type v3, type v4);
+#  define glxproto_6s(name, rop, type) \
+   void __indirect_gl ## name (type v1, type v2, type v3, type v4, type v5, type v6);
+#  define glxproto_enum1_1s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1);
+#  define glxproto_enum1_1v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v);
+#  define glxproto_enum1_2s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1, type v2);
+#  define glxproto_enum1_2v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v);
+#  define glxproto_enum1_3s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1, type v2, type v3);
+#  define glxproto_enum1_3v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v);
+#  define glxproto_enum1_4s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1, type v2, type v3, type v4);
+#  define glxproto_enum1_4v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v);
+#  define glxproto_enum1_Vv(name, rop, type) \
+   void __indirect_gl ## name (GLenum pname, const type * v);
+#  define glxproto_enum2_1s(name, rop, type) \
+   void __indirect_gl ## name (GLenum target, GLenum pname, type v1);
+#define glxproto_enum2_Vv(name, rop, type) \
+   void __indirect_gl ## name (GLenum target, GLenum pname, const type * v);
+
+# endif /* !defined( _INDIRECT_H_ ) */
+
+#define glxproto_1(name, rop, type) \
+   glxproto_1s(name,      rop, type) \
+   glxproto_Cv(name ## v, rop, type, 1)
+
+#define glxvendr_1(name, rop, type, VEN) \
+   glxproto_1s(name ## VEN,      rop, type) \
+   glxproto_Cv(name ## v ## VEN, rop, type, 1)
+
+#define glxproto_2(name, rop, type) \
+   glxproto_2s(name,      rop, type) \
+   glxproto_Cv(name ## v, rop, type, 2)
+
+#define glxvendr_2(name, rop, type, VEN) \
+   glxproto_2s(name ## VEN,      rop, type) \
+   glxproto_Cv(name ## v ## VEN, rop, type, 2)
+
+#define glxproto_3(name, rop, type) \
+   glxproto_3s(name,      rop, type) \
+   glxproto_Cv(name ## v, rop, type, 3)
+
+#define glxvendr_3(name, rop, type, VEN) \
+   glxproto_3s(name ## VEN,      rop, type) \
+   glxproto_Cv(name ## v ## VEN, rop, type, 3)
+
+#define glxproto_4(name, rop, type) \
+   glxproto_4s(name,      rop, type) \
+   glxproto_Cv(name ## v, rop, type, 4)
+
+#define glxproto_enum1_1(name, rop, type) \
+   glxproto_enum1_1s(name,      rop, type) \
+   glxproto_enum1_1v(name ## v, rop, type)
+
+#define glxvendr_enum1_1(name, rop, type, VEN) \
+   glxproto_enum1_1s(name ## VEN,      rop, type) \
+   glxproto_enum1_1v(name ## v ## VEN, rop, type)
+
+#define glxproto_enum1_2(name, rop, type) \
+   glxproto_enum1_2s(name,      rop, type) \
+   glxproto_enum1_2v(name ## v, rop, type)
+
+#define glxvendr_enum1_2(name, rop, type, VEN) \
+   glxproto_enum1_2s(name ## VEN,      rop, type) \
+   glxproto_enum1_2v(name ## v ## VEN, rop, type)
+
+#define glxproto_enum1_3(name, rop, type) \
+   glxproto_enum1_3s(name,      rop, type) \
+   glxproto_enum1_3v(name ## v, rop, type)
+
+#define glxvendr_enum1_3(name, rop, type, VEN) \
+   glxproto_enum1_3s(name ## VEN,      rop, type) \
+   glxproto_enum1_3v(name ## v ## VEN, rop, type)
+
+#define glxproto_enum1_4(name, rop, type) \
+   glxproto_enum1_4s(name,      rop, type) \
+   glxproto_enum1_4v(name ## v, rop, type)
+
+#define glxvendr_enum1_4(name, rop, type, VEN) \
+   glxproto_enum1_4s(name ## VEN,      rop, type) \
+   glxproto_enum1_4v(name ## v ## VEN, rop, type)
+
+#define glxproto_enum1_V(name, rop, type) \
+   glxproto_enum1_1s(name,      rop,      type) \
+   glxproto_enum1_Vv(name ## v, rop ## v, type)
+
+#define glxvendr_enum1_V(name, rop, type, VEN) \
+   glxproto_enum1_1s(name ## VEN,      rop ## VEN,      type) \
+   glxproto_enum1_Vv(name ## v ## VEN, rop ## v ## VEN, type)
+
+#define glxproto_enum2_V(name, rop, type) \
+   glxproto_enum2_1s(name,      rop,      type) \
+   glxproto_enum2_Vv(name ## v, rop ## v, type)
+
+#define glxvendr_enum2_V(name, rop, type, VEN) \
+   glxproto_enum2_1s(name ## VEN,      rop ## VEN,      type) \
+   glxproto_enum2_Vv(name ## v ## VEN, rop ## v ## VEN, type)
+
+glxproto_1s(CallList, X_GLrop_CallList, GLuint)
+glxproto_1s(ListBase, X_GLrop_ListBase, GLuint)
+glxproto_1s(Begin,    X_GLrop_Begin,    GLenum)
+
+glxproto_3(Color3b,  X_GLrop_Color3bv,  GLbyte)
+glxproto_3(Color3s,  X_GLrop_Color3sv,  GLshort)
+glxproto_3(Color3i,  X_GLrop_Color3iv,  GLint)
+glxproto_3(Color3ub, X_GLrop_Color3ubv, GLubyte)
+glxproto_3(Color3us, X_GLrop_Color3usv, GLushort)
+glxproto_3(Color3ui, X_GLrop_Color3uiv, GLuint)
+glxproto_3(Color3f,  X_GLrop_Color3fv,  GLfloat)
+glxproto_3(Color3d,  X_GLrop_Color3dv,  GLdouble)
+
+glxproto_4(Color4b,  X_GLrop_Color4bv,  GLbyte)
+glxproto_4(Color4s,  X_GLrop_Color4sv,  GLshort)
+glxproto_4(Color4i,  X_GLrop_Color4iv,  GLint)
+glxproto_4(Color4ub, X_GLrop_Color4ubv, GLubyte)
+glxproto_4(Color4us, X_GLrop_Color4usv, GLushort)
+glxproto_4(Color4ui, X_GLrop_Color4uiv, GLuint)
+glxproto_4(Color4f,  X_GLrop_Color4fv,  GLfloat)
+glxproto_4(Color4d,  X_GLrop_Color4dv,  GLdouble)
+
+glxproto_1(FogCoordf, X_GLrop_FogCoordfv, GLfloat)
+glxproto_1(FogCoordd, X_GLrop_FogCoorddv, GLdouble)
+
+glxproto_3(SecondaryColor3b,  X_GLrop_SecondaryColor3bv,  GLbyte)
+glxproto_3(SecondaryColor3s,  X_GLrop_SecondaryColor3sv,  GLshort)
+glxproto_3(SecondaryColor3i,  X_GLrop_SecondaryColor3iv,  GLint)
+glxproto_3(SecondaryColor3ub, X_GLrop_SecondaryColor3ubv, GLubyte)
+glxproto_3(SecondaryColor3us, X_GLrop_SecondaryColor3usv, GLushort)
+glxproto_3(SecondaryColor3ui, X_GLrop_SecondaryColor3uiv, GLuint)
+glxproto_3(SecondaryColor3f,  X_GLrop_SecondaryColor3fv,  GLfloat)
+glxproto_3(SecondaryColor3d,  X_GLrop_SecondaryColor3dv,  GLdouble)
+
+glxproto_1(EdgeFlag, X_GLrop_EdgeFlagv, GLboolean)
+
+glxproto_1(Indexd,  X_GLrop_Indexdv,  GLdouble)
+glxproto_1(Indexf,  X_GLrop_Indexfv,  GLfloat)
+glxproto_1(Indexi,  X_GLrop_Indexiv,  GLint)
+glxproto_1(Indexs,  X_GLrop_Indexsv,  GLshort)
+glxproto_1(Indexub, X_GLrop_Indexubv, GLubyte)
+
+glxproto_void(End, X_GLrop_End)
+
+glxproto_3(Normal3b, X_GLrop_Normal3bv, GLbyte)
+glxproto_3(Normal3s, X_GLrop_Normal3sv, GLshort)
+glxproto_3(Normal3i, X_GLrop_Normal3iv, GLint)
+glxproto_3(Normal3f, X_GLrop_Normal3fv, GLfloat)
+glxproto_3(Normal3d, X_GLrop_Normal3dv, GLdouble)
+
+glxproto_2(RasterPos2s, X_GLrop_RasterPos2sv, GLshort)
+glxproto_2(RasterPos2i, X_GLrop_RasterPos2iv, GLint)
+glxproto_2(RasterPos2f, X_GLrop_RasterPos2fv, GLfloat)
+glxproto_2(RasterPos2d, X_GLrop_RasterPos2dv, GLdouble)
+glxproto_3(RasterPos3s, X_GLrop_RasterPos3sv, GLshort)
+glxproto_3(RasterPos3i, X_GLrop_RasterPos3iv, GLint)
+glxproto_3(RasterPos3f, X_GLrop_RasterPos3fv, GLfloat)
+glxproto_3(RasterPos3d, X_GLrop_RasterPos3dv, GLdouble)
+glxproto_4(RasterPos4s, X_GLrop_RasterPos4sv, GLshort)
+glxproto_4(RasterPos4i, X_GLrop_RasterPos4iv, GLint)
+glxproto_4(RasterPos4f, X_GLrop_RasterPos4fv, GLfloat)
+glxproto_4(RasterPos4d, X_GLrop_RasterPos4dv, GLdouble)
+
+glxproto_1(TexCoord1s, X_GLrop_TexCoord1sv, GLshort)
+glxproto_1(TexCoord1i, X_GLrop_TexCoord1iv, GLint)
+glxproto_1(TexCoord1f, X_GLrop_TexCoord1fv, GLfloat)
+glxproto_1(TexCoord1d, X_GLrop_TexCoord1dv, GLdouble)
+glxproto_2(TexCoord2s, X_GLrop_TexCoord2sv, GLshort)
+glxproto_2(TexCoord2i, X_GLrop_TexCoord2iv, GLint)
+glxproto_2(TexCoord2f, X_GLrop_TexCoord2fv, GLfloat)
+glxproto_2(TexCoord2d, X_GLrop_TexCoord2dv, GLdouble)
+glxproto_3(TexCoord3s, X_GLrop_TexCoord3sv, GLshort)
+glxproto_3(TexCoord3i, X_GLrop_TexCoord3iv, GLint)
+glxproto_3(TexCoord3f, X_GLrop_TexCoord3fv, GLfloat)
+glxproto_3(TexCoord3d, X_GLrop_TexCoord3dv, GLdouble)
+glxproto_4(TexCoord4s, X_GLrop_TexCoord4sv, GLshort)
+glxproto_4(TexCoord4i, X_GLrop_TexCoord4iv, GLint)
+glxproto_4(TexCoord4f, X_GLrop_TexCoord4fv, GLfloat)
+glxproto_4(TexCoord4d, X_GLrop_TexCoord4dv, GLdouble)
+
+glxproto_2(Vertex2s, X_GLrop_Vertex2sv, GLshort)
+glxproto_2(Vertex2i, X_GLrop_Vertex2iv, GLint)
+glxproto_2(Vertex2f, X_GLrop_Vertex2fv, GLfloat)
+glxproto_2(Vertex2d, X_GLrop_Vertex2dv, GLdouble)
+glxproto_3(Vertex3s, X_GLrop_Vertex3sv, GLshort)
+glxproto_3(Vertex3i, X_GLrop_Vertex3iv, GLint)
+glxproto_3(Vertex3f, X_GLrop_Vertex3fv, GLfloat)
+glxproto_3(Vertex3d, X_GLrop_Vertex3dv, GLdouble)
+glxproto_4(Vertex4s, X_GLrop_Vertex4sv, GLshort)
+glxproto_4(Vertex4i, X_GLrop_Vertex4iv, GLint)
+glxproto_4(Vertex4f, X_GLrop_Vertex4fv, GLfloat)
+glxproto_4(Vertex4d, X_GLrop_Vertex4dv, GLdouble)
+
+glxproto_enum1_4v(ClipPlane, X_GLrop_ClipPlane, GLdouble)
+
+glxproto_2s(ColorMaterial, X_GLrop_ColorMaterial, GLenum)
+
+glxproto_1s(CullFace, X_GLrop_CullFace, GLenum)
+
+glxproto_enum1_V(Fogi, X_GLrop_Fogi, GLint)
+glxproto_enum1_V(Fogf, X_GLrop_Fogf, GLfloat)
+
+glxproto_1s(FrontFace, X_GLrop_FrontFace, GLenum)
+glxproto_2s(Hint,      X_GLrop_Hint,      GLenum)
+
+glxproto_enum2_V(Lighti,      X_GLrop_Lighti,      GLint)
+glxproto_enum2_V(Lightf,      X_GLrop_Lightf,      GLfloat)
+
+glxproto_enum1_V(LightModeli, X_GLrop_LightModeli, GLint)
+glxproto_enum1_V(LightModelf, X_GLrop_LightModelf, GLfloat)
+
+glxproto_1s(LineWidth, X_GLrop_LineWidth, GLfloat)
+
+glxproto_enum2_V(Materiali, X_GLrop_Materiali, GLint)
+glxproto_enum2_V(Materialf, X_GLrop_Materialf, GLfloat)
+
+glxproto_1s(PointSize, X_GLrop_PointSize, GLfloat)
+
+glxproto_2s(PolygonMode, X_GLrop_PolygonMode, GLenum)
+
+glxproto_1s(ShadeModel, X_GLrop_ShadeModel, GLenum)
+
+glxproto_enum2_V(TexParameteri, X_GLrop_TexParameteri, GLint)
+glxproto_enum2_V(TexParameterf, X_GLrop_TexParameterf, GLfloat)
+
+glxproto_enum2_V(TexEnvi, X_GLrop_TexEnvi, GLint)
+glxproto_enum2_V(TexEnvf, X_GLrop_TexEnvf, GLfloat)
+glxproto_enum2_V(TexGeni, X_GLrop_TexGeni, GLint)
+glxproto_enum2_V(TexGenf, X_GLrop_TexGenf, GLfloat)
+glxproto_enum2_V(TexGend, X_GLrop_TexGend, GLdouble)
+
+glxproto_void(InitNames, X_GLrop_InitNames)
+glxproto_1s(LoadName, X_GLrop_LoadName, GLuint)
+glxproto_1s(PassThrough, X_GLrop_PassThrough, GLfloat)
+glxproto_void(PopName, X_GLrop_PopName)
+glxproto_1s(PushName, X_GLrop_PushName, GLuint)
+
+glxproto_1s(DrawBuffer, X_GLrop_DrawBuffer, GLenum)
+glxproto_1s(Clear, X_GLrop_Clear, GLbitfield)
+
+glxproto_4s(ClearAccum,   X_GLrop_ClearAccum,   GLfloat)
+glxproto_1s(ClearIndex,   X_GLrop_ClearIndex,   GLfloat)
+glxproto_4s(ClearColor,   X_GLrop_ClearColor,   GLclampf)
+glxproto_1s(ClearStencil, X_GLrop_ClearStencil, GLint)
+glxproto_1s(ClearDepth,   X_GLrop_ClearDepth,   GLclampd)
+
+glxproto_1s(StencilMask,  X_GLrop_StencilMask,  GLuint)
+glxproto_4s(ColorMask,    X_GLrop_ColorMask,    GLboolean)
+glxproto_1s(DepthMask,    X_GLrop_DepthMask,    GLboolean)
+glxproto_1s(IndexMask,    X_GLrop_IndexMask,    GLuint)
+
+glxproto_enum1_1s(Accum, X_GLrop_Accum, GLfloat)
+
+glxproto_void(PopAttrib, X_GLrop_PopAttrib)
+glxproto_1s(PushAttrib,  X_GLrop_PushAttrib, GLbitfield)
+
+glxproto_1(EvalCoord1f, X_GLrop_EvalCoord1fv, GLfloat)
+glxproto_1(EvalCoord1d, X_GLrop_EvalCoord1dv, GLdouble)
+glxproto_2(EvalCoord2f, X_GLrop_EvalCoord2fv, GLfloat)
+glxproto_2(EvalCoord2d, X_GLrop_EvalCoord2dv, GLdouble)
+glxproto_enum1_2s(EvalMesh1, X_GLrop_EvalMesh1, GLint)
+glxproto_enum1_4s(EvalMesh2, X_GLrop_EvalMesh2, GLint)
+glxproto_1s(EvalPoint1, X_GLrop_EvalPoint1, GLint)
+glxproto_2s(EvalPoint2, X_GLrop_EvalPoint2, GLint)
+
+glxproto_enum1_1s(AlphaFunc, X_GLrop_AlphaFunc, GLclampf)
+
+glxproto_2s(BlendFunc,         X_GLrop_BlendFunc,         GLenum)
+glxproto_4s(BlendFuncSeparate, X_GLrop_BlendFuncSeparate, GLenum)
+
+glxproto_1s(LogicOp, X_GLrop_LogicOp, GLenum)
+
+glxproto_3s(StencilOp, X_GLrop_StencilOp, GLenum)
+glxproto_1s(DepthFunc, X_GLrop_DepthFunc, GLenum)
+
+glxproto_2s(PixelZoom, X_GLrop_PixelZoom, GLfloat)
+
+glxproto_enum1_1s(PixelTransferf, X_GLrop_PixelTransferf, GLfloat)
+glxproto_enum1_1s(PixelTransferi, X_GLrop_PixelTransferi, GLint)
+
+glxproto_1s(ReadBuffer, X_GLrop_ReadBuffer, GLenum)
+
+glxproto_2s(DepthRange, X_GLrop_DepthRange, GLclampd)
+
+glxproto_6s(Frustum, X_GLrop_Frustum, GLdouble)
+
+glxproto_void(LoadIdentity, X_GLrop_LoadIdentity)
+glxproto_1s(MatrixMode, X_GLrop_MatrixMode, GLenum)
+glxproto_Cv(LoadMatrixf, X_GLrop_LoadMatrixf, GLfloat, 16)
+glxproto_Cv(MultMatrixf, X_GLrop_MultMatrixf, GLfloat, 16)
+glxproto_Cv(LoadMatrixd, X_GLrop_LoadMatrixd, GLdouble, 16)
+glxproto_Cv(MultMatrixd, X_GLrop_MultMatrixd, GLdouble, 16)
+glxproto_Cv_transpose(LoadTransposeMatrixfARB, X_GLrop_LoadMatrixf, GLfloat, 4)
+glxproto_Cv_transpose(MultTransposeMatrixfARB, X_GLrop_MultMatrixf, GLfloat, 4)
+glxproto_Cv_transpose(LoadTransposeMatrixdARB, X_GLrop_LoadMatrixd, GLdouble, 4)
+glxproto_Cv_transpose(MultTransposeMatrixdARB, X_GLrop_MultMatrixd, GLdouble, 4)
+
+glxproto_6s(Ortho, X_GLrop_Ortho, GLdouble)
+
+glxproto_void(PushMatrix, X_GLrop_PushMatrix)
+glxproto_void(PopMatrix,  X_GLrop_PopMatrix)
+
+glxproto_4s(Rotatef,    X_GLrop_Rotatef,    GLfloat)
+glxproto_3s(Scalef,     X_GLrop_Scalef,     GLfloat)
+glxproto_3s(Translatef, X_GLrop_Translatef, GLfloat)
+glxproto_4s(Rotated,    X_GLrop_Rotated,    GLdouble)
+glxproto_3s(Scaled,     X_GLrop_Scaled,     GLdouble)
+glxproto_3s(Translated, X_GLrop_Translated, GLdouble)
+
+glxproto_2s(PolygonOffset, X_GLrop_PolygonOffset, GLfloat)
+
+glxproto_enum1_1s(BindTexture, X_GLrop_BindTexture, GLuint)
+
+glxproto_4s(BlendColor,    X_GLrop_BlendColor,    GLclampf)
+glxproto_1s(BlendEquation, X_GLrop_BlendEquation, GLenum)
+
+glxproto_enum2_Vv(ColorTableParameteriv, X_GLrop_ColorTableParameteriv, GLint)
+glxproto_enum2_Vv(ColorTableParameterfv, X_GLrop_ColorTableParameterfv, GLfloat)
+
+glxproto_enum2_V(ConvolutionParameteri, X_GLrop_ConvolutionParameteri, GLint)
+glxproto_enum2_V(ConvolutionParameterf, X_GLrop_ConvolutionParameterf, GLfloat)
+
+glxproto_enum2_1s(Minmax, X_GLrop_Minmax, GLboolean)
+
+glxproto_1s(ResetHistogram, X_GLrop_ResetHistogram, GLenum)
+glxproto_1s(ResetMinmax,    X_GLrop_ResetMinmax,    GLenum)
+
+glxproto_1s(     ActiveTextureARB, X_GLrop_ActiveTextureARB,    GLenum)
+glxvendr_enum1_1(MultiTexCoord1s,  X_GLrop_MultiTexCoord1svARB, GLshort,  ARB)
+glxvendr_enum1_1(MultiTexCoord1i,  X_GLrop_MultiTexCoord1ivARB, GLint,    ARB)
+glxvendr_enum1_1(MultiTexCoord1f,  X_GLrop_MultiTexCoord1fvARB, GLfloat,  ARB)
+glxvendr_enum1_1(MultiTexCoord1d,  X_GLrop_MultiTexCoord1dvARB, GLdouble, ARB)
+glxvendr_enum1_2(MultiTexCoord2s,  X_GLrop_MultiTexCoord2svARB, GLshort,  ARB)
+glxvendr_enum1_2(MultiTexCoord2i,  X_GLrop_MultiTexCoord2ivARB, GLint,    ARB)
+glxvendr_enum1_2(MultiTexCoord2f,  X_GLrop_MultiTexCoord2fvARB, GLfloat,  ARB)
+glxvendr_enum1_2(MultiTexCoord2d,  X_GLrop_MultiTexCoord2dvARB, GLdouble, ARB)
+glxvendr_enum1_3(MultiTexCoord3s,  X_GLrop_MultiTexCoord3svARB, GLshort,  ARB)
+glxvendr_enum1_3(MultiTexCoord3i,  X_GLrop_MultiTexCoord3ivARB, GLint,    ARB)
+glxvendr_enum1_3(MultiTexCoord3f,  X_GLrop_MultiTexCoord3fvARB, GLfloat,  ARB)
+glxvendr_enum1_3(MultiTexCoord3d,  X_GLrop_MultiTexCoord3dvARB, GLdouble, ARB)
+glxvendr_enum1_4(MultiTexCoord4s,  X_GLrop_MultiTexCoord4svARB, GLshort,  ARB)
+glxvendr_enum1_4(MultiTexCoord4i,  X_GLrop_MultiTexCoord4ivARB, GLint,    ARB)
+glxvendr_enum1_4(MultiTexCoord4f,  X_GLrop_MultiTexCoord4fvARB, GLfloat,  ARB)
+glxvendr_enum1_4(MultiTexCoord4d,  X_GLrop_MultiTexCoord4dvARB, GLdouble, ARB)
+
+glxvendr_enum1_V(PointParameterf, X_GLrop_PointParameterf, GLfloat, ARB)
+glxproto_enum1_V(PointParameteri, X_GLrop_PointParameteri, GLint)
+
+glxvendr_3(WindowPos3f, X_GLrop_WindowPos3fARB, GLfloat, ARB)
+
+glxproto_1s(ActiveStencilFaceEXT, X_GLrop_ActiveStencilFaceEXT, GLenum)
+
+glxproto_4s(Rects, X_GLrop_Rectsv, GLshort)
+glxproto_4s(Recti, X_GLrop_Rectiv, GLint)
+glxproto_4s(Rectf, X_GLrop_Rectfv, GLfloat)
+glxproto_4s(Rectd, X_GLrop_Rectdv, GLdouble)
+
+#if !defined( GENERATE_GLX_PROTOCOL_FUNCTIONS )
+GLboolean __indirect_glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
+GLboolean __indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences);
+void __indirect_glArrayElement(GLint i);
+void __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+void __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid *lists);
+void __indirect_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table);
+void __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+void __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+void __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+void __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+void __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+void __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+void __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+void __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+void __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+void __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+void __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+void __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void __indirect_glDeleteLists(GLuint list, GLsizei range);
+void __indirect_glDeleteTextures(GLsizei n, const GLuint *textures);
+void __indirect_glDeleteTexturesEXT(GLsizei n, const GLuint *textures);
+void __indirect_glDisable(GLenum cap);
+void __indirect_glDisableClientState(GLenum array);
+void __indirect_glDrawArrays(GLenum mode, GLint first, GLsizei count);
+void __indirect_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+void __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+void __indirect_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+void __indirect_glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
+void __indirect_glEnable(GLenum cap);
+void __indirect_glEnableClientState(GLenum array);
+void __indirect_glEndList(void);
+void __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
+void __indirect_glFinish(void);
+void __indirect_glFlush(void);
+GLuint __indirect_glGenLists(GLsizei range);
+void __indirect_glGenTextures(GLsizei n, GLuint *textures);
+void __indirect_glGenTexturesEXT(GLsizei n, GLuint *textures);
+void __indirect_glGetBooleanv(GLenum val, GLboolean *b);
+void __indirect_glGetClipPlane(GLenum plane, GLdouble *equation);
+void __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
+void __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);
+void __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);
+void __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
+void __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
+void __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
+void __indirect_glGetDoublev(GLenum val, GLdouble *d);
+GLenum __indirect_glGetError(void);
+void __indirect_glGetFloatv(GLenum val, GLfloat *f);
+void __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+void __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
+void __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
+void __indirect_glGetIntegerv(GLenum val, GLint *i);
+void __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat *params);
+void __indirect_glGetLightiv(GLenum light, GLenum pname, GLint *params);
+void __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble *v);
+void __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat *v);
+void __indirect_glGetMapiv(GLenum target, GLenum query, GLint *v);
+void __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
+void __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint *params);
+void __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+void __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
+void __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
+void __indirect_glGetPixelMapfv(GLenum map, GLfloat *values);
+void __indirect_glGetPixelMapuiv(GLenum map, GLuint *values);
+void __indirect_glGetPixelMapusv(GLenum map, GLushort *values);
+void __indirect_glGetPointerv(GLenum pname, void **params);
+void __indirect_glGetPolygonStipple(GLubyte *mask);
+const GLubyte *__indirect_glGetString(GLenum name);
+void __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+void __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
+void __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint *params);
+void __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
+void __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
+void __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
+void __indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *texels);
+void __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
+void __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
+void __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
+void __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
+void __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+void __indirect_glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
+void __indirect_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean __indirect_glIsEnabled(GLenum cap);
+GLboolean __indirect_glIsList(GLuint list);
+GLboolean __indirect_glIsTexture(GLuint texture);
+GLboolean __indirect_glIsTextureEXT(GLuint texture);
+void __indirect_glLineStipple(GLint factor, GLushort pattern);
+void __indirect_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *pnts);
+void __indirect_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *pnts);
+void __indirect_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustr, GLint uord, GLdouble v1, GLdouble v2, GLint vstr, GLint vord, const GLdouble *pnts);
+void __indirect_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustr, GLint uord, GLfloat v1, GLfloat v2, GLint vstr, GLint vord, const GLfloat *pnts);
+void __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
+void __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
+void __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+void __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+void __indirect_glNewList(GLuint list, GLenum mode);
+void __indirect_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
+void __indirect_glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);
+void __indirect_glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);
+void __indirect_glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);
+void __indirect_glPixelStoref(GLenum pname, GLfloat param);
+void __indirect_glPixelStorei(GLenum pname, GLint param);
+void __indirect_glPolygonStipple(const GLubyte *mask);
+void __indirect_glPopClientAttrib(void);
+void __indirect_glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+void __indirect_glPushClientAttrib(GLuint mask);
+void __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+void __indirect_glRectdv(const GLdouble *v1, const GLdouble *v2);
+void __indirect_glRectfv(const GLfloat *v1, const GLfloat *v2);
+void __indirect_glRectiv(const GLint *v1, const GLint *v2);
+void __indirect_glRectsv(const GLshort *v1, const GLshort *v2);
+GLint __indirect_glRenderMode(GLenum mode);
+void __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
+void __indirect_glSelectBuffer(GLsizei numnames, GLuint *buffer);
+void __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+void __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask);
+void __indirect_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void __indirect_glTexImage1D(GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *image);
+void __indirect_glTexImage2D(GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *image);
+void __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *image);
+void __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+void __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+void __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *image);
+void __indirect_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+
+void __indirect_glClientActiveTextureARB(GLenum texture);
+
+void __indirect_glSampleCoverageARB( GLfloat value, GLboolean invert );
+
+void __indirect_glWindowPos2dARB(GLdouble x, GLdouble y);
+void __indirect_glWindowPos2iARB(GLint x, GLint y);
+void __indirect_glWindowPos2fARB(GLfloat x, GLfloat y);
+void __indirect_glWindowPos2sARB(GLshort x, GLshort y);
+void __indirect_glWindowPos2dvARB(const GLdouble * p);
+void __indirect_glWindowPos2fvARB(const GLfloat * p);
+void __indirect_glWindowPos2ivARB(const GLint * p);
+void __indirect_glWindowPos2svARB(const GLshort * p);
+void __indirect_glWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z);
+void __indirect_glWindowPos3iARB(GLint x, GLint y, GLint z);
+void __indirect_glWindowPos3sARB(GLshort x, GLshort y, GLshort z);
+void __indirect_glWindowPos3dvARB(const GLdouble * p);
+void __indirect_glWindowPos3ivARB(const GLint * p);
+void __indirect_glWindowPos3svARB(const GLshort * p);
+
+void __indirect_glMultiDrawArrays(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
+void __indirect_glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid ** indices, GLsizei primcount);
+
+void __indirect_glSampleMaskSGIS( GLfloat value, GLboolean invert );
+void __indirect_glSamplePatternSGIS( GLenum pass );
+
+/* ARB 12. GL_ARB_texture_compression / GL 1.3 */
+
+void __indirect_glGetCompressedTexImage( GLenum target, GLint level,
+    GLvoid * img );
+void __indirect_glCompressedTexImage1D( GLenum target, GLint level,
+    GLenum internalformat, GLsizei width,
+    GLint border, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexImage2D( GLenum target, GLint level,
+    GLenum internalformat, GLsizei width, GLsizei height,
+    GLint border, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexImage3D( GLenum target, GLint level,
+    GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
+    GLint border, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexSubImage1D( GLenum target, GLint level,
+    GLint xoffset,
+    GLsizei width,
+    GLenum format, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexSubImage2D( GLenum target, GLint level,
+    GLint xoffset, GLint yoffset,
+    GLsizei width, GLsizei height,
+    GLenum format, GLsizei image_size, const GLvoid *data );
+void __indirect_glCompressedTexSubImage3D( GLenum target, GLint level,
+    GLint xoffset, GLint yoffset, GLint zoffset,
+    GLsizei width, GLsizei height, GLsizei depth,
+    GLenum format, GLsizei image_size, const GLvoid *data );
+
+/* 145. GL_EXT_secondary_color / GL 1.4 */
+
+void __indirect_glSecondaryColorPointer (GLint, GLenum, GLsizei, const GLvoid *);
+
+/* 149. GL_EXT_fog_coord / GL 1.4 */
+
+void __indirect_glFogCoordPointer (GLenum, GLsizei, const GLvoid *);
+
+# undef glxproto_void
+# undef glxproto_Cv
+# undef glxproto_Cv_transpose
+# undef glxproto_1s
+# undef glxproto_2s
+# undef glxproto_3s
+# undef glxproto_4s
+# undef glxproto_6s
+# undef glxproto_enum1_1s
+# undef glxproto_enum1_1v
+# undef glxproto_enum1_2s
+# undef glxproto_enum1_2v
+# undef glxproto_enum1_3s
+# undef glxproto_enum1_3v
+# undef glxproto_enum1_4s
+# undef glxproto_enum1_4v
+# undef glxproto_enum1_Vv
+# undef glxproto_enum2_1s
+# undef glxproto_enum2_Vv
+# undef glxproto_1
+# undef glxvendr_1
+# undef glxproto_2
+# undef glxvendr_2
+# undef glxproto_3
+# undef glxvendr_3
+# undef glxproto_4
+# undef glxproto_enum1_1
+# undef glxvendr_enum1_1
+# undef glxproto_enum1_2
+# undef glxvendr_enum1_2
+# undef glxproto_enum1_3
+# undef glxvendr_enum1_3
+# undef glxproto_enum1_4
+# undef glxvendr_enum1_4
+# undef glxproto_enum1_V
+# undef glxvendr_enum1_V
+# undef glxproto_enum2_V
+# undef glxvendr_enum2_V
+#endif /* !defined( GENERATE_GLX_PROTOCOL_FUNCTIONS ) */
+
+#endif /* _INDIRECT_H_ */

src/glx/x11/indirect_init.c

@@ -0,0 +1,624 @@
+/* $XFree86: xc/lib/GL/glx/indirect_init.c,v 1.9 2004/01/28 18:11:41 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *   Brian Paul <brian@precisioninsight.com>
+ */
+
+#include "indirect_init.h"
+#include "indirect.h"
+#include "glapi.h"
+
+
+/*
+** No-op function
+*/
+static int NoOp(void)
+{
+    return 0;
+}
+
+/**
+ * \name Vertex array pointer bridge functions
+ *
+ * When EXT_vertex_array was moved into the core GL spec, the \c count
+ * parameter was lost.  This libGL really only wants to implement the GL 1.1
+ * version, but we need to support applications that were written to the old
+ * interface.  These bridge functions are part of the glue that makes this
+ * happen.
+ */
+/*@{*/
+static void ColorPointerEXT(GLint size, GLenum type, GLsizei stride,
+			    GLsizei count, const GLvoid * pointer )
+{
+    (void) count; __indirect_glColorPointer( size, type, stride, pointer );
+}
+
+static void EdgeFlagPointerEXT(GLsizei stride,
+			       GLsizei count, const GLboolean * pointer )
+{
+    (void) count; __indirect_glEdgeFlagPointer( stride, pointer );
+}
+
+static void IndexPointerEXT(GLenum type, GLsizei stride,
+			    GLsizei count, const GLvoid * pointer )
+{
+    (void) count; __indirect_glIndexPointer( type, stride, pointer );
+}
+
+static void NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
+			     const GLvoid * pointer )
+{
+    (void) count; __indirect_glNormalPointer( type, stride, pointer );
+}
+
+static void TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
+			       GLsizei count, const GLvoid * pointer )
+{
+    (void) count; __indirect_glTexCoordPointer( size, type, stride, pointer );
+}
+
+static void VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
+			    GLsizei count, const GLvoid * pointer )
+{
+    (void) count; __indirect_glVertexPointer( size, type, stride, pointer );
+}
+/*@}*/
+
+
+__GLapi *__glXNewIndirectAPI(void)
+{
+    __GLapi *glAPI;
+    GLuint entries;
+
+    entries = _glapi_get_dispatch_table_size();
+    glAPI = (__GLapi *) Xmalloc(entries * sizeof(void *));
+
+    /* first, set all entries to point to no-op functions */
+    {
+       int i;
+       void **dispatch = (void **) glAPI;
+       for (i = 0; i < entries; i++) {
+          dispatch[i] = (void *) NoOp;
+       }
+    }
+
+    /* now, initialize the entries we understand */
+    glAPI->Accum = __indirect_glAccum;
+    glAPI->AlphaFunc = __indirect_glAlphaFunc;
+    glAPI->AreTexturesResident = __indirect_glAreTexturesResident;
+    glAPI->ArrayElement = __indirect_glArrayElement;
+    glAPI->Begin = __indirect_glBegin;
+    glAPI->BindTexture = __indirect_glBindTexture;
+    glAPI->Bitmap = __indirect_glBitmap;
+    glAPI->BlendFunc = __indirect_glBlendFunc;
+    glAPI->CallList = __indirect_glCallList;
+    glAPI->CallLists = __indirect_glCallLists;
+    glAPI->Clear = __indirect_glClear;
+    glAPI->ClearAccum = __indirect_glClearAccum;
+    glAPI->ClearColor = __indirect_glClearColor;
+    glAPI->ClearDepth = __indirect_glClearDepth;
+    glAPI->ClearIndex = __indirect_glClearIndex;
+    glAPI->ClearStencil = __indirect_glClearStencil;
+    glAPI->ClipPlane = __indirect_glClipPlane;
+    glAPI->Color3b = __indirect_glColor3b;
+    glAPI->Color3bv = __indirect_glColor3bv;
+    glAPI->Color3d = __indirect_glColor3d;
+    glAPI->Color3dv = __indirect_glColor3dv;
+    glAPI->Color3f = __indirect_glColor3f;
+    glAPI->Color3fv = __indirect_glColor3fv;
+    glAPI->Color3i = __indirect_glColor3i;
+    glAPI->Color3iv = __indirect_glColor3iv;
+    glAPI->Color3s = __indirect_glColor3s;
+    glAPI->Color3sv = __indirect_glColor3sv;
+    glAPI->Color3ub = __indirect_glColor3ub;
+    glAPI->Color3ubv = __indirect_glColor3ubv;
+    glAPI->Color3ui = __indirect_glColor3ui;
+    glAPI->Color3uiv = __indirect_glColor3uiv;
+    glAPI->Color3us = __indirect_glColor3us;
+    glAPI->Color3usv = __indirect_glColor3usv;
+    glAPI->Color4b = __indirect_glColor4b;
+    glAPI->Color4bv = __indirect_glColor4bv;
+    glAPI->Color4d = __indirect_glColor4d;
+    glAPI->Color4dv = __indirect_glColor4dv;
+    glAPI->Color4f = __indirect_glColor4f;
+    glAPI->Color4fv = __indirect_glColor4fv;
+    glAPI->Color4i = __indirect_glColor4i;
+    glAPI->Color4iv = __indirect_glColor4iv;
+    glAPI->Color4s = __indirect_glColor4s;
+    glAPI->Color4sv = __indirect_glColor4sv;
+    glAPI->Color4ub = __indirect_glColor4ub;
+    glAPI->Color4ubv = __indirect_glColor4ubv;
+    glAPI->Color4ui = __indirect_glColor4ui;
+    glAPI->Color4uiv = __indirect_glColor4uiv;
+    glAPI->Color4us = __indirect_glColor4us;
+    glAPI->Color4usv = __indirect_glColor4usv;
+    glAPI->ColorMask = __indirect_glColorMask;
+    glAPI->ColorMaterial = __indirect_glColorMaterial;
+    glAPI->ColorPointer = __indirect_glColorPointer;
+    glAPI->CopyPixels = __indirect_glCopyPixels;
+    glAPI->CopyTexImage1D = __indirect_glCopyTexImage1D;
+    glAPI->CopyTexImage2D = __indirect_glCopyTexImage2D;
+    glAPI->CopyTexSubImage1D = __indirect_glCopyTexSubImage1D;
+    glAPI->CopyTexSubImage2D = __indirect_glCopyTexSubImage2D;
+    glAPI->CullFace = __indirect_glCullFace;
+    glAPI->DeleteLists = __indirect_glDeleteLists;
+    glAPI->DeleteTextures = __indirect_glDeleteTextures;
+    glAPI->DepthFunc = __indirect_glDepthFunc;
+    glAPI->DepthMask = __indirect_glDepthMask;
+    glAPI->DepthRange = __indirect_glDepthRange;
+    glAPI->Disable = __indirect_glDisable;
+    glAPI->DisableClientState = __indirect_glDisableClientState;
+    glAPI->DrawArrays = __indirect_glDrawArrays;
+    glAPI->DrawBuffer = __indirect_glDrawBuffer;
+    glAPI->DrawElements = __indirect_glDrawElements;
+    glAPI->DrawPixels = __indirect_glDrawPixels;
+    glAPI->DrawRangeElements = __indirect_glDrawRangeElements;
+    glAPI->EdgeFlag = __indirect_glEdgeFlag;
+    glAPI->EdgeFlagPointer = __indirect_glEdgeFlagPointer;
+    glAPI->EdgeFlagv = __indirect_glEdgeFlagv;
+    glAPI->Enable = __indirect_glEnable;
+    glAPI->EnableClientState = __indirect_glEnableClientState;
+    glAPI->End = __indirect_glEnd;
+    glAPI->EndList = __indirect_glEndList;
+    glAPI->EvalCoord1d = __indirect_glEvalCoord1d;
+    glAPI->EvalCoord1dv = __indirect_glEvalCoord1dv;
+    glAPI->EvalCoord1f = __indirect_glEvalCoord1f;
+    glAPI->EvalCoord1fv = __indirect_glEvalCoord1fv;
+    glAPI->EvalCoord2d = __indirect_glEvalCoord2d;
+    glAPI->EvalCoord2dv = __indirect_glEvalCoord2dv;
+    glAPI->EvalCoord2f = __indirect_glEvalCoord2f;
+    glAPI->EvalCoord2fv = __indirect_glEvalCoord2fv;
+    glAPI->EvalMesh1 = __indirect_glEvalMesh1;
+    glAPI->EvalMesh2 = __indirect_glEvalMesh2;
+    glAPI->EvalPoint1 = __indirect_glEvalPoint1;
+    glAPI->EvalPoint2 = __indirect_glEvalPoint2;
+    glAPI->FeedbackBuffer = __indirect_glFeedbackBuffer;
+    glAPI->Finish = __indirect_glFinish;
+    glAPI->Flush = __indirect_glFlush;
+    glAPI->Fogf = __indirect_glFogf;
+    glAPI->Fogfv = __indirect_glFogfv;
+    glAPI->Fogi = __indirect_glFogi;
+    glAPI->Fogiv = __indirect_glFogiv;
+    glAPI->FrontFace = __indirect_glFrontFace;
+    glAPI->Frustum = __indirect_glFrustum;
+    glAPI->GenLists = __indirect_glGenLists;
+    glAPI->GenTextures = __indirect_glGenTextures;
+    glAPI->GetBooleanv = __indirect_glGetBooleanv;
+    glAPI->GetClipPlane = __indirect_glGetClipPlane;
+    glAPI->GetDoublev = __indirect_glGetDoublev;
+    glAPI->GetError = __indirect_glGetError;
+    glAPI->GetFloatv = __indirect_glGetFloatv;
+    glAPI->GetIntegerv = __indirect_glGetIntegerv;
+    glAPI->GetLightfv = __indirect_glGetLightfv;
+    glAPI->GetLightiv = __indirect_glGetLightiv;
+    glAPI->GetMapdv = __indirect_glGetMapdv;
+    glAPI->GetMapfv = __indirect_glGetMapfv;
+    glAPI->GetMapiv = __indirect_glGetMapiv;
+    glAPI->GetMaterialfv = __indirect_glGetMaterialfv;
+    glAPI->GetMaterialiv = __indirect_glGetMaterialiv;
+    glAPI->GetPixelMapfv = __indirect_glGetPixelMapfv;
+    glAPI->GetPixelMapuiv = __indirect_glGetPixelMapuiv;
+    glAPI->GetPixelMapusv = __indirect_glGetPixelMapusv;
+    glAPI->GetPointerv = __indirect_glGetPointerv;
+    glAPI->GetPolygonStipple = __indirect_glGetPolygonStipple;
+    glAPI->GetString = __indirect_glGetString;
+    glAPI->GetTexEnvfv = __indirect_glGetTexEnvfv;
+    glAPI->GetTexEnviv = __indirect_glGetTexEnviv;
+    glAPI->GetTexGendv = __indirect_glGetTexGendv;
+    glAPI->GetTexGenfv = __indirect_glGetTexGenfv;
+    glAPI->GetTexGeniv = __indirect_glGetTexGeniv;
+    glAPI->GetTexImage = __indirect_glGetTexImage;
+    glAPI->GetTexLevelParameterfv = __indirect_glGetTexLevelParameterfv;
+    glAPI->GetTexLevelParameteriv = __indirect_glGetTexLevelParameteriv;
+    glAPI->GetTexParameterfv = __indirect_glGetTexParameterfv;
+    glAPI->GetTexParameteriv = __indirect_glGetTexParameteriv;
+    glAPI->Hint = __indirect_glHint;
+    glAPI->IndexMask = __indirect_glIndexMask;
+    glAPI->IndexPointer = __indirect_glIndexPointer;
+    glAPI->Indexd = __indirect_glIndexd;
+    glAPI->Indexdv = __indirect_glIndexdv;
+    glAPI->Indexf = __indirect_glIndexf;
+    glAPI->Indexfv = __indirect_glIndexfv;
+    glAPI->Indexi = __indirect_glIndexi;
+    glAPI->Indexiv = __indirect_glIndexiv;
+    glAPI->Indexs = __indirect_glIndexs;
+    glAPI->Indexsv = __indirect_glIndexsv;
+    glAPI->Indexub = __indirect_glIndexub;
+    glAPI->Indexubv = __indirect_glIndexubv;
+    glAPI->InitNames = __indirect_glInitNames;
+    glAPI->InterleavedArrays = __indirect_glInterleavedArrays;
+    glAPI->IsEnabled = __indirect_glIsEnabled;
+    glAPI->IsList = __indirect_glIsList;
+    glAPI->IsTexture = __indirect_glIsTexture;
+    glAPI->LightModelf = __indirect_glLightModelf;
+    glAPI->LightModelfv = __indirect_glLightModelfv;
+    glAPI->LightModeli = __indirect_glLightModeli;
+    glAPI->LightModeliv = __indirect_glLightModeliv;
+    glAPI->Lightf = __indirect_glLightf;
+    glAPI->Lightfv = __indirect_glLightfv;
+    glAPI->Lighti = __indirect_glLighti;
+    glAPI->Lightiv = __indirect_glLightiv;
+    glAPI->LineStipple = __indirect_glLineStipple;
+    glAPI->LineWidth = __indirect_glLineWidth;
+    glAPI->ListBase = __indirect_glListBase;
+    glAPI->LoadIdentity = __indirect_glLoadIdentity;
+    glAPI->LoadMatrixd = __indirect_glLoadMatrixd;
+    glAPI->LoadMatrixf = __indirect_glLoadMatrixf;
+    glAPI->LoadName = __indirect_glLoadName;
+    glAPI->LogicOp = __indirect_glLogicOp;
+    glAPI->Map1d = __indirect_glMap1d;
+    glAPI->Map1f = __indirect_glMap1f;
+    glAPI->Map2d = __indirect_glMap2d;
+    glAPI->Map2f = __indirect_glMap2f;
+    glAPI->MapGrid1d = __indirect_glMapGrid1d;
+    glAPI->MapGrid1f = __indirect_glMapGrid1f;
+    glAPI->MapGrid2d = __indirect_glMapGrid2d;
+    glAPI->MapGrid2f = __indirect_glMapGrid2f;
+    glAPI->Materialf = __indirect_glMaterialf;
+    glAPI->Materialfv = __indirect_glMaterialfv;
+    glAPI->Materiali = __indirect_glMateriali;
+    glAPI->Materialiv = __indirect_glMaterialiv;
+    glAPI->MatrixMode = __indirect_glMatrixMode;
+    glAPI->MultMatrixd = __indirect_glMultMatrixd;
+    glAPI->MultMatrixf = __indirect_glMultMatrixf;
+    glAPI->NewList = __indirect_glNewList;
+    glAPI->Normal3b = __indirect_glNormal3b;
+    glAPI->Normal3bv = __indirect_glNormal3bv;
+    glAPI->Normal3d = __indirect_glNormal3d;
+    glAPI->Normal3dv = __indirect_glNormal3dv;
+    glAPI->Normal3f = __indirect_glNormal3f;
+    glAPI->Normal3fv = __indirect_glNormal3fv;
+    glAPI->Normal3i = __indirect_glNormal3i;
+    glAPI->Normal3iv = __indirect_glNormal3iv;
+    glAPI->Normal3s = __indirect_glNormal3s;
+    glAPI->Normal3sv = __indirect_glNormal3sv;
+    glAPI->NormalPointer = __indirect_glNormalPointer;
+    glAPI->Ortho = __indirect_glOrtho;
+    glAPI->PassThrough = __indirect_glPassThrough;
+    glAPI->PixelMapfv = __indirect_glPixelMapfv;
+    glAPI->PixelMapuiv = __indirect_glPixelMapuiv;
+    glAPI->PixelMapusv = __indirect_glPixelMapusv;
+    glAPI->PixelStoref = __indirect_glPixelStoref;
+    glAPI->PixelStorei = __indirect_glPixelStorei;
+    glAPI->PixelTransferf = __indirect_glPixelTransferf;
+    glAPI->PixelTransferi = __indirect_glPixelTransferi;
+    glAPI->PixelZoom = __indirect_glPixelZoom;
+    glAPI->PointSize = __indirect_glPointSize;
+    glAPI->PolygonMode = __indirect_glPolygonMode;
+    glAPI->PolygonOffset = __indirect_glPolygonOffset;
+    glAPI->PolygonStipple = __indirect_glPolygonStipple;
+    glAPI->PopAttrib = __indirect_glPopAttrib;
+    glAPI->PopClientAttrib = __indirect_glPopClientAttrib;
+    glAPI->PopMatrix = __indirect_glPopMatrix;
+    glAPI->PopName = __indirect_glPopName;
+    glAPI->PrioritizeTextures = __indirect_glPrioritizeTextures;
+    glAPI->PushAttrib = __indirect_glPushAttrib;
+    glAPI->PushClientAttrib = __indirect_glPushClientAttrib;
+    glAPI->PushMatrix = __indirect_glPushMatrix;
+    glAPI->PushName = __indirect_glPushName;
+    glAPI->RasterPos2d = __indirect_glRasterPos2d;
+    glAPI->RasterPos2dv = __indirect_glRasterPos2dv;
+    glAPI->RasterPos2f = __indirect_glRasterPos2f;
+    glAPI->RasterPos2fv = __indirect_glRasterPos2fv;
+    glAPI->RasterPos2i = __indirect_glRasterPos2i;
+    glAPI->RasterPos2iv = __indirect_glRasterPos2iv;
+    glAPI->RasterPos2s = __indirect_glRasterPos2s;
+    glAPI->RasterPos2sv = __indirect_glRasterPos2sv;
+    glAPI->RasterPos3d = __indirect_glRasterPos3d;
+    glAPI->RasterPos3dv = __indirect_glRasterPos3dv;
+    glAPI->RasterPos3f = __indirect_glRasterPos3f;
+    glAPI->RasterPos3fv = __indirect_glRasterPos3fv;
+    glAPI->RasterPos3i = __indirect_glRasterPos3i;
+    glAPI->RasterPos3iv = __indirect_glRasterPos3iv;
+    glAPI->RasterPos3s = __indirect_glRasterPos3s;
+    glAPI->RasterPos3sv = __indirect_glRasterPos3sv;
+    glAPI->RasterPos4d = __indirect_glRasterPos4d;
+    glAPI->RasterPos4dv = __indirect_glRasterPos4dv;
+    glAPI->RasterPos4f = __indirect_glRasterPos4f;
+    glAPI->RasterPos4fv = __indirect_glRasterPos4fv;
+    glAPI->RasterPos4i = __indirect_glRasterPos4i;
+    glAPI->RasterPos4iv = __indirect_glRasterPos4iv;
+    glAPI->RasterPos4s = __indirect_glRasterPos4s;
+    glAPI->RasterPos4sv = __indirect_glRasterPos4sv;
+    glAPI->ReadBuffer = __indirect_glReadBuffer;
+    glAPI->ReadPixels = __indirect_glReadPixels;
+    glAPI->Rectd = __indirect_glRectd;
+    glAPI->Rectdv = __indirect_glRectdv;
+    glAPI->Rectf = __indirect_glRectf;
+    glAPI->Rectfv = __indirect_glRectfv;
+    glAPI->Recti = __indirect_glRecti;
+    glAPI->Rectiv = __indirect_glRectiv;
+    glAPI->Rects = __indirect_glRects;
+    glAPI->Rectsv = __indirect_glRectsv;
+    glAPI->RenderMode = __indirect_glRenderMode;
+    glAPI->Rotated = __indirect_glRotated;
+    glAPI->Rotatef = __indirect_glRotatef;
+    glAPI->Scaled = __indirect_glScaled;
+    glAPI->Scalef = __indirect_glScalef;
+    glAPI->Scissor = __indirect_glScissor;
+    glAPI->SelectBuffer = __indirect_glSelectBuffer;
+    glAPI->ShadeModel = __indirect_glShadeModel;
+    glAPI->StencilFunc = __indirect_glStencilFunc;
+    glAPI->StencilMask = __indirect_glStencilMask;
+    glAPI->StencilOp = __indirect_glStencilOp;
+    glAPI->TexCoord1d = __indirect_glTexCoord1d;
+    glAPI->TexCoord1dv = __indirect_glTexCoord1dv;
+    glAPI->TexCoord1f = __indirect_glTexCoord1f;
+    glAPI->TexCoord1fv = __indirect_glTexCoord1fv;
+    glAPI->TexCoord1i = __indirect_glTexCoord1i;
+    glAPI->TexCoord1iv = __indirect_glTexCoord1iv;
+    glAPI->TexCoord1s = __indirect_glTexCoord1s;
+    glAPI->TexCoord1sv = __indirect_glTexCoord1sv;
+    glAPI->TexCoord2d = __indirect_glTexCoord2d;
+    glAPI->TexCoord2dv = __indirect_glTexCoord2dv;
+    glAPI->TexCoord2f = __indirect_glTexCoord2f;
+    glAPI->TexCoord2fv = __indirect_glTexCoord2fv;
+    glAPI->TexCoord2i = __indirect_glTexCoord2i;
+    glAPI->TexCoord2iv = __indirect_glTexCoord2iv;
+    glAPI->TexCoord2s = __indirect_glTexCoord2s;
+    glAPI->TexCoord2sv = __indirect_glTexCoord2sv;
+    glAPI->TexCoord3d = __indirect_glTexCoord3d;
+    glAPI->TexCoord3dv = __indirect_glTexCoord3dv;
+    glAPI->TexCoord3f = __indirect_glTexCoord3f;
+    glAPI->TexCoord3fv = __indirect_glTexCoord3fv;
+    glAPI->TexCoord3i = __indirect_glTexCoord3i;
+    glAPI->TexCoord3iv = __indirect_glTexCoord3iv;
+    glAPI->TexCoord3s = __indirect_glTexCoord3s;
+    glAPI->TexCoord3sv = __indirect_glTexCoord3sv;
+    glAPI->TexCoord4d = __indirect_glTexCoord4d;
+    glAPI->TexCoord4dv = __indirect_glTexCoord4dv;
+    glAPI->TexCoord4f = __indirect_glTexCoord4f;
+    glAPI->TexCoord4fv = __indirect_glTexCoord4fv;
+    glAPI->TexCoord4i = __indirect_glTexCoord4i;
+    glAPI->TexCoord4iv = __indirect_glTexCoord4iv;
+    glAPI->TexCoord4s = __indirect_glTexCoord4s;
+    glAPI->TexCoord4sv = __indirect_glTexCoord4sv;
+    glAPI->TexCoordPointer = __indirect_glTexCoordPointer;
+    glAPI->TexEnvf = __indirect_glTexEnvf;
+    glAPI->TexEnvfv = __indirect_glTexEnvfv;
+    glAPI->TexEnvi = __indirect_glTexEnvi;
+    glAPI->TexEnviv = __indirect_glTexEnviv;
+    glAPI->TexGend = __indirect_glTexGend;
+    glAPI->TexGendv = __indirect_glTexGendv;
+    glAPI->TexGenf = __indirect_glTexGenf;
+    glAPI->TexGenfv = __indirect_glTexGenfv;
+    glAPI->TexGeni = __indirect_glTexGeni;
+    glAPI->TexGeniv = __indirect_glTexGeniv;
+    glAPI->TexImage1D = __indirect_glTexImage1D;
+    glAPI->TexImage2D = __indirect_glTexImage2D;
+    glAPI->TexParameterf = __indirect_glTexParameterf;
+    glAPI->TexParameterfv = __indirect_glTexParameterfv;
+    glAPI->TexParameteri = __indirect_glTexParameteri;
+    glAPI->TexParameteriv = __indirect_glTexParameteriv;
+    glAPI->TexSubImage1D = __indirect_glTexSubImage1D;
+    glAPI->TexSubImage2D = __indirect_glTexSubImage2D;
+    glAPI->Translated = __indirect_glTranslated;
+    glAPI->Translatef = __indirect_glTranslatef;
+    glAPI->Vertex2d = __indirect_glVertex2d;
+    glAPI->Vertex2dv = __indirect_glVertex2dv;
+    glAPI->Vertex2f = __indirect_glVertex2f;
+    glAPI->Vertex2fv = __indirect_glVertex2fv;
+    glAPI->Vertex2i = __indirect_glVertex2i;
+    glAPI->Vertex2iv = __indirect_glVertex2iv;
+    glAPI->Vertex2s = __indirect_glVertex2s;
+    glAPI->Vertex2sv = __indirect_glVertex2sv;
+    glAPI->Vertex3d = __indirect_glVertex3d;
+    glAPI->Vertex3dv = __indirect_glVertex3dv;
+    glAPI->Vertex3f = __indirect_glVertex3f;
+    glAPI->Vertex3fv = __indirect_glVertex3fv;
+    glAPI->Vertex3i = __indirect_glVertex3i;
+    glAPI->Vertex3iv = __indirect_glVertex3iv;
+    glAPI->Vertex3s = __indirect_glVertex3s;
+    glAPI->Vertex3sv = __indirect_glVertex3sv;
+    glAPI->Vertex4d = __indirect_glVertex4d;
+    glAPI->Vertex4dv = __indirect_glVertex4dv;
+    glAPI->Vertex4f = __indirect_glVertex4f;
+    glAPI->Vertex4fv = __indirect_glVertex4fv;
+    glAPI->Vertex4i = __indirect_glVertex4i;
+    glAPI->Vertex4iv = __indirect_glVertex4iv;
+    glAPI->Vertex4s = __indirect_glVertex4s;
+    glAPI->Vertex4sv = __indirect_glVertex4sv;
+    glAPI->VertexPointer = __indirect_glVertexPointer;
+    glAPI->Viewport = __indirect_glViewport;
+
+    /* 1.2 */
+    glAPI->CopyTexSubImage3D = __indirect_glCopyTexSubImage3D;
+    glAPI->DrawRangeElements = __indirect_glDrawRangeElements;
+    glAPI->TexImage3D = __indirect_glTexImage3D;
+    glAPI->TexSubImage3D = __indirect_glTexSubImage3D;
+
+    /* OpenGL 1.2  GL_ARB_imaging */
+    glAPI->BlendColor = __indirect_glBlendColor;
+    glAPI->BlendEquation = __indirect_glBlendEquation;
+    glAPI->ColorSubTable = __indirect_glColorSubTable;
+    glAPI->ColorTable = __indirect_glColorTable;
+    glAPI->ColorTableParameterfv = __indirect_glColorTableParameterfv;
+    glAPI->ColorTableParameteriv = __indirect_glColorTableParameteriv;
+    glAPI->ConvolutionFilter1D = __indirect_glConvolutionFilter1D;
+    glAPI->ConvolutionFilter2D = __indirect_glConvolutionFilter2D;
+    glAPI->ConvolutionParameterf = __indirect_glConvolutionParameterf;
+    glAPI->ConvolutionParameterfv = __indirect_glConvolutionParameterfv;
+    glAPI->ConvolutionParameteri = __indirect_glConvolutionParameteri;
+    glAPI->ConvolutionParameteriv = __indirect_glConvolutionParameteriv;
+    glAPI->CopyColorSubTable = __indirect_glCopyColorSubTable;
+    glAPI->CopyColorTable = __indirect_glCopyColorTable;
+    glAPI->CopyConvolutionFilter1D = __indirect_glCopyConvolutionFilter1D;
+    glAPI->CopyConvolutionFilter2D = __indirect_glCopyConvolutionFilter2D;
+    glAPI->GetColorTable = __indirect_glGetColorTable;
+    glAPI->GetColorTableParameterfv = __indirect_glGetColorTableParameterfv;
+    glAPI->GetColorTableParameteriv = __indirect_glGetColorTableParameteriv;
+    glAPI->GetConvolutionFilter = __indirect_glGetConvolutionFilter;
+    glAPI->GetConvolutionParameterfv = __indirect_glGetConvolutionParameterfv;
+    glAPI->GetConvolutionParameteriv = __indirect_glGetConvolutionParameteriv;
+    glAPI->GetHistogram = __indirect_glGetHistogram;
+    glAPI->GetHistogramParameterfv = __indirect_glGetHistogramParameterfv;
+    glAPI->GetHistogramParameteriv = __indirect_glGetHistogramParameteriv;
+    glAPI->GetMinmax = __indirect_glGetMinmax;
+    glAPI->GetMinmaxParameterfv = __indirect_glGetMinmaxParameterfv;
+    glAPI->GetMinmaxParameteriv = __indirect_glGetMinmaxParameteriv;
+    glAPI->GetSeparableFilter = __indirect_glGetSeparableFilter;
+    glAPI->Histogram = __indirect_glHistogram;
+    glAPI->Minmax = __indirect_glMinmax;
+    glAPI->ResetHistogram = __indirect_glResetHistogram;
+    glAPI->ResetMinmax = __indirect_glResetMinmax;
+    glAPI->SeparableFilter2D = __indirect_glSeparableFilter2D;
+
+    /* 1.4 */
+    glAPI->MultiDrawArraysEXT = __indirect_glMultiDrawArrays;
+    glAPI->MultiDrawElementsEXT = __indirect_glMultiDrawElements;
+
+    /* ARB 1. GL_ARB_multitexture */
+    glAPI->ActiveTextureARB = __indirect_glActiveTextureARB;
+    glAPI->ClientActiveTextureARB = __indirect_glClientActiveTextureARB;
+    glAPI->MultiTexCoord1dARB = __indirect_glMultiTexCoord1dARB;
+    glAPI->MultiTexCoord1dvARB = __indirect_glMultiTexCoord1dvARB;
+    glAPI->MultiTexCoord1fARB = __indirect_glMultiTexCoord1fARB;
+    glAPI->MultiTexCoord1fvARB = __indirect_glMultiTexCoord1fvARB;
+    glAPI->MultiTexCoord1iARB = __indirect_glMultiTexCoord1iARB;
+    glAPI->MultiTexCoord1ivARB = __indirect_glMultiTexCoord1ivARB;
+    glAPI->MultiTexCoord1sARB = __indirect_glMultiTexCoord1sARB;
+    glAPI->MultiTexCoord1svARB = __indirect_glMultiTexCoord1svARB;
+    glAPI->MultiTexCoord2dARB = __indirect_glMultiTexCoord2dARB;
+    glAPI->MultiTexCoord2dvARB = __indirect_glMultiTexCoord2dvARB;
+    glAPI->MultiTexCoord2fARB = __indirect_glMultiTexCoord2fARB;
+    glAPI->MultiTexCoord2fvARB = __indirect_glMultiTexCoord2fvARB;
+    glAPI->MultiTexCoord2iARB = __indirect_glMultiTexCoord2iARB;
+    glAPI->MultiTexCoord2ivARB = __indirect_glMultiTexCoord2ivARB;
+    glAPI->MultiTexCoord2sARB = __indirect_glMultiTexCoord2sARB;
+    glAPI->MultiTexCoord2svARB = __indirect_glMultiTexCoord2svARB;
+    glAPI->MultiTexCoord3dARB = __indirect_glMultiTexCoord3dARB;
+    glAPI->MultiTexCoord3dvARB = __indirect_glMultiTexCoord3dvARB;
+    glAPI->MultiTexCoord3fARB = __indirect_glMultiTexCoord3fARB;
+    glAPI->MultiTexCoord3fvARB = __indirect_glMultiTexCoord3fvARB;
+    glAPI->MultiTexCoord3iARB = __indirect_glMultiTexCoord3iARB;
+    glAPI->MultiTexCoord3ivARB = __indirect_glMultiTexCoord3ivARB;
+    glAPI->MultiTexCoord3sARB = __indirect_glMultiTexCoord3sARB;
+    glAPI->MultiTexCoord3svARB = __indirect_glMultiTexCoord3svARB;
+    glAPI->MultiTexCoord4dARB = __indirect_glMultiTexCoord4dARB;
+    glAPI->MultiTexCoord4dvARB = __indirect_glMultiTexCoord4dvARB;
+    glAPI->MultiTexCoord4fARB = __indirect_glMultiTexCoord4fARB;
+    glAPI->MultiTexCoord4fvARB = __indirect_glMultiTexCoord4fvARB;
+    glAPI->MultiTexCoord4iARB = __indirect_glMultiTexCoord4iARB;
+    glAPI->MultiTexCoord4ivARB = __indirect_glMultiTexCoord4ivARB;
+    glAPI->MultiTexCoord4sARB = __indirect_glMultiTexCoord4sARB;
+    glAPI->MultiTexCoord4svARB = __indirect_glMultiTexCoord4svARB;
+
+    /* ARB 3. GL_ARB_transpose_matrix */
+    glAPI->LoadTransposeMatrixdARB = __indirect_glLoadTransposeMatrixdARB;
+    glAPI->LoadTransposeMatrixfARB = __indirect_glLoadTransposeMatrixfARB;
+    glAPI->MultTransposeMatrixdARB = __indirect_glMultTransposeMatrixdARB;
+    glAPI->MultTransposeMatrixfARB = __indirect_glMultTransposeMatrixfARB;
+
+    /* ARB 5. GL_ARB_multisample */
+    glAPI->SampleCoverageARB = __indirect_glSampleCoverageARB;
+
+    /* ARB 12. GL_ARB_texture_compression / 1.3 */
+    glAPI->GetCompressedTexImageARB = __indirect_glGetCompressedTexImage;
+    glAPI->CompressedTexImage1DARB = __indirect_glCompressedTexImage1D;
+    glAPI->CompressedTexImage2DARB = __indirect_glCompressedTexImage2D;
+    glAPI->CompressedTexImage3DARB = __indirect_glCompressedTexImage3D;
+    glAPI->CompressedTexSubImage1DARB = __indirect_glCompressedTexSubImage1D;
+    glAPI->CompressedTexSubImage2DARB = __indirect_glCompressedTexSubImage2D;
+    glAPI->CompressedTexSubImage3DARB = __indirect_glCompressedTexSubImage3D;
+
+    /* ARB 14. GL_ARB_point_parameters */
+    glAPI->PointParameterfEXT = __indirect_glPointParameterfARB;
+    glAPI->PointParameterfvEXT = __indirect_glPointParameterfvARB;
+
+    /* ARB 15. GL_ARB_window_pos */
+    glAPI->WindowPos2dMESA = __indirect_glWindowPos2dARB;
+    glAPI->WindowPos2iMESA = __indirect_glWindowPos2iARB;
+    glAPI->WindowPos2fMESA = __indirect_glWindowPos2fARB;
+    glAPI->WindowPos2iMESA = __indirect_glWindowPos2iARB;
+    glAPI->WindowPos2sMESA = __indirect_glWindowPos2sARB;
+    glAPI->WindowPos2dvMESA = __indirect_glWindowPos2dvARB;
+    glAPI->WindowPos2fvMESA = __indirect_glWindowPos2fvARB;
+    glAPI->WindowPos2ivMESA = __indirect_glWindowPos2ivARB;
+    glAPI->WindowPos2svMESA = __indirect_glWindowPos2svARB;
+    glAPI->WindowPos3dMESA = __indirect_glWindowPos3dARB;
+    glAPI->WindowPos3fMESA = __indirect_glWindowPos3fARB;
+    glAPI->WindowPos3iMESA = __indirect_glWindowPos3iARB;
+    glAPI->WindowPos3sMESA = __indirect_glWindowPos3sARB;
+    glAPI->WindowPos3dvMESA = __indirect_glWindowPos3dvARB;
+    glAPI->WindowPos3fvMESA = __indirect_glWindowPos3fvARB;
+    glAPI->WindowPos3ivMESA = __indirect_glWindowPos3ivARB;
+    glAPI->WindowPos3svMESA = __indirect_glWindowPos3svARB;
+
+    /* 25. GL_SGIS_multisample */
+    glAPI->SampleMaskSGIS = __indirect_glSampleMaskSGIS;
+    glAPI->SamplePatternSGIS = __indirect_glSamplePatternSGIS;
+
+    /* 30. GL_EXT_vertex_array */
+    glAPI->ColorPointerEXT    = ColorPointerEXT;
+    glAPI->EdgeFlagPointerEXT = EdgeFlagPointerEXT;
+    glAPI->IndexPointerEXT    = IndexPointerEXT;
+    glAPI->NormalPointerEXT   = NormalPointerEXT;
+    glAPI->TexCoordPointerEXT = TexCoordPointerEXT;
+    glAPI->VertexPointerEXT   = VertexPointerEXT;
+
+    /* 145. GL_EXT_secondary_color / GL 1.4 */
+    glAPI->SecondaryColor3bEXT       = __indirect_glSecondaryColor3b;
+    glAPI->SecondaryColor3bvEXT      = __indirect_glSecondaryColor3bv;
+    glAPI->SecondaryColor3sEXT       = __indirect_glSecondaryColor3s;
+    glAPI->SecondaryColor3svEXT      = __indirect_glSecondaryColor3sv;
+    glAPI->SecondaryColor3iEXT       = __indirect_glSecondaryColor3i;
+    glAPI->SecondaryColor3ivEXT      = __indirect_glSecondaryColor3iv;
+    glAPI->SecondaryColor3ubEXT      = __indirect_glSecondaryColor3ub;
+    glAPI->SecondaryColor3ubvEXT     = __indirect_glSecondaryColor3ubv;
+    glAPI->SecondaryColor3usEXT      = __indirect_glSecondaryColor3us;
+    glAPI->SecondaryColor3usvEXT     = __indirect_glSecondaryColor3usv;
+    glAPI->SecondaryColor3uiEXT      = __indirect_glSecondaryColor3ui;
+    glAPI->SecondaryColor3uivEXT     = __indirect_glSecondaryColor3uiv;
+    glAPI->SecondaryColor3fEXT       = __indirect_glSecondaryColor3f;
+    glAPI->SecondaryColor3fvEXT      = __indirect_glSecondaryColor3fv;
+    glAPI->SecondaryColor3dEXT       = __indirect_glSecondaryColor3d;
+    glAPI->SecondaryColor3dvEXT      = __indirect_glSecondaryColor3dv;
+    glAPI->SecondaryColorPointerEXT  = __indirect_glSecondaryColorPointer;
+
+    /* 149. GL_EXT_fog_coord / GL 1.4 */
+    glAPI->FogCoordfEXT       = __indirect_glFogCoordf;
+    glAPI->FogCoordfvEXT      = __indirect_glFogCoordfv;
+    glAPI->FogCoorddEXT       = __indirect_glFogCoordd;
+    glAPI->FogCoorddvEXT      = __indirect_glFogCoorddv;
+    glAPI->FogCoordPointerEXT = __indirect_glFogCoordPointer;
+
+    /* 173. GL_EXT_blend_func_separate / GL 1.4 */
+    glAPI->BlendFuncSeparateEXT = __indirect_glBlendFuncSeparate;
+
+    /* 262. GL_NV_point_sprite / GL 1.4 */
+    glAPI->PointParameteriNV = __indirect_glPointParameteri;
+    glAPI->PointParameterivNV = __indirect_glPointParameteriv;
+
+    /* 268. GL_EXT_stencil_two_side */
+    glAPI->ActiveStencilFaceEXT = __indirect_glActiveStencilFaceEXT;
+
+    return glAPI;
+}

src/glx/x11/indirect_init.h

@@ -0,0 +1,42 @@
+/* $XFree86: xc/lib/GL/glx/indirect_init.h,v 1.2 2000/02/08 17:18:33 dawes Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *
+ */
+
+#ifndef _INDIRECT_INIT_H_
+#define _INDIRECT_INIT_H_
+
+#include "glxclient.h"
+
+extern __GLapi *__glXNewIndirectAPI(void);
+
+#endif /* _INDIRECT_INIT_H_ */

src/glx/x11/indirect_wrap.h

@@ -0,0 +1,730 @@
+/* $XFree86: xc/lib/GL/glx/indirect_wrap.h,v 1.4 2003/09/28 20:15:04 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *
+ */
+
+/* NOTE: This file could be automatically generated */
+
+#ifndef _INDIRECT_WRAP_H_
+#define _INDIRECT_WRAP_H_
+
+#define glAccum __indirect_glAccum
+#define glAlphaFunc __indirect_glAlphaFunc
+#define glAreTexturesResident __indirect_glAreTexturesResident
+#define glArrayElement __indirect_glArrayElement
+#define glBegin __indirect_glBegin
+#define glBindTexture __indirect_glBindTexture
+#define glBitmap __indirect_glBitmap
+#define glBlendFunc __indirect_glBlendFunc
+#define glCallList __indirect_glCallList
+#define glCallLists __indirect_glCallLists
+#define glClear __indirect_glClear
+#define glClearAccum __indirect_glClearAccum
+#define glClearColor __indirect_glClearColor
+#define glClearDepth __indirect_glClearDepth
+#define glClearIndex __indirect_glClearIndex
+#define glClearStencil __indirect_glClearStencil
+#define glClipPlane __indirect_glClipPlane
+#define glColor3b __indirect_glColor3b
+#define glColor3bv __indirect_glColor3bv
+#define glColor3d __indirect_glColor3d
+#define glColor3dv __indirect_glColor3dv
+#define glColor3f __indirect_glColor3f
+#define glColor3fv __indirect_glColor3fv
+#define glColor3i __indirect_glColor3i
+#define glColor3iv __indirect_glColor3iv
+#define glColor3s __indirect_glColor3s
+#define glColor3sv __indirect_glColor3sv
+#define glColor3ub __indirect_glColor3ub
+#define glColor3ubv __indirect_glColor3ubv
+#define glColor3ui __indirect_glColor3ui
+#define glColor3uiv __indirect_glColor3uiv
+#define glColor3us __indirect_glColor3us
+#define glColor3usv __indirect_glColor3usv
+#define glColor4b __indirect_glColor4b
+#define glColor4bv __indirect_glColor4bv
+#define glColor4d __indirect_glColor4d
+#define glColor4dv __indirect_glColor4dv
+#define glColor4f __indirect_glColor4f
+#define glColor4fv __indirect_glColor4fv
+#define glColor4i __indirect_glColor4i
+#define glColor4iv __indirect_glColor4iv
+#define glColor4s __indirect_glColor4s
+#define glColor4sv __indirect_glColor4sv
+#define glColor4ub __indirect_glColor4ub
+#define glColor4ubv __indirect_glColor4ubv
+#define glColor4ui __indirect_glColor4ui
+#define glColor4uiv __indirect_glColor4uiv
+#define glColor4us __indirect_glColor4us
+#define glColor4usv __indirect_glColor4usv
+#define glColorMask __indirect_glColorMask
+#define glColorMaterial __indirect_glColorMaterial
+#define glColorPointer __indirect_glColorPointer
+#define glCopyPixels __indirect_glCopyPixels
+#define glCopyTexImage1D __indirect_glCopyTexImage1D
+#define glCopyTexImage2D __indirect_glCopyTexImage2D
+#define glCopyTexSubImage1D __indirect_glCopyTexSubImage1D
+#define glCopyTexSubImage2D __indirect_glCopyTexSubImage2D
+#define glCullFace __indirect_glCullFace
+#define glDeleteLists __indirect_glDeleteLists
+#define glDeleteTextures __indirect_glDeleteTextures
+#define glDepthFunc __indirect_glDepthFunc
+#define glDepthMask __indirect_glDepthMask
+#define glDepthRange __indirect_glDepthRange
+#define glDisable __indirect_glDisable
+#define glDisableClientState __indirect_glDisableClientState
+#define glDrawArrays __indirect_glDrawArrays
+#define glDrawBuffer __indirect_glDrawBuffer
+#define glDrawElements __indirect_glDrawElements
+#define glDrawPixels __indirect_glDrawPixels
+#define glEdgeFlag __indirect_glEdgeFlag
+#define glEdgeFlagPointer __indirect_glEdgeFlagPointer
+#define glEdgeFlagv __indirect_glEdgeFlagv
+#define glEnable __indirect_glEnable
+#define glEnableClientState __indirect_glEnableClientState
+#define glEnd __indirect_glEnd
+#define glEndList __indirect_glEndList
+#define glEvalCoord1d __indirect_glEvalCoord1d
+#define glEvalCoord1dv __indirect_glEvalCoord1dv
+#define glEvalCoord1f __indirect_glEvalCoord1f
+#define glEvalCoord1fv __indirect_glEvalCoord1fv
+#define glEvalCoord2d __indirect_glEvalCoord2d
+#define glEvalCoord2dv __indirect_glEvalCoord2dv
+#define glEvalCoord2f __indirect_glEvalCoord2f
+#define glEvalCoord2fv __indirect_glEvalCoord2fv
+#define glEvalMesh1 __indirect_glEvalMesh1
+#define glEvalMesh2 __indirect_glEvalMesh2
+#define glEvalPoint1 __indirect_glEvalPoint1
+#define glEvalPoint2 __indirect_glEvalPoint2
+#define glFeedbackBuffer __indirect_glFeedbackBuffer
+#define glFinish __indirect_glFinish
+#define glFlush __indirect_glFlush
+#define glFogf __indirect_glFogf
+#define glFogfv __indirect_glFogfv
+#define glFogi __indirect_glFogi
+#define glFogiv __indirect_glFogiv
+#define glFrontFace __indirect_glFrontFace
+#define glFrustum __indirect_glFrustum
+#define glGenLists __indirect_glGenLists
+#define glGenTextures __indirect_glGenTextures
+#define glGetBooleanv __indirect_glGetBooleanv
+#define glGetClipPlane __indirect_glGetClipPlane
+#define glGetDoublev __indirect_glGetDoublev
+#define glGetError __indirect_glGetError
+#define glGetFloatv __indirect_glGetFloatv
+#define glGetIntegerv __indirect_glGetIntegerv
+#define glGetLightfv __indirect_glGetLightfv
+#define glGetLightiv __indirect_glGetLightiv
+#define glGetMapdv __indirect_glGetMapdv
+#define glGetMapfv __indirect_glGetMapfv
+#define glGetMapiv __indirect_glGetMapiv
+#define glGetMaterialfv __indirect_glGetMaterialfv
+#define glGetMaterialiv __indirect_glGetMaterialiv
+#define glGetPixelMapfv __indirect_glGetPixelMapfv
+#define glGetPixelMapuiv __indirect_glGetPixelMapuiv
+#define glGetPixelMapusv __indirect_glGetPixelMapusv
+#define glGetPointerv __indirect_glGetPointerv
+#define glGetPolygonStipple __indirect_glGetPolygonStipple
+#define glGetString __indirect_glGetString
+#define glGetTexEnvfv __indirect_glGetTexEnvfv
+#define glGetTexEnviv __indirect_glGetTexEnviv
+#define glGetTexGendv __indirect_glGetTexGendv
+#define glGetTexGenfv __indirect_glGetTexGenfv
+#define glGetTexGeniv __indirect_glGetTexGeniv
+#define glGetTexImage __indirect_glGetTexImage
+#define glGetTexLevelParameterfv __indirect_glGetTexLevelParameterfv
+#define glGetTexLevelParameteriv __indirect_glGetTexLevelParameteriv
+#define glGetTexParameterfv __indirect_glGetTexParameterfv
+#define glGetTexParameteriv __indirect_glGetTexParameteriv
+#define glHint __indirect_glHint
+#define glIndexMask __indirect_glIndexMask
+#define glIndexPointer __indirect_glIndexPointer
+#define glIndexd __indirect_glIndexd
+#define glIndexdv __indirect_glIndexdv
+#define glIndexf __indirect_glIndexf
+#define glIndexfv __indirect_glIndexfv
+#define glIndexi __indirect_glIndexi
+#define glIndexiv __indirect_glIndexiv
+#define glIndexs __indirect_glIndexs
+#define glIndexsv __indirect_glIndexsv
+#define glIndexub __indirect_glIndexub
+#define glIndexubv __indirect_glIndexubv
+#define glInitNames __indirect_glInitNames
+#define glInterleavedArrays __indirect_glInterleavedArrays
+#define glIsEnabled __indirect_glIsEnabled
+#define glIsList __indirect_glIsList
+#define glIsTexture __indirect_glIsTexture
+#define glLightModelf __indirect_glLightModelf
+#define glLightModelfv __indirect_glLightModelfv
+#define glLightModeli __indirect_glLightModeli
+#define glLightModeliv __indirect_glLightModeliv
+#define glLightf __indirect_glLightf
+#define glLightfv __indirect_glLightfv
+#define glLighti __indirect_glLighti
+#define glLightiv __indirect_glLightiv
+#define glLineStipple __indirect_glLineStipple
+#define glLineWidth __indirect_glLineWidth
+#define glListBase __indirect_glListBase
+#define glLoadIdentity __indirect_glLoadIdentity
+#define glLoadMatrixd __indirect_glLoadMatrixd
+#define glLoadMatrixf __indirect_glLoadMatrixf
+#define glLoadName __indirect_glLoadName
+#define glLogicOp __indirect_glLogicOp
+#define glMap1d __indirect_glMap1d
+#define glMap1f __indirect_glMap1f
+#define glMap2d __indirect_glMap2d
+#define glMap2f __indirect_glMap2f
+#define glMapGrid1d __indirect_glMapGrid1d
+#define glMapGrid1f __indirect_glMapGrid1f
+#define glMapGrid2d __indirect_glMapGrid2d
+#define glMapGrid2f __indirect_glMapGrid2f
+#define glMaterialf __indirect_glMaterialf
+#define glMaterialfv __indirect_glMaterialfv
+#define glMateriali __indirect_glMateriali
+#define glMaterialiv __indirect_glMaterialiv
+#define glMatrixMode __indirect_glMatrixMode
+#define glMultMatrixd __indirect_glMultMatrixd
+#define glMultMatrixf __indirect_glMultMatrixf
+#define glNewList __indirect_glNewList
+#define glNormal3b __indirect_glNormal3b
+#define glNormal3bv __indirect_glNormal3bv
+#define glNormal3d __indirect_glNormal3d
+#define glNormal3dv __indirect_glNormal3dv
+#define glNormal3f __indirect_glNormal3f
+#define glNormal3fv __indirect_glNormal3fv
+#define glNormal3i __indirect_glNormal3i
+#define glNormal3iv __indirect_glNormal3iv
+#define glNormal3s __indirect_glNormal3s
+#define glNormal3sv __indirect_glNormal3sv
+#define glNormalPointer __indirect_glNormalPointer
+#define glOrtho __indirect_glOrtho
+#define glPassThrough __indirect_glPassThrough
+#define glPixelMapfv __indirect_glPixelMapfv
+#define glPixelMapuiv __indirect_glPixelMapuiv
+#define glPixelMapusv __indirect_glPixelMapusv
+#define glPixelStoref __indirect_glPixelStoref
+#define glPixelStorei __indirect_glPixelStorei
+#define glPixelTransferf __indirect_glPixelTransferf
+#define glPixelTransferi __indirect_glPixelTransferi
+#define glPixelZoom __indirect_glPixelZoom
+#define glPointSize __indirect_glPointSize
+#define glPolygonMode __indirect_glPolygonMode
+#define glPolygonOffset __indirect_glPolygonOffset
+#define glPolygonStipple __indirect_glPolygonStipple
+#define glPopAttrib __indirect_glPopAttrib
+#define glPopClientAttrib __indirect_glPopClientAttrib
+#define glPopMatrix __indirect_glPopMatrix
+#define glPopName __indirect_glPopName
+#define glPrioritizeTextures __indirect_glPrioritizeTextures
+#define glPushAttrib __indirect_glPushAttrib
+#define glPushClientAttrib __indirect_glPushClientAttrib
+#define glPushMatrix __indirect_glPushMatrix
+#define glPushName __indirect_glPushName
+#define glRasterPos2d __indirect_glRasterPos2d
+#define glRasterPos2dv __indirect_glRasterPos2dv
+#define glRasterPos2f __indirect_glRasterPos2f
+#define glRasterPos2fv __indirect_glRasterPos2fv
+#define glRasterPos2i __indirect_glRasterPos2i
+#define glRasterPos2iv __indirect_glRasterPos2iv
+#define glRasterPos2s __indirect_glRasterPos2s
+#define glRasterPos2sv __indirect_glRasterPos2sv
+#define glRasterPos3d __indirect_glRasterPos3d
+#define glRasterPos3dv __indirect_glRasterPos3dv
+#define glRasterPos3f __indirect_glRasterPos3f
+#define glRasterPos3fv __indirect_glRasterPos3fv
+#define glRasterPos3i __indirect_glRasterPos3i
+#define glRasterPos3iv __indirect_glRasterPos3iv
+#define glRasterPos3s __indirect_glRasterPos3s
+#define glRasterPos3sv __indirect_glRasterPos3sv
+#define glRasterPos4d __indirect_glRasterPos4d
+#define glRasterPos4dv __indirect_glRasterPos4dv
+#define glRasterPos4f __indirect_glRasterPos4f
+#define glRasterPos4fv __indirect_glRasterPos4fv
+#define glRasterPos4i __indirect_glRasterPos4i
+#define glRasterPos4iv __indirect_glRasterPos4iv
+#define glRasterPos4s __indirect_glRasterPos4s
+#define glRasterPos4sv __indirect_glRasterPos4sv
+#define glReadBuffer __indirect_glReadBuffer
+#define glReadPixels __indirect_glReadPixels
+#define glRectd __indirect_glRectd
+#define glRectdv __indirect_glRectdv
+#define glRectf __indirect_glRectf
+#define glRectfv __indirect_glRectfv
+#define glRecti __indirect_glRecti
+#define glRectiv __indirect_glRectiv
+#define glRects __indirect_glRects
+#define glRectsv __indirect_glRectsv
+#define glRenderMode __indirect_glRenderMode
+#define glRotated __indirect_glRotated
+#define glRotatef __indirect_glRotatef
+#define glScaled __indirect_glScaled
+#define glScalef __indirect_glScalef
+#define glScissor __indirect_glScissor
+#define glSelectBuffer __indirect_glSelectBuffer
+#define glShadeModel __indirect_glShadeModel
+#define glStencilFunc __indirect_glStencilFunc
+#define glStencilMask __indirect_glStencilMask
+#define glStencilOp __indirect_glStencilOp
+#define glTexCoord1d __indirect_glTexCoord1d
+#define glTexCoord1dv __indirect_glTexCoord1dv
+#define glTexCoord1f __indirect_glTexCoord1f
+#define glTexCoord1fv __indirect_glTexCoord1fv
+#define glTexCoord1i __indirect_glTexCoord1i
+#define glTexCoord1iv __indirect_glTexCoord1iv
+#define glTexCoord1s __indirect_glTexCoord1s
+#define glTexCoord1sv __indirect_glTexCoord1sv
+#define glTexCoord2d __indirect_glTexCoord2d
+#define glTexCoord2dv __indirect_glTexCoord2dv
+#define glTexCoord2f __indirect_glTexCoord2f
+#define glTexCoord2fv __indirect_glTexCoord2fv
+#define glTexCoord2i __indirect_glTexCoord2i
+#define glTexCoord2iv __indirect_glTexCoord2iv
+#define glTexCoord2s __indirect_glTexCoord2s
+#define glTexCoord2sv __indirect_glTexCoord2sv
+#define glTexCoord3d __indirect_glTexCoord3d
+#define glTexCoord3dv __indirect_glTexCoord3dv
+#define glTexCoord3f __indirect_glTexCoord3f
+#define glTexCoord3fv __indirect_glTexCoord3fv
+#define glTexCoord3i __indirect_glTexCoord3i
+#define glTexCoord3iv __indirect_glTexCoord3iv
+#define glTexCoord3s __indirect_glTexCoord3s
+#define glTexCoord3sv __indirect_glTexCoord3sv
+#define glTexCoord4d __indirect_glTexCoord4d
+#define glTexCoord4dv __indirect_glTexCoord4dv
+#define glTexCoord4f __indirect_glTexCoord4f
+#define glTexCoord4fv __indirect_glTexCoord4fv
+#define glTexCoord4i __indirect_glTexCoord4i
+#define glTexCoord4iv __indirect_glTexCoord4iv
+#define glTexCoord4s __indirect_glTexCoord4s
+#define glTexCoord4sv __indirect_glTexCoord4sv
+#define glTexCoordPointer __indirect_glTexCoordPointer
+#define glTexEnvf __indirect_glTexEnvf
+#define glTexEnvfv __indirect_glTexEnvfv
+#define glTexEnvi __indirect_glTexEnvi
+#define glTexEnviv __indirect_glTexEnviv
+#define glTexGend __indirect_glTexGend
+#define glTexGendv __indirect_glTexGendv
+#define glTexGenf __indirect_glTexGenf
+#define glTexGenfv __indirect_glTexGenfv
+#define glTexGeni __indirect_glTexGeni
+#define glTexGeniv __indirect_glTexGeniv
+#define glTexImage1D __indirect_glTexImage1D
+#define glTexImage2D __indirect_glTexImage2D
+#define glTexParameterf __indirect_glTexParameterf
+#define glTexParameterfv __indirect_glTexParameterfv
+#define glTexParameteri __indirect_glTexParameteri
+#define glTexParameteriv __indirect_glTexParameteriv
+#define glTexSubImage1D __indirect_glTexSubImage1D
+#define glTexSubImage2D __indirect_glTexSubImage2D
+#define glTranslated __indirect_glTranslated
+#define glTranslatef __indirect_glTranslatef
+#define glVertex2d __indirect_glVertex2d
+#define glVertex2dv __indirect_glVertex2dv
+#define glVertex2f __indirect_glVertex2f
+#define glVertex2fv __indirect_glVertex2fv
+#define glVertex2i __indirect_glVertex2i
+#define glVertex2iv __indirect_glVertex2iv
+#define glVertex2s __indirect_glVertex2s
+#define glVertex2sv __indirect_glVertex2sv
+#define glVertex3d __indirect_glVertex3d
+#define glVertex3dv __indirect_glVertex3dv
+#define glVertex3f __indirect_glVertex3f
+#define glVertex3fv __indirect_glVertex3fv
+#define glVertex3i __indirect_glVertex3i
+#define glVertex3iv __indirect_glVertex3iv
+#define glVertex3s __indirect_glVertex3s
+#define glVertex3sv __indirect_glVertex3sv
+#define glVertex4d __indirect_glVertex4d
+#define glVertex4dv __indirect_glVertex4dv
+#define glVertex4f __indirect_glVertex4f
+#define glVertex4fv __indirect_glVertex4fv
+#define glVertex4i __indirect_glVertex4i
+#define glVertex4iv __indirect_glVertex4iv
+#define glVertex4s __indirect_glVertex4s
+#define glVertex4sv __indirect_glVertex4sv
+#define glVertexPointer __indirect_glVertexPointer
+#define glViewport __indirect_glViewport
+
+/* 1.2 */
+#define glCopyTexSubImage3D __indirect_glCopyTexSubImage3D
+#define glDrawRangeElements __indirect_glDrawRangeElements
+#define glTexImage3D __indirect_glTexImage3D
+#define glTexSubImage3D __indirect_glTexSubImage3D
+
+/* 1.4 */
+#define glMultiDrawArrays __indirect_glMultiDrawArrays
+#define glMultiDrawElements __indirect_glMultiDrawElements
+#define glBlendFuncSeparate __indirect_glBlendFuncSeparate
+
+/* GL_ARB_imaging */
+#define glBlendColor __indirect_glBlendColor
+#define glBlendEquation __indirect_glBlendEquation
+#define glColorSubTable __indirect_glColorSubTable
+#define glColorTable __indirect_glColorTable
+#define glColorTableParameterfv __indirect_glColorTableParameterfv
+#define glColorTableParameteriv __indirect_glColorTableParameteriv
+#define glConvolutionFilter1D __indirect_glConvolutionFilter1D
+#define glConvolutionFilter2D __indirect_glConvolutionFilter2D
+#define glConvolutionParameterf __indirect_glConvolutionParameterf
+#define glConvolutionParameterfv __indirect_glConvolutionParameterfv
+#define glConvolutionParameteri __indirect_glConvolutionParameteri
+#define glConvolutionParameteriv __indirect_glConvolutionParameteriv
+#define glCopyColorSubTable __indirect_glCopyColorSubTable
+#define glCopyColorTable __indirect_glCopyColorTable
+#define glCopyConvolutionFilter1D __indirect_glCopyConvolutionFilter1D
+#define glCopyConvolutionFilter2D __indirect_glCopyConvolutionFilter2D
+#define glGetColorTable __indirect_glGetColorTable
+#define glGetColorTableParameterfv __indirect_glGetColorTableParameterfv
+#define glGetColorTableParameteriv __indirect_glGetColorTableParameteriv
+#define glGetConvolutionFilter __indirect_glGetConvolutionFilter
+#define glGetConvolutionParameterfv __indirect_glGetConvolutionParameterfv
+#define glGetConvolutionParameteriv __indirect_glGetConvolutionParameteriv
+#define glGetHistogram __indirect_glGetHistogram
+#define glGetHistogramParameterfv __indirect_glGetHistogramParameterfv
+#define glGetHistogramParameteriv __indirect_glGetHistogramParameteriv
+#define glGetMinmax __indirect_glGetMinmax
+#define glGetMinmaxParameterfv __indirect_glGetMinmaxParameterfv
+#define glGetMinmaxParameteriv __indirect_glGetMinmaxParameteriv
+#define glGetSeparableFilter __indirect_glGetSeparableFilter
+#define glHistogram __indirect_glHistogram
+#define glMinmax __indirect_glMinmax
+#define glResetHistogram __indirect_glResetHistogram
+#define glResetMinmax __indirect_glResetMinmax
+#define glSeparableFilter2D __indirect_glSeparableFilter2D
+
+/* ARB 1. GL_ARB_multitexture */
+#define glActiveTextureARB __indirect_glActiveTextureARB
+#define glClientActiveTextureARB __indirect_glClientActiveTextureARB
+#define glMultiTexCoord1dARB __indirect_glMultiTexCoord1dARB
+#define glMultiTexCoord1dvARB __indirect_glMultiTexCoord1dvARB
+#define glMultiTexCoord1fARB __indirect_glMultiTexCoord1fARB
+#define glMultiTexCoord1fvARB __indirect_glMultiTexCoord1fvARB
+#define glMultiTexCoord1iARB __indirect_glMultiTexCoord1iARB
+#define glMultiTexCoord1ivARB __indirect_glMultiTexCoord1ivARB
+#define glMultiTexCoord1sARB __indirect_glMultiTexCoord1sARB
+#define glMultiTexCoord1svARB __indirect_glMultiTexCoord1svARB
+#define glMultiTexCoord2dARB __indirect_glMultiTexCoord2dARB
+#define glMultiTexCoord2dvARB __indirect_glMultiTexCoord2dvARB
+#define glMultiTexCoord2fARB __indirect_glMultiTexCoord2fARB
+#define glMultiTexCoord2fvARB __indirect_glMultiTexCoord2fvARB
+#define glMultiTexCoord2iARB __indirect_glMultiTexCoord2iARB
+#define glMultiTexCoord2ivARB __indirect_glMultiTexCoord2ivARB
+#define glMultiTexCoord2sARB __indirect_glMultiTexCoord2sARB
+#define glMultiTexCoord2svARB __indirect_glMultiTexCoord2svARB
+#define glMultiTexCoord3dARB __indirect_glMultiTexCoord3dARB
+#define glMultiTexCoord3dvARB __indirect_glMultiTexCoord3dvARB
+#define glMultiTexCoord3fARB __indirect_glMultiTexCoord3fARB
+#define glMultiTexCoord3fvARB __indirect_glMultiTexCoord3fvARB
+#define glMultiTexCoord3iARB __indirect_glMultiTexCoord3iARB
+#define glMultiTexCoord3ivARB __indirect_glMultiTexCoord3ivARB
+#define glMultiTexCoord3sARB __indirect_glMultiTexCoord3sARB
+#define glMultiTexCoord3svARB __indirect_glMultiTexCoord3svARB
+#define glMultiTexCoord4dARB __indirect_glMultiTexCoord4dARB
+#define glMultiTexCoord4dvARB __indirect_glMultiTexCoord4dvARB
+#define glMultiTexCoord4fARB __indirect_glMultiTexCoord4fARB
+#define glMultiTexCoord4fvARB __indirect_glMultiTexCoord4fvARB
+#define glMultiTexCoord4iARB __indirect_glMultiTexCoord4iARB
+#define glMultiTexCoord4ivARB __indirect_glMultiTexCoord4ivARB
+#define glMultiTexCoord4sARB __indirect_glMultiTexCoord4sARB
+#define glMultiTexCoord4svARB __indirect_glMultiTexCoord4svARB
+
+/* ARB 3. ARB_transpose_matrix */
+
+#define glLoadTransposeMatrixdARB __indirect_glLoadTransposeMatrixdARB
+#define glLoadTransposeMatrixfARB __indirect_glLoadTransposeMatrixfARB
+#define glMultTransposeMatrixdARB __indirect_glMultTransposeMatrixdARB
+#define glMultTransposeMatrixfARB __indirect_glMultTransposeMatrixfARB
+
+/* ARB 5. ARB_multisample */
+
+#define glSampleCoverageARB __indirect_glSampleCoverageARB
+
+/* ARB 12. ARB_texture_compression */
+
+/* FIXME: Not yet supported. */
+
+/* ARB 14. ARB_point_parameters / GL 1.4 / NV_point_sprite */
+
+#define glPointParameterfARB __indirect_glPointParameterfARB
+#define glPointParameterfvARB __indirect_glPointParameterfvARB
+#define glPointParameteri __indirect_glPointParameteri
+#define glPointParameteriv __indirect_glPointParameteriv
+
+/* ARB 25. ARB_window_pos */
+
+#define glWindowPos2dARB __indirect_glWindowPos2dARB
+#define glWindowPos2fARB __indirect_glWindowPos2fARB
+#define glWindowPos2iARB __indirect_glWindowPos2iARB
+#define glWindowPos2sARB __indirect_glWindowPos2sARB
+#define glWindowPos2dvARB __indirect_glWindowPos2dvARB
+#define glWindowPos2fvARB __indirect_glWindowPos2fvARB
+#define glWindowPos2ivARB __indirect_glWindowPos2ivARB
+#define glWindowPos2svARB __indirect_glWindowPos2svARB
+#define glWindowPos3dARB __indirect_glWindowPos3dARB
+#define glWindowPos3fARB __indirect_glWindowPos3fARB
+#define glWindowPos3iARB __indirect_glWindowPos3iARB
+#define glWindowPos3sARB __indirect_glWindowPos3sARB
+#define glWindowPos3dvARB __indirect_glWindowPos3dvARB
+#define glWindowPos3fvARB __indirect_glWindowPos3fvARB
+#define glWindowPos3ivARB __indirect_glWindowPos3ivARB
+#define glWindowPos3svARB __indirect_glWindowPos3svARB
+
+/*
+ * Extensions
+ */
+
+#define glBlendColorEXT __indirect_glBlendColorEXT
+
+#define glPolygonOffsetEXT __indirect_glPolygonOffsetEXT
+
+#define glCopyTexSubImage3DEXT __indirect_glCopyTexSubImage3DEXT
+#define glTexImage3DEXT __indirect_glTexImage3DEXT
+#define glTexSubImage3DEXT __indirect_glTexSubImage3DEXT
+
+#define glGetTexFilterFuncSGIS __indirect_glGetTexFilterFuncSGIS
+#define glTexFilterFuncSGIS __indirect_glTexFilterFuncSGIS
+
+#define glTexSubImage1DEXT __indirect_glTexSubImage1DEXT
+#define glTexSubImage2DEXT __indirect_glTexSubImage2DEXT
+
+#define glCopyTexImage1DEXT __indirect_glCopyTexImage1DEXT
+#define glCopyTexImage2DEXT __indirect_glCopyTexImage2DEXT
+#define glCopyTexSubImage1DEXT __indirect_glCopyTexSubImage1DEXT
+#define glCopyTexSubImage2DEXT __indirect_glCopyTexSubImage2DEXT
+
+#define glGetHistogramEXT __indirect_glGetHistogramEXT
+#define glGetHistogramParameterfvEXT __indirect_glGetHistogramParameterfvEXT
+#define glGetHistogramParameterivEXT __indirect_glGetHistogramParameterivEXT
+#define glGetMinmaxEXT __indirect_glGetMinmaxEXT
+#define glGetMinmaxParameterfvEXT __indirect_glGetMinmaxParameterfvEXT
+#define glGetMinmaxParameterivEXT __indirect_glGetMinmaxParameterivEXT
+#define glHistogramEXT __indirect_glHistogramEXT
+#define glMinmaxEXT __indirect_glMinmaxEXT
+#define glResetHistogramEXT __indirect_glResetHistogramEXT
+#define glResetMinmaxEXT __indirect_glResetMinmaxEXT
+
+#define glConvolutionFilter1DEXT __indirect_glConvolutionFilter1DEXT
+#define glConvolutionFilter2DEXT __indirect_glConvolutionFilter2DEXT
+#define glConvolutionParameterfEXT __indirect_glConvolutionParameterfEXT
+#define glConvolutionParameterfvEXT __indirect_glConvolutionParameterfvEXT
+#define glConvolutionParameteriEXT __indirect_glConvolutionParameteriEXT
+#define glConvolutionParameterivEXT __indirect_glConvolutionParameterivEXT
+#define glCopyConvolutionFilter1DEXT __indirect_glCopyConvolutionFilter1DEXT
+#define glCopyConvolutionFilter2DEXT __indirect_glCopyConvolutionFilter2DEXT
+#define glGetConvolutionFilterEXT __indirect_glGetConvolutionFilterEXT
+#define glGetConvolutionParameterfvEXT __indirect_glGetConvolutionParameterfvEXT
+#define glGetConvolutionParameterivEXT __indirect_glGetConvolutionParameterivEXT
+#define glGetSeparableFilterEXT __indirect_glGetSeparableFilterEXT
+#define glSeparableFilter2DEXT __indirect_glSeparableFilter2DEXT
+
+#define glColorTableSGI __indirect_glColorTableSGI
+#define glColorTableParameterfvSGI __indirect_glColorTableParameterfvSGI
+#define glColorTableParameterivSGI __indirect_glColorTableParameterivSGI
+#define glCopyColorTableSGI __indirect_glCopyColorTableSGI
+#define glGetColorTableSGI __indirect_glGetColorTableSGI
+#define glGetColorTableParameterfvSGI __indirect_glGetColorTableParameterfvSGI
+#define glGetColorTableParameterivSGI __indirect_glGetColorTableParameterivSGI
+
+#define glPixelTexGenParameterfSGIS __indirect_glPixelTexGenParameterfSGIS
+#define glPixelTexGenParameteriSGIS __indirect_glPixelTexGenParameteriSGIS
+#define glGetPixelTexGenParameterfvSGIS __indirect_glGetPixelTexGenParameterfvSGIS
+#define glGetPixelTexGenParameterivSGIS __indirect_glGetPixelTexGenParameterivSGIS
+
+#define glTexImage4DSGIS __indirect_glTexImage4DSGIS
+#define glTexSubImage4DSGIS __indirect_glTexSubImage4DSGIS
+
+#define glAreTexturesResidentEXT __indirect_glAreTexturesResidentEXT
+#define glBindTextureEXT __indirect_glBindTextureEXT
+#define glDeleteTexturesEXT __indirect_glDeleteTexturesEXT
+#define glGenTexturesEXT __indirect_glGenTexturesEXT
+#define glIsTextureEXT __indirect_glIsTextureEXT
+#define glPrioritizeTexturesEXT __indirect_glPrioritizeTexturesEXT
+
+#define glDetailTexFuncSGIS __indirect_glDetailTexFuncSGIS
+#define glGetDetailTexFuncSGIS __indirect_glGetDetailTexFuncSGIS
+
+#define glGetSharpenTexFuncSGIS __indirect_glGetSharpenTexFuncSGIS
+#define glSharpenTexFuncSGIS __indirect_glSharpenTexFuncSGIS
+
+#define glSampleMaskSGIS __indirect_glSampleMaskSGIS
+#define glSamplePatternSGIS __indirect_glSamplePatternSGIS
+
+#define glArrayElementEXT __indirect_glArrayElementEXT
+#define glColorPointerEXT __indirect_glColorPointerEXT
+#define glDrawArraysEXT __indirect_glDrawArraysEXT
+#define glEdgeFlagPointerEXT __indirect_glEdgeFlagPointerEXT
+#define glGetPointervEXT __indirect_glGetPointervEXT
+#define glIndexPointerEXT __indirect_glIndexPointerEXT
+#define glNormalPointerEXT __indirect_glNormalPointerEXT
+#define glTexCoordPointerEXT __indirect_glTexCoordPointerEXT
+#define glVertexPointerEXT __indirect_glVertexPointerEXT
+
+#define glBlendEquationEXT __indirect_glBlendEquationEXT
+
+#define glSpriteParameterfSGIX __indirect_glSpriteParameterfSGIX
+#define glSpriteParameterfvSGIX __indirect_glSpriteParameterfvSGIX
+#define glSpriteParameteriSGIX __indirect_glSpriteParameteriSGIX
+#define glSpriteParameterivSGIX __indirect_glSpriteParameterivSGIX
+
+#define glPointParameterfEXT __indirect_glPointParameterfEXT
+#define glPointParameterfvEXT __indirect_glPointParameterfvEXT
+
+#define glGetInstrumentsSGIX __indirect_glGetInstrumentsSGIX
+#define glInstrumentsBufferSGIX __indirect_glInstrumentsBufferSGIX
+#define glPollInstrumentsSGIX __indirect_glPollInstrumentsSGIX
+#define glReadInstrumentsSGIX __indirect_glReadInstrumentsSGIX
+#define glStartInstrumentsSGIX __indirect_glStartInstrumentsSGIX
+#define glStopInstrumentsSGIX __indirect_glStopInstrumentsSGIX
+
+#define glFrameZoomSGIX __indirect_glFrameZoomSGIX
+
+#define glReferencePlaneSGIX __indirect_glReferencePlaneSGIX
+
+#define glFlushRasterSGIX __indirect_glFlushRasterSGIX
+
+#define glGetImageTransformParameterfvHP __indirect_glGetImageTransformParameterfvHP
+#define glGetImageTransformParameterivHP __indirect_glGetImageTransformParameterivHP
+#define glImageTransformParameterfHP __indirect_glImageTransformParameterfHP
+#define glImageTransformParameterfvHP __indirect_glImageTransformParameterfvHP
+#define glImageTransformParameteriHP __indirect_glImageTransformParameteriHP
+#define glImageTransformParameterivHP __indirect_glImageTransformParameterivHP
+
+#define glColorSubTableEXT __indirect_glColorSubTableEXT
+#define glCopyColorSubTableEXT __indirect_glCopyColorSubTableEXT
+
+#define glHintPGI __indirect_glHintPGI
+
+#define glColorTableEXT __indirect_glColorTableEXT
+#define glGetColorTableEXT __indirect_glGetColorTableEXT
+#define glGetColorTableParameterfvEXT __indirect_glGetColorTableParameterfvEXT
+#define glGetColorTableParameterivEXT __indirect_glGetColorTableParameterivEXT
+
+#define glGetListParameterfvSGIX __indirect_glGetListParameterfvSGIX
+#define glGetListParameterivSGIX __indirect_glGetListParameterivSGIX
+#define glListParameterfSGIX __indirect_glListParameterfSGIX
+#define glListParameterfvSGIX __indirect_glListParameterfvSGIX
+#define glListParameteriSGIX __indirect_glListParameteriSGIX
+#define glListParameterivSGIX __indirect_glListParameterivSGIX
+
+#define glIndexMaterialEXT __indirect_glIndexMaterialEXT
+
+#define glIndexFuncEXT __indirect_glIndexFuncEXT
+
+#define glLockArraysEXT __indirect_glLockArraysEXT
+#define glUnlockArraysEXT __indirect_glUnlockArraysEXT
+
+#define glCullParameterfvEXT __indirect_glCullParameterfvEXT
+#define glCullParameterdvEXT __indirect_glCullParameterdvEXT
+
+#define glBlendFuncSeparateINGR __indirect_glBlendFuncSeparateINGR
+
+#define glWindowPos2iMESA __indirect_WindowPos2iMESA
+#define glWindowPos2sMESA __indirect_WindowPos2sMESA
+#define glWindowPos2fMESA __indirect_WindowPos2fMESA
+#define glWindowPos2dMESA __indirect_WindowPos2dMESA
+#define glWindowPos2ivMESA __indirect_WindowPos2ivMESA
+#define glWindowPos2svMESA __indirect_WindowPos2svMESA
+#define glWindowPos2fvMESA __indirect_WindowPos2fvMESA
+#define glWindowPos2dvMESA __indirect_WindowPos2dvMESA
+#define glWindowPos3iMESA __indirect_WindowPos3iMESA
+#define glWindowPos3sMESA __indirect_WindowPos3sMESA
+#define glWindowPos3fMESA __indirect_WindowPos3fMESA
+#define glWindowPos3dMESA __indirect_WindowPos3dMESA
+#define glWindowPos3ivMESA __indirect_WindowPos3ivMESA
+#define glWindowPos3svMESA __indirect_WindowPos3svMESA
+#define glWindowPos3fvMESA __indirect_WindowPos3fvMESA
+#define glWindowPos3dvMESA __indirect_WindowPos3dvMESA
+#define glWindowPos4iMESA __indirect_WindowPos4iMESA
+#define glWindowPos4sMESA __indirect_WindowPos4sMESA
+#define glWindowPos4fMESA __indirect_WindowPos4fMESA
+#define glWindowPos4dMESA __indirect_WindowPos4dMESA
+#define glWindowPos4ivMESA __indirect_WindowPos4ivMESA
+#define glWindowPos4svMESA __indirect_WindowPos4svMESA
+#define glWindowPos4fvMESA __indirect_WindowPos4fvMESA
+#define glWindowPos4dvMESA __indirect_WindowPos4dvMESA
+
+#define glResizeBuffersMESA __indirect_glResizeBuffersMESA
+
+#define glActiveStencilFaceEXT __indirect_glActiveStencilFaceEXT
+
+#define glPointParameterfARB __indirect_glPointParameterfARB
+#define glPointParameterfvARB __indirect_glPointParameterfvARB
+
+#define glActiveStencilFaceEXT __indirect_glActiveStencilFaceEXT
+
+#define glWindowPos2dARB __indirect_glWindowPos2dARB
+#define glWindowPos2iARB __indirect_glWindowPos2iARB
+#define glWindowPos2fARB __indirect_glWindowPos2fARB
+#define glWindowPos2iARB __indirect_glWindowPos2iARB
+#define glWindowPos2sARB __indirect_glWindowPos2sARB
+#define glWindowPos2dvARB __indirect_glWindowPos2dvARB
+#define glWindowPos2fvARB __indirect_glWindowPos2fvARB
+#define glWindowPos2ivARB __indirect_glWindowPos2ivARB
+#define glWindowPos2svARB __indirect_glWindowPos2svARB
+#define glWindowPos3dARB __indirect_glWindowPos3dARB
+#define glWindowPos3fARB __indirect_glWindowPos3fARB
+#define glWindowPos3iARB __indirect_glWindowPos3iARB
+#define glWindowPos3sARB __indirect_glWindowPos3sARB
+#define glWindowPos3dvARB __indirect_glWindowPos3dvARB
+#define glWindowPos3fvARB __indirect_glWindowPos3fvARB
+#define glWindowPos3ivARB __indirect_glWindowPos3ivARB
+#define glWindowPos3svARB __indirect_glWindowPos3svARB
+
+/* 145. GL_EXT_secondary_color / GL 1.4 */
+
+#define glSecondaryColor3b __indirect_glSecondaryColor3b
+#define glSecondaryColor3bv __indirect_glSecondaryColor3bv
+#define glSecondaryColor3d __indirect_glSecondaryColor3d
+#define glSecondaryColor3dv __indirect_glSecondaryColor3dv
+#define glSecondaryColor3f __indirect_glSecondaryColor3f
+#define glSecondaryColor3fv __indirect_glSecondaryColor3fv
+#define glSecondaryColor3i __indirect_glSecondaryColor3i
+#define glSecondaryColor3iv __indirect_glSecondaryColor3iv
+#define glSecondaryColor3s __indirect_glSecondaryColor3s
+#define glSecondaryColor3sv __indirect_glSecondaryColor3sv
+#define glSecondaryColor3ub __indirect_glSecondaryColor3ub
+#define glSecondaryColor3ubv __indirect_glSecondaryColor3ubv
+#define glSecondaryColor3ui __indirect_glSecondaryColor3ui
+#define glSecondaryColor3uiv __indirect_glSecondaryColor3uiv
+#define glSecondaryColor3us __indirect_glSecondaryColor3us
+#define glSecondaryColor3usv __indirect_glSecondaryColor3usv
+#define glSecondaryColorPointer __indirect_glSecondaryColorPointer
+
+/* 149. GL_EXT_fog_coord / GL 1.4 */
+
+#define glFogCoordf __indirect_glFogCoordf
+#define glFogCoordd __indirect_glFogCoordd
+#define glFogCoordfv __indirect_glFogCoordfv
+#define glFogCoorddv __indirect_glFogCoorddv
+#define glFogCoordPointer __indirect_glFogCoordPointer
+
+#endif /* _INDIRECT_WRAP_H_ */

src/glx/x11/packrender.h

@@ -0,0 +1,250 @@
+/* $XFree86: xc/lib/GL/glx/packrender.h,v 1.7tsi Exp $ */
+#ifndef __GLX_packrender_h__
+#define __GLX_packrender_h__
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#define NEED_GL_FUNCS_WRAPPED
+#include "glxclient.h"
+
+/*
+** The macros in this header convert the client machine's native data types to
+** wire protocol data types.  The header is part of the porting layer of the
+** client library, and it is intended that hardware vendors will rewrite this
+** header to suit their own machines.
+*/
+
+/*
+** Pad a count of bytes to the nearest multiple of 4.  The X protocol
+** transfers data in 4 byte quantities, so this macro is used to
+** insure the right amount of data being sent.
+*/
+#define __GLX_PAD(a) (((a)+3) & ~3)
+
+/*
+ ** Network size parameters
+ */
+#define sz_double 8
+
+/* Setup for all commands */
+#define __GLX_DECLARE_VARIABLES() \
+    __GLXcontext *gc;		  \
+    GLubyte *pc, *pixelHeaderPC;  \
+    GLuint compsize, cmdlen
+
+#define __GLX_LOAD_VARIABLES()	   \
+    gc = __glXGetCurrentContext(); \
+    pc = gc->pc;                   \
+    /* Muffle compilers */		    \
+    cmdlen = 0;         (void)cmdlen;	    \
+    compsize = 0;       (void)compsize;	    \
+    pixelHeaderPC = 0;  (void)pixelHeaderPC
+
+/*
+** Variable sized command support macro.  This macro is used by calls
+** that are potentially larger than __GLX_SMALL_RENDER_CMD_SIZE.
+** Because of their size, they may not automatically fit in the buffer.
+** If the buffer can't hold the command then it is flushed so that
+** the command will fit in the next buffer.
+*/
+#define __GLX_BEGIN_VARIABLE(opcode,size)	\
+    if (pc + (size) > gc->bufEnd) {		\
+	pc = __glXFlushRenderBuffer(gc, pc);	\
+    }						\
+    __GLX_PUT_SHORT(0,size);			\
+    __GLX_PUT_SHORT(2,opcode)
+
+#define __GLX_BEGIN_VARIABLE_LARGE(opcode,size)	\
+    pc = __glXFlushRenderBuffer(gc, pc);	\
+    __GLX_PUT_LONG(0,size);			\
+    __GLX_PUT_LONG(4,opcode)
+
+#define __GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode,size) \
+    if (pc + (size) > gc->bufEnd) {		     \
+	pc = __glXFlushRenderBuffer(gc, pc);	     \
+    }						     \
+    __GLX_PUT_SHORT(0,size);			     \
+    __GLX_PUT_SHORT(2,opcode);			     \
+    pc += __GLX_RENDER_HDR_SIZE;		     \
+    pixelHeaderPC = pc;				     \
+    pc += __GLX_PIXEL_HDR_SIZE
+
+#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,size) \
+    pc = __glXFlushRenderBuffer(gc, pc);		   \
+    __GLX_PUT_LONG(0,size);				   \
+    __GLX_PUT_LONG(4,opcode);				   \
+    pc += __GLX_RENDER_LARGE_HDR_SIZE;			   \
+    pixelHeaderPC = pc;					   \
+    pc += __GLX_PIXEL_HDR_SIZE
+
+#define __GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(opcode,size) \
+    if (pc + (size) > gc->bufEnd) {		        \
+	pc = __glXFlushRenderBuffer(gc, pc); 	        \
+    }						        \
+    __GLX_PUT_SHORT(0,size);			        \
+    __GLX_PUT_SHORT(2,opcode);			        \
+    pc += __GLX_RENDER_HDR_SIZE;		        \
+    pixelHeaderPC = pc;				        \
+    pc += __GLX_PIXEL_3D_HDR_SIZE
+
+#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(opcode,size) \
+    pc = __glXFlushRenderBuffer(gc, pc);	   	      \
+    __GLX_PUT_LONG(0,size);				      \
+    __GLX_PUT_LONG(4,opcode);				      \
+    pc += __GLX_RENDER_LARGE_HDR_SIZE;			      \
+    pixelHeaderPC = pc;					      \
+    pc += __GLX_PIXEL_3D_HDR_SIZE
+
+/*
+** Fixed size command support macro.  This macro is used by calls that
+** are never larger than __GLX_SMALL_RENDER_CMD_SIZE.  Because they
+** always fit in the buffer, and because the buffer promises to
+** maintain enough room for them, we don't need to check for space
+** before doing the storage work.
+*/
+#define __GLX_BEGIN(opcode,size) \
+    __GLX_PUT_SHORT(0,size);     \
+    __GLX_PUT_SHORT(2,opcode)
+
+/*
+** Finish a rendering command by advancing the pc.  If the pc is now past
+** the limit pointer then there is no longer room for a
+** __GLX_SMALL_RENDER_CMD_SIZE sized command, which will break the
+** assumptions present in the __GLX_BEGIN macro.  In this case the
+** rendering buffer is flushed out into the X protocol stream (which may
+** or may not do I/O).
+*/
+#define __GLX_END(size)			       \
+    pc += size;				       \
+    if (pc > gc->limit) {		       \
+	(void) __glXFlushRenderBuffer(gc, pc); \
+    } else {				       \
+	gc->pc = pc;			       \
+    }
+
+/* Array copy macros */
+#define __GLX_MEM_COPY(dest,src,bytes) \
+    if (src && dest) \
+    	memcpy(dest, src, bytes)
+
+/* Single item copy macros */
+#define __GLX_PUT_CHAR(offset,a) \
+    *((INT8 *) (pc + offset)) = a
+
+#ifndef _CRAY
+#define __GLX_PUT_SHORT(offset,a) \
+    *((INT16 *) (pc + offset)) = a
+
+#define __GLX_PUT_LONG(offset,a) \
+    *((INT32 *) (pc + offset)) = a
+
+#define __GLX_PUT_FLOAT(offset,a) \
+    *((FLOAT32 *) (pc + offset)) = a
+
+#else
+#define __GLX_PUT_SHORT(offset,a) \
+ { GLubyte *cp = (pc+offset); \
+   int shift = (64-16) - ((int)(cp) >> (64-6)); \
+   *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }
+
+#define __GLX_PUT_LONG(offset,a) \
+ { GLubyte *cp = (pc+offset); \
+   int shift = (64-32) - ((int)(cp) >> (64-6)); \
+   *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }
+
+#define __GLX_PUT_FLOAT(offset,a) \
+    gl_put_float((pc + offset),a)
+
+#define __GLX_PUT_DOUBLE(offset,a) \
+    gl_put_double(pc + offset, a)
+
+extern void gl_put_float(/*GLubyte *, struct cray_single*/);
+extern void gl_put_double(/*GLubyte *, struct cray_double*/);
+#endif
+
+#ifndef _CRAY
+
+#ifdef __GLX_ALIGN64
+/*
+** This can certainly be done better for a particular machine
+** architecture!
+*/
+#define __GLX_PUT_DOUBLE(offset,a) \
+    __GLX_MEM_COPY(pc + offset, &a, 8)
+#else
+#define __GLX_PUT_DOUBLE(offset,a) \
+    *((FLOAT64 *) (pc + offset)) = a
+#endif
+
+#endif
+
+#define __GLX_PUT_CHAR_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT8)
+
+#ifndef _CRAY
+#define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT16)
+
+#define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT32)
+
+#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT32)
+
+#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT64)
+
+#else
+#define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
+    gl_put_short_array((GLubyte *)(pc + offset), a, alen * __GLX_SIZE_INT16)
+
+#define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
+    gl_put_long_array((GLubyte *)(pc + offset), (long *)a, alen * __GLX_SIZE_INT32)
+
+#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
+    gl_put_float_array((GLubyte *)(pc + offset), (float *)a, alen * __GLX_SIZE_FLOAT32)
+
+#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
+    gl_put_double_array((GLubyte *)(pc + offset), (double *)a, alen * __GLX_SIZE_FLOAT64)
+
+extern gl_put_short_array (GLubyte *, short *, int);
+extern gl_put_long_array (GLubyte *, long *, int);
+extern gl_put_float_array (GLubyte *, float *, int);
+extern gl_put_double_array (GLubyte *, double *, int);
+
+#endif /* _CRAY */
+
+#endif /* !__GLX_packrender_h__ */

src/glx/x11/packsingle.h

@@ -0,0 +1,219 @@
+/* $XFree86: xc/lib/GL/glx/packsingle.h,v 1.5tsi Exp $ */
+#ifndef __GLX_packsingle_h__
+#define __GLX_packsingle_h__
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+
+/*
+** The macros in this header convert wire protocol data types to the client
+** machine's native data types.  The header is part of the porting layer of
+** the client library, and it is intended that hardware vendors will rewrite
+** this header to suit their own machines.
+*/
+
+/*
+** Dummy define to make the GetReqExtra macro happy.  The value is not
+** used, but instead the code in __GLX_SINGLE_BEGIN issues its own store
+** to req->reqType with the proper code (our extension code).
+*/
+#define X_GLXSingle 0
+
+/* Declare common variables used during a single command */
+#define __GLX_SINGLE_DECLARE_VARIABLES()	 \
+    __GLXcontext *gc = __glXGetCurrentContext(); \
+    GLubyte *pc, *pixelHeaderPC;		 \
+    GLuint compsize, cmdlen;			 \
+    Display *dpy = gc->currentDpy;		 \
+    xGLXSingleReq *req
+
+#define __GLX_SINGLE_LOAD_VARIABLES() \
+    pc = gc->pc;           \
+    /* Muffle compilers */		     \
+    pixelHeaderPC = 0;  (void)pixelHeaderPC; \
+    compsize = 0;       (void)compsize;	     \
+    cmdlen = 0;         (void)cmdlen
+
+/* Start a single command */
+#define __GLX_SINGLE_BEGIN(opcode,bytes)	   \
+    if (dpy) {					   \
+	(void) __glXFlushRenderBuffer(gc, pc);	   \
+	LockDisplay(dpy);			   \
+	GetReqExtra(GLXSingle,bytes,req);	   \
+	req->reqType = gc->majorOpcode;		   \
+	req->glxCode = opcode;			   \
+	req->contextTag = gc->currentContextTag;   \
+	pc = ((GLubyte *)(req) + sz_xGLXSingleReq)
+
+/* End a single command */
+#define __GLX_SINGLE_END()			   \
+	UnlockDisplay(dpy);			   \
+	SyncHandle();				   \
+    }
+
+/* Store data to sending for a single command */
+#define __GLX_SINGLE_PUT_CHAR(offset,a)	\
+    *((INT8 *) (pc + offset)) = a
+
+#ifndef CRAY
+#define __GLX_SINGLE_PUT_SHORT(offset,a) \
+    *((INT16 *) (pc + offset)) = a
+
+#define __GLX_SINGLE_PUT_LONG(offset,a)	\
+    *((INT32 *) (pc + offset)) = a
+
+#define __GLX_SINGLE_PUT_FLOAT(offset,a) \
+    *((FLOAT32 *) (pc + offset)) = a
+
+#else
+#define __GLX_SINGLE_PUT_SHORT(offset,a) \
+    { GLubyte *cp = (pc+offset); \
+      int shift = (64-16) - ((int)(cp) >> (64-6)); \
+      *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }
+
+#define __GLX_SINGLE_PUT_LONG(offset,a) \
+    { GLubyte *cp = (pc+offset); \
+      int shift = (64-32) - ((int)(cp) >> (64-6)); \
+      *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }
+
+#define __GLX_SINGLE_PUT_FLOAT(offset,a) \
+    gl_put_float(pc + offset, a)
+#endif
+
+/* Read support macros */
+#define __GLX_SINGLE_READ_XREPLY()		    \
+    (void) _XReply(dpy, (xReply*) &reply, 0, False)
+
+#define __GLX_SINGLE_GET_RETVAL(a,cast)	\
+    a = (cast) reply.retval
+
+#define __GLX_SINGLE_GET_SIZE(a) \
+    a = (GLint) reply.size
+
+#ifndef _CRAY
+#define __GLX_SINGLE_GET_CHAR(p) \
+    *p = *(GLbyte *)&reply.pad3;
+
+#define __GLX_SINGLE_GET_SHORT(p) \
+    *p = *(GLshort *)&reply.pad3;
+
+#define __GLX_SINGLE_GET_LONG(p) \
+    *p = *(GLint *)&reply.pad3;
+
+#define __GLX_SINGLE_GET_FLOAT(p) \
+    *p = *(GLfloat *)&reply.pad3;
+
+#else
+#define __GLX_SINGLE_GET_CHAR(p) \
+    *p = reply.pad3 >> 24;
+
+#define __GLX_SINGLE_GET_SHORT(p) \
+    {int t = reply.pad3 >> 16; \
+     *p = (t & 0x8000) ? (t | ~0xffff) : (t & 0xffff);}
+
+#define __GLX_SINGLE_GET_LONG(p) \
+    {int t = reply.pad3; \
+     *p = (t & 0x80000000) ? (t | ~0xffffffff) : (t & 0xffffffff);}
+
+#define PAD3OFFSET 16
+#define __GLX_SINGLE_GET_FLOAT(p) \
+    *p = gl_ntoh_float((GLubyte *)&reply + PAD3OFFSET);
+
+#define __GLX_SINGLE_GET_DOUBLE(p) \
+    *p = gl_ntoh_double((GLubyte *)&reply + PAD3OFFSET);
+
+extern float gl_ntoh_float(GLubyte *);
+extern float gl_ntoh_double(GLubyte *);
+#endif
+
+#ifndef _CRAY
+
+#ifdef __GLX_ALIGN64
+#define __GLX_SINGLE_GET_DOUBLE(p) \
+    __GLX_MEM_COPY(p, &reply.pad3, 8)
+#else
+#define __GLX_SINGLE_GET_DOUBLE(p) \
+    *p = *(GLdouble *)&reply.pad3
+#endif
+
+#endif
+	  
+/* Get an array of typed data */
+#define __GLX_SINGLE_GET_VOID_ARRAY(a,alen)	\
+{						\
+    GLint slop = alen*__GLX_SIZE_INT8 & 3;	\
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT8);	\
+    if (slop) _XEatData(dpy,4-slop);		\
+}
+
+#define __GLX_SINGLE_GET_CHAR_ARRAY(a,alen)	\
+{						\
+    GLint slop = alen*__GLX_SIZE_INT8 & 3;	\
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT8);	\
+    if (slop) _XEatData(dpy,4-slop);		\
+}
+					
+
+#define __GLX_SINGLE_GET_SHORT_ARRAY(a,alen)	\
+{						\
+    GLint slop = (alen*__GLX_SIZE_INT16) & 3;	\
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT16);\
+    if (slop) _XEatData(dpy,4-slop);		\
+}
+
+#define __GLX_SINGLE_GET_LONG_ARRAY(a,alen) \
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT32);  	
+
+#ifndef _CRAY
+#define __GLX_SINGLE_GET_FLOAT_ARRAY(a,alen) \
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_FLOAT32);  	
+
+#define __GLX_SINGLE_GET_DOUBLE_ARRAY(a,alen) \
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_FLOAT64);  	
+
+#else
+#define __GLX_SINGLE_GET_FLOAT_ARRAY(a,alen) \
+    gl_get_float_array(dpy,a,alen);
+
+#define __GLX_SINGLE_GET_DOUBLE_ARRAY(a,alen) \
+    gl_get_double_array(dpy, a, alen);
+
+extern void gl_get_float_array(Display *dpy, float *a, int alen);
+extern void gl_get_double_array(Display *dpy, double *a, int alen);
+#endif
+
+#endif /* !__GLX_packsingle_h__ */

src/glx/x11/packvendpriv.h

@@ -0,0 +1,220 @@
+/* $XFree86: xc/lib/GL/glx/packvendpriv.h,v 1.5tsi Exp $ */
+#ifndef __GLX_packvendpriv_h__
+#define __GLX_packvendpriv_h__
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+
+/*
+** The macros in this header convert wire protocol data types to the client
+** machine's native data types.  The header is part of the porting layer of
+** the client library, and it is intended that hardware vendors will rewrite
+** this header to suit their own machines.
+*/
+
+/*
+** Dummy define to make the GetReqExtra macro happy.  The value is not
+** used, but instead the code in __GLX_VENDPRIV_BEGIN issues its own store
+** to req->reqType with the proper code (our extension code).
+*/
+#define X_GLXVendpriv 0
+
+/* Declare common variables used during a single command */
+#define __GLX_VENDPRIV_DECLARE_VARIABLES()	 \
+    __GLXcontext *gc = __glXGetCurrentContext(); \
+    GLubyte *pc, *pixelHeaderPC;		 \
+    GLuint compsize, cmdlen;			 \
+    Display *dpy = gc->currentDpy;		 \
+    xGLXVendorPrivateReq *req
+
+#define __GLX_VENDPRIV_LOAD_VARIABLES() \
+    pc = gc->pc;            \
+    /* Muffle compilers */		     \
+    pixelHeaderPC = 0;  (void)pixelHeaderPC; \
+    compsize = 0;       (void)compsize;	     \
+    cmdlen = 0;         (void)cmdlen
+
+/* Start a vendor private command */
+#define __GLX_VENDPRIV_BEGIN(glxcode, opcode,bytes)	   \
+    if (dpy) {					   	   \
+	(void) __glXFlushRenderBuffer(gc, pc);	   	   \
+	LockDisplay(dpy);			   	   \
+	GetReqExtra(GLXVendorPrivate,bytes,req);	   \
+	req->reqType = gc->majorOpcode;		   	   \
+	req->glxCode = glxcode;			   	   \
+	req->vendorCode = opcode;                          \
+	req->contextTag = gc->currentContextTag;   	   \
+	pc = ((GLubyte *)(req) + sz_xGLXVendorPrivateReq)
+
+/* End a vendor private command */
+#define __GLX_VENDPRIV_END()			   \
+	UnlockDisplay(dpy);			   \
+	SyncHandle();				   \
+    }
+
+/* Store data to sending for a vendor private command */
+#define __GLX_VENDPRIV_PUT_CHAR(offset,a)	\
+    *((INT8 *) (pc + offset)) = a
+
+#ifndef CRAY
+#define __GLX_VENDPRIV_PUT_SHORT(offset,a) \
+    *((INT16 *) (pc + offset)) = a
+
+#define __GLX_VENDPRIV_PUT_LONG(offset,a)	\
+    *((INT32 *) (pc + offset)) = a
+
+#define __GLX_VENDPRIV_PUT_FLOAT(offset,a) \
+    *((FLOAT32 *) (pc + offset)) = a
+
+#else
+#define __GLX_VENDPRIV_PUT_SHORT(offset,a) \
+    { GLubyte *cp = (pc+offset); \
+      int shift = (64-16) - ((int)(cp) >> (64-6)); \
+      *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }
+
+#define __GLX_VENDPRIV_PUT_LONG(offset,a) \
+    { GLubyte *cp = (pc+offset); \
+      int shift = (64-32) - ((int)(cp) >> (64-6)); \
+      *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }
+
+#define __GLX_VENDPRIV_PUT_FLOAT(offset,a) \
+    gl_put_float(pc + offset, a)
+#endif
+
+/* Read support macros */
+#define __GLX_VENDPRIV_READ_XREPLY()		    \
+    (void) _XReply(dpy, (xReply*) &reply, 0, False)
+
+#define __GLX_VENDPRIV_GET_RETVAL(a,cast)	\
+    a = (cast) reply.retval
+
+#define __GLX_VENDPRIV_GET_SIZE(a) \
+    a = (GLint) reply.size
+
+#ifndef _CRAY
+#define __GLX_VENDPRIV_GET_CHAR(p) \
+    *p = *(GLbyte *)&reply.pad3;
+
+#define __GLX_VENDPRIV_GET_SHORT(p) \
+    *p = *(GLshort *)&reply.pad3;
+
+#define __GLX_VENDPRIV_GET_LONG(p) \
+    *p = *(GLint *)&reply.pad3;
+
+#define __GLX_VENDPRIV_GET_FLOAT(p) \
+    *p = *(GLfloat *)&reply.pad3;
+
+#else
+#define __GLX_VENDPRIV_GET_CHAR(p) \
+    *p = reply.pad3 >> 24;
+
+#define __GLX_VENDPRIV_GET_SHORT(p) \
+    {int t = reply.pad3 >> 16; \
+     *p = (t & 0x8000) ? (t | ~0xffff) : (t & 0xffff);}
+
+#define __GLX_VENDPRIV_GET_LONG(p) \
+    {int t = reply.pad3; \
+     *p = (t & 0x80000000) ? (t | ~0xffffffff) : (t & 0xffffffff);}
+
+#define PAD3OFFSET 16
+#define __GLX_VENDPRIV_GET_FLOAT(p) \
+    *p = gl_ntoh_float((GLubyte *)&reply + PAD3OFFSET);
+
+#define __GLX_VENDPRIV_GET_DOUBLE(p) \
+    *p = gl_ntoh_double((GLubyte *)&reply + PAD3OFFSET);
+
+extern float gl_ntoh_float(GLubyte *);
+extern float gl_ntoh_double(GLubyte *);
+#endif
+
+#ifndef _CRAY
+
+#ifdef __GLX_ALIGN64
+#define __GLX_VENDPRIV_GET_DOUBLE(p) \
+    __GLX_MEM_COPY(p, &reply.pad3, 8)
+#else
+#define __GLX_VENDPRIV_GET_DOUBLE(p) \
+    *p = *(GLdouble *)&reply.pad3
+#endif
+
+#endif
+	  
+/* Get an array of typed data */
+#define __GLX_VENDPRIV_GET_VOID_ARRAY(a,alen) \
+{						\
+    GLint slop = alen*__GLX_SIZE_INT8 & 3;	\
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT8);  	\
+    if (slop) _XEatData(dpy,4-slop);		\
+}
+
+#define __GLX_VENDPRIV_GET_CHAR_ARRAY(a,alen) \
+{						\
+    GLint slop = alen*__GLX_SIZE_INT8 & 3;	\
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT8);  	\
+    if (slop) _XEatData(dpy,4-slop);		\
+}
+					
+
+#define __GLX_VENDPRIV_GET_SHORT_ARRAY(a,alen) \
+{						\
+    GLint slop = (alen*__GLX_SIZE_INT16) & 3;	\
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT16);	\
+    if (slop) _XEatData(dpy,4-slop);		\
+}
+
+#define __GLX_VENDPRIV_GET_LONG_ARRAY(a,alen) \
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT32);  	
+
+#ifndef _CRAY
+#define __GLX_VENDPRIV_GET_FLOAT_ARRAY(a,alen) \
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_FLOAT32);  	
+
+#define __GLX_VENDPRIV_GET_DOUBLE_ARRAY(a,alen) \
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_FLOAT64);  	
+
+#else
+#define __GLX_VENDPRIV_GET_FLOAT_ARRAY(a,alen) \
+    gl_get_float_array(dpy,a,alen);
+
+#define __GLX_VENDPRIV_GET_DOUBLE_ARRAY(a,alen) \
+    gl_get_double_array(dpy, a, alen);
+
+extern void gl_get_float_array(Display *dpy, float *a, int alen);
+extern void gl_get_double_array(Display *dpy, double *a, int alen);
+#endif
+
+#endif /* !__GLX_packvendpriv_h__ */

src/glx/x11/pixel.c

@@ -0,0 +1,462 @@
+/* $XFree86: xc/lib/GL/glx/pixel.c,v 1.8 2003/09/28 20:15:04 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+
+static GLubyte MsbToLsbTable[256] = {
+    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
+    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
+    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
+    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
+    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
+    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
+};
+
+static GLubyte LowBitsMask[9] = {
+    0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff,
+};
+
+static GLubyte HighBitsMask[9] = {
+    0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff,
+};
+
+
+/*
+** Copy bitmap data from clients packed memory applying unpacking modes as the
+** data is transfered into the destImage buffer.  Return in modes the
+** set of pixel modes that are to be done by the server.
+*/
+static void FillBitmap(__GLXcontext *gc, GLint width, GLint height,
+		       GLenum format, const GLvoid *userdata,
+		       GLubyte *destImage)
+{
+    const __GLXattribute * state = gc->client_state_private;
+    GLint rowLength = state->storeUnpack.rowLength;
+    GLint alignment = state->storeUnpack.alignment;
+    GLint skipPixels = state->storeUnpack.skipPixels;
+    GLint skipRows = state->storeUnpack.skipRows;
+    GLint lsbFirst = state->storeUnpack.lsbFirst;
+    GLint elementsLeft, bitOffset, currentByte, nextByte, highBitMask;
+    GLint lowBitMask, i;
+    GLint components, groupsPerRow, rowSize, padding, elementsPerRow;
+    const GLubyte *start, *iter;
+
+    if (rowLength > 0) {
+	groupsPerRow = rowLength;
+    } else {
+	groupsPerRow = width;
+    }
+    components = __glElementsPerGroup(format,GL_BITMAP);
+    rowSize = (groupsPerRow * components + 7) >> 3;
+    padding = (rowSize % alignment);
+    if (padding) {
+	rowSize += alignment - padding;
+    }
+    start = ((const GLubyte*) userdata) + skipRows * rowSize + 
+	((skipPixels * components) >> 3);
+    bitOffset = (skipPixels * components) & 7;
+    highBitMask = LowBitsMask[8-bitOffset];
+    lowBitMask = HighBitsMask[bitOffset];
+    elementsPerRow = width * components;
+    for (i = 0; i < height; i++) {
+	elementsLeft = elementsPerRow;
+	iter = start;
+	while (elementsLeft) {
+	    /* First retrieve low bits from current byte */
+	    if (lsbFirst) {
+		currentByte = MsbToLsbTable[iter[0]];
+	    } else {
+		currentByte = iter[0];
+	    }
+	    if (bitOffset) {
+		/* Need to read next byte to finish current byte */
+		if (elementsLeft > (8 - bitOffset)) {
+		    if (lsbFirst) {
+			nextByte = MsbToLsbTable[iter[1]];
+		    } else {
+			nextByte = iter[1];
+		    }
+		    currentByte = 
+			((currentByte & highBitMask) << bitOffset) |
+			    ((nextByte & lowBitMask) >> (8 - bitOffset));
+		} else {
+		    currentByte = 
+			((currentByte & highBitMask) << bitOffset);
+		}
+	    } 
+	    if (elementsLeft >= 8) {
+		*destImage = currentByte;
+		elementsLeft -= 8;
+	    } else {
+		*destImage = currentByte & HighBitsMask[elementsLeft];
+		elementsLeft = 0;
+	    }
+	    destImage++;
+	    iter++;
+	}
+	start += rowSize;
+    }
+}
+
+/*
+** Extract array from user's data applying all pixel store modes.
+** The internal packed array format used has LSB_FIRST = FALSE and 
+** ALIGNMENT = 1.
+*/
+void __glFillImage(__GLXcontext *gc, GLint dim, GLint width, GLint height,
+		   GLint depth, GLenum format, GLenum type,
+		   const GLvoid *userdata, GLubyte *newimage, GLubyte *modes)
+{
+    const __GLXattribute * state = gc->client_state_private;
+    GLint rowLength = state->storeUnpack.rowLength;
+    GLint imageHeight = state->storeUnpack.imageHeight;
+    GLint alignment = state->storeUnpack.alignment;
+    GLint skipPixels = state->storeUnpack.skipPixels;
+    GLint skipRows = state->storeUnpack.skipRows;
+    GLint skipImages = state->storeUnpack.skipImages;
+    GLint swapBytes = state->storeUnpack.swapEndian;
+    GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
+    GLint elementsPerRow, imageSize, rowsPerImage, h, i, j, k;
+    const GLubyte *start, *iter, *itera, *iterb, *iterc;
+    GLubyte *iter2;
+
+    if (type == GL_BITMAP) {
+	FillBitmap(gc, width, height, format, userdata, newimage);
+    } else {
+	components = __glElementsPerGroup(format,type);
+	if (rowLength > 0) {
+	    groupsPerRow = rowLength;
+	} else {
+	    groupsPerRow = width;
+	}
+	if (imageHeight > 0) {
+	    rowsPerImage = imageHeight;
+	} else {
+	    rowsPerImage = height;
+	}
+
+	elementSize = __glBytesPerElement(type);
+	groupSize = elementSize * components;
+	if (elementSize == 1) swapBytes = 0;
+
+	rowSize = groupsPerRow * groupSize;
+	padding = (rowSize % alignment);
+	if (padding) {
+	    rowSize += alignment - padding;
+	}
+	imageSize = rowSize * rowsPerImage;
+	start = ((const GLubyte*) userdata) + skipImages * imageSize +
+		skipRows * rowSize + skipPixels * groupSize;
+	iter2 = newimage;
+	elementsPerRow = width * components;
+
+	if (swapBytes) {
+	    itera = start;
+	    for (h = 0; h < depth; h++) {
+		iterb = itera;
+		for (i = 0; i < height; i++) {
+		    iterc = iterb;
+		    for (j = 0; j < elementsPerRow; j++) {
+			for (k = 1; k <= elementSize; k++) {
+			    iter2[k-1] = iterc[elementSize - k];
+			}
+			iter2 += elementSize;
+			iterc += elementSize;
+		    }
+		    iterb += rowSize;
+		}
+		itera += imageSize;
+	    }
+	} else {
+	    itera = start;
+	    for (h = 0; h < depth; h++) {
+		if (rowSize == elementsPerRow * elementSize) {
+		    /* Ha!  This is mondo easy! */
+		    __GLX_MEM_COPY(iter2, itera,
+				   elementsPerRow * elementSize * height);
+		    iter2 += elementsPerRow * elementSize * height;
+		} else {
+		    iter = itera;
+		    for (i = 0; i < height; i++) {
+			__GLX_MEM_COPY(iter2, iter, elementsPerRow*elementSize);
+			iter2 += elementsPerRow * elementSize;
+			iter += rowSize;
+		    }
+		}
+		itera += imageSize;
+	    }    
+	}
+    }
+
+    /* Setup store modes that describe what we just did */
+    if (modes) {
+	if (dim == 3) {
+	    GLubyte *pc = modes;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,0);
+	    __GLX_PUT_LONG(20,0);
+	    __GLX_PUT_LONG(24,0);
+	    __GLX_PUT_LONG(28,0);
+	    __GLX_PUT_LONG(32,1);
+	} else {
+	    GLubyte *pc = modes;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+    }
+}
+
+/*
+** Empty a bitmap in LSB_FIRST=GL_FALSE and ALIGNMENT=4 format packing it
+** into the clients memory using the pixel store PACK modes.
+*/
+static void EmptyBitmap(__GLXcontext *gc, GLint width, GLint height,
+			GLenum format, const GLubyte *sourceImage,
+			GLvoid *userdata)
+{
+    const __GLXattribute * state = gc->client_state_private;
+    GLint rowLength = state->storePack.rowLength;
+    GLint alignment = state->storePack.alignment;
+    GLint skipPixels = state->storePack.skipPixels;
+    GLint skipRows = state->storePack.skipRows;
+    GLint lsbFirst = state->storePack.lsbFirst;
+    GLint components, groupsPerRow, rowSize, padding, elementsPerRow;
+    GLint sourceRowSize, sourcePadding, sourceSkip;
+    GLubyte *start, *iter;
+    GLint elementsLeft, bitOffset, currentByte, highBitMask, lowBitMask;
+    GLint writeMask, i;
+    GLubyte writeByte;
+
+    components = __glElementsPerGroup(format,GL_BITMAP);
+    if (rowLength > 0) {
+	groupsPerRow = rowLength;
+    } else {
+	groupsPerRow = width;
+    }
+
+    rowSize = (groupsPerRow * components + 7) >> 3;
+    padding = (rowSize % alignment);
+    if (padding) {
+	rowSize += alignment - padding;
+    }
+    sourceRowSize = (width * components + 7) >> 3;
+    sourcePadding = (sourceRowSize % 4);
+    if (sourcePadding) {
+	sourceSkip = 4 - sourcePadding;
+    } else {
+	sourceSkip = 0;
+    }
+    start = ((GLubyte*) userdata) + skipRows * rowSize + 
+	((skipPixels * components) >> 3);
+    bitOffset = (skipPixels * components) & 7;
+    highBitMask = LowBitsMask[8-bitOffset];
+    lowBitMask = HighBitsMask[bitOffset];
+    elementsPerRow = width * components;
+    for (i = 0; i < height; i++) {
+	elementsLeft = elementsPerRow;
+	iter = start;
+	writeMask = highBitMask;
+	writeByte = 0;
+	while (elementsLeft) {
+	    /* Set up writeMask (to write to current byte) */
+	    if (elementsLeft + bitOffset < 8) {
+		/* Need to trim writeMask */
+		writeMask &= HighBitsMask[bitOffset+elementsLeft];
+	    }
+
+	    if (lsbFirst) {
+		currentByte = MsbToLsbTable[iter[0]];
+	    } else {
+		currentByte = iter[0];
+	    }
+
+	    if (bitOffset) {
+		writeByte |= (sourceImage[0] >> bitOffset);
+		currentByte = (currentByte & ~writeMask) | 
+		    (writeByte & writeMask);
+		writeByte = (sourceImage[0] << (8 - bitOffset));
+	    } else {
+		currentByte = (currentByte & ~writeMask) |
+		    (sourceImage[0] & writeMask);
+	    }
+
+	    if (lsbFirst) {
+		iter[0] = MsbToLsbTable[currentByte];
+	    } else {
+		iter[0] = currentByte;
+	    }
+
+	    if (elementsLeft >= 8) {
+		elementsLeft -= 8;
+	    } else {
+		elementsLeft = 0;
+	    }
+	    sourceImage++;
+	    iter++;
+	    writeMask = 0xff;
+	}
+	if (writeByte) {
+	    /* Some data left over that still needs writing */
+	    writeMask &= lowBitMask;
+	    if (lsbFirst) {
+		currentByte = MsbToLsbTable[iter[0]];
+	    } else {
+		currentByte = iter[0];
+	    }
+	    currentByte = (currentByte & ~writeMask) | (writeByte & writeMask);
+	    if (lsbFirst) {
+		iter[0] = MsbToLsbTable[currentByte];
+	    } else {
+		iter[0] = currentByte;
+	    }
+	}
+	start += rowSize;
+	sourceImage += sourceSkip;
+    }
+}
+
+/*
+** Insert array into user's data applying all pixel store modes.
+** The packed array format from the server is LSB_FIRST = FALSE,
+** SWAP_BYTES = the current pixel storage pack mode, and ALIGNMENT = 4.
+** Named __glEmptyImage() because it is the opposite of __glFillImage().
+*/
+/* ARGSUSED */
+void __glEmptyImage(__GLXcontext *gc, GLint dim, GLint width, GLint height, 
+		    GLint depth, GLenum format, GLenum type,
+		    const GLubyte *sourceImage, GLvoid *userdata)
+{
+    const __GLXattribute * state = gc->client_state_private;
+    GLint rowLength = state->storePack.rowLength;
+    GLint imageHeight = state->storePack.imageHeight;
+    GLint alignment = state->storePack.alignment;
+    GLint skipPixels = state->storePack.skipPixels;
+    GLint skipRows = state->storePack.skipRows;
+    GLint skipImages = state->storePack.skipImages;
+    GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
+    GLint elementsPerRow, sourceRowSize, sourcePadding, h, i;
+    GLint imageSize, rowsPerImage;
+    GLubyte *start, *iter, *itera;
+
+    if (type == GL_BITMAP) {
+	EmptyBitmap(gc, width, height, format, sourceImage, userdata);
+    } else {
+	components = __glElementsPerGroup(format,type);
+	if (rowLength > 0) {
+	    groupsPerRow = rowLength;
+	} else {
+	    groupsPerRow = width;
+	}
+	if (imageHeight > 0) {
+	    rowsPerImage = imageHeight;
+	} else {
+	    rowsPerImage = height;
+	}
+	elementSize = __glBytesPerElement(type);
+	groupSize = elementSize * components;
+	rowSize = groupsPerRow * groupSize;
+	padding = (rowSize % alignment);
+	if (padding) {
+	    rowSize += alignment - padding;
+	}
+	sourceRowSize = width * groupSize;
+	sourcePadding = (sourceRowSize % 4);
+	if (sourcePadding) {
+	    sourceRowSize += 4 - sourcePadding;
+	}
+	imageSize = sourceRowSize * rowsPerImage;
+	start = ((GLubyte*) userdata) + skipImages * imageSize +
+		skipRows * rowSize + skipPixels * groupSize;
+	elementsPerRow = width * components;
+
+	itera = start;
+	for (h = 0; h < depth; h++) {
+	    if ((rowSize == sourceRowSize) && (sourcePadding == 0)) {
+		/* Ha!  This is mondo easy! */
+		__GLX_MEM_COPY(itera, sourceImage,
+			       elementsPerRow * elementSize * height);
+		sourceImage += elementsPerRow * elementSize * height;
+	    } else {
+		iter = itera;
+		for (i = 0; i < height; i++) {
+		    __GLX_MEM_COPY(iter, sourceImage,
+				   elementsPerRow * elementSize);
+		    sourceImage += sourceRowSize;
+		    iter += rowSize;
+		}
+	    }
+	    itera += imageSize;
+	}
+    }
+}

src/glx/x11/pixelstore.c

@@ -0,0 +1,301 @@
+/* $XFree86: xc/lib/GL/glx/pixelstore.c,v 1.4 2004/01/28 18:11:43 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#define NEED_GL_FUNCS_WRAPPED
+#include "glxclient.h"
+#include "indirect_wrap.h"
+
+/*
+** Specify parameters that control the storage format of pixel arrays.
+*/
+void glPixelStoref(GLenum pname, GLfloat param)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = gc->client_state_private;
+    Display *dpy = gc->currentDpy;
+    GLuint a;
+
+    if (!dpy) return;
+
+    switch (pname) {
+      case GL_PACK_ROW_LENGTH:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.rowLength = a;
+	break;
+      case GL_PACK_IMAGE_HEIGHT:
+        a = (GLuint) (param + 0.5);
+        if (((GLint) a) < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storePack.imageHeight = a;
+        break;
+      case GL_PACK_SKIP_ROWS:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.skipRows = a;
+	break;
+      case GL_PACK_SKIP_PIXELS:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.skipPixels = a;
+	break;
+      case GL_PACK_SKIP_IMAGES:
+        a = (GLuint) (param + 0.5);
+        if (((GLint) a) < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storePack.skipImages = a;
+        break;
+      case GL_PACK_ALIGNMENT:
+	a = (GLint) (param + 0.5);
+	switch (a) {
+	  case 1: case 2: case 4: case 8:
+	    state->storePack.alignment = a;
+	    break;
+	  default:
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	break;
+      case GL_PACK_SWAP_BYTES:
+	state->storePack.swapEndian = (param != 0);
+	break;
+      case GL_PACK_LSB_FIRST:
+	state->storePack.lsbFirst = (param != 0);
+	break;
+
+      case GL_UNPACK_ROW_LENGTH:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.rowLength = a;
+	break;
+      case GL_UNPACK_IMAGE_HEIGHT:
+        a = (GLuint) (param + 0.5);
+        if (((GLint) a) < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storeUnpack.imageHeight = a;
+        break;
+      case GL_UNPACK_SKIP_ROWS:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.skipRows = a;
+	break;
+      case GL_UNPACK_SKIP_PIXELS:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.skipPixels = a;
+	break;
+      case GL_UNPACK_SKIP_IMAGES:
+        a = (GLuint) (param + 0.5);
+        if (((GLint) a) < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storeUnpack.skipImages = a;
+        break;
+      case GL_UNPACK_ALIGNMENT:
+	a = (GLint) (param + 0.5);
+	switch (a) {
+	  case 1: case 2: case 4: case 8:
+	    state->storeUnpack.alignment = a;
+	    break;
+	  default:
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	break;
+      case GL_UNPACK_SWAP_BYTES:
+	state->storeUnpack.swapEndian = (param != 0);
+	break;
+      case GL_UNPACK_LSB_FIRST:
+	state->storeUnpack.lsbFirst = (param != 0);
+	break;
+      default:
+	/*
+	** NOTE: there are currently no pixel storage commands that need to
+	** be sent to the server.  This may change in future versions
+	** of the API, however.
+	*/
+	__glXSetError(gc, GL_INVALID_ENUM);
+	break;
+    }
+}
+
+void glPixelStorei(GLenum pname, GLint param)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = gc->client_state_private;
+    Display *dpy = gc->currentDpy;
+
+    if (!dpy) return;
+
+    switch (pname) {
+      case GL_PACK_ROW_LENGTH:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.rowLength = param;
+	break;
+      case GL_PACK_IMAGE_HEIGHT:
+        if (param < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storePack.imageHeight = param;
+        break;
+      case GL_PACK_SKIP_ROWS:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.skipRows = param;
+	break;
+      case GL_PACK_SKIP_PIXELS:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.skipPixels = param;
+	break;
+      case GL_PACK_SKIP_IMAGES:
+        if (param < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storePack.skipImages = param;
+        break;
+      case GL_PACK_ALIGNMENT:
+	switch (param) {
+	  case 1: case 2: case 4: case 8:
+	    state->storePack.alignment = param;
+	    break;
+	  default:
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	break;
+      case GL_PACK_SWAP_BYTES:
+	state->storePack.swapEndian = (param != 0);
+	break;
+      case GL_PACK_LSB_FIRST:
+	state->storePack.lsbFirst = (param != 0);
+	break;
+
+      case GL_UNPACK_ROW_LENGTH:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.rowLength = param;
+	break;
+      case GL_UNPACK_IMAGE_HEIGHT:
+        if (param < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storeUnpack.imageHeight = param;
+        break;
+      case GL_UNPACK_SKIP_ROWS:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.skipRows = param;
+	break;
+      case GL_UNPACK_SKIP_PIXELS:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.skipPixels = param;
+	break;
+      case GL_UNPACK_SKIP_IMAGES:
+        if (param < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storeUnpack.skipImages = param;
+        break;
+      case GL_UNPACK_ALIGNMENT:
+	switch (param) {
+	  case 1: case 2: case 4: case 8:
+	    state->storeUnpack.alignment = param;
+	    break;
+	  default:
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	break;
+      case GL_UNPACK_SWAP_BYTES:
+	state->storeUnpack.swapEndian = (param != 0);
+	break;
+      case GL_UNPACK_LSB_FIRST:
+	state->storeUnpack.lsbFirst = (param != 0);
+	break;
+      default:
+	/*
+	** NOTE: there are currently no pixel storage commands that need to
+	** be sent to the server.  This may change in future versions
+	** of the API, however.
+	*/
+	__glXSetError(gc, GL_INVALID_ENUM);
+	break;
+    }
+}

src/glx/x11/render2.c

@@ -0,0 +1,512 @@
+/* $XFree86: xc/lib/GL/glx/render2.c,v 1.6 2004/01/31 09:29:33 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+#include "size.h"
+
+/*
+** This file contains routines that might need to be transported as
+** GLXRender or GLXRenderLarge commands, and these commands don't
+** use the pixel header.  See renderpix.c for those routines.
+*/
+
+void glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
+{
+    __GLX_DECLARE_VARIABLES();
+    __GLX_LOAD_VARIABLES();
+
+    compsize = __glCallLists_size(n,type);
+    cmdlen = __GLX_PAD(12 + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_CallLists,cmdlen);
+	__GLX_PUT_LONG(4,n);
+	__GLX_PUT_LONG(8,type);
+	__GLX_PUT_CHAR_ARRAY(12,lists,compsize);
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_CallLists,cmdlen+4);
+	__GLX_PUT_LONG(8,n);
+	__GLX_PUT_LONG(12,type);
+	__glXSendLargeCommand(gc, pc, 16, lists, compsize);
+    }
+}
+
+void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
+	     GLint order, const GLdouble *pnts)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLint k;
+
+    __GLX_LOAD_VARIABLES();
+    k = __glEvalComputeK(target);
+    if (k == 0) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    } else if (stride < k || order <= 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = k * order * __GLX_SIZE_FLOAT64;
+    cmdlen = 28+compsize;
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_Map1d,cmdlen);
+	__GLX_PUT_DOUBLE(4,u1);
+	__GLX_PUT_DOUBLE(12,u2);
+	__GLX_PUT_LONG(20,target);
+	__GLX_PUT_LONG(24,order);
+	/*
+	** NOTE: the doubles that follow are not aligned because of 3
+	** longs preceeding
+	*/
+	__glFillMap1d(k, order, stride, pnts, (pc+28));
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1d,cmdlen+4);
+	__GLX_PUT_DOUBLE(8,u1);
+	__GLX_PUT_DOUBLE(16,u2);
+	__GLX_PUT_LONG(24,target);
+	__GLX_PUT_LONG(28,order);
+
+	/*
+	** NOTE: the doubles that follow are not aligned because of 3
+	** longs preceeding
+	*/
+	if (stride != k) {
+	    GLubyte *buf;
+
+	    buf = (GLubyte *) Xmalloc(compsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    __glFillMap1d(k, order, stride, pnts, buf);
+	    __glXSendLargeCommand(gc, pc, 32, buf, compsize);
+	    Xfree((char*) buf);
+	} else {
+	    /* Data is already packed.  Just send it out */
+	    __glXSendLargeCommand(gc, pc, 32, pnts, compsize);
+	}
+    }
+}
+
+void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
+	     GLint order, const GLfloat *pnts)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLint k;
+
+    __GLX_LOAD_VARIABLES();
+    k = __glEvalComputeK(target);
+    if (k == 0) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    } else if (stride < k || order <= 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = k * order * __GLX_SIZE_FLOAT32;
+    cmdlen = 20+compsize;
+    if (!gc->currentDpy) return;
+
+    /*
+    ** The order that arguments are packed is different from the order
+    ** for glMap1d.
+    */
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_Map1f,cmdlen);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_FLOAT(8,u1);
+	__GLX_PUT_FLOAT(12,u2);
+	__GLX_PUT_LONG(16,order);
+	__glFillMap1f(k, order, stride, pnts, (GLubyte*) (pc+20));
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1f,cmdlen+4);
+	__GLX_PUT_LONG(8,target);
+	__GLX_PUT_FLOAT(12,u1);
+	__GLX_PUT_FLOAT(16,u2);
+	__GLX_PUT_LONG(20,order);
+
+	if (stride != k) {
+	    GLubyte *buf;
+
+	    buf = (GLubyte *) Xmalloc(compsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    __glFillMap1f(k, order, stride, pnts, buf);
+	    __glXSendLargeCommand(gc, pc, 24, buf, compsize);
+	    Xfree((char*) buf);
+	} else {
+	    /* Data is already packed.  Just send it out */
+	    __glXSendLargeCommand(gc, pc, 24, pnts, compsize);
+	}
+    }
+}
+
+void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustr, GLint uord,
+	     GLdouble v1, GLdouble v2, GLint vstr, GLint vord,
+	     const GLdouble *pnts)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLint k;
+
+    __GLX_LOAD_VARIABLES();
+    k = __glEvalComputeK(target);
+    if (k == 0) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    } else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = k * uord * vord * __GLX_SIZE_FLOAT64;
+    cmdlen = 48+compsize; 
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_Map2d,cmdlen);
+	__GLX_PUT_DOUBLE(4,u1);
+	__GLX_PUT_DOUBLE(12,u2);
+	__GLX_PUT_DOUBLE(20,v1);
+	__GLX_PUT_DOUBLE(28,v2);
+	__GLX_PUT_LONG(36,target);
+	__GLX_PUT_LONG(40,uord);
+	__GLX_PUT_LONG(44,vord);
+	/*
+	** Pack into a u-major ordering.
+	** NOTE: the doubles that follow are not aligned because of 5
+	** longs preceeding
+	*/
+	__glFillMap2d(k, uord, vord, ustr, vstr, pnts, (GLdouble*) (pc+48));
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2d,cmdlen+4);
+	__GLX_PUT_DOUBLE(8,u1);
+	__GLX_PUT_DOUBLE(16,u2);
+	__GLX_PUT_DOUBLE(24,v1);
+	__GLX_PUT_DOUBLE(32,v2);
+	__GLX_PUT_LONG(40,target);
+	__GLX_PUT_LONG(44,uord);
+	__GLX_PUT_LONG(48,vord);
+
+	/*
+	** NOTE: the doubles that follow are not aligned because of 5
+	** longs preceeding
+	*/
+	if ((vstr != k) || (ustr != k*vord)) {
+	    GLdouble *buf;
+
+	    buf = (GLdouble *) Xmalloc(compsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    /*
+	    ** Pack into a u-major ordering.
+	    */
+	    __glFillMap2d(k, uord, vord, ustr, vstr, pnts, buf);
+	    __glXSendLargeCommand(gc, pc, 52, buf, compsize);
+	    Xfree((char*) buf);
+	} else {
+	    /* Data is already packed.  Just send it out */
+	    __glXSendLargeCommand(gc, pc, 52, pnts, compsize);
+	}
+    }
+}
+
+void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustr, GLint uord,
+	     GLfloat v1, GLfloat v2, GLint vstr, GLint vord,
+	     const GLfloat *pnts)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLint k;
+
+    __GLX_LOAD_VARIABLES();
+    k = __glEvalComputeK(target);
+    if (k == 0) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    } else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = k * uord * vord * __GLX_SIZE_FLOAT32;
+    cmdlen = 32+compsize; 
+    if (!gc->currentDpy) return;
+
+    /*
+    ** The order that arguments are packed is different from the order
+    ** for glMap2d.
+    */
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_Map2f,cmdlen);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_FLOAT(8,u1);
+	__GLX_PUT_FLOAT(12,u2);
+	__GLX_PUT_LONG(16,uord);
+	__GLX_PUT_FLOAT(20,v1);
+	__GLX_PUT_FLOAT(24,v2);
+	__GLX_PUT_LONG(28,vord);
+	/*
+	** Pack into a u-major ordering.
+	*/
+	__glFillMap2f(k, uord, vord, ustr, vstr, pnts, (GLfloat*) (pc+32));
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2f,cmdlen+4);
+	__GLX_PUT_LONG(8,target);
+	__GLX_PUT_FLOAT(12,u1);
+	__GLX_PUT_FLOAT(16,u2);
+	__GLX_PUT_LONG(20,uord);
+	__GLX_PUT_FLOAT(24,v1);
+	__GLX_PUT_FLOAT(28,v2);
+	__GLX_PUT_LONG(32,vord);
+
+	if ((vstr != k) || (ustr != k*vord)) {
+	    GLfloat *buf;
+
+	    buf = (GLfloat *) Xmalloc(compsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    /*
+	    ** Pack into a u-major ordering.
+	    */
+	    __glFillMap2f(k, uord, vord, ustr, vstr, pnts, buf);
+	    __glXSendLargeCommand(gc, pc, 36, buf, compsize);
+	    Xfree((char*) buf);
+	} else {
+	    /* Data is already packed.  Just send it out */
+	    __glXSendLargeCommand(gc, pc, 36, pnts, compsize);
+	}
+    }
+}
+
+void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (mapsize < 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = mapsize * __GLX_SIZE_FLOAT32;
+    cmdlen = 12+compsize;
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_PixelMapfv,cmdlen);
+	__GLX_PUT_LONG(4,map);
+	__GLX_PUT_LONG(8,mapsize);
+	__GLX_PUT_FLOAT_ARRAY(12,values,mapsize);
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_PixelMapfv,cmdlen+4);
+	__GLX_PUT_LONG(8,map);
+	__GLX_PUT_LONG(12,mapsize);
+	__glXSendLargeCommand(gc, pc, 16, values, compsize);
+    }
+}
+
+void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (mapsize < 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = mapsize * __GLX_SIZE_CARD32;
+    cmdlen = 12+compsize;
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_PixelMapuiv,cmdlen);
+	__GLX_PUT_LONG(4,map);
+	__GLX_PUT_LONG(8,mapsize);
+	__GLX_PUT_LONG_ARRAY(12,values,mapsize);
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_PixelMapuiv,cmdlen+4);
+	__GLX_PUT_LONG(8,map);
+	__GLX_PUT_LONG(12,mapsize);
+	__glXSendLargeCommand(gc, pc, 16, values, compsize);
+    }
+}
+
+void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (mapsize < 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = mapsize * __GLX_SIZE_CARD16;
+    cmdlen = __GLX_PAD(12 + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_PixelMapusv,cmdlen);
+	__GLX_PUT_LONG(4,map);
+	__GLX_PUT_LONG(8,mapsize);
+	__GLX_PUT_SHORT_ARRAY(12,values,mapsize);
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_PixelMapusv,cmdlen+4);
+	__GLX_PUT_LONG(8,map);
+	__GLX_PUT_LONG(12,mapsize);
+	__glXSendLargeCommand(gc, pc, 16, values, compsize);
+    }
+}
+
+void glEnable(GLenum cap)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (!gc->currentDpy) return;
+
+    switch(cap) {
+	case GL_COLOR_ARRAY:
+	case GL_EDGE_FLAG_ARRAY:
+	case GL_INDEX_ARRAY:
+	case GL_NORMAL_ARRAY:
+	case GL_TEXTURE_COORD_ARRAY:
+	case GL_VERTEX_ARRAY:
+	case GL_SECONDARY_COLOR_ARRAY:
+	case GL_FOG_COORD_ARRAY:
+	    glEnableClientState(cap);
+	    return;
+	default:
+	    break;
+    }
+
+    __GLX_BEGIN(X_GLrop_Enable,8);
+    __GLX_PUT_LONG(4,cap);
+    __GLX_END(8);
+}
+
+void glDisable(GLenum cap)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (!gc->currentDpy) return;
+
+    switch(cap) {
+	case GL_COLOR_ARRAY:
+	case GL_EDGE_FLAG_ARRAY:
+	case GL_INDEX_ARRAY:
+	case GL_NORMAL_ARRAY:
+	case GL_TEXTURE_COORD_ARRAY:
+	case GL_VERTEX_ARRAY:
+	case GL_SECONDARY_COLOR_ARRAY:
+	case GL_FOG_COORD_ARRAY:
+	    glDisableClientState(cap);
+	    return;
+	default:
+	    break;
+    }
+
+    __GLX_BEGIN(X_GLrop_Disable,8);
+    __GLX_PUT_LONG(4,cap);
+    __GLX_END(8);
+}
+
+void glSampleCoverageARB( GLfloat value, GLboolean invert )
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (!gc->currentDpy) return;
+
+    __GLX_BEGIN(X_GLrop_SampleCoverageARB,12);
+    __GLX_PUT_FLOAT(4,value);
+    __GLX_PUT_CHAR(8,invert);
+    __GLX_END(12);
+}
+
+void glSampleMaskSGIS( GLfloat value, GLboolean invert )
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (!gc->currentDpy) return;
+
+    __GLX_BEGIN(X_GLvop_SampleMaskSGIS,12);
+    __GLX_PUT_FLOAT(4,value);
+    __GLX_PUT_CHAR(8,invert);
+    __GLX_END(12);
+}
+
+void glSamplePatternSGIS( GLenum pass )
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (!gc->currentDpy) return;
+
+    __GLX_BEGIN(X_GLvop_SamplePatternSGIS,8);
+    __GLX_PUT_LONG(4,pass);
+    __GLX_END(8);
+}

src/glx/x11/renderpix.c

@@ -0,0 +1,906 @@
+/* $XFree86: xc/lib/GL/glx/renderpix.c,v 1.5 2003/09/28 20:15:04 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+
+/*
+** This file contains routines that deal with unpacking data from client
+** memory using the pixel store unpack modes and then shipping it to
+** the server.  For all of these routines (except glPolygonStipple) there
+** are two forms of the transport - small and large.  Small commands are
+** the commands that fit into the "rendering" transport buffer.  Large
+** commands are sent to the server in chunks by __glXSendLargeCommand.
+**
+** All of the commands send over a pixel header (see glxproto.h) which
+** describes the pixel store modes that the server must use to properly
+** handle the data.  Any pixel store modes not done by the __glFillImage
+** routine are passed on to the server.
+*/
+
+/*
+** Send a large image to the server.  If necessary, a buffer is allocated
+** to hold the unpacked data that is copied from the clients memory.
+*/
+static void SendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim,
+			   GLint width, GLint height, GLint depth,
+			   GLenum format, GLenum type, const GLvoid *src,
+			   GLubyte *pc, GLubyte *modes)
+{
+    if (!gc->fastImageUnpack) {
+	/* Allocate a temporary holding buffer */
+	GLubyte *buf = (GLubyte *) Xmalloc(compsize);
+	if (!buf) {
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	    return;
+	}
+
+	/* Apply pixel store unpack modes to copy data into buf */
+	(*gc->fillImage)(gc, dim, width, height, depth, format, type, src, buf,
+			 modes);
+
+	/* Send large command */
+	__glXSendLargeCommand(gc, gc->pc, pc - gc->pc, buf, compsize);
+
+	/* Free buffer */
+	Xfree((char*) buf);
+    } else {
+	/* Just send the data straight as is */
+	__glXSendLargeCommand(gc, gc->pc, pc - gc->pc, pc, compsize);
+    }
+}
+
+/*
+** Send a large null image to the server.  To be backwards compatible,
+** data must be sent to the server even when the application has passed
+** a null pointer into glTexImage1D, glTexImage2D or glTexImage3D.
+*/
+static void SendLargeNULLImage(__GLXcontext *gc, GLint compsize,
+			       GLint width, GLint height, GLint depth,
+			       GLenum format, GLenum type, const GLvoid *src,
+			       GLubyte *pc, GLubyte *modes)
+{
+    GLubyte *buf = (GLubyte *) Xmalloc(compsize);
+
+    /* Allocate a temporary holding buffer */
+    if (!buf) {
+	__glXSetError(gc, GL_OUT_OF_MEMORY);
+	return;
+    }
+
+    /* Send large command */
+    __glXSendLargeCommand(gc, gc->pc, pc - gc->pc, buf, compsize);
+
+    /* Free buffer */
+    Xfree((char*) buf);
+}
+
+/************************************************************************/
+
+void glPolygonStipple(const GLubyte *mask)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP);
+    cmdlen = __GLX_PAD(__GLX_POLYGONSTIPPLE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    __GLX_BEGIN(X_GLrop_PolygonStipple,cmdlen);
+    pc += __GLX_RENDER_HDR_SIZE;
+    pixelHeaderPC = pc;
+    pc += __GLX_PIXEL_HDR_SIZE;
+    (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
+		     mask, pc, pixelHeaderPC);
+    __GLX_END(__GLX_PAD(compsize));
+}
+
+void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig,
+	      GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP);
+    cmdlen = __GLX_PAD(__GLX_BITMAP_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_Bitmap,cmdlen);
+	__GLX_PUT_LONG(0,width);
+	__GLX_PUT_LONG(4,height);
+	__GLX_PUT_FLOAT(8,xorig);
+	__GLX_PUT_FLOAT(12,yorig);
+	__GLX_PUT_FLOAT(16,xmove);
+	__GLX_PUT_FLOAT(20,ymove);
+	pc += __GLX_BITMAP_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX,
+			     GL_BITMAP, bitmap, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_Bitmap,cmdlen+4);
+	__GLX_PUT_LONG(0,width);
+	__GLX_PUT_LONG(4,height);
+	__GLX_PUT_FLOAT(8,xorig);
+	__GLX_PUT_FLOAT(12,yorig);
+	__GLX_PUT_FLOAT(16,xmove);
+	__GLX_PUT_FLOAT(20,ymove);
+	pc += __GLX_BITMAP_HDR_SIZE;
+	SendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX,
+		       GL_BITMAP, bitmap, pc, pixelHeaderPC);
+    }
+}
+
+void glTexImage1D(GLenum target, GLint level, GLint components,
+		  GLsizei width, GLint border, GLenum format, GLenum type,
+		  const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (target == GL_PROXY_TEXTURE_1D) {
+	compsize = 0;
+    } else {
+	compsize = __glImageSize(width, 1, 1, format, type);
+    }
+    cmdlen = __GLX_PAD(__GLX_TEXIMAGE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_TexImage1D,cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,components);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(20,border);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	pc += __GLX_TEXIMAGE_HDR_SIZE;
+	if (compsize > 0 && image != NULL) {
+	    (*gc->fillImage)(gc, 1, width, 1, 1, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_TexImage1D,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,components);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,1);
+	__GLX_PUT_LONG(20,border);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	pc += __GLX_TEXIMAGE_HDR_SIZE;
+	if (image != NULL) {
+	    SendLargeImage(gc, compsize, 1, width, 1, 1, format,
+			   type, image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    {
+		GLubyte *pc = pixelHeaderPC;
+		__GLX_PUT_CHAR(0,GL_FALSE);
+		__GLX_PUT_CHAR(1,GL_FALSE);
+		__GLX_PUT_CHAR(2,0);
+		__GLX_PUT_CHAR(3,0);
+		__GLX_PUT_LONG(4,0);
+		__GLX_PUT_LONG(8,0);
+		__GLX_PUT_LONG(12,0);
+		__GLX_PUT_LONG(16,1);
+	    }
+	    SendLargeNULLImage(gc, compsize, width, 1, 1, format,
+			       type, image, pc, pixelHeaderPC);
+	}
+    }
+}
+
+void glTexImage2D(GLenum target, GLint level, GLint components,
+		  GLsizei width, GLsizei height, GLint border, GLenum format,
+		  GLenum type, const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (target == GL_PROXY_TEXTURE_2D ||
+        target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
+	compsize = 0;
+    } else {
+	compsize = __glImageSize(width, height, 1, format, type);
+    }
+    cmdlen = __GLX_PAD(__GLX_TEXIMAGE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_TexImage2D,cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,components);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,border);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	pc += __GLX_TEXIMAGE_HDR_SIZE;
+	if (compsize > 0 && image != NULL) {
+	    (*gc->fillImage)(gc, 2, width, height, 1, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_TexImage2D,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,components);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,border);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	pc += __GLX_TEXIMAGE_HDR_SIZE;
+	if (image != NULL) {
+	    SendLargeImage(gc, compsize, 2, width, height, 1, format,
+			   type, image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    {
+		GLubyte *pc = pixelHeaderPC;
+		__GLX_PUT_CHAR(0,GL_FALSE);
+		__GLX_PUT_CHAR(1,GL_FALSE);
+		__GLX_PUT_CHAR(2,0);
+		__GLX_PUT_CHAR(3,0);
+		__GLX_PUT_LONG(4,0);
+		__GLX_PUT_LONG(8,0);
+		__GLX_PUT_LONG(12,0);
+		__GLX_PUT_LONG(16,1);
+	    }
+	    SendLargeNULLImage(gc, compsize, width, height, 1, format,
+			       type, image, pc, pixelHeaderPC);
+	}
+    }
+}
+
+void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type,
+		  const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(width, height, 1, format, type);
+    cmdlen = __GLX_PAD(__GLX_DRAWPIXELS_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_DrawPixels,cmdlen);
+	__GLX_PUT_LONG(0,width);
+	__GLX_PUT_LONG(4,height);
+	__GLX_PUT_LONG(8,format);
+	__GLX_PUT_LONG(12,type);
+	pc += __GLX_DRAWPIXELS_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, 2, width, height, 1, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_DrawPixels,cmdlen+4);
+	__GLX_PUT_LONG(0,width);
+	__GLX_PUT_LONG(4,height);
+	__GLX_PUT_LONG(8,format);
+	__GLX_PUT_LONG(12,type);
+	pc += __GLX_DRAWPIXELS_HDR_SIZE;
+	SendLargeImage(gc, compsize, 2, width, height, 1, format,
+		       type, image, pc, pixelHeaderPC);
+    }
+}
+
+static void __glx_TexSubImage1D2D(GLshort opcode, GLenum target, GLint level,
+			GLint xoffset, GLint yoffset, GLsizei width, 	
+			GLsizei height, GLenum format, GLenum type, 	
+			const GLvoid *image, GLint dim)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (image == NULL) {
+	compsize = 0;
+    } else {
+        compsize = __glImageSize(width, height, 1, format, type);
+    }
+
+    cmdlen = __GLX_PAD(__GLX_TEXSUBIMAGE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode, cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,xoffset);
+	__GLX_PUT_LONG(12,yoffset);
+	__GLX_PUT_LONG(16,width);
+	__GLX_PUT_LONG(20,height);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(32,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(32,GL_FALSE);
+	}
+	pc += __GLX_TEXSUBIMAGE_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, 
+			     pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,xoffset);
+	__GLX_PUT_LONG(12,yoffset);
+	__GLX_PUT_LONG(16,width);
+	__GLX_PUT_LONG(20,height);
+	__GLX_PUT_LONG(24,format);
+	__GLX_PUT_LONG(28,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(32,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(32,GL_FALSE);
+	}
+	pc += __GLX_TEXSUBIMAGE_HDR_SIZE;
+	SendLargeImage(gc, compsize, dim, width, height, 1,
+		       format, type, image, pc, pixelHeaderPC);
+    }
+}
+	
+void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, 
+			GLsizei width, GLenum format, GLenum type,
+		      	const GLvoid *image)
+{
+    __glx_TexSubImage1D2D(X_GLrop_TexSubImage1D, target, level, xoffset, 
+			 0, width, 1, format, type, image, 1);
+}
+
+void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, 
+			GLint yoffset, GLsizei width, GLsizei height, 
+			GLenum format, GLenum type, const GLvoid *image)
+{
+    __glx_TexSubImage1D2D(X_GLrop_TexSubImage2D, target, level, xoffset, 
+			 yoffset, width, height, format, type, image, 2);
+}
+
+void glColorTable(GLenum target, GLenum internalformat, GLsizei width,
+		  GLenum format, GLenum type, const GLvoid *table)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    switch (target) {
+	case GL_PROXY_TEXTURE_1D:
+	case GL_PROXY_TEXTURE_2D:
+	case GL_PROXY_TEXTURE_3D:
+	case GL_PROXY_COLOR_TABLE:
+	case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
+	case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
+	case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
+	    compsize = 0;
+	    break;
+	default:
+	    compsize = __glImageSize(width, 1, 1, format, type);
+	    break;
+    }
+    cmdlen = __GLX_PAD(__GLX_COLOR_TABLE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) {
+	 return;
+    }
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+        /* Use GLXRender protocol to send small command */
+        __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_ColorTable, (short)cmdlen);
+        __GLX_PUT_LONG(0, (long)target);
+        __GLX_PUT_LONG(4, (long)internalformat);
+        __GLX_PUT_LONG(8, width);
+        __GLX_PUT_LONG(12, (long)format);
+        __GLX_PUT_LONG(16, (long)type);
+        pc += __GLX_COLOR_TABLE_HDR_SIZE;
+        if (compsize > 0 && table != NULL) {
+            (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, pc,
+                             pixelHeaderPC);
+        } else {
+            /* Setup default store modes */
+            GLubyte *pc = pixelHeaderPC;
+            __GLX_PUT_CHAR(0, GL_FALSE);
+            __GLX_PUT_CHAR(1, GL_FALSE);
+            __GLX_PUT_CHAR(2, 0);
+            __GLX_PUT_CHAR(3, 0);
+            __GLX_PUT_LONG(4, 0);
+            __GLX_PUT_LONG(8, 0);
+            __GLX_PUT_LONG(12, 0);
+            __GLX_PUT_LONG(16, 1);
+        }
+        __GLX_END(__GLX_PAD(compsize));
+    } else {
+        /* Use GLXRenderLarge protocol to send command */
+        __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_ColorTable, cmdlen+4);
+        __GLX_PUT_LONG(0, (long)target);
+        __GLX_PUT_LONG(4, (long)internalformat);
+        __GLX_PUT_LONG(8, width);
+        __GLX_PUT_LONG(12, (long)format);
+        __GLX_PUT_LONG(16, (long)type);
+        pc += __GLX_COLOR_TABLE_HDR_SIZE;
+        SendLargeImage(gc, compsize, 1, width, 1, 1, format,
+                       type, table, pc, pixelHeaderPC);
+    }
+}
+
+void glColorSubTable(GLenum target, GLsizei start, GLsizei count,
+		     GLenum format, GLenum type, const GLvoid *table)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(count, 1, 1, format, type);
+    cmdlen = __GLX_PAD(__GLX_COLOR_SUBTABLE_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) {
+	 return;
+    }
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+        /* Use GLXRender protocol to send small command */
+        __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_ColorSubTable, (short)cmdlen);
+        __GLX_PUT_LONG(0, (long)target);
+        __GLX_PUT_LONG(4, start);
+        __GLX_PUT_LONG(8, count);
+        __GLX_PUT_LONG(12, (long)format);
+        __GLX_PUT_LONG(16, (long)type);
+        pc += __GLX_COLOR_SUBTABLE_HDR_SIZE;
+        if (compsize > 0 && table != NULL) {
+            (*gc->fillImage)(gc, 1, start+count, 1, 1, format, type, table, pc,
+                             pixelHeaderPC);
+        } else {
+            /* Setup default store modes */
+            GLubyte *pc = pixelHeaderPC;
+            __GLX_PUT_CHAR(0, GL_FALSE);
+            __GLX_PUT_CHAR(1, GL_FALSE);
+            __GLX_PUT_CHAR(2, 0);
+            __GLX_PUT_CHAR(3, 0);
+            __GLX_PUT_LONG(4, 0);
+            __GLX_PUT_LONG(8, 0);
+            __GLX_PUT_LONG(12, 0);
+            __GLX_PUT_LONG(16, 1);
+        }
+        __GLX_END(__GLX_PAD(compsize));
+    } else {
+        /* Use GLXRenderLarge protocol to send command */
+        __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_ColorSubTable, cmdlen+4);
+        __GLX_PUT_LONG(0, (long)target);
+        __GLX_PUT_LONG(4, start);
+        __GLX_PUT_LONG(8, count);
+        __GLX_PUT_LONG(12, (long)format);
+        __GLX_PUT_LONG(16, (long)type);
+        pc += __GLX_COLOR_SUBTABLE_HDR_SIZE;
+        SendLargeImage(gc, compsize, 1, start+count, 1, 1, format,
+                       type, table, pc, pixelHeaderPC);
+    }
+}
+
+static void __glx_ConvolutionFilter1D2D(GLshort opcode, GLint dim,
+			GLenum target,
+			GLenum internalformat,
+			GLsizei width, GLsizei height,
+			GLenum format, GLenum type, const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(width, height, 1, format, type);
+    cmdlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode, cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += __GLX_CONV_FILT_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, dim, width, height, 1, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += __GLX_CONV_FILT_HDR_SIZE;
+	SendLargeImage(gc, compsize, dim, width, height, 1, format,
+		       type, image, pc, pixelHeaderPC);
+    }
+}
+
+void glConvolutionFilter1D(GLenum target, GLenum internalformat,
+				GLsizei width, GLenum format,
+				GLenum type, const GLvoid *image)
+{
+     __glx_ConvolutionFilter1D2D(X_GLrop_ConvolutionFilter1D, 1, target, 
+				 internalformat, width, 1, format, type,
+				 image);
+}
+
+void glConvolutionFilter2D(GLenum target, GLenum internalformat,
+				GLsizei width, GLsizei height, GLenum format,
+				GLenum type, const GLvoid *image)
+{
+     __glx_ConvolutionFilter1D2D(X_GLrop_ConvolutionFilter2D, 2, target,
+				internalformat, width, height, format, type,
+				image);
+}
+
+void glSeparableFilter2D(GLenum target, GLenum internalformat,
+				GLsizei width, GLsizei height, GLenum format,
+				GLenum type, const GLvoid *row,
+				const GLvoid *column)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLuint compsize2, hdrlen, totalhdrlen, image1len, image2len;
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(width, 1, 1, format, type);
+    compsize2 = __glImageSize(height, 1, 1, format, type);
+    totalhdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);
+    hdrlen = __GLX_PAD(__GLX_CONV_FILT_HDR_SIZE);
+    image1len = __GLX_PAD(compsize);
+    image2len = __GLX_PAD(compsize2);
+    cmdlen = totalhdrlen + image1len + image2len;
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_SeparableFilter2D, cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += hdrlen;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, 1, width, 1, 1, format, type,
+			     row, pc, pixelHeaderPC);
+	    pc += image1len;
+	}
+	if (compsize2 > 0) {
+            (*gc->fillImage)(gc, 1, height, 1, 1, format, type,
+			     column, pc, NULL);
+	    pc += image2len;
+	}
+	if ((compsize == 0) && (compsize2 == 0)) {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,1);
+	}
+	__GLX_END(0);
+    } else {
+	GLint bufsize;
+
+	bufsize = image1len + image2len;
+
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_SeparableFilter2D,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += hdrlen;
+
+	if (!gc->fastImageUnpack) {
+	    /* Allocate a temporary holding buffer */
+	    GLubyte *buf = (GLubyte *) Xmalloc(bufsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    (*gc->fillImage)(gc, 1, width, 1, 1, format, type, row, buf, pixelHeaderPC);
+
+	    (*gc->fillImage)(gc, 1, height, 1, 1, format, type, column,
+				 buf + image1len, pixelHeaderPC);
+
+	    /* Send large command */
+	    __glXSendLargeCommand(gc, gc->pc, (GLint)(pc - gc->pc), buf, bufsize);
+	    /* Free buffer */
+	    Xfree((char*) buf);
+	} else {
+	    /* Just send the data straight as is */
+	    __glXSendLargeCommand(gc, gc->pc, (GLint)(pc - gc->pc), pc, bufsize);
+	}
+    }
+}
+
+void glTexImage3D(GLenum target, GLint level, GLint internalformat,
+		  GLsizei width, GLsizei height, GLsizei depth, GLint border,
+		  GLenum format, GLenum type, const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if ((target == GL_PROXY_TEXTURE_3D) || (image == NULL)) {
+	compsize = 0;
+    } else {
+	compsize = __glImageSize(width, height, depth, format, type);
+    }
+    cmdlen = __GLX_PAD(__GLX_TEXIMAGE_3D_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(X_GLrop_TexImage3D,cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,depth);
+	__GLX_PUT_LONG(24,0);    /* size4d */
+	__GLX_PUT_LONG(28,border);
+	__GLX_PUT_LONG(32,format);
+	__GLX_PUT_LONG(36,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(40,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(40,GL_FALSE);
+	}
+	pc += __GLX_TEXIMAGE_3D_HDR_SIZE;
+	if (compsize > 0 && image != NULL) {
+	    (*gc->fillImage)(gc, 3, width, height, depth, format, type,
+			     image, pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,0);
+	    __GLX_PUT_LONG(20,0);
+	    __GLX_PUT_LONG(24,0);
+	    __GLX_PUT_LONG(28,0);
+	    __GLX_PUT_LONG(32,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(X_GLrop_TexImage3D,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,depth);
+	__GLX_PUT_LONG(24,0);    /* size4d */
+	__GLX_PUT_LONG(28,border);
+	__GLX_PUT_LONG(32,format);
+	__GLX_PUT_LONG(36,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(40,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(40,GL_FALSE);
+	}
+	pc += __GLX_TEXIMAGE_3D_HDR_SIZE;
+	SendLargeImage(gc, compsize, 3, width, height, depth, format,
+		       type, image, pc, pixelHeaderPC);
+    }
+}
+
+void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
+		     GLint zoffset, GLsizei width, GLsizei height,
+		     GLsizei depth, GLenum format, GLenum type,
+		     const GLvoid *image)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (image == NULL) {
+	compsize = 0;
+    } else {
+        compsize = __glImageSize(width, height, depth, format, type);
+    }
+    cmdlen = __GLX_PAD(__GLX_TEXSUBIMAGE_3D_CMD_HDR_SIZE + compsize);
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(X_GLrop_TexSubImage3D,cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,xoffset);
+	__GLX_PUT_LONG(12,yoffset);
+	__GLX_PUT_LONG(16,zoffset);
+	__GLX_PUT_LONG(20,0); /* woffset */
+	__GLX_PUT_LONG(24,width);
+	__GLX_PUT_LONG(28,height);
+	__GLX_PUT_LONG(32,depth);
+	__GLX_PUT_LONG(36,0);      /* size4d */
+	__GLX_PUT_LONG(40,format);
+	__GLX_PUT_LONG(44,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(48,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(48,GL_FALSE);
+	}
+	pc += __GLX_TEXSUBIMAGE_3D_HDR_SIZE;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, 3, width, height, depth, format, type, image,
+			     pc, pixelHeaderPC);
+	} else {
+	    /* Setup default store modes */
+	    GLubyte *pc = pixelHeaderPC;
+	    __GLX_PUT_CHAR(0,GL_FALSE);
+	    __GLX_PUT_CHAR(1,GL_FALSE);
+	    __GLX_PUT_CHAR(2,0);
+	    __GLX_PUT_CHAR(3,0);
+	    __GLX_PUT_LONG(4,0);
+	    __GLX_PUT_LONG(8,0);
+	    __GLX_PUT_LONG(12,0);
+	    __GLX_PUT_LONG(16,0);
+	    __GLX_PUT_LONG(20,0);
+	    __GLX_PUT_LONG(24,0);
+	    __GLX_PUT_LONG(28,0);
+	    __GLX_PUT_LONG(32,1);
+	}
+	__GLX_END(__GLX_PAD(compsize));
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(X_GLrop_TexSubImage3D,
+						 cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,level);
+	__GLX_PUT_LONG(8,xoffset);
+	__GLX_PUT_LONG(12,yoffset);
+	__GLX_PUT_LONG(16,zoffset);
+	__GLX_PUT_LONG(20,0);    /* woffset */
+	__GLX_PUT_LONG(24,width);
+	__GLX_PUT_LONG(28,height);
+	__GLX_PUT_LONG(32,depth);
+	__GLX_PUT_LONG(36,0);    /* size4d */
+	__GLX_PUT_LONG(40,format);
+	__GLX_PUT_LONG(44,type);
+	if (image == NULL) {
+	    __GLX_PUT_LONG(48,GL_TRUE);
+	} else {
+	    __GLX_PUT_LONG(48,GL_FALSE);
+	}
+	pc += __GLX_TEXSUBIMAGE_3D_HDR_SIZE;
+	SendLargeImage(gc, compsize, 3, width, height, depth, format, type,
+		       image, pc, pixelHeaderPC);
+    }
+}

src/glx/x11/singlepix.c

@@ -0,0 +1,415 @@
+/* $XFree86: xc/lib/GL/glx/singlepix.c,v 1.3 2001/03/21 16:04:39 dawes Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packsingle.h"
+
+void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
+		  GLenum format, GLenum type, GLvoid *pixels)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    const __GLXattribute * state;
+    xGLXReadPixelsReply reply;
+    GLubyte *buf;
+
+    if (!dpy) return;
+    __GLX_SINGLE_LOAD_VARIABLES();
+    state = gc->client_state_private;
+
+    /* Send request */
+    __GLX_SINGLE_BEGIN(X_GLsop_ReadPixels,__GLX_PAD(26));
+    __GLX_SINGLE_PUT_LONG(0,x);
+    __GLX_SINGLE_PUT_LONG(4,y);
+    __GLX_SINGLE_PUT_LONG(8,width);
+    __GLX_SINGLE_PUT_LONG(12,height);
+    __GLX_SINGLE_PUT_LONG(16,format);
+    __GLX_SINGLE_PUT_LONG(20,type);
+    __GLX_SINGLE_PUT_CHAR(24,state->storePack.swapEndian);
+    __GLX_SINGLE_PUT_CHAR(25,GL_FALSE);
+    __GLX_SINGLE_READ_XREPLY();
+    compsize = reply.length << 2;
+
+    if (compsize != 0) {
+	/* Allocate a holding buffer to transform the data from */
+	buf = (GLubyte*) Xmalloc(compsize);
+	if (!buf) {
+	    /* Throw data away */
+	    _XEatData(dpy, compsize);
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	} else {
+	    /*
+	    ** Fetch data into holding buffer.  Apply pixel store pack modes
+	    ** to put data back into client memory
+	    */
+	    __GLX_SINGLE_GET_CHAR_ARRAY(buf,compsize);
+	    __glEmptyImage(gc, 2, width, height, 1, format, type, buf, pixels);
+	    Xfree((char*) buf);
+	}
+    } else {
+	/*
+	** GL error occurred; don't modify user's buffer.
+	*/
+    }
+    __GLX_SINGLE_END();
+}
+
+void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type,
+		   GLvoid *texels)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    const __GLXattribute * state;
+    xGLXGetTexImageReply reply;
+    GLubyte *buf;
+
+    if (!dpy) return;
+    __GLX_SINGLE_LOAD_VARIABLES();
+    state = gc->client_state_private;
+
+    /* Send request */
+    __GLX_SINGLE_BEGIN(X_GLsop_GetTexImage,__GLX_PAD(17));
+    __GLX_SINGLE_PUT_LONG(0,target);
+    __GLX_SINGLE_PUT_LONG(4,level);
+    __GLX_SINGLE_PUT_LONG(8,format);
+    __GLX_SINGLE_PUT_LONG(12,type);
+    __GLX_SINGLE_PUT_CHAR(16,state->storePack.swapEndian);
+    __GLX_SINGLE_READ_XREPLY();
+    compsize = reply.length << 2;
+
+    if (compsize != 0) {
+	/* Allocate a holding buffer to transform the data from */
+	buf = (GLubyte*) Xmalloc(compsize);
+	if (!buf) {
+	    /* Throw data away */
+	    _XEatData(dpy, compsize);
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	} else {
+	    GLint width, height, depth;
+
+	    /*
+	    ** Fetch data into holding buffer.  Apply pixel store pack modes
+	    ** to put data back into client memory
+	    */
+	    width = reply.width;
+	    height = reply.height;
+	    depth = reply.depth;
+	    __GLX_SINGLE_GET_CHAR_ARRAY(buf,compsize);
+	    __glEmptyImage(gc, 2, width, height, depth, format, type, buf,
+			   texels);
+	    Xfree((char*) buf);
+	}
+    } else {
+	/*
+	** GL error occured, don't modify user's buffer.
+	*/
+    }
+    __GLX_SINGLE_END();
+}
+
+void glGetPolygonStipple(GLubyte *mask)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    xGLXSingleReply reply;
+    GLubyte buf[128];
+
+    if (!dpy) return;
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_GetPolygonStipple,__GLX_PAD(1));
+    __GLX_SINGLE_PUT_CHAR(0,GL_FALSE);
+    __GLX_SINGLE_READ_XREPLY();
+    if (reply.length == 32) {
+	__GLX_SINGLE_GET_CHAR_ARRAY(buf,128);
+	__glEmptyImage(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, buf, mask);
+    }
+    __GLX_SINGLE_END();
+}
+
+void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    const __GLXattribute * state;
+    xGLXGetColorTableReply reply;
+    GLubyte *buf;
+
+    if (!dpy) return;
+    __GLX_SINGLE_LOAD_VARIABLES();
+    state = gc->client_state_private;
+
+    /* Send request */
+    __GLX_SINGLE_BEGIN(X_GLsop_GetColorTable,__GLX_PAD(13));
+    __GLX_SINGLE_PUT_LONG(0,(long)target);
+    __GLX_SINGLE_PUT_LONG(4,(long)format);
+    __GLX_SINGLE_PUT_LONG(8,(long)type);
+    __GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
+    __GLX_SINGLE_READ_XREPLY();
+    compsize = (long)reply.length << 2;
+
+    if (compsize != 0) {
+        /* Allocate a holding buffer to transform the data from */
+        buf = (GLubyte*)Xmalloc(compsize);
+        if (!buf) {
+            /* Throw data away */
+            _XEatData(dpy, compsize);
+            __glXSetError(gc, GL_OUT_OF_MEMORY);
+        } else {
+            GLint width;
+
+            /*
+            ** Fetch data into holding buffer.  Apply pixel store pack modes
+            ** to put data back into client memory
+            */
+            width = (int)reply.width;
+            __GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
+            __glEmptyImage(gc, 1, width, 1, 1, format, type, buf, table);
+            Xfree((char*) buf);
+        }
+    } else {
+        /*
+        ** GL error occured, don't modify user's buffer.
+        */
+    }
+    __GLX_SINGLE_END();
+}
+
+void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type,
+			    GLvoid *image)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    const __GLXattribute * state;
+    xGLXGetConvolutionFilterReply reply;
+    GLubyte *buf;
+
+    if (!dpy) return;
+    __GLX_SINGLE_LOAD_VARIABLES();
+    state = gc->client_state_private;
+
+    /* Send request */
+    __GLX_SINGLE_BEGIN(X_GLsop_GetConvolutionFilter, __GLX_PAD(13));
+    __GLX_SINGLE_PUT_LONG(0,target);
+    __GLX_SINGLE_PUT_LONG(4,format);
+    __GLX_SINGLE_PUT_LONG(8,type);
+    __GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
+    __GLX_SINGLE_READ_XREPLY();
+    compsize = reply.length << 2;
+
+    if (compsize != 0) {
+	/* Allocate a holding buffer to transform the data from */
+	buf = (GLubyte*) Xmalloc(compsize);
+	if (!buf) {
+	    /* Throw data away */
+	    _XEatData(dpy, compsize);
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	} else {
+	    GLint width, height;
+
+	    /*
+	    ** Fetch data into holding buffer.  Apply pixel store pack modes
+	    ** to put data back into client memory
+	    */
+	    width = reply.width;
+	    height = reply.height;
+	    __GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),compsize);
+	    __glEmptyImage(gc, 2, width, height, 1, format, type, buf, image);
+	    Xfree((char*) buf);
+	}
+    } else {
+	/*
+	** GL error occured, don't modify user's buffer.
+	*/
+    }
+    __GLX_SINGLE_END();
+}
+
+void glGetSeparableFilter(GLenum target, GLenum format, GLenum type,
+			  GLvoid *row, GLvoid *column, GLvoid *span)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    const __GLXattribute * state;
+    xGLXGetSeparableFilterReply reply;
+    GLubyte *rowBuf, *colBuf;
+
+    if (!dpy) return;
+    __GLX_SINGLE_LOAD_VARIABLES();
+    state = gc->client_state_private;
+
+    /* Send request */
+    __GLX_SINGLE_BEGIN(X_GLsop_GetSeparableFilter, __GLX_PAD(13));
+    __GLX_SINGLE_PUT_LONG(0,target);
+    __GLX_SINGLE_PUT_LONG(4,format);
+    __GLX_SINGLE_PUT_LONG(8,type);
+    __GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
+    __GLX_SINGLE_READ_XREPLY();
+    compsize = reply.length << 2;
+
+    if (compsize != 0) {
+	GLint width, height;
+	GLint widthsize, heightsize;
+
+	width = reply.width;
+	height = reply.height;
+
+	widthsize = __glImageSize(width,1,1,format, type);
+	heightsize = __glImageSize(height,1,1,format, type);
+
+	/* Allocate a holding buffer to transform the data from */
+	rowBuf = (GLubyte*) Xmalloc(widthsize);
+	if (!rowBuf) {
+	    /* Throw data away */
+	    _XEatData(dpy, compsize);
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    return;
+	} else {
+	    __GLX_SINGLE_GET_CHAR_ARRAY(((char*)rowBuf),widthsize);
+	    __glEmptyImage(gc, 1, width, 1, 1, format, type, rowBuf, row);
+	    Xfree((char*) rowBuf);
+	}
+	colBuf = (GLubyte*) Xmalloc(heightsize);
+	if (!colBuf) {
+	    /* Throw data away */
+	    _XEatData(dpy, compsize - __GLX_PAD(widthsize));
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    return;
+	} else {
+	    __GLX_SINGLE_GET_CHAR_ARRAY(((char*)colBuf),heightsize);
+	    __glEmptyImage(gc, 1, height, 1, 1, format, type, colBuf, column);
+	    Xfree((char*) colBuf);
+	}
+    } else {
+	/*
+	** don't modify user's buffer.
+	*/
+    }
+    __GLX_SINGLE_END();
+    
+}
+
+void glGetHistogram(GLenum target, GLboolean reset, GLenum format,
+		    GLenum type, GLvoid *values)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    const __GLXattribute * state;
+    xGLXGetHistogramReply reply;
+    GLubyte *buf;
+
+    if (!dpy) return;
+    __GLX_SINGLE_LOAD_VARIABLES();
+    state = gc->client_state_private;
+
+    /* Send request */
+    __GLX_SINGLE_BEGIN(X_GLsop_GetHistogram,__GLX_PAD(14));
+    __GLX_SINGLE_PUT_LONG(0,(long)target);
+    __GLX_SINGLE_PUT_LONG(4,(long)format);
+    __GLX_SINGLE_PUT_LONG(8,(long)type);
+    __GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
+    __GLX_SINGLE_PUT_CHAR(13,reset);
+    __GLX_SINGLE_READ_XREPLY();
+    compsize = (long)reply.length << 2;
+
+    if (compsize != 0) {
+        /* Allocate a holding buffer to transform the data from */
+        buf = (GLubyte*)Xmalloc(compsize);
+        if (!buf) {
+            /* Throw data away */
+            _XEatData(dpy, compsize);
+            __glXSetError(gc, GL_OUT_OF_MEMORY);
+        } else {
+            GLint width;
+
+            /*
+            ** Fetch data into holding buffer.  Apply pixel store pack modes
+            ** to put data back into client memory
+            */
+            width = (int)reply.width;
+            __GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
+            __glEmptyImage(gc, 1, width, 1, 1, format, type, buf, values);
+            Xfree((char*) buf);
+        }
+    } else {
+        /*
+        ** GL error occured, don't modify user's buffer.
+        */
+    }
+    __GLX_SINGLE_END();
+}
+
+void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type,
+		 GLvoid *values)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    const __GLXattribute * state;
+    xGLXGetMinmaxReply reply;
+    GLubyte *buf;
+
+    if (!dpy) return;
+    __GLX_SINGLE_LOAD_VARIABLES();
+    state = gc->client_state_private;
+
+    /* Send request */
+    __GLX_SINGLE_BEGIN(X_GLsop_GetMinmax,__GLX_PAD(14));
+    __GLX_SINGLE_PUT_LONG(0,(long)target);
+    __GLX_SINGLE_PUT_LONG(4,(long)format);
+    __GLX_SINGLE_PUT_LONG(8,(long)type);
+    __GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
+    __GLX_SINGLE_PUT_CHAR(13,reset);
+    __GLX_SINGLE_READ_XREPLY();
+    compsize = (long)reply.length << 2;
+
+    if (compsize != 0) {
+        /* Allocate a holding buffer to transform the data from */
+        buf = (GLubyte*)Xmalloc(compsize);
+        if (!buf) {
+            /* Throw data away */
+            _XEatData(dpy, compsize);
+            __glXSetError(gc, GL_OUT_OF_MEMORY);
+        } else {
+            /*
+            ** Fetch data into holding buffer.  Apply pixel store pack modes
+            ** to put data back into client memory
+            */
+            __GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
+            __glEmptyImage(gc, 1, 2, 1, 1, format, type, buf, values);
+            Xfree((char*) buf);
+        }
+    } else {
+        /*
+        ** GL error occured, don't modify user's buffer.
+        */
+    }
+    __GLX_SINGLE_END();
+}

src/glx/x11/size.h

@@ -0,0 +1,72 @@
+/* $XFree86: xc/lib/GL/glx/size.h,v 1.4 2003/09/28 20:15:04 alanh Exp $ */
+#ifndef _size_h_
+#define _size_h_
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+/*
+** These are _size functions that are needed to pack the arguments
+** into the protocol
+*/
+extern GLint __glBitmap_size(GLsizei w, GLsizei h);
+extern GLint __glCallLists_size(GLsizei n, GLenum type);
+extern GLint __glColorTableParameterfv_size(GLenum pname);
+extern GLint __glColorTableParameteriv_size(GLenum pname);
+extern GLint __glConvolutionParameterfv_size(GLenum pname);
+extern GLint __glConvolutionParameteriv_size(GLenum pname);
+extern GLint __glDrawPixels_size(GLenum format, GLenum type, GLsizei w,GLsizei h);
+extern GLint __glFogfv_size(GLenum pname);
+extern GLint __glFogiv_size(GLenum pname);
+extern GLint __glLightModelfv_size(GLenum pname);
+extern GLint __glLightModeliv_size(GLenum pname);
+extern GLint __glLightfv_size(GLenum pname);
+extern GLint __glLightiv_size(GLenum pname);
+extern GLint __glMaterialfv_size(GLenum pname);
+extern GLint __glMaterialiv_size(GLenum pname);
+extern GLint __glTexEnvfv_size(GLenum e);
+extern GLint __glTexEnviv_size(GLenum e);
+extern GLint __glTexGendv_size(GLenum e);
+extern GLint __glTexGenfv_size(GLenum e);
+extern GLint __glTexGeniv_size(GLenum pname);
+extern GLint __glTexImage1D_size(GLenum format, GLenum type, GLsizei w);
+extern GLint __glTexImage2D_size(GLenum format, GLenum type, GLsizei w, GLsizei h);
+extern GLint __glTexImage3D_size(GLenum format, GLenum type, GLsizei w, GLsizei h, GLsizei d);
+extern GLint __glTexParameterfv_size(GLenum e);
+extern GLint __glTexParameteriv_size(GLenum e);
+extern GLint __glPointParameterfvARB_size(GLenum e);
+extern GLint __glPointParameteriv_size(GLenum e);
+
+#endif /* _size_h_ */

src/glx/x11/xf86dri.h

@@ -0,0 +1,122 @@
+/* $XFree86: xc/lib/GL/dri/xf86dri.h,v 1.8 2002/10/30 12:51:25 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/**
+ * \file xf86dri.h
+ * Protocol numbers and function prototypes for DRI X protocol.
+ *
+ * \author Kevin E. Martin <martin@valinux.com>
+ * \author Jens Owen <jens@tungstengraphics.com>
+ * \author Rickard E. (Rik) Faith <faith@valinux.com>
+ */
+
+#ifndef _XF86DRI_H_
+#define _XF86DRI_H_
+
+#include <X11/Xfuncproto.h>
+#include <xf86drm.h>
+
+#define X_XF86DRIQueryVersion			0
+#define X_XF86DRIQueryDirectRenderingCapable	1
+#define X_XF86DRIOpenConnection			2
+#define X_XF86DRICloseConnection		3
+#define X_XF86DRIGetClientDriverName		4
+#define X_XF86DRICreateContext			5
+#define X_XF86DRIDestroyContext			6
+#define X_XF86DRICreateDrawable			7
+#define X_XF86DRIDestroyDrawable		8
+#define X_XF86DRIGetDrawableInfo		9
+#define X_XF86DRIGetDeviceInfo			10
+#define X_XF86DRIAuthConnection                 11
+#define X_XF86DRIOpenFullScreen                 12   /* Deprecated */
+#define X_XF86DRICloseFullScreen                13   /* Deprecated */
+
+#define XF86DRINumberEvents		0
+
+#define XF86DRIClientNotLocal		0
+#define XF86DRIOperationNotSupported	1
+#define XF86DRINumberErrors		(XF86DRIOperationNotSupported + 1)
+
+#ifndef _XF86DRI_SERVER_
+
+#include <GL/internal/dri_interface.h>
+
+_XFUNCPROTOBEGIN
+
+Bool XF86DRIQueryExtension( Display *dpy, int *event_base, int *error_base );
+
+Bool XF86DRIQueryVersion( Display *dpy, int *majorVersion, int *minorVersion,
+    int *patchVersion );
+
+Bool XF86DRIQueryDirectRenderingCapable( Display *dpy, int screen,
+    Bool *isCapable );
+
+Bool XF86DRIOpenConnection( Display *dpy, int screen, drm_handle_t *hSAREA,
+    char **busIDString );
+
+Bool XF86DRIAuthConnection( Display *dpy, int screen, drm_magic_t magic );
+
+Bool XF86DRICloseConnection( Display *dpy, int screen );
+
+Bool XF86DRIGetClientDriverName( Display *dpy, int screen,
+    int *ddxDriverMajorVersion, int *ddxDriverMinorVersion,
+    int *ddxDriverPatchVersion, char **clientDriverName );
+
+Bool XF86DRICreateContext( Display *dpy, int screen, Visual *visual,
+    XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
+
+Bool XF86DRICreateContextWithConfig( Display *dpy, int screen, int configID,
+    XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
+
+extern GLboolean XF86DRIDestroyContext( __DRInativeDisplay *dpy, int screen,
+    __DRIid context_id );
+
+extern GLboolean XF86DRICreateDrawable( __DRInativeDisplay *dpy, int screen,
+    __DRIid drawable, drm_drawable_t *hHWDrawable );
+
+extern GLboolean XF86DRIDestroyDrawable( __DRInativeDisplay *dpy, int screen, 
+    __DRIid drawable);
+
+Bool XF86DRIGetDrawableInfo( Display *dpy, int screen, Drawable drawable,
+    unsigned int *index, unsigned int *stamp, 
+    int *X, int *Y, int *W, int *H,
+    int *numClipRects, drm_clip_rect_t ** pClipRects,
+    int *backX, int *backY,
+    int *numBackClipRects, drm_clip_rect_t **pBackClipRects );
+
+Bool XF86DRIGetDeviceInfo( Display *dpy, int screen,
+    drm_handle_t *hFrameBuffer, int *fbOrigin, int *fbSize,
+    int *fbStride, int *devPrivateSize, void **pDevPrivate );
+
+_XFUNCPROTOEND
+
+#endif /* _XF86DRI_SERVER_ */
+
+#endif /* _XF86DRI_H_ */
+

src/glx/x11/xf86dristr.h

@@ -0,0 +1,343 @@
+/* $XFree86: xc/lib/GL/dri/xf86dristr.h,v 1.10 2002/10/30 12:51:25 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <martin@valinux.com>
+ *   Jens Owen <jens@tungstengraphics.com>
+ *   Rickard E. (Rik) Fiath <faith@valinux.com>
+ *
+ */
+
+#ifndef _XF86DRISTR_H_
+#define _XF86DRISTR_H_
+
+#include "xf86dri.h"
+
+#define XF86DRINAME "XFree86-DRI"
+
+/* The DRI version number.  This was originally set to be the same of the
+ * XFree86 version number.  However, this version is really indepedent of
+ * the XFree86 version.
+ *
+ * Version History:
+ *    4.0.0: Original
+ *    4.0.1: Patch to bump clipstamp when windows are destroyed, 28 May 02
+ *    4.1.0: Add transition from single to multi in DRMInfo rec, 24 Jun 02
+ */
+#define XF86DRI_MAJOR_VERSION	4
+#define XF86DRI_MINOR_VERSION	1
+#define XF86DRI_PATCH_VERSION	0
+
+typedef struct _XF86DRIQueryVersion {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIQueryVersion */
+    CARD16	length B16;
+} xXF86DRIQueryVersionReq;
+#define sz_xXF86DRIQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD16	majorVersion B16;	/* major version of DRI protocol */
+    CARD16	minorVersion B16;	/* minor version of DRI protocol */
+    CARD32	patchVersion B32;       /* patch version of DRI protocol */
+    CARD32	pad3 B32;
+    CARD32	pad4 B32;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+} xXF86DRIQueryVersionReply;
+#define sz_xXF86DRIQueryVersionReply	32
+
+typedef struct _XF86DRIQueryDirectRenderingCapable {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* X_DRIQueryDirectRenderingCapable */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRIQueryDirectRenderingCapableReq;
+#define sz_xXF86DRIQueryDirectRenderingCapableReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    BOOL	isCapable;
+    BOOL	pad2;
+    BOOL	pad3;
+    BOOL	pad4;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+    CARD32	pad7 B32;
+    CARD32	pad8 B32;
+    CARD32	pad9 B32;
+} xXF86DRIQueryDirectRenderingCapableReply;
+#define sz_xXF86DRIQueryDirectRenderingCapableReply	32
+
+typedef struct _XF86DRIOpenConnection {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIOpenConnection */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRIOpenConnectionReq;
+#define sz_xXF86DRIOpenConnectionReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	hSAREALow B32;
+    CARD32	hSAREAHigh B32;
+    CARD32	busIdStringLength B32;
+    CARD32	pad6 B32;
+    CARD32	pad7 B32;
+    CARD32	pad8 B32;
+} xXF86DRIOpenConnectionReply;
+#define sz_xXF86DRIOpenConnectionReply	32
+
+typedef struct _XF86DRIAuthConnection {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICloseConnection */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32      magic B32;
+} xXF86DRIAuthConnectionReq;
+#define sz_xXF86DRIAuthConnectionReq	12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber B16;
+    CARD32      length B32;
+    CARD32      authenticated B32;
+    CARD32      pad2 B32;
+    CARD32      pad3 B32;
+    CARD32      pad4 B32;
+    CARD32      pad5 B32;
+    CARD32      pad6 B32;
+} xXF86DRIAuthConnectionReply;
+#define zx_xXF86DRIAuthConnectionReply  32
+
+typedef struct _XF86DRICloseConnection {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICloseConnection */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRICloseConnectionReq;
+#define sz_xXF86DRICloseConnectionReq	8
+
+typedef struct _XF86DRIGetClientDriverName {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIGetClientDriverName */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRIGetClientDriverNameReq;
+#define sz_xXF86DRIGetClientDriverNameReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	ddxDriverMajorVersion B32;
+    CARD32	ddxDriverMinorVersion B32;
+    CARD32	ddxDriverPatchVersion B32;
+    CARD32	clientDriverNameLength B32;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+} xXF86DRIGetClientDriverNameReply;
+#define sz_xXF86DRIGetClientDriverNameReply	32
+
+typedef struct _XF86DRICreateContext {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICreateContext */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	visual B32;
+    CARD32	context B32;
+} xXF86DRICreateContextReq;
+#define sz_xXF86DRICreateContextReq	16
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	hHWContext B32;
+    CARD32	pad2 B32;
+    CARD32	pad3 B32;
+    CARD32	pad4 B32;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+} xXF86DRICreateContextReply;
+#define sz_xXF86DRICreateContextReply	32
+
+typedef struct _XF86DRIDestroyContext {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIDestroyContext */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	context B32;
+} xXF86DRIDestroyContextReq;
+#define sz_xXF86DRIDestroyContextReq	12
+
+typedef struct _XF86DRICreateDrawable {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICreateDrawable */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	drawable B32;
+} xXF86DRICreateDrawableReq;
+#define sz_xXF86DRICreateDrawableReq	12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	hHWDrawable B32;
+    CARD32	pad2 B32;
+    CARD32	pad3 B32;
+    CARD32	pad4 B32;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+} xXF86DRICreateDrawableReply;
+#define sz_xXF86DRICreateDrawableReply	32
+
+typedef struct _XF86DRIDestroyDrawable {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIDestroyDrawable */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	drawable B32;
+} xXF86DRIDestroyDrawableReq;
+#define sz_xXF86DRIDestroyDrawableReq	12
+
+typedef struct _XF86DRIGetDrawableInfo {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIGetDrawableInfo */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	drawable B32;
+} xXF86DRIGetDrawableInfoReq;
+#define sz_xXF86DRIGetDrawableInfoReq	12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	drawableTableIndex B32;
+    CARD32	drawableTableStamp B32;
+    INT16	drawableX B16;
+    INT16	drawableY B16;
+    INT16	drawableWidth B16;
+    INT16	drawableHeight B16;
+    CARD32	numClipRects B32;
+    INT16       backX B16;
+    INT16       backY B16;
+    CARD32      numBackClipRects B32;
+} xXF86DRIGetDrawableInfoReply;
+
+#define sz_xXF86DRIGetDrawableInfoReply	36
+
+
+typedef struct _XF86DRIGetDeviceInfo {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIGetDeviceInfo */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRIGetDeviceInfoReq;
+#define sz_xXF86DRIGetDeviceInfoReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	hFrameBufferLow B32;
+    CARD32	hFrameBufferHigh B32;
+    CARD32	framebufferOrigin B32;
+    CARD32	framebufferSize B32;
+    CARD32	framebufferStride B32;
+    CARD32	devPrivateSize B32;
+} xXF86DRIGetDeviceInfoReply;
+#define sz_xXF86DRIGetDeviceInfoReply	32
+
+typedef struct _XF86DRIOpenFullScreen {
+    CARD8       reqType;	/* always DRIReqCode */
+    CARD8       driReqType;	/* always X_DRIOpenFullScreen */
+    CARD16      length B16;
+    CARD32      screen B32;
+    CARD32      drawable B32;
+} xXF86DRIOpenFullScreenReq;
+#define sz_xXF86DRIOpenFullScreenReq    12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber B16;
+    CARD32      length B32;
+    CARD32      isFullScreen B32;
+    CARD32      pad2 B32;
+    CARD32      pad3 B32;
+    CARD32      pad4 B32;
+    CARD32      pad5 B32;
+    CARD32      pad6 B32;
+} xXF86DRIOpenFullScreenReply;
+#define sz_xXF86DRIOpenFullScreenReply  32
+
+typedef struct _XF86DRICloseFullScreen {
+    CARD8       reqType;	/* always DRIReqCode */
+    CARD8       driReqType;	/* always X_DRICloseFullScreen */
+    CARD16      length B16;
+    CARD32      screen B32;
+    CARD32      drawable B32;
+} xXF86DRICloseFullScreenReq;
+#define sz_xXF86DRICloseFullScreenReq   12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber B16;
+    CARD32      length B32;
+    CARD32      pad2 B32;
+    CARD32      pad3 B32;
+    CARD32      pad4 B32;
+    CARD32      pad5 B32;
+    CARD32      pad6 B32;
+    CARD32      pad7 B32;
+} xXF86DRICloseFullScreenReply;
+#define sz_xXF86DRICloseFullScreenReply  32
+
+
+#endif /* _XF86DRISTR_H_ */

src/glx/x11/xfont.c

@@ -0,0 +1,377 @@
+/* $XFree86: xc/lib/GL/glx/xfont.c,v 1.6 2001/05/02 15:06:02 dawes Exp $ */
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ *
+ * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/* xfonts.c -- glXUseXFont() for Mesa written by
+ * Copyright (C) 1995 Thorsten.Ohl @ Physik.TH-Darmstadt.de
+ */
+
+/*
+  This was take from Mesa and modified to work in the real GLX structure.
+  It provides a fully client side implementation of glXUseXFont and is
+  called by that routine when direct rendering is enabled.
+*/
+
+
+#include "glxclient.h"
+
+/* Some debugging info.  */
+
+#ifdef DEBUG
+#undef _R
+#undef _G
+#undef _B
+#include <ctype.h>
+
+int debug_xfonts = 0;
+
+static void
+dump_char_struct (XCharStruct *ch, char *prefix)
+{
+  printf ("%slbearing = %d, rbearing = %d, width = %d\n",
+          prefix, ch->lbearing, ch->rbearing, ch->width);
+  printf ("%sascent = %d, descent = %d, attributes = %u\n",
+          prefix, ch->ascent, ch->descent, (unsigned int) ch->attributes);
+}
+
+static void
+dump_font_struct (XFontStruct *font)
+{
+  printf ("ascent = %d, descent = %d\n", font->ascent, font->descent);
+  printf ("char_or_byte2 = (%u,%u)\n",
+          font->min_char_or_byte2, font->max_char_or_byte2);
+  printf ("byte1 = (%u,%u)\n", font->min_byte1, font->max_byte1);
+  printf ("all_chars_exist = %s\n", font->all_chars_exist ? "True" : 
+"False");
+  printf ("default_char = %c (\\%03o)\n",
+          (char) (isprint (font->default_char) ? font->default_char : ' '),
+          font->default_char);
+  dump_char_struct (&font->min_bounds, "min> ");
+  dump_char_struct (&font->max_bounds, "max> ");
+#if 0
+  for (c = font->min_char_or_byte2; c <= font->max_char_or_byte2; c++)
+    {
+      char prefix[8];
+      sprintf (prefix, "%d> ", c);
+      dump_char_struct (&font->per_char[c], prefix);
+    }
+#endif
+}
+
+static void
+dump_bitmap (unsigned int width, unsigned int height, GLubyte *bitmap)
+{
+  unsigned int x, y;
+
+  printf ("    ");
+  for (x = 0; x < 8*width; x++)
+    printf ("%o", 7 - (x % 8));
+  putchar ('\n');
+  for (y = 0; y < height; y++)
+    {
+      printf ("%3o:", y);
+      for (x = 0; x < 8*width; x++)
+        putchar ((bitmap[width*(height - y - 1) + x/8] & (1 << (7 - (x % 
+8))))
+                 ? '*' : '.');
+      printf ("   ");
+      for (x = 0; x < width; x++)
+        printf ("0x%02x, ", bitmap[width*(height - y - 1) + x]);
+      putchar ('\n');
+    }
+}
+#endif /* DEBUG */
+
+
+/* Implementation.  */
+
+/* Fill a BITMAP with a character C from thew current font
+   in the graphics context GC.  WIDTH is the width in bytes
+   and HEIGHT is the height in bits.
+
+   Note that the generated bitmaps must be used with
+
+        glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
+        glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
+        glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
+        glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
+        glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
+        glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+
+   Possible optimizations:
+
+     * use only one reusable pixmap with the maximum dimensions.
+     * draw the entire font into a single pixmap (careful with
+       proportional fonts!).
+*/
+
+
+/*
+ * Generate OpenGL-compatible bitmap.
+ */
+static void
+fill_bitmap (Display *dpy, Window win, GC gc,
+             unsigned int width, unsigned int height,
+             int x0, int y0, unsigned int c, GLubyte *bitmap)
+{
+  XImage *image;
+  unsigned int x, y;
+  Pixmap pixmap;
+  XChar2b char2b;
+
+  pixmap = XCreatePixmap (dpy, win, 8*width, height, 1);
+  XSetForeground(dpy, gc, 0);
+  XFillRectangle (dpy, pixmap, gc, 0, 0, 8*width, height);
+  XSetForeground(dpy, gc, 1);
+
+  char2b.byte1 = (c >> 8) & 0xff;
+  char2b.byte2 = (c & 0xff);
+
+  XDrawString16 (dpy, pixmap, gc, x0, y0, &char2b, 1);
+
+  image = XGetImage (dpy, pixmap, 0, 0, 8*width, height, 1, XYPixmap);
+  if (image) {
+    /* Fill the bitmap (X11 and OpenGL are upside down wrt each other).  */
+    for (y = 0; y < height; y++)
+      for (x = 0; x < 8*width; x++)
+        if (XGetPixel (image, x, y))
+          bitmap[width*(height - y - 1) + x/8] |= (1 << (7 - (x % 8)));
+    XDestroyImage (image);
+  }
+
+  XFreePixmap (dpy, pixmap);
+}
+
+/*
+ * determine if a given glyph is valid and return the
+ * corresponding XCharStruct.
+ */
+static XCharStruct *isvalid(XFontStruct *fs, int which)
+{
+  unsigned int  rows,pages;
+  int           byte1 = 0, byte2 = 0;
+  int           i,valid = 1;
+
+  rows = fs->max_byte1 - fs->min_byte1 + 1;
+  pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
+
+  if (rows == 1) {
+    /* "linear" fonts */
+    if ((fs->min_char_or_byte2 > which) ||
+        (fs->max_char_or_byte2 < which)) valid = 0;
+  } else {
+    /* "matrix" fonts */
+    byte2 = which & 0xff;
+    byte1 = which >> 8;
+    if ((fs->min_char_or_byte2 > byte2) ||
+        (fs->max_char_or_byte2 < byte2) ||
+        (fs->min_byte1 > byte1) ||
+        (fs->max_byte1 < byte1)) valid = 0;
+  }
+
+  if (valid) {
+    if (fs->per_char) {
+      if (rows == 1) {
+        /* "linear" fonts */
+        return(fs->per_char + (which-fs->min_char_or_byte2) );
+      } else {
+        /* "matrix" fonts */
+        i = ((byte1 - fs->min_byte1) * pages) +
+             (byte2 - fs->min_char_or_byte2);
+        return(fs->per_char + i);
+      }
+    } else {
+        return(&fs->min_bounds);
+    }
+  }
+  return(NULL);
+}
+
+
+void DRI_glXUseXFont( Font font, int first, int count, int listbase )
+{
+  GLXContext CC;
+  Display *dpy;
+  Window win;
+  Pixmap pixmap;
+  GC gc;
+  XGCValues values;
+  unsigned long valuemask;
+  XFontStruct *fs;
+
+  GLint swapbytes, lsbfirst, rowlength;
+  GLint skiprows, skippixels, alignment;
+
+  unsigned int max_width, max_height, max_bm_width, max_bm_height;
+  GLubyte *bm;
+
+  int i;
+
+  CC = __glXGetCurrentContext();
+  dpy = CC->currentDpy;
+  win = CC->currentDrawable;
+
+  fs = XQueryFont (dpy, font);
+  if (!fs)
+    {
+      __glXSetError(CC, GL_INVALID_VALUE);
+      return;
+    }
+
+  /* Allocate a bitmap that can fit all characters.  */
+  max_width = fs->max_bounds.rbearing - fs->min_bounds.lbearing;
+  max_height = fs->max_bounds.ascent + fs->max_bounds.descent;
+  max_bm_width = (max_width + 7) / 8;
+  max_bm_height = max_height;
+
+  bm = (GLubyte *) Xmalloc((max_bm_width * max_bm_height) * sizeof 
+(GLubyte));
+  if (!bm) {
+      XFreeFontInfo( NULL, fs, 1 );
+      __glXSetError(CC, GL_OUT_OF_MEMORY);
+      return;
+    }
+
+#if 0
+  /* get the page info */
+  pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
+  firstchar = (fs->min_byte1 << 8) + fs->min_char_or_byte2;
+  lastchar = (fs->max_byte1 << 8) + fs->max_char_or_byte2;
+  rows = fs->max_byte1 - fs->min_byte1 + 1;
+  unsigned int first_char, last_char, pages, rows;
+#endif
+
+  /* Save the current packing mode for bitmaps.  */
+  glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapbytes);
+  glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirst);
+  glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlength);
+  glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprows);
+  glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skippixels);
+  glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignment);
+
+  /* Enforce a standard packing mode which is compatible with
+     fill_bitmap() from above.  This is actually the default mode,
+     except for the (non)alignment.  */
+  glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
+  glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
+  glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
+  glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
+  glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+
+  pixmap = XCreatePixmap (dpy, win, 10, 10, 1);
+  values.foreground = BlackPixel (dpy, DefaultScreen (dpy));
+  values.background = WhitePixel (dpy, DefaultScreen (dpy));
+  values.font = fs->fid;
+  valuemask = GCForeground | GCBackground | GCFont;
+  gc = XCreateGC (dpy, pixmap, valuemask, &values);
+  XFreePixmap (dpy, pixmap);
+
+#ifdef DEBUG
+  if (debug_xfonts)
+    dump_font_struct (fs);
+#endif
+
+  for (i = 0; i < count; i++)
+    {
+      unsigned int width, height, bm_width, bm_height;
+      GLfloat x0, y0, dx, dy;
+      XCharStruct *ch;
+      int x, y;
+      unsigned int c = first + i;
+      int list = listbase + i;
+      int valid;
+
+      /* check on index validity and get the bounds */
+      ch = isvalid(fs, c);
+      if (!ch) {
+        ch = &fs->max_bounds;
+        valid = 0;
+      } else {
+        valid = 1;
+      }
+
+#ifdef DEBUG
+      if (debug_xfonts) {
+          char s[7];
+          sprintf (s, isprint (c) ? "%c> " : "\\%03o> ", c);
+          dump_char_struct (ch, s);
+      }
+#endif
+
+      /* glBitmap()' parameters:
+         straight from the glXUseXFont(3) manpage.  */
+      width = ch->rbearing - ch->lbearing;
+      height = ch->ascent + ch->descent;
+      x0 = - ch->lbearing;
+      y0 = ch->descent - 1;
+      dx = ch->width;
+      dy = 0;
+
+      /* X11's starting point.  */
+      x = - ch->lbearing;
+      y = ch->ascent;
+
+      /* Round the width to a multiple of eight.  We will use this also
+         for the pixmap for capturing the X11 font.  This is slightly
+         inefficient, but it makes the OpenGL part real easy.  */
+      bm_width = (width + 7) / 8;
+      bm_height = height;
+
+      glNewList (list, GL_COMPILE);
+        if (valid && (bm_width > 0) && (bm_height > 0)) {
+
+            memset (bm, '\0', bm_width * bm_height);
+            fill_bitmap (dpy, win, gc, bm_width, bm_height, x, y, c, bm);
+
+            glBitmap (width, height, x0, y0, dx, dy, bm);
+#ifdef DEBUG
+            if (debug_xfonts) {
+                printf ("width/height = %u/%u\n", width, height);
+                printf ("bm_width/bm_height = %u/%u\n", bm_width, 
+bm_height);
+                dump_bitmap (bm_width, bm_height, bm);
+              }
+#endif
+          } else {
+            glBitmap (0, 0, 0.0, 0.0, dx, dy, NULL);
+          }
+      glEndList ();
+    }
+
+  Xfree(bm);
+  XFreeFontInfo( NULL, fs, 1 );
+  XFreeGC (dpy, gc);
+
+  /* Restore saved packing modes.  */
+  glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
+  glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
+  glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
+  glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
+  glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
+  glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
+}
+
+/* The End. */