fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-24 15:20:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

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

Browse source 
by adding 'glx/x11' to SRC_DIRS in your build config.
This commit is contained in:
Adam Jackson 2004-10-25 21:09:16 +00:00
parent bcd8735546
commit cb3610e37c
37 changed files with 20024 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

115
src/glx/x11/Makefile Normal file
View file

@ -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

615
src/glx/x11/XF86dri.c Normal file
View file

@ -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;
}

186
src/glx/x11/clientattrib.c Normal file
View file

@ -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;
}
}
}

522
src/glx/x11/compsize.c Normal file
View file

@ -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);
}

73
src/glx/x11/dispatch.c Normal file
View file

@ -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 */

475
src/glx/x11/dri_glx.c Normal file
View file

@ -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 */

61
src/glx/x11/dri_glx.h Normal file
View file

@ -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_ */

162
src/glx/x11/eval.c Normal file
View file

@ -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;
}
}

819
src/glx/x11/g_render.c Normal file
View file

@ -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]);
}

663
src/glx/x11/g_single.c Normal file
View file

@ -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();
}

88
src/glx/x11/g_vendpriv.c Normal file
View file

@ -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;
}

556
src/glx/x11/glx_pbuffer.c Normal file
View file

@ -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)

102
src/glx/x11/glx_query.c Normal file
View file

@ -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;
}

346
src/glx/x11/glx_texture_compression.c Normal file
View file

@ -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 );
}
}

833
src/glx/x11/glxclient.h Normal file
View file

@ -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__ */

3082
src/glx/x11/glxcmds.c Normal file
View file

File diff suppressed because it is too large Load diff

1872
src/glx/x11/glxext.c Normal file
View file

File diff suppressed because it is too large Load diff

710
src/glx/x11/glxextensions.c Normal file
View file

@ -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 );
}

253
src/glx/x11/glxextensions.h Normal file
View file

@ -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 */

647
src/glx/x11/indirect.h Normal file
View file

@ -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_ */

624
src/glx/x11/indirect_init.c Normal file
View file

@ -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;
}

42
src/glx/x11/indirect_init.h Normal file
View file

@ -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_ */

730
src/glx/x11/indirect_wrap.h Normal file
View file

@ -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_ */

250
src/glx/x11/packrender.h Normal file
View file

@ -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__ */

219
src/glx/x11/packsingle.h Normal file
View file

@ -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__ */

220
src/glx/x11/packvendpriv.h Normal file
View file

@ -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__ */

462
src/glx/x11/pixel.c Normal file
View file

@ -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;
}
}
}

301
src/glx/x11/pixelstore.c Normal file
View file

@ -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;
}
}

512
src/glx/x11/render2.c Normal file
View file

@ -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);
}

906
src/glx/x11/renderpix.c Normal file
View file

@ -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);
}
}

1097
src/glx/x11/single2.c Normal file
View file

File diff suppressed because it is too large Load diff

415
src/glx/x11/singlepix.c Normal file
View file

@ -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();
}

72
src/glx/x11/size.h Normal file
View file

@ -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_ */

1152
src/glx/x11/vertarr.c Normal file
View file

File diff suppressed because it is too large Load diff

122
src/glx/x11/xf86dri.h Normal file
View file

@ -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_ */

343
src/glx/x11/xf86dristr.h Normal file
View file

@ -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_ */

377
src/glx/x11/xfont.c Normal file
View file

@ -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. */