Restore ability to build full driver.

Add config options to choose between full/subset driver, and fbdev vs. DRI
windowing systems.

Make-config

@@ -1,7 +1,7 @@
-# $Id: Make-config,v 1.63 2002/06/10 17:01:46 brianp Exp $
+# $Id: Make-config,v 1.67 2002/11/12 02:49:14 brianp Exp $
 
-MESA_MAJOR=4
-MESA_MINOR=1
+MESA_MAJOR=5
+MESA_MINOR=0
 MESA_TINY=0
 VERSION=$(MESA_MAJOR).$(MESA_MINOR)
 
@@ -155,7 +155,7 @@ cygnus:
 	"CFLAGS = -I. -DWIN32 -D__WIN32__ -D_WINDOWS \
 		-O2 -funroll-loops \
 		-fexpensive-optimizations -fomit-frame-pointer -ffast-math \
-		-malign-loops=2 -malign-jumps=2 -malign-functions=2" \
+		-malign-loops=2 -malign-functions=2" \
 	"CCFLAGS = $(CFLAGS)" \
 	"MAKELIB = ../bin/mklib.ar-ruv" \
 	"WLIBS = ../lib/wing32.a -lkernel32 -luser32 -lgdi32"
@@ -174,7 +174,7 @@ cygnus-linux:
 	"CFLAGS = -I. -DWIN32 -D__WIN32__ -D_WINDOWS \
 		-O2 -funroll-loops \
 		-fexpensive-optimizations -fomit-frame-pointer -ffast-math \
-		-malign-loops=2 -malign-jumps=2 -malign-functions=2" \
+		-malign-loops=2 -malign-functions=2" \
 	"MAKELIB = ../bin/mklib.cygnus-linux" \
 	"WLIBS = ../lib/wing32.a -lkernel32 -luser32 -lgdi32"
 
@@ -308,6 +308,7 @@ hpux9-gcc-sl:
 	"MAKELIB = ../bin/mklib.hpux" \
 	"APP_LIB_DEPS = -L/usr/lib/X11R5 -lXext -lXmu -lXi -lX11 -lm"
 
+# The hpux10 configs should work for hpux11 as well.
 hpux10:
 	$(MAKE) $(MFLAGS) -f Makefile.X11 targets \
 	"GL_LIB = libGL.a" \
@@ -316,19 +317,23 @@ hpux10:
 	"GLW_LIB = libGLw.a" \
 	"OSMESA_LIB = libOSMesa.a" \
 	"CC = cc" \
+	"CPLUSPLUS = aCC" \
 	"CFLAGS = +O3 +DAportable -Aa -D_HPUX_SOURCE -I/usr/include/X11R6 -I/usr/contrib/X11R6/include -DUSE_XSHM" \
+	"CCFLAGS = +O3 +DAportable -Aa -D_HPUX_SOURCE -I/usr/include/X11R6 -I/usr/contrib/X11R6/include -DUSE_XSHM" \
 	"MAKELIB = ../bin/mklib.ar-ruv" \
-	"APP_LIB_DEPS = -L/usr/lib/X11R6 -L/usr/contrib/X11R6/lib -lXext -lXmu -lXi -lX11 -lm"
+	"APP_LIB_DEPS = -L/usr/lib/X11R6 -L/usr/contrib/X11R6/lib -lXext -lXmu -lXi -lX11 -lm -L/usr/lib -lCsup"
 
 hpux10-sl:
 	$(MAKE) $(MFLAGS) -f Makefile.X11 targets \
 	"GL_LIB = libGL" \
 	"GLU_LIB = libGLU" \
 	"GLUT_LIB = libglut" \
-	"GLW_LIB = libGLw.a" \
-	"OSMESA_LIB = libOSMesa.a" \
+	"GLW_LIB = libGLw" \
+	"OSMESA_LIB = libOSMesa" \
 	"CC = cc" \
-	"CFLAGS = +z -Ae +O2 +Onolimit +Oaggressive -D_HPUX_SOURCE -I/usr/include/X11R6 -I/usr/contrib/X11R6/include -DUSE_XSHM" \
+	"CPLUSPLUS = aCC" \
+	"CFLAGS = +O3 +DAportable +z -Aa -D_HPUX_SOURCE -I/usr/include/X11R6 -I/usr/contrib/X11R6/include -DUSE_XSHM" \
+	"CCFLAGS = +O3 +DAportable +Z -Aa -D_HPUX_SOURCE -I/usr/include/X11R6 -I/usr/contrib/X11R6/include -DUSE_XSHM" \
 	"MAKELIB = ../bin/mklib.hpux" \
 	"APP_LIB_DEPS = -L/usr/lib/X11R6 -L/usr/contrib/X11R6/lib -lXext -lXmu -lXi -lX11 -lm"
 
@@ -641,7 +646,7 @@ linux-x86-static:
 	"OSMESA_LIB = libOSMesa.a" \
 	"CC = gcc" \
 	"CPLUSPLUS = g++" \
-	"CFLAGS = -Wall -O3 -ansi -pedantic -fPIC -ffast-math -funroll-loops -fomit-frame-pointer -malign-loops=2 -malign-jumps=2 -malign-functions=2 -D_POSIX_SOURCE -D_POSIX_C_SOURCE=199309L -D_SVID_SOURCE -D_BSD_SOURCE -DUSE_XSHM -DUSE_X86_ASM -DUSE_MMX_ASM -DUSE_3DNOW_ASM -DUSE_SSE_ASM -DPTHREADS -I/usr/X11R6/include" \
+	"CFLAGS = -Wall -O3 -ansi -pedantic -fPIC -ffast-math -funroll-loops -fomit-frame-pointer -malign-loops=2 -malign-functions=2 -D_POSIX_SOURCE -D_POSIX_C_SOURCE=199309L -D_SVID_SOURCE -D_BSD_SOURCE -DUSE_XSHM -DUSE_X86_ASM -DUSE_MMX_ASM -DUSE_3DNOW_ASM -DUSE_SSE_ASM -DPTHREADS -I/usr/X11R6/include" \
 	"MAKELIB = ../bin/mklib.ar-ruv" \
 	"GL_LIB_DEPS = -L/usr/X11R6/lib -lX11 -lXext -lm -lm -lpthread" \
 	"GLU_LIB_DEPS = -L../lib -lGL -lm" \
@@ -737,7 +742,7 @@ linux-386-opt-glide:
 	"OSMESA_LIB = libOSMesa.so" \
 	"CC = gcc" \
 	"CPLUSPLUS = g++" \
-	"CFLAGS = -O3 -m486 -fomit-frame-pointer -pipe -ansi -pedantic -ffast-math -fexpensive-optimizations -malign-loops=2 -malign-jumps=2 -malign-functions=2 -D_SVID_SOURCE -D_BSD_SOURCE -DUSE_XSHM -DFX -DUSE_X86_ASM -DPTHREADS -I/usr/X11R6/include -I/usr/include/glide -I/usr/local/glide/include" \
+	"CFLAGS = -O3 -m486 -fomit-frame-pointer -pipe -ansi -pedantic -ffast-math -fexpensive-optimizations -malign-loops=2 -malign-functions=2 -D_SVID_SOURCE -D_BSD_SOURCE -DUSE_XSHM -DFX -DUSE_X86_ASM -DPTHREADS -I/usr/X11R6/include -I/usr/include/glide -I/usr/local/glide/include" \
 	"CCFLAGS = $(CFLAGS)" \
 	"MAKELIB = ../bin/mklib.linux" \
 	"GL_LIB_DEPS = -L/usr/X11R6/lib -lX11 -lXext -lm -L/usr/local/glide/lib -lglide2x -lm -lpthread" \
@@ -757,7 +762,7 @@ linux-x86-glide:
 	"OSMESA_LIB = libOSMesa.so" \
 	"CC = gcc" \
 	"CPLUSPLUS = g++" \
-	"CFLAGS = -O3 -ansi -pedantic -fPIC -ffast-math -funroll-loops -fomit-frame-pointer -malign-loops=2 -malign-jumps=2 -malign-functions=2 -D_SVID_SOURCE -D_BSD_SOURCE -DUSE_X86_ASM -DUSE_MMX_ASM -DUSE_3DNOW_ASM -DUSE_SSE_ASM -DUSE_XSHM -DFX -DPTHREADS -I/usr/X11R6/include -I/usr/include/glide -I/usr/local/glide/include -I/usr/src/mesa-glx/src/FX/X86" \
+	"CFLAGS = -O3 -ansi -pedantic -fPIC -ffast-math -funroll-loops -fomit-frame-pointer -malign-loops=2 -malign-functions=2 -D_SVID_SOURCE -D_BSD_SOURCE -DUSE_X86_ASM -DUSE_MMX_ASM -DUSE_3DNOW_ASM -DUSE_SSE_ASM -DUSE_XSHM -DFX -DPTHREADS -I/usr/X11R6/include -I/usr/include/glide -I/usr/local/glide/include -I/usr/src/mesa-glx/src/FX/X86" \
 	"MAKELIB = ../bin/mklib.linux" \
 	"GL_LIB_DEPS = -L/usr/X11R6/lib -lX11 -lXext -lm -L/usr/local/glide/lib -lglide2x -lm -lpthread" \
 	"GLU_LIB_DEPS = -L../lib -lGL -lm" \
@@ -914,7 +919,7 @@ linux-osmesa32:
 # May want to add these CFLAGS for better performance under LynxOS and GCC:
 # -fPIC -O2 -ansi -pedantic -mieee-fp -DUSE_XSHM -funroll-loops
 # -fexpensive-optimizations -fomit-frame-pointer -ffast-math
-# and  -malign-loops=2 -malign-jumps=2 -malign-functions=2 for Pentium
+# and  -malign-loops=2 -malign-functions=2 for Pentium
 lynxos:
 	$(MAKE) $(MFLAGS) -f Makefile.X11 targets \
 	"GL_LIB = libGL.a" \
@@ -1548,7 +1553,7 @@ linux-x86-debug:
 	"OSMESA_LIB = libOSMesa.so" \
 	"CC = gcc" \
 	"CPLUSPLUS = g++" \
-	"CFLAGS = -O2 -g -ansi -pedantic -Wall -Wmissing-prototypes -fPIC -ffast-math -malign-loops=2 -malign-jumps=2 -malign-functions=2 -D_POSIX_SOURCE -D_POSIX_C_SOURCE=199309L -D_SVID_SOURCE -D_BSD_SOURCE -DUSE_XSHM -DUSE_X86_ASM -DUSE_MMX_ASM -DUSE_3DNOW_ASM -DUSE_SSE_ASM -DPTHREADS -I/usr/X11R6/include -DDEBUG -DMESA_DEBUG" \
+	"CFLAGS = -O2 -g -ansi -pedantic -Wall -Wmissing-prototypes -fPIC -ffast-math -malign-loops=2 -malign-functions=2 -D_POSIX_SOURCE -D_POSIX_C_SOURCE=199309L -D_SVID_SOURCE -D_BSD_SOURCE -DUSE_XSHM -DUSE_X86_ASM -DUSE_MMX_ASM -DUSE_3DNOW_ASM -DUSE_SSE_ASM -DPTHREADS -I/usr/X11R6/include -DDEBUG -DMESA_DEBUG" \
 	"MAKELIB = ../bin/mklib.linux" \
 	"GL_LIB_DEPS = -L/usr/X11R6/lib -lX11 -lXext -lm -lm -lpthread" \
 	"GLU_LIB_DEPS = -L../lib -lGL -lm" \

Makefile.X11

@@ -1,7 +1,7 @@
-# $Id: Makefile.X11,v 1.65 2002/10/15 15:40:57 brianp Exp $
+# $Id: Makefile.X11,v 1.69 2002/11/13 15:33:51 brianp Exp $
 
 # Mesa 3-D graphics library
-# Version:  4.1
+# Version:  5.0
 # 
 # Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
 # 
@@ -51,8 +51,8 @@ default:
 	@echo "  make hpux9-sl             for HP systems with HPUX 9.x, make shared libs"
 	@echo "  make hpux9-gcc            for HP systems with HPUX 9.x using GCC"
 	@echo "  make hpux9-gcc-sl         for HP systems with HPUX 9.x, GCC, make shared libs"
-	@echo "  make hpux10               for HP systems with HPUX 10.x"
-	@echo "  make hpux10-sl            for HP systems with HPUX 10.x, shared libs"
+	@echo "  make hpux10               for HP systems with HPUX 10.x and 11.x"
+	@echo "  make hpux10-sl            for HP systems with HPUX 10.x and 11.x, shared libs"
 	@echo "  make hpux10-gcc           for HP systems with HPUX 10.x w/ GCC"
 	@echo "  make hpux10-gcc-sl        for HP systems with HPUX 10.x w/ GCC, shared libs"
 	@echo "  make irix4                for SGI systems with IRIX 4.x"
@@ -330,10 +330,10 @@ realclean: clean
 	cd samples     && $(MAKE) -f Makefile.X11 realclean || true
 
 
-DIRECTORY = Mesa-4.1
-LIB_NAME = MesaLib-4.1
-DEMO_NAME = MesaDemos-4.1
-GLU_NAME = MesaGLU-4.1
+DIRECTORY = Mesa-5.0
+LIB_NAME = MesaLib-5.0
+DEMO_NAME = MesaDemos-5.0
+GLU_NAME = MesaGLU-5.0
 GLUT_NAME = GLUT-3.7
 
 
@@ -354,12 +354,10 @@ LIB_FILES =	\
 	$(DIRECTORY)/missing						\
 	$(DIRECTORY)/mkinstalldirs					\
 	$(DIRECTORY)/stamp-h.in						\
-	$(DIRECTORY)/docs/CONFIG					\
 	$(DIRECTORY)/docs/CONFORM					\
 	$(DIRECTORY)/docs/COPYING					\
 	$(DIRECTORY)/docs/COPYRIGHT					\
 	$(DIRECTORY)/docs/DEVINFO					\
-	$(DIRECTORY)/docs/IAFA-PACKAGE					\
 	$(DIRECTORY)/docs/INSTALL					\
 	$(DIRECTORY)/docs/INSTALL.GNU					\
 	$(DIRECTORY)/docs/README					\
@@ -400,7 +398,6 @@ LIB_FILES =	\
 	$(DIRECTORY)/include/GL/xmesa_x.h				\
 	$(DIRECTORY)/include/GL/xmesa_xf86.h				\
 	$(DIRECTORY)/include/GLView.h					\
-	$(DIRECTORY)/include/dmesadxe.h					\
 	$(DIRECTORY)/include/Makefile.in				\
 	$(DIRECTORY)/include/Makefile.am				\
 	$(DIRECTORY)/src/Makefile*					\

docs/README.DJ

@@ -1,4 +1,4 @@
-			Mesa 4.0 DOS/DJGPP Port v1.1
+			Mesa 4.1 DOS/DJGPP Port v1.2
 			~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
@@ -6,7 +6,7 @@
 Description:
 ~~~~~~~~~~~~
 
-Well, guess what... this is the DOS port of Mesa 4.0.4, for DJGPP fans... Whoa!
+Well, guess what... this is the DOS port of Mesa 4.1, for DJGPP fans... Whoa!
 The driver has its origins in ddsample.c, written by Brian Paul and found by me
 in Mesa 3.4.2.
 
@@ -66,7 +66,7 @@ Tested on:
 	CPU:		K6-2 (CXT) @500(412.5) MHz
 	Mainboard:	ViA Apollo VP2/97 w/ 128 MB SDRAM
 	Video card:	PowerColor Evil King3 (Voodoo3 3000) w/ 16384 kB SDRAM
-	DJGPP:		djdev 2.03 + gcc v3.1 + make v3.79.1
+	DJGPP:		djdev 2.04 + gcc v3.2 + make v3.79.1
 
 
 
@@ -86,33 +86,27 @@ FAQ:
    A) You must have the DXE2 package (available on SimTel.Net, courtesy of
       Andrew Zabolotny) installed in order to build the dynamic modules.
 
-   Q) I have DXE2, but I couln'd build the `dxe2gen.exe'.
+   Q) I have DXE2, but I couldn't build the `dxe2gen.exe'.
    Q) I built `dxe2gen.exe', but it doesn't do the job right.
    A) There is a patched version on my web page.
 
    Q) DXE2 modules give me headaches...
    A) The DXE2 modules are not compulsory. The static libraries are still built
-      and you can use them in the old-fashioned, classic way. For example:
+      and you can use them in the old-fashioned, classic way... and learn to
+      live with your ~2MB executable size. For example:
 	gcc -o OUT.exe IN.c -lglut -lglu -lgl
 
    Q) Okay, DXE2 modules are built. How can I use them?
-   A) Usage of the dynamic modules requires three things:
-	- include DMESADXE.H in one of the sources, so references inside
-	  dynamic modules will get resolved (or use `-include' directive).
-	- link against import libraries (libI*.a) and LIBDL.A, which will do
-	  the dynamic linkage job for you
-	- put the DXEs somewhere along the library path (LD_LIBRARY_PATH) or
-	  in the current directory
+   A) Build your export object file; then link it with your application.
       For example:
-	gcc -o OUT.exe -include dmesadxe.h IN.c -ligl -liglu -liglut -ldl
+	dxe2res -o dmesadxe.c gl.dxe glu.dxe glut.dxe
+	gcc -o dmesadxe.o dmesadxe.c
+	gcc -o OUT.exe dmesadxe.o IN.c -liglut -liglu -ligl -ldl
 
-   Q) The application dies with "Abort!" due to unresolved symbols.
-   A) This is bad! Extract the unresolved symbol list from this module. For
-      example:
-	dxe2gen --show-unres gl.dxe > u
-      Check DMESADXE.H; the symbols in `u' must either be present here or be
-      exported from another module that has to be loaded before your faulting
-      one. Then recompile.
+   Q) What is that `dxe2res.exe' thing?
+   A) That is an utility that generates the export file for a given set of
+      modules. If you can't find it in the DXE2 package, you must be looking at
+      the wrong archive :)
 
 3. Using Mesa for DJGPP
 
@@ -138,7 +132,7 @@ FAQ:
       GLUT took this into account for _WIN32 DLL's only; I don't want to modify
       his headers. The only workaround is to link GLUT the old way :-(
 
-   Q) The DJGPP port of Mesa is so SLOOOW! The Win32 OpenGL performs so much
+   Q) DMesa is so SLOOOW! The Win32 OpenGL performs so much
       better...
    A) Is that a question? If you have a Voodoo3/Banshee card, you're lucky. The
       Glide port is on my web page. If you haven't, sorry; everything is done
@@ -196,11 +190,15 @@ History:
 ~~~~~~~~
 
 v1.0	mar-2002	initial release
+
 v1.1	sep-2002	+ added 3dfx Glide3 support
 			+ added refresh rate control
 			+ added fonts in glut
 			* lots of minor changes
 
+v1.2	nov-2002	* synced w/ Mesa-4.1
+			- removed dmesadxe.h
+
 
 
 Contact:

docs/README.WIN32

@@ -1,9 +1,13 @@
 File: docs/README.WIN32
 
-Last updated: Aug 15, 2002 - Karl Schultz - kschultz@users.sourceforge.net
+Last updated: Nov 08, 2002 - Karl Schultz - kschultz@users.sourceforge.net
 
 Quick Start
 
+Unzip both ZIP files (MesaLib and MesaDemos) into the same directory.
+This is important because the current makefiles in MesaLib assume that
+the directories in MesaDemos are present.
+
 If you have Microsoft Visual C++ 6.0 installed, simply go to the top directory
 of the Mesa distribution and type 'nmake -f Makefile.win NODEBUG=1' for
 an optimized build.  Note that you may have to run ...VC98/BIN/VCVARS32.BAT

docs/README.X11

@@ -1,5 +1,5 @@
 
-                       Mesa 4.0 Unix/X11 Information
+                          Mesa Unix/X11 Information
 
 
 
@@ -18,21 +18,15 @@ There are two ways to compile Mesa on Unix/X11 systems:
     the top-level Makefile and Make-config files.  There are instructions in
     each file.
 
+    When finished, the Mesa libraries will be in the Mesa-x.y/lib/ directory.
+
 
 2. The new way:
     Type './configure' and then 'make'.  This uses GNU autoconfig.
+    Run 'make check' to build the demos.
     See docs/INSTALL for more details.
-
-
-The top-level makefile will execute the makefiles in a number of sub-
-directories.  When finished, the Mesa libraries will be in the Mesa-4.0/lib/
-directory.  A few GLUT demos in the demos/ directory should be ready to run.
-
-If you also downloaded and unpacked the demos there should be executables
-in the "xdemos/", "samples/", and "book/" directories for you to try out.
-
-If you have compilation problems you should try to fix them and return the
-patches to the author.
+    When finished, the Mesa libraries will be in the Mesa-x.y/src/.libs/,
+    Mesa-x.y/si-glu/.libs, etc directories.
 
 
 Notes on assembly language optimizations:
@@ -323,4 +317,4 @@ Summary of X-related environment variables:
 
 
 ----------------------------------------------------------------------
-$Id: README.X11,v 3.8 2001/09/23 16:10:02 brianp Exp $
+$Id: README.X11,v 3.9 2002/10/29 23:42:48 brianp Exp $

docs/RELNOTES-5.0

@@ -0,0 +1,85 @@
+
+                            Mesa 5.0 release notes
+
+                              November 13, 2002
+
+                                PLEASE READ!!!!
+
+
+
+Introduction
+------------
+
+Mesa uses an even/odd version number scheme like the Linux kernel.
+Even-numbered versions (such as 5.0) designate stable releases.
+Odd-numbered versions (such as 4.1) designate new developmental releases.
+
+Mesa 5.0 is basically just a stabilization of Mesa 4.1.  To see a list of
+bug fixes, etc. see the VERSIONS file.
+
+
+
+New Features in Mesa 5.0
+------------------------
+
+Mesa 5.0 supports OpenGL 1.4.  Note Mesa's versioning convention:
+
+   OpenGL Version    Mesa Version
+   ------------------------------
+        1.0             1.x
+        1.1             2.x
+        1.2             3.x
+        1.3             4.x
+        1.4             5.x
+
+OpenGL 1.4 (and Mesa 5.0) incorporates the following OpenGL extensions as
+standard features:
+
+	GL_ARB_depth_texture
+	GL_ARB_shadow
+	GL_ARB_texture_env_crossbar
+	GL_ARB_texture_mirror_repeat
+	GL_ARB_window_pos
+	GL_EXT_blend_color
+	GL_EXT_blend_func_separate
+	GL_EXT_blend_logic_op
+	GL_EXT_blend_minmax
+	GL_EXT_blend_subtract
+	GL_EXT_fog_coord
+	GL_EXT_multi_draw_arrays
+	GL_EXT_point_parameters
+	GL_EXT_secondary_color
+	GL_EXT_stencil_wrap
+	GL_SGIS_generate_mipmap
+
+
+
+Device Driver Status
+--------------------
+
+A number of Mesa's software drivers haven't been actively maintained for
+some time.  We rely on volunteers to maintain many of these drivers.
+Here's the current status of all included drivers:
+
+
+Driver			Status
+----------------------	---------------------
+XMesa (Xlib)		implements OpenGL 1.4
+OSMesa (off-screen)	implements OpenGL 1.4
+FX (3dfx Voodoo1/2)	implements OpenGL 1.3
+SVGA			implements OpenGL 1.3
+Wind River UGL		implements OpenGL 1.3
+Windows/Win32		implements OpenGL 1.4
+DOS/DJGPP		implements OpenGL 1.3
+GGI			implements OpenGL 1.3
+DOS			implements OpenGL 1.4
+BeOS			needs updating (underway)
+Allegro			needs updating
+D3D			needs updating
+
+Note: supporting OpenGL 1.4 (vs. 1.3 or 1.2) usually only requires that the
+driver call the _mesa_enable_1_4_extensions() function.
+
+
+----------------------------------------------------------------------
+$Id: RELNOTES-5.0,v 3.2 2002/11/13 15:33:51 brianp Exp $

docs/VERSIONS

@@ -1,4 +1,4 @@
-$Id: VERSIONS,v 1.103 2002/10/29 15:09:37 brianp Exp $
+$Id: VERSIONS,v 1.118 2002/11/13 15:33:50 brianp Exp $
 
 
 Mesa Version History
@@ -1044,7 +1044,7 @@ Mesa Version History
 	- assorted conformance fixes for 16-bit/channel rendering
 	- texcombine alpha subtraction mode was broken
 	- fixed some blend problems when GLchan==GLfloat (Gerk Huisma)
-	- clamp colors to [0,1] in OSMesa if GLchan==GLfloat (Gerk Huisma)
+	- clamp colors to [0,inf] in OSMesa if GLchan==GLfloat (Gerk Huisma)
 	- fixed divide by zero error in NURBS tessellator (Jon Perry)
 	- fixed GL_LINEAR fog bug by adding clamping
 	- fixed FP exceptions found using Alpha CPU
@@ -1055,5 +1055,28 @@ Mesa Version History
     Changes:
 	- New spec file and Python code to generate some GL dispatch files
 	- Glide driver defaults to "no" with autoconf/automake
-	- floating point color channels now clamped to [0,inf)
 	- updated demos/stex3d with new options
+
+
+5.0  November 13, 2002
+    New:
+	- OpenGL 1.4 support (glGetString(GL_VERSION) returns "1.4")
+	- removed some overlooked debugging code
+	- glxinfo updated to support GLX_ARB_multisample
+	- GLUT now support GLX_ARB_multisample
+	- updated DOS driver (Daniel Borca)
+    Bug fixes:
+	- GL_POINT and GL_LINE-mode polygons didn't obey cull state
+	- fixed potential bug in _mesa_align_malloc/calloc()
+	- fixed missing triangle bug when running vertex programs
+	- fixed a few HPUX compilation problems
+	- FX (Glide) driver didn't compile
+	- setting GL_TEXTURE_BORDER_COLOR with glTexParameteriv() didn't work
+	- a few EXT functions, like glGenTexturesEXT, were no-ops
+	- a few OpenGL 1.4 functions like glFogCoord*, glBlendFuncSeparate,
+	  glMultiDrawArrays and glMultiDrawElements were missing
+	- glGet*(GL_ACTIVE_STENCIL_FACE_EXT) was broken
+	- Pentium 4 Mobile was mistakenly identified as having 3DNow!
+	- fixed one-bit error in point/line fragment Z calculation
+	- fixed potential segfault in fakeglx code
+	- fixed color overflow problem in DOT3 texture env mode

docs/index.html

@@ -0,0 +1,90 @@
+<HTML>
+<HEAD>
+  <TITLE>Index to Mesa Documentation</TITLE>
+</HEAD>
+
+<BODY>
+
+<H1>Main Documentation</H1>
+<UL>
+<LI><A HREF="README">README</A> - general, top-level documentation
+<LI><A HREF="INSTALL">INSTALL</A> - compilation/installation instructions
+<LI><A HREF="VERSIONS">VERSIONS</A> - version history / change log
+<LI><A HREF="COPYRIGHT">COPYRIGHT</A> - copyright and license information
+<LI><A HREF="COPYING">COPYING</A> - some parts of Mesa are GPL'd
+<LI><A HREF="CONFORM">CONFORM</A>
+    - results of running the OpenGL conformance tests
+<LI><A HREF="DEVINFO">DEVINFO</A> - information for Mesa developers
+<LI><A HREF="http://www.mesa3d.org/">www.mesa3d.org</A> - Mesa website
+</UL>
+
+<H1>Platform and Driver Information</H1>
+<P>
+Be warned, some of these files may be very out of date.
+</P>
+<UL>
+<LI><A HREF="README.X11">README.X11</A> - X Window System / Unix / Linux
+<LI><A HREF="README.WIN32">README.WIN32</A> - Microsoft Windows
+<LI><A HREF="README.VMS">README.VMS</A> - DEC VMS
+<LI><A HREF="README.GGI">README.GGI</A> - GGI
+<LI><A HREF="README.3DFX">README.3DFX</A> - 3Dfx/Glide driver
+<LI><A HREF="README.AMIWIN">README.AMIWIN</A> - Amiga Amiwin
+<LI><A HREF="README.BEOS">README.BEOS</A> - BeOS
+<LI><A HREF="README.D3D">README.D3D</A> - Direct3D driver
+<LI><A HREF="README.DJ">README.DJ</A> - DJGPP
+<LI><A HREF="README.LYNXOS">README.LYNXOS</A> - LynxOS
+<LI><A HREF="README.MINGW32">README.MINGW32</A> - Mingw32
+<LI><A HREF="README.NeXT">README.NeXT</A> - NeXT
+<LI><A HREF="README.OpenStep">README.OpenStep</A> - OpenStep
+<LI><A HREF="README.OS2">README.OS2</A> - OS/2
+<LI><A HREF="README.WINDML">README.WINDML</A> - WindML
+</UL>
+
+<H1>Release Notes</H1>
+<UL>
+<LI><A HREF="RELNOTES-5.0">RELNOTES-5.0</A>
+<LI><A HREF="RELNOTES-4.1">RELNOTES-4.1</A>
+<LI><A HREF="RELNOTES-4.0.3">RELNOTES-4.0.3</A>
+<LI><A HREF="RELNOTES-4.0.2">RELNOTES-4.0.2</A>
+<LI><A HREF="RELNOTES-4.0.1">RELNOTES-4.0.1</A>
+<LI><A HREF="RELNOTES-4.0">RELNOTES-4.0</A>
+<LI><A HREF="RELNOTES-3.5">RELNOTES-3.5</A>
+<LI><A HREF="RELNOTES-3.4.2">RELNOTES-3.4.2</A>
+<LI><A HREF="RELNOTES-3.4.1">RELNOTES-3.4.1</A>
+<LI><A HREF="RELNOTES-3.4">RELNOTES-3.4</A>
+<LI><A HREF="RELNOTES-3.3">RELNOTES-3.3</A>
+<LI><A HREF="RELNOTES-3.2.1">RELNOTES-3.2.1</A>
+<LI><A HREF="RELNOTES-3.2">RELNOTES-3.2</A>
+<LI><A HREF="RELNOTES-3.1">RELNOTES-3.1</A>
+</UL>
+
+<H1>Mesa Extension Specifications</H1>
+<UL>
+<LI><A HREF="MESA_agp_offset.spec">MESA_agp_offset.spec</A>
+<LI><A HREF="MESA_copy_sub_buffer.spec">MESA_copy_sub_buffer.spec</A>
+<LI><A HREF="MESA_packed_depth_stencil.spec">MESA_packed_depth_stencil.spec</A>
+<LI><A HREF="MESA_pack_invert.spec">MESA_pack_invert.spec</A>
+<LI><A HREF="MESA_pixmap_colormap.spec">MESA_pixmap_colormap.spec</A>
+<LI><A HREF="MESA_release_buffers.spec">MESA_release_buffers.spec</A>
+<LI><A HREF="MESA_resize_buffers.spec">MESA_resize_buffers.spec</A>
+<LI><A HREF="MESA_set_3dfx_mode.spec">MESA_set_3dfx_mode.spec</A>
+<LI><A HREF="MESA_sprite_point.spec">MESA_sprite_point.spec</A> (obsolete)
+<LI><A HREF="MESA_trace.spec">MESA_trace.spec</A> (obsolete)
+<LI><A HREF="MESA_window_pos.spec">MESA_window_pos.spec</A>
+<LI><A HREF="MESA_ycbcr_texture.spec">MESA_ycbcr_texture.spec</A>
+</UL>
+
+<H1>Source Code Documentation</H1>
+<P>
+<A HREF="http://www.doxygen.org">Doxygen</A> is used to automatically
+produce cross-referenced documentation from the Mesa sources.
+This is not included in the normal Mesa distribution.
+Download Mesa from CVS if interested.
+</P>
+<P>
+<A HREF="../doxy/core/index.html">Source documentation</A>
+</P>
+
+
+</BODY>
+</HTML>

doxygen/.cvsignore

@@ -0,0 +1,10 @@
+*.tag
+array_cache
+core
+math
+miniglx
+radeon_subset
+swrast
+swrast_setup
+tnl
+tnl_dd

doxygen/README

@@ -5,3 +5,5 @@ See http://www.doxygen.org/ for more info.
 
 Either run 'make' (Unix) or 'doxy.bat' (Windows) to run doxygen
 and generate souce code documentation.
+
+Then, load doxy/core/index.html into your web browser.

doxygen/array_cache.doxy

@@ -4,10 +4,10 @@
 # General configuration options
 #---------------------------------------------------------------------------
 PROJECT_NAME           = "Mesa array_cache"
-PROJECT_NUMBER         = 4.1
-OUTPUT_DIRECTORY       = .
+PROJECT_NUMBER         = 
+OUTPUT_DIRECTORY       = 
 OUTPUT_LANGUAGE        = English
-EXTRACT_ALL            = YES
+EXTRACT_ALL            = NO
 EXTRACT_PRIVATE        = NO
 EXTRACT_STATIC         = NO
 EXTRACT_LOCAL_CLASSES  = YES
@@ -38,14 +38,14 @@ GENERATE_BUGLIST       = YES
 ALIASES                = 
 ENABLED_SECTIONS       = 
 MAX_INITIALIZER_LINES  = 30
-OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_FOR_C  = NO
 SHOW_USED_FILES        = YES
 #---------------------------------------------------------------------------
 # configuration options related to warning and progress messages
 #---------------------------------------------------------------------------
 QUIET                  = YES
 WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_UNDOCUMENTED   = NO
 WARN_FORMAT            = 
 WARN_LOGFILE           = 
 #---------------------------------------------------------------------------

doxygen/core.doxy

@@ -4,12 +4,12 @@
 # General configuration options
 #---------------------------------------------------------------------------
 PROJECT_NAME           = "Mesa Core"
-PROJECT_NUMBER         = 4.1
+PROJECT_NUMBER         = 
 OUTPUT_DIRECTORY       = 
 OUTPUT_LANGUAGE        = English
-EXTRACT_ALL            = YES
+EXTRACT_ALL            = NO
 EXTRACT_PRIVATE        = NO
-EXTRACT_STATIC         = NO
+EXTRACT_STATIC         = YES
 EXTRACT_LOCAL_CLASSES  = YES
 HIDE_UNDOC_MEMBERS     = NO
 HIDE_UNDOC_CLASSES     = NO
@@ -19,7 +19,7 @@ ALWAYS_DETAILED_SEC    = NO
 INLINE_INHERITED_MEMB  = NO
 FULL_PATH_NAMES        = NO
 STRIP_FROM_PATH        = 
-INTERNAL_DOCS          = NO
+INTERNAL_DOCS          = YES
 STRIP_CODE_COMMENTS    = YES
 CASE_SENSE_NAMES       = YES
 SHORT_NAMES            = NO
@@ -38,21 +38,21 @@ GENERATE_BUGLIST       = YES
 ALIASES                = 
 ENABLED_SECTIONS       = 
 MAX_INITIALIZER_LINES  = 30
-OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_FOR_C  = NO
 SHOW_USED_FILES        = YES
 #---------------------------------------------------------------------------
 # configuration options related to warning and progress messages
 #---------------------------------------------------------------------------
 QUIET                  = YES
 WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_UNDOCUMENTED   = NO
 WARN_FORMAT            = 
 WARN_LOGFILE           = 
 #---------------------------------------------------------------------------
 # configuration options related to the input files
 #---------------------------------------------------------------------------
 INPUT                  = ../src/
-FILE_PATTERNS          = *.h *.c
+FILE_PATTERNS          = *.c *.h
 RECURSIVE              = NO
 EXCLUDE                = ../src/glapitemp.h ../src/glapioffsets.h
 EXCLUDE_PATTERNS       = 
@@ -65,16 +65,16 @@ FILTER_SOURCE_FILES    = NO
 #---------------------------------------------------------------------------
 # configuration options related to source browsing
 #---------------------------------------------------------------------------
-SOURCE_BROWSER         = NO
+SOURCE_BROWSER         = YES
 INLINE_SOURCES         = NO
 REFERENCED_BY_RELATION = YES
 REFERENCES_RELATION    = YES
 #---------------------------------------------------------------------------
 # configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
-ALPHABETICAL_INDEX     = YES
+ALPHABETICAL_INDEX     = NO
 COLS_IN_ALPHA_INDEX    = 5
-IGNORE_PREFIX          = _
+IGNORE_PREFIX          = 
 #---------------------------------------------------------------------------
 # configuration options related to the HTML output
 #---------------------------------------------------------------------------
@@ -149,7 +149,7 @@ TAGFILES		= tnl_dd.tag=../tnl_dd \
                          swrast.tag=../swrast \
                          swrast_setup.tag=../swrast_setup \
                          tnl.tag=../tnl \
-                         array_cache.tag=array_cache
+			 miniglx.tag=../miniglx
 GENERATE_TAGFILE       = core.tag
 ALLEXTERNALS           = NO
 PERL_PATH              = 

doxygen/header.html

@@ -1,12 +1,14 @@
-<html><head><title>Mesa API docs</title>
+<html><head><title>Mesa Source Code Documentation</title>
 <link href="doxygen.css" rel="stylesheet" type="text/css">
 </head>
 <body><center>
+<a href="../core/index.html">Mesa Core</a>&nbsp;
+<a href="../miniglx/index.html">MiniGLX</a>&nbsp;
 <a href="../array_cache/index.html">array_cache</a>&nbsp;
-<a href="../core/index.html">core</a>&nbsp;
 <a href="../math/index.html">math</a>&nbsp;
 <a href="../swrast/index.html">swrast</a>&nbsp;
 <a href="../swrast_setup/index.html">swrast_setup</a>&nbsp;
 <a href="../tnl/index.html">tnl</a>&nbsp;
 <a href="../tnl_dd/index.html">tnl_dd</a>&nbsp;
+<a href="../radeon_subset/index.html">radeon_subset</a>&nbsp;
 </center>

doxygen/makefile

@@ -5,6 +5,7 @@ default:
 	doxygen swrast.doxy
 	doxygen swrast_setup.doxy
 	doxygen tnl.doxy
+	doxygen miniglx.doxy
 	doxygen core.doxy
 	echo "Building again, to resolve tags"
 	doxygen tnl_dd.doxy
@@ -13,9 +14,11 @@ default:
 	doxygen swrast.doxy
 	doxygen swrast_setup.doxy
 	doxygen tnl.doxy
+	doxygen miniglx.doxy
+	doxygen radeon_subset.doxy
 
 
 clean:
-	rm -rf array_cache core math swrast swrast_setup tnl_dd tnl
+	rm -rf array_cache core math swrast swrast_setup tnl_dd tnl miniglx radeon_subset
 	rm -rf *.tag
 

doxygen/math.doxy

@@ -3,13 +3,13 @@
 #---------------------------------------------------------------------------
 # General configuration options
 #---------------------------------------------------------------------------
-PROJECT_NAME           = "Mesa math"
-PROJECT_NUMBER         = 4.1
+PROJECT_NAME           = "Mesa math module"
+PROJECT_NUMBER         = 
 OUTPUT_DIRECTORY       = .
 OUTPUT_LANGUAGE        = English
 EXTRACT_ALL            = YES
 EXTRACT_PRIVATE        = NO
-EXTRACT_STATIC         = NO
+EXTRACT_STATIC         = YES
 EXTRACT_LOCAL_CLASSES  = YES
 HIDE_UNDOC_MEMBERS     = NO
 HIDE_UNDOC_CLASSES     = NO
@@ -73,7 +73,7 @@ REFERENCES_RELATION    = YES
 #---------------------------------------------------------------------------
 # configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
-ALPHABETICAL_INDEX     = YES
+ALPHABETICAL_INDEX     = NO
 COLS_IN_ALPHA_INDEX    = 5
 IGNORE_PREFIX          = 
 #---------------------------------------------------------------------------

doxygen/miniglx.doxy

@@ -0,0 +1,184 @@
+# Doxyfile 0.1
+
+#---------------------------------------------------------------------------
+# General configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = "MiniGLX"
+PROJECT_NUMBER         = 
+OUTPUT_DIRECTORY       = 
+OUTPUT_LANGUAGE        = English
+EXTRACT_ALL            = NO
+EXTRACT_PRIVATE        = NO
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = NO
+STRIP_FROM_PATH        = 
+INTERNAL_DOCS          = YES
+STRIP_CODE_COMMENTS    = YES
+CASE_SENSE_NAMES       = YES
+SHORT_NAMES            = NO
+HIDE_SCOPE_NAMES       = NO
+VERBATIM_HEADERS       = NO
+SHOW_INCLUDE_FILES     = NO
+JAVADOC_AUTOBRIEF      = NO
+INHERIT_DOCS           = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = NO
+DISTRIBUTE_GROUP_DOC   = NO
+TAB_SIZE               = 8
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+ALIASES                = 
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+OPTIMIZE_OUTPUT_FOR_C  = NO
+SHOW_USED_FILES        = YES
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = YES
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = NO
+WARN_FORMAT            = 
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = ../src/miniglx/ ../include/GL/miniglx.h
+FILE_PATTERNS          = *.h *.c
+RECURSIVE              = NO
+EXCLUDE                = ../src/miniglx/glapi.c
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = NO
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = miniglx
+HTML_HEADER            = header.html
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = 
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = 
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = 
+MAN_EXTENSION          = 
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = ../include/
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES		= core.tag=../core \
+			 tnl_dd.tag=../tnl_dd \
+			 array_cache.tag=../array_cache \
+                         math.tag=../math \
+                         swrast.tag=../swrast \
+                         swrast_setup.tag=../swrast_setup \
+                         tnl.tag=../tnl \
+                         array_cache.tag=array_cache
+GENERATE_TAGFILE       = miniglx.tag
+ALLEXTERNALS           = NO
+PERL_PATH              = 
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = NO
+HAVE_DOT               = NO
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+TEMPLATE_RELATIONS     = YES
+HIDE_UNDOC_RELATIONS   = YES
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+GRAPHICAL_HIERARCHY    = YES
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO
+CGI_NAME               = 
+CGI_URL                = 
+DOC_URL                = 
+DOC_ABSPATH            = 
+BIN_ABSPATH            = 
+EXT_DOC_PATHS          = 

doxygen/radeon_subset.doxy

@@ -0,0 +1,208 @@
+# Doxyfile 0.1
+
+#---------------------------------------------------------------------------
+# General configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = "Radeon Subset Driver"
+PROJECT_NUMBER         = 
+OUTPUT_DIRECTORY       = 
+OUTPUT_LANGUAGE        = English
+EXTRACT_ALL            = NO
+EXTRACT_PRIVATE        = NO
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = NO
+STRIP_FROM_PATH        = 
+INTERNAL_DOCS          = YES
+STRIP_CODE_COMMENTS    = YES
+CASE_SENSE_NAMES       = YES
+SHORT_NAMES            = NO
+HIDE_SCOPE_NAMES       = NO
+VERBATIM_HEADERS       = NO
+SHOW_INCLUDE_FILES     = NO
+JAVADOC_AUTOBRIEF      = NO
+INHERIT_DOCS           = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = NO
+DISTRIBUTE_GROUP_DOC   = NO
+TAB_SIZE               = 8
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+ALIASES                = 
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+OPTIMIZE_OUTPUT_FOR_C  = NO
+SHOW_USED_FILES        = YES
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = YES
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = NO
+WARN_FORMAT            = 
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = \
+			../src/drv/common/mm.c \
+			../src/drv/common/mm.h \
+			../src/drv/radeon/radeon_context.c \
+			../src/drv/radeon/radeon_context.h \
+		 	../src/drv/radeon/radeon_ioctl.c \
+		 	../src/drv/radeon/radeon_ioctl.h \
+		 	../src/drv/radeon/radeon_lock.c \
+		 	../src/drv/radeon/radeon_lock.h \
+		 	../src/drv/radeon/radeon_screen.c \
+		 	../src/drv/radeon/radeon_screen.h \
+		 	../src/drv/radeon/radeon_state.c \
+		 	../src/drv/radeon/radeon_state.h \
+		 	../src/drv/radeon/radeon_state_init.c \
+			../src/drv/radeon/radeon_subset.h \
+			../src/drv/radeon/radeon_subset_bitmap.c \
+			../src/drv/radeon/radeon_subset_readpix.c \
+			../src/drv/radeon/radeon_subset_select.c \
+			../src/drv/radeon/radeon_subset_tex.c \
+			../src/drv/radeon/radeon_subset_vtx.c \
+		 	../src/drv/radeon/radeon_tcl.h \
+		 	../src/drv/radeon/radeon_tex.h \
+		 	../src/drv/radeon/radeon_vtxfmt.h \
+			../src/drv/radeon/server
+FILE_PATTERNS          = *.h *.c
+RECURSIVE              = NO
+EXCLUDE                = 
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = NO
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = radeon_subset
+HTML_HEADER            = header.html
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = 
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = 
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = 
+MAN_EXTENSION          = 
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = ../include/
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES		= core.tag=../core \
+			 tnl_dd.tag=../tnl_dd \
+			 array_cache.tag=../array_cache \
+                         math.tag=../math \
+                         swrast.tag=../swrast \
+                         swrast_setup.tag=../swrast_setup \
+                         tnl.tag=../tnl \
+                         miniglx.tag=../miniglx \
+                         array_cache.tag=array_cache
+GENERATE_TAGFILE       = radeon_subset.tag
+ALLEXTERNALS           = NO
+PERL_PATH              = 
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = NO
+HAVE_DOT               = NO
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+TEMPLATE_RELATIONS     = YES
+HIDE_UNDOC_RELATIONS   = YES
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+GRAPHICAL_HIERARCHY    = YES
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO
+CGI_NAME               = 
+CGI_URL                = 
+DOC_URL                = 
+DOC_ABSPATH            = 
+BIN_ABSPATH            = 
+EXT_DOC_PATHS          = 

doxygen/swrast.doxy

@@ -3,8 +3,8 @@
 #---------------------------------------------------------------------------
 # General configuration options
 #---------------------------------------------------------------------------
-PROJECT_NAME           = "Mesa swrast"
-PROJECT_NUMBER         = 4.1
+PROJECT_NAME           = "Mesa Software Rasterization (swrast)"
+PROJECT_NUMBER         = 
 OUTPUT_DIRECTORY       = 
 OUTPUT_LANGUAGE        = English
 EXTRACT_ALL            = NO
@@ -19,7 +19,7 @@ ALWAYS_DETAILED_SEC    = NO
 INLINE_INHERITED_MEMB  = NO
 FULL_PATH_NAMES        = NO
 STRIP_FROM_PATH        = 
-INTERNAL_DOCS          = NO
+INTERNAL_DOCS          = YES
 STRIP_CODE_COMMENTS    = YES
 CASE_SENSE_NAMES       = YES
 SHORT_NAMES            = NO
@@ -38,22 +38,21 @@ GENERATE_BUGLIST       = YES
 ALIASES                = 
 ENABLED_SECTIONS       = 
 MAX_INITIALIZER_LINES  = 30
-OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_FOR_C  = YES
 SHOW_USED_FILES        = YES
 #---------------------------------------------------------------------------
 # configuration options related to warning and progress messages
 #---------------------------------------------------------------------------
 QUIET                  = YES
 WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_UNDOCUMENTED   = NO
 WARN_FORMAT            = 
 WARN_LOGFILE           = 
 #---------------------------------------------------------------------------
 # configuration options related to the input files
 #---------------------------------------------------------------------------
 INPUT                  = ../src/swrast/
-FILE_PATTERNS          = *.c \
-                         *.h
+FILE_PATTERNS          = *.c *.h
 RECURSIVE              = NO
 EXCLUDE                = 
 EXCLUDE_PATTERNS       = 
@@ -136,7 +135,7 @@ ENABLE_PREPROCESSING   = YES
 MACRO_EXPANSION        = NO
 EXPAND_ONLY_PREDEF     = NO
 SEARCH_INCLUDES        = YES
-INCLUDE_PATH           = 
+INCLUDE_PATH           = ../include/
 INCLUDE_FILE_PATTERNS  = 
 PREDEFINED             = 
 EXPAND_AS_DEFINED      = 
@@ -156,7 +155,7 @@ PERL_PATH              =
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool   
 #---------------------------------------------------------------------------
-CLASS_DIAGRAMS         = YES
+CLASS_DIAGRAMS         = NO
 HAVE_DOT               = NO
 CLASS_GRAPH            = YES
 COLLABORATION_GRAPH    = YES

doxygen/swrast_setup.doxy

@@ -4,7 +4,7 @@
 # General configuration options
 #---------------------------------------------------------------------------
 PROJECT_NAME           = "Mesa swrast_setup"
-PROJECT_NUMBER         = 4.1
+PROJECT_NUMBER         = 
 OUTPUT_DIRECTORY       = 
 OUTPUT_LANGUAGE        = English
 EXTRACT_ALL            = YES

doxygen/tnl.doxy

@@ -3,8 +3,8 @@
 #---------------------------------------------------------------------------
 # General configuration options
 #---------------------------------------------------------------------------
-PROJECT_NAME           = "Mesa tnl"
-PROJECT_NUMBER         = 4.1
+PROJECT_NAME           = "Mesa Transform and Lighting (tnl)"
+PROJECT_NUMBER         = 
 OUTPUT_DIRECTORY       = 
 OUTPUT_LANGUAGE        = English
 EXTRACT_ALL            = YES

doxygen/tnl_dd.doxy

@@ -4,7 +4,7 @@
 # General configuration options
 #---------------------------------------------------------------------------
 PROJECT_NAME           = "Mesa tnl_dd"
-PROJECT_NUMBER         = 4.1
+PROJECT_NUMBER         = 
 OUTPUT_DIRECTORY       = 
 OUTPUT_LANGUAGE        = English
 EXTRACT_ALL            = YES
@@ -52,7 +52,7 @@ WARN_LOGFILE           =
 # configuration options related to the input files
 #---------------------------------------------------------------------------
 INPUT                  = ../src/tnl_dd/
-FILE_PATTERNS          = *.h
+FILE_PATTERNS          = *.c *.h
 RECURSIVE              = YES
 EXCLUDE                = 
 EXCLUDE_PATTERNS       = 

include/GL/dmesa.h

@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  4.0
+ * Version:  5.0
  * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  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"),
@@ -23,7 +23,7 @@
  */
 
 /*
- * DOS/DJGPP device driver v1.0 for Mesa 4.0
+ * DOS/DJGPP device driver v1.2 for Mesa 4.1
  *
  *  Copyright (C) 2002 - Borca Daniel
  *  Email : dborca@yahoo.com
@@ -31,10 +31,10 @@
  */
 
 
-#ifndef DMESA_included
-#define DMESA_included
+#ifndef DMESA_H_included
+#define DMESA_H_included
 
-#define DMESA_MAJOR_VERSION 4
+#define DMESA_MAJOR_VERSION 5
 #define DMESA_MINOR_VERSION 0
 
 typedef struct dmesa_context *DMesaContext;
@@ -45,8 +45,10 @@ typedef struct dmesa_buffer *DMesaBuffer;
 extern "C" {
 #endif
 
-DMesaVisual DMesaCreateVisual (GLint width, GLint height, GLint colDepth,
-                               GLboolean dbFlag, GLint depthSize,
+DMesaVisual DMesaCreateVisual (GLint width, GLint height,
+                               GLint colDepth,
+                               GLboolean dbFlag,
+                               GLint depthSize,
                                GLint stencilSize,
                                GLint accumSize);
 

include/GL/glx.h

@@ -1,4 +1,4 @@
-/* $Id: glx.h,v 1.38 2002/10/14 13:52:27 brianp Exp $ */
+/* $Id: glx.h,v 1.38.4.1 2003/02/23 19:37:15 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -295,7 +295,7 @@ extern void glXGetSelectedEvent( Display *dpy, GLXDrawable drawable,
 
 
 /* GLX 1.4 and later */
-extern void (*glXGetProcAddress(const GLubyte *procname))();
+extern void (*glXGetProcAddress(const GLubyte *procname))( void );
 
 
 #ifndef GLX_GLXEXT_LEGACY

include/GL/internal/glcore.h

@@ -58,12 +58,12 @@ typedef struct __GLinterfaceRec __GLinterface;
 ** and used by the "operating system".
 */
 
-/*
-** Mode and limit information for a context.  This information is
-** kept around in the context so that values can be used during
-** command execution, and for returning information about the
-** context to the application.
-*/
+/**
+ * Mode and limit information for a context.  This information is
+ * kept around in the context so that values can be used during
+ * command execution, and for returning information about the
+ * context to the application.
+ */
 typedef struct __GLcontextModesRec {
     GLboolean rgbMode;
     GLboolean colorIndexMode;

progs/demos/Makefile

@@ -0,0 +1,25 @@
+
+PROGS = gears \
+	glinfo \
+	texobj \
+	bounce \
+	terrain
+
+
+##### RULES #####
+
+.SUFFIXES:
+.SUFFIXES: .c
+
+
+# make executable from .c file:
+.c: $(LIB_DEP)
+	gcc -I../include -I../util -g $< -L../lib -lglut -lGL -lm -o $@
+
+
+default: $(PROGS)
+
+
+clean:
+	-rm *.o *~
+

progs/demos/bounce.c

@@ -1,4 +1,4 @@
-/* $Id: bounce.c,v 1.3 2000/08/16 20:36:34 brianp Exp $ */
+/* $Id: bounce.c,v 1.3.8.1 2003/02/23 19:25:07 keithw Exp $ */
 
 /*
  * Bouncing ball demo.
@@ -33,8 +33,8 @@ GLfloat Xmin = -4.0, Xmax = 4.0;
 GLfloat Ymin = -3.8, Ymax = 4.0;
 GLfloat G = -0.1;
 
-static GLuint 
-make_ball(void)
+static void
+draw_ball(void)
 {
   GLuint list;
   GLfloat a, b;
@@ -43,9 +43,9 @@ make_ball(void)
   GLuint color;
   GLfloat x, y, z;
 
-  list = glGenLists(1);
+/*   list = glGenLists(1); */
 
-  glNewList(list, GL_COMPILE);
+/*   glNewList(list, GL_COMPILE); */
 
   color = 0;
   for (a = -90.0; a + da <= 90.0; a += da) {
@@ -54,10 +54,10 @@ make_ball(void)
     for (b = 0.0; b <= 360.0; b += db) {
 
       if (color) {
-	glIndexi(RED);
+/* 	glIndexi(RED); */
         glColor3f(1, 0, 0);
       } else {
-	glIndexi(WHITE);
+/* 	glIndexi(WHITE); */
         glColor3f(1, 1, 1);
       }
 
@@ -77,11 +77,12 @@ make_ball(void)
 
   }
 
-  glEndList();
+/*   glEndList(); */
 
-  return list;
+/*   return list; */
 }
 
+
 static void 
 reshape(int width, int height)
 {
@@ -110,7 +111,7 @@ draw(void)
 
   glClear(GL_COLOR_BUFFER_BIT);
 
-  glIndexi(CYAN);
+/*   glIndexi(CYAN); */
   glColor3f(0, 1, 1);
   glBegin(GL_LINES);
   for (i = -5; i <= 5; i++) {
@@ -138,7 +139,8 @@ draw(void)
   glRotatef(90.0, 1.0, 0.0, 0.0);
   glRotatef(Zrot, 0.0, 0.0, 1.0);
 
-  glCallList(Ball);
+/*   glCallList(Ball); */
+  draw_ball();
 
   glPopMatrix();
 
@@ -198,7 +200,7 @@ int main(int argc, char *argv[])
      glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
 
   glutCreateWindow("Bounce");
-  Ball = make_ball();
+/*   Ball = make_ball(); */
   glCullFace(GL_BACK);
   glEnable(GL_CULL_FACE);
   glDisable(GL_DITHER);

progs/demos/clearspd.c

@@ -1,4 +1,4 @@
-/* $Id: clearspd.c,v 1.4 2002/04/22 16:03:37 brianp Exp $ */
+/* $Id: clearspd.c,v 1.5 2002/10/31 12:38:32 keithw Exp $ */
 
 /*
  * Simple GLUT program to measure glClear() and glutSwapBuffers() speed.
@@ -61,6 +61,12 @@ static void Display( void )
       glutSwapBuffers();
    }
 
+   /* NOTE: If clearspd doesn't map it's window immediately on
+    * starting, swaps will be istantaneous, so this will send Loops
+    * towards infinity.  When a window is finally mapped, it may be
+    * minutes before the first call to glutSwapBuffers, making it look
+    * like there's a driver bug.
+    */
    if (t1-t0 < MinPeriod) {
       /* Next time do more clears to get longer elapsed time */
       Loops *= 2;

progs/demos/gears.c

@@ -1,4 +1,4 @@
-/* $Id: gears.c,v 1.6 2000/04/06 02:22:59 brianp Exp $ */
+/* $Id: gears.c,v 1.6.12.1 2003/02/23 19:25:07 keithw Exp $ */
 
 /*
  * 3-D gear wheels.  This program is in the public domain.
@@ -59,7 +59,7 @@ gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
 
   glShadeModel(GL_FLAT);
 
-  glNormal3f(0.0, 0.0, 1.0);
+/*   glNormal3f(0.0, 0.0, 1.0); */
 
   /* draw front face */
   glBegin(GL_QUAD_STRIP);
@@ -87,7 +87,7 @@ gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
   }
   glEnd();
 
-  glNormal3f(0.0, 0.0, -1.0);
+/*   glNormal3f(0.0, 0.0, -1.0); */
 
   /* draw back face */
   glBegin(GL_QUAD_STRIP);
@@ -127,18 +127,18 @@ gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
     len = sqrt(u * u + v * v);
     u /= len;
     v /= len;
-    glNormal3f(v, -u, 0.0);
+/*     glNormal3f(v, -u, 0.0); */
     glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
     glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
-    glNormal3f(cos(angle), sin(angle), 0.0);
+/*     glNormal3f(cos(angle), sin(angle), 0.0); */
     glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
     glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
     u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
     v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
-    glNormal3f(v, -u, 0.0);
+/*     glNormal3f(v, -u, 0.0); */
     glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
     glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
-    glNormal3f(cos(angle), sin(angle), 0.0);
+/*     glNormal3f(cos(angle), sin(angle), 0.0); */
   }
 
   glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
@@ -149,10 +149,11 @@ gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
   glShadeModel(GL_SMOOTH);
 
   /* draw inside radius cylinder */
+  glColor3f( .5, .5, .5 );
   glBegin(GL_QUAD_STRIP);
   for (i = 0; i <= teeth; i++) {
     angle = i * 2.0 * M_PI / teeth;
-    glNormal3f(-cos(angle), -sin(angle), 0.0);
+/*     glNormal3f(-cos(angle), -sin(angle), 0.0); */
     glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
     glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
   }
@@ -167,6 +168,11 @@ static GLfloat angle = 0.0;
 static void
 draw(void)
 {
+  static GLfloat red[4] = {0.8, 0.1, 0.0, 1.0};
+  static GLfloat green[4] = {0.0, 0.8, 0.2, 1.0};
+  static GLfloat blue[4] = {0.2, 0.2, 1.0, 1.0};
+
+  glClearColor( 1,0,1,1 );
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
   glPushMatrix();
@@ -177,19 +183,23 @@ draw(void)
     glPushMatrix();
       glTranslatef(-3.0, -2.0, 0.0);
       glRotatef(angle, 0.0, 0.0, 1.0);
-      glCallList(gear1);
+      glColor3fv( red);
+      gear(1.0, 4.0, 1.0, 20, 0.7);
     glPopMatrix();
 
+
     glPushMatrix();
       glTranslatef(3.1, -2.0, 0.0);
       glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
-      glCallList(gear2);
+      glColor3fv( green);
+      gear(0.5, 2.0, 2.0, 10, 0.7);
     glPopMatrix();
 
     glPushMatrix();
       glTranslatef(-3.1, 4.2, 0.0);
       glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
-      glCallList(gear3);
+      glColor3fv( blue);
+      gear(1.3, 2.0, 0.5, 10, 0.7);
     glPopMatrix();
 
   glPopMatrix();
@@ -284,37 +294,15 @@ static void
 init(int argc, char *argv[])
 {
   static GLfloat pos[4] = {5.0, 5.0, 10.0, 0.0};
-  static GLfloat red[4] = {0.8, 0.1, 0.0, 1.0};
-  static GLfloat green[4] = {0.0, 0.8, 0.2, 1.0};
-  static GLfloat blue[4] = {0.2, 0.2, 1.0, 1.0};
   GLint i;
 
-  glLightfv(GL_LIGHT0, GL_POSITION, pos);
-  glEnable(GL_CULL_FACE);
-  glEnable(GL_LIGHTING);
-  glEnable(GL_LIGHT0);
-  glEnable(GL_DEPTH_TEST);
+/*   glLightfv(GL_LIGHT0, GL_POSITION, pos); */
+   glEnable(GL_CULL_FACE); 
+/*   glEnable(GL_LIGHTING); */
+/*   glEnable(GL_LIGHT0); */
+/*   glEnable(GL_DEPTH_TEST); */
 
-  /* make the gears */
-  gear1 = glGenLists(1);
-  glNewList(gear1, GL_COMPILE);
-  glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
-  gear(1.0, 4.0, 1.0, 20, 0.7);
-  glEndList();
-
-  gear2 = glGenLists(1);
-  glNewList(gear2, GL_COMPILE);
-  glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
-  gear(0.5, 2.0, 2.0, 10, 0.7);
-  glEndList();
-
-  gear3 = glGenLists(1);
-  glNewList(gear3, GL_COMPILE);
-  glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
-  gear(1.3, 2.0, 0.5, 10, 0.7);
-  glEndList();
-
-  glEnable(GL_NORMALIZE);
+/*   glEnable(GL_NORMALIZE); */
 
   for ( i=1; i<argc; i++ ) {
     if (strcmp(argv[i], "-info")==0) {
@@ -345,7 +333,7 @@ int main(int argc, char *argv[])
   glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
 
   glutInitWindowPosition(0, 0);
-  glutInitWindowSize(300, 300);
+  glutInitWindowSize(900, 900);
   glutCreateWindow("Gears");
   init(argc, argv);
 

progs/demos/isosurf.c

@@ -1,4 +1,4 @@
-/* $Id: isosurf.c,v 1.15 2002/10/18 17:47:35 kschultz Exp $ */
+/* $Id: isosurf.c,v 1.15.4.1 2003/02/23 21:04:25 keithw Exp $ */
 
 /*
  * Display an isosurface of 3-D wind speed volume.
@@ -484,7 +484,7 @@ static void draw_surface( unsigned int with_state )
 	    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, col[j]);
 	    glBegin( GL_TRIANGLES );
 	    for (k = 0 ; k < nr ; k++) {
-	       glNormal3fv( &compressed_data[tri_indices[i+k]][3] );
+	       glColor3fv( &compressed_data[tri_indices[i+k]][3] );
 	       glVertex3fv( &compressed_data[tri_indices[i+k]][0] );
 	    }
 	    glEnd();
@@ -492,7 +492,7 @@ static void draw_surface( unsigned int with_state )
       } else {
 	 glBegin( GL_TRIANGLES );
 	 for (i = 0 ; i < num_tri_verts ; i++) {
-	    glNormal3fv( &compressed_data[tri_indices[i]][3] );
+	    glColor3fv( &compressed_data[tri_indices[i]][3] );
 	    glVertex3fv( &compressed_data[tri_indices[i]][0] );
 	 }
 	 glEnd();
@@ -506,7 +506,7 @@ static void draw_surface( unsigned int with_state )
        */
       glBegin( GL_POINTS );
       for ( i = 0 ; i < numuniq ; i++ ) {
-         glNormal3fv( &compressed_data[i][3] );
+         glColor3fv( &compressed_data[i][3] );
          glVertex3fv( &compressed_data[i][0] );
       }
       glEnd();
@@ -515,7 +515,7 @@ static void draw_surface( unsigned int with_state )
    case (GLVERTEX|STRIPS):
       glBegin( GL_TRIANGLE_STRIP );
       for (i=0;i<numverts;i++) {
-         glNormal3fv( &data[i][3] );
+         glColor3fv( &data[i][0] );
          glVertex3fv( &data[i][0] );
       }
       glEnd();
@@ -595,24 +595,24 @@ static void InitMaterials(void)
     static float lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0};
     static float lmodel_twoside[] = {GL_FALSE};
 
-    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
-    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
-    glLightfv(GL_LIGHT0, GL_POSITION, position0);
-    glEnable(GL_LIGHT0);
+/*     glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); */
+/*     glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); */
+/*     glLightfv(GL_LIGHT0, GL_POSITION, position0); */
+/*     glEnable(GL_LIGHT0); */
 
-    glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
-    glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
-    glLightfv(GL_LIGHT1, GL_POSITION, position1);
-    glEnable(GL_LIGHT1);
+/*     glLightfv(GL_LIGHT1, GL_AMBIENT, ambient); */
+/*     glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse); */
+/*     glLightfv(GL_LIGHT1, GL_POSITION, position1); */
+/*     glEnable(GL_LIGHT1); */
 
-    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
-    glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
+/*     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); */
+/*     glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); */
 
-    glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_mat_shininess);
-    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_mat_specular);
-    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, front_mat_diffuse);
+/*     glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_mat_shininess); */
+/*     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_mat_specular); */
+/*     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, front_mat_diffuse); */
 
-    glPolygonStipple (halftone);
+/*     glPolygonStipple (halftone); */
 }
 
 
@@ -736,65 +736,6 @@ static void ModeMenu(int m)
       print_flags("primitive", state & PRIMITIVE_MASK);
       print_flags("render style", state & RENDER_STYLE_MASK);
 
-      if ((state & PRIMITIVE_MASK) != STRIPS &&
-	  ((state & RENDER_STYLE_MASK) == DRAW_ELTS ||
-	   (state & RENDER_STYLE_MASK) == ARRAY_ELT || 
-	   (state & PRIMITIVE_MASK) == POINTS))
-      {
-	 fprintf(stderr, "enabling small arrays\n");
-	 /* Rendering any primitive with draw-element/array-element
-	  *  --> Can't do strips here as ordering has been lost in
-	  *  compaction process...
-	  */
-	 glVertexPointerEXT( 3, GL_FLOAT, sizeof(data[0]), numuniq,
-			     compressed_data );
-	 glNormalPointerEXT( GL_FLOAT, sizeof(data[0]), numuniq,
-			     &compressed_data[0][3]);
-#ifdef GL_EXT_compiled_vertex_array
-	 if (allowed & LOCKED) {
-	    if (state & LOCKED) {
-	       glLockArraysEXT( 0, numuniq );
-	    } else {
-	       glUnlockArraysEXT();
-	    }
-	 }
-#endif
-      }
-      else if ((state & PRIMITIVE_MASK) == TRIANGLES &&
-	       (state & RENDER_STYLE_MASK) == DRAW_ARRAYS) {
-	 fprintf(stderr, "enabling big arrays\n");
-	 /* Only get here for TRIANGLES and drawarrays
-	  */
-	 glVertexPointerEXT( 3, GL_FLOAT, sizeof(data[0]), (numverts-2) * 3,
-			     expanded_data );
-	 glNormalPointerEXT( GL_FLOAT, sizeof(data[0]), (numverts-2) * 3,
-			     &expanded_data[0][3]);
-
-#ifdef GL_EXT_compiled_vertex_array
-	 if (allowed & LOCKED) {
-	    if (state & LOCKED) {
-	       glLockArraysEXT( 0, (numverts-2)*3 );
-	    } else {
-	       glUnlockArraysEXT();
-	    }
-	 }
-#endif
-      }
-      else {
-	 fprintf(stderr, "enabling normal arrays\n");
-	 glVertexPointerEXT( 3, GL_FLOAT, sizeof(data[0]), numverts, data );
-	 glNormalPointerEXT( GL_FLOAT, sizeof(data[0]), numverts, &data[0][3]);
-#ifdef GL_EXT_compiled_vertex_array
-	 if (allowed & LOCKED) {
-	    if (state & LOCKED) {
-	       glLockArraysEXT( 0, numverts );
-	    } else {
-	       glUnlockArraysEXT();
-	    }
-	 }
-#endif
-      }
-
    }
 #endif
 
@@ -827,9 +768,9 @@ static void Init(int argc, char *argv[])
    plane[3] = 0.0;
 
    glClearColor(0.0, 0.0, 1.0, 0.0);
-   glEnable( GL_DEPTH_TEST );
-   glEnable( GL_VERTEX_ARRAY_EXT );
-   glEnable( GL_NORMAL_ARRAY_EXT );
+/*    glEnable( GL_DEPTH_TEST ); */
+/*    glEnable( GL_VERTEX_ARRAY_EXT ); */
+/*    glEnable( GL_NORMAL_ARRAY_EXT ); */
 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
@@ -837,24 +778,24 @@ static void Init(int argc, char *argv[])
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
-   glClipPlane(GL_CLIP_PLANE0, plane);
+/*    glClipPlane(GL_CLIP_PLANE0, plane); */
 
    InitMaterials();
 
    set_matrix();
 
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
+/*    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); */
 
-   glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
-   glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+/*    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); */
+/*    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); */
 
 
    /* Green fog is easy to see */
-   glFogi(GL_FOG_MODE,GL_EXP2);
-   glFogfv(GL_FOG_COLOR,fogColor);
-   glFogf(GL_FOG_DENSITY,0.15);
-   glHint(GL_FOG_HINT,GL_DONT_CARE);
+/*    glFogi(GL_FOG_MODE,GL_EXP2); */
+/*    glFogfv(GL_FOG_COLOR,fogColor); */
+/*    glFogf(GL_FOG_DENSITY,0.15); */
+/*    glHint(GL_FOG_HINT,GL_DONT_CARE); */
 
    {
       static int firsttime = 1;
@@ -872,7 +813,7 @@ static void Init(int argc, char *argv[])
    }
 
    ModeMenu(SHADE_SMOOTH|
-	    LIT|
+	    UNLIT|
 	    POINT_FILTER|
 	    NO_USER_CLIP|
 	    NO_MATERIALS|
@@ -1121,6 +1062,9 @@ int main(int argc, char **argv)
    glutSpecialFunc(SpecialKey);
    glutDisplayFunc(Display);
 
+/*    Benchmark(5,0); */
+/*    Benchmark(5,0); */
+/*    Benchmark(5,0); */
    glutMainLoop();
    return 0;
 }

progs/demos/terrain.c

@@ -51,7 +51,7 @@ static GLfloat terraincolor[256 * 256][3];
 
 static int win = 0;
 
-static int fog = 1;
+static int fog = 0;
 static int bfcull = 1;
 static int usetex = 1;
 static int poutline = 0;
@@ -105,6 +105,21 @@ calcposobs(void)
       obs[1] = 0.0;
 }
 
+static void 
+perspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)
+{
+   GLdouble xmin, xmax, ymin, ymax;
+
+   ymax = zNear * tan(fovy * M_PI / 360.0);
+   ymin = -ymax;
+   xmin = ymin * aspect;
+   xmax = ymax * aspect;
+
+   /* don't call glFrustum() because of error semantics (covglu) */
+   glFrustum(xmin, xmax, ymin, ymax, zNear, zFar);
+}
+
+
 static void
 reshape(int width, int height)
 {
@@ -113,7 +128,7 @@ reshape(int width, int height)
    glViewport(0, 0, (GLint) width, (GLint) height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
-   gluPerspective(50.0, ((GLfloat) width / (GLfloat) height),
+   perspective(50.0, ((GLfloat) width / (GLfloat) height),
 		  lenghtXmnt * stepYmnt * 0.01, lenghtXmnt * stepYmnt * 0.7);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
@@ -209,13 +224,25 @@ printstring(void *font, char *string)
       glutBitmapCharacter(font, string[i]);
 }
 
+
+
+static void _subset_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+   glBegin( GL_QUADS );
+   glVertex2f( x1, y1 );
+   glVertex2f( x2, y1 );
+   glVertex2f( x2, y2 );
+   glVertex2f( x1, y2 );
+   glEnd();
+}
+
 static void
 printhelp(void)
 {
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glColor4f(0.0, 0.0, 0.0, 0.5);
-   glRecti(40, 40, 600, 440);
+   _subset_Rectf(40, 40, 600, 440);
    glDisable(GL_BLEND);
 
    glColor3f(1.0, 0.0, 0.0);
@@ -351,6 +378,87 @@ dojoy(void)
 #endif
 }
 
+static void 
+lookAt(GLfloat eyex, GLfloat eyey, GLfloat eyez,
+	  GLfloat centerx, GLfloat centery, GLfloat centerz,
+	  GLfloat upx, GLfloat upy, GLfloat upz)
+{
+   GLfloat m[16];
+   GLfloat x[3], y[3], z[3];
+   GLfloat mag;
+
+   /* Make rotation matrix */
+
+   /* Z vector */
+   z[0] = eyex - centerx;
+   z[1] = eyey - centery;
+   z[2] = eyez - centerz;
+   mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
+   if (mag) {			/* mpichler, 19950515 */
+      z[0] /= mag;
+      z[1] /= mag;
+      z[2] /= mag;
+   }
+
+   /* Y vector */
+   y[0] = upx;
+   y[1] = upy;
+   y[2] = upz;
+
+   /* X vector = Y cross Z */
+   x[0] = y[1] * z[2] - y[2] * z[1];
+   x[1] = -y[0] * z[2] + y[2] * z[0];
+   x[2] = y[0] * z[1] - y[1] * z[0];
+
+   /* Recompute Y = Z cross X */
+   y[0] = z[1] * x[2] - z[2] * x[1];
+   y[1] = -z[0] * x[2] + z[2] * x[0];
+   y[2] = z[0] * x[1] - z[1] * x[0];
+
+   /* mpichler, 19950515 */
+   /* cross product gives area of parallelogram, which is < 1.0 for
+    * non-perpendicular unit-length vectors; so normalize x, y here
+    */
+
+   mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
+   if (mag) {
+      x[0] /= mag;
+      x[1] /= mag;
+      x[2] /= mag;
+   }
+
+   mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
+   if (mag) {
+      y[0] /= mag;
+      y[1] /= mag;
+      y[2] /= mag;
+   }
+
+#define M(row,col)  m[col*4+row]
+   M(0, 0) = x[0];
+   M(0, 1) = x[1];
+   M(0, 2) = x[2];
+   M(0, 3) = 0.0;
+   M(1, 0) = y[0];
+   M(1, 1) = y[1];
+   M(1, 2) = y[2];
+   M(1, 3) = 0.0;
+   M(2, 0) = z[0];
+   M(2, 1) = z[1];
+   M(2, 2) = z[2];
+   M(2, 3) = 0.0;
+   M(3, 0) = 0.0;
+   M(3, 1) = 0.0;
+   M(3, 2) = 0.0;
+   M(3, 3) = 1.0;
+#undef M
+   glMultMatrixf(m);
+
+   /* Translate Eye to Origin */
+   glTranslatef(-eyex, -eyey, -eyez);
+
+}
+
 static void
 drawscene(void)
 {
@@ -359,24 +467,24 @@ drawscene(void)
    dojoy();
 
    glShadeModel(GL_SMOOTH);
-   glEnable(GL_DEPTH_TEST);
+/*    glEnable(GL_DEPTH_TEST); */
 
    if (usetex)
       glEnable(GL_TEXTURE_2D);
    else
       glDisable(GL_TEXTURE_2D);
 
-   if (fog)
-      glEnable(GL_FOG);
-   else
-      glDisable(GL_FOG);
+/*    if (fog) */
+/*       glEnable(GL_FOG); */
+/*    else */
+/*       glDisable(GL_FOG); */
 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    glPushMatrix();
 
    calcposobs();
-   gluLookAt(obs[0], obs[1], obs[2],
+   lookAt(obs[0], obs[1], obs[2],
 	     obs[0] + dir[0], obs[1] + dir[1], obs[2] + dir[2],
 	     0.0, 1.0, 0.0);
 
@@ -384,8 +492,8 @@ drawscene(void)
    glPopMatrix();
 
    glDisable(GL_TEXTURE_2D);
-   glDisable(GL_DEPTH_TEST);
-   glDisable(GL_FOG);
+/*    glDisable(GL_DEPTH_TEST); */
+/*    glDisable(GL_FOG); */
    glShadeModel(GL_FLAT);
 
    glMatrixMode(GL_PROJECTION);
@@ -549,7 +657,7 @@ calccolor(GLfloat height, GLfloat c[3])
 static void
 loadpic(void)
 {
-   GLubyte bufferter[256 * 256], terrainpic[256 * 256];
+   GLubyte bufferter[256 * 256], terrainpic[256 * 256][4];
    FILE *FilePic;
    int i, tmp;
    GLenum gluerr;
@@ -565,25 +673,28 @@ loadpic(void)
       terrain[i] = (bufferter[i] * (heightMnt / 255.0f));
       calccolor((GLfloat) bufferter[i], terraincolor[i]);
       tmp = (((int) bufferter[i]) + 96);
-      terrainpic[i] = (tmp > 255) ? 255 : tmp;
+      terrainpic[i][0] = (tmp > 255) ? 255 : tmp;
+      terrainpic[i][1] = (tmp > 255) ? 255 : tmp;
+      terrainpic[i][2] = (tmp > 255) ? 255 : tmp;
+      terrainpic[i][0] = 255;
    }
 
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-   if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 1, 256, 256, GL_LUMINANCE,
+   if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, 256, 256, GL_RGBA,
 				   GL_UNSIGNED_BYTE,
-				   (GLvoid *) (&terrainpic[0])))) {
+				   (GLvoid *) (&terrainpic[0][0])))) {
       fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr));
       exit(-1);
    }
 
-   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
-   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 		   GL_LINEAR_MIPMAP_LINEAR);
-   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
-   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+   glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glEnable(GL_TEXTURE_2D);
 }
 
@@ -593,21 +704,21 @@ init(void)
    float fogcolor[4] = { 0.6, 0.7, 0.7, 1.0 };
 
    glClearColor(fogcolor[0], fogcolor[1], fogcolor[2], fogcolor[3]);
-   glClearDepth(1.0);
-   glDepthFunc(GL_LEQUAL);
+/*    glClearDepth(1.0); */
+/*    glDepthFunc(GL_LEQUAL); */
    glShadeModel(GL_SMOOTH);
-   glEnable(GL_DEPTH_TEST);
+/*    glEnable(GL_DEPTH_TEST); */
    glEnable(GL_CULL_FACE);
 
    glDisable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-   glEnable(GL_FOG);
-   glFogi(GL_FOG_MODE, GL_EXP2);
-   glFogfv(GL_FOG_COLOR, fogcolor);
-   glFogf(GL_FOG_DENSITY, 0.0007);
+/*    glEnable(GL_FOG); */
+/*    glFogi(GL_FOG_MODE, GL_EXP2); */
+/*    glFogfv(GL_FOG_COLOR, fogcolor); */
+/*    glFogf(GL_FOG_DENSITY, 0.0007); */
 #ifdef FX
-   glHint(GL_FOG_HINT, GL_NICEST);
+/*    glHint(GL_FOG_HINT, GL_NICEST); */
 #endif
 
    reshape(scrwidth, scrheight);

progs/demos/texobj.c

@@ -1,4 +1,4 @@
-/* $Id: texobj.c,v 1.6 2002/01/04 21:05:57 brianp Exp $ */
+/* $Id: texobj.c,v 1.6.6.1 2003/02/23 19:25:07 keithw Exp $ */
 
 /*
  * Example of using the 1.1 texture object functions.
@@ -17,7 +17,7 @@ static GLuint Window = 0;
 
 static GLuint TexObj[2];
 static GLfloat Angle = 0.0f;
-static GLboolean UseObj = GL_FALSE;
+static GLboolean UseObj = GL_TRUE;
 
 
 #if defined(GL_VERSION_1_1) || defined(GL_VERSION_1_2)
@@ -34,7 +34,7 @@ static GLboolean UseObj = GL_FALSE;
 
 static void draw( void )
 {
-   glDepthFunc(GL_EQUAL);
+/*    glDepthFunc(GL_EQUAL); */
    /*   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );*/
    glClear( GL_COLOR_BUFFER_BIT );
 
@@ -147,7 +147,7 @@ static void init( void )
      0, 0, 2, 2, 2, 2, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0 };
 
-   GLubyte tex[64][3];
+   GLubyte tex[64][4];
    GLint i, j;
 
 
@@ -156,7 +156,7 @@ static void init( void )
    /* Setup texturing */
    glEnable( GL_TEXTURE_2D );
    glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
-   glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST );
+/*    glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST ); */
 
 
    /* generate texture object IDs */
@@ -174,7 +174,7 @@ static void init( void )
    if (UseObj) {
 #ifdef TEXTURE_OBJECT
       glBindTexture( GL_TEXTURE_2D, TexObj[0] );
-      assert(glIsTexture(TexObj[0]));
+/*       assert(glIsTexture(TexObj[0])); */
 #endif
    }
    else {
@@ -190,11 +190,12 @@ static void init( void )
          else {
             tex[p][0] = 255;   tex[p][1] = 255;   tex[p][2] = 255;
          }
+	 tex[p][3] = 255;
       }
    }
 
-   glTexImage2D( GL_TEXTURE_2D, 0, 3, width, height, 0,
-                 GL_RGB, GL_UNSIGNED_BYTE, tex );
+   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
+                 GL_RGBA, GL_UNSIGNED_BYTE, tex );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
@@ -208,9 +209,9 @@ static void init( void )
    if (UseObj) {
 #ifdef TEXTURE_OBJECT
       glBindTexture( GL_TEXTURE_2D, TexObj[1] );
-      assert(glIsTexture(TexObj[1]));
+/*       assert(glIsTexture(TexObj[1])); */
 #endif
-      assert(!glIsTexture(TexObj[1] + 999));
+/*       assert(!glIsTexture(TexObj[1] + 999)); */
    }
    else {
       glNewList( TexObj[1], GL_COMPILE );
@@ -227,8 +228,8 @@ static void init( void )
          }
       }
    }
-   glTexImage2D( GL_TEXTURE_2D, 0, 3, width, height, 0,
-                 GL_RGB, GL_UNSIGNED_BYTE, tex );
+   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
+                 GL_RGBA, GL_UNSIGNED_BYTE, tex );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );

progs/demos/tunnel.c

@@ -498,7 +498,7 @@ main(int ac, char **av)
    glEnable(GL_CULL_FACE);
    glEnable(GL_TEXTURE_2D);
 
-   glEnable(GL_FOG);
+/*    glEnable(GL_FOG); */
    glFogi(GL_FOG_MODE, GL_EXP2);
    glFogfv(GL_FOG_COLOR, fogcolor);
 

progs/samples/Makefile

@@ -0,0 +1,28 @@
+
+PROGS = prim \
+	star \
+	line \
+	point \
+	depth \
+	tri \
+	bitmap1 \
+	bitmap2
+
+
+##### RULES #####
+
+.SUFFIXES:
+.SUFFIXES: .c
+
+
+# make executable from .c file:
+.c: $(LIB_DEP)
+	gcc -I../include -g $< -L../lib -lglut -lGL -lm -o $@
+
+
+default: $(PROGS)
+
+
+clean:
+	-rm *.o *~
+

progs/samples/bitmap1.c

@@ -104,7 +104,7 @@ static void Init(void)
 {
 
     glClearColor(0.0, 0.0, 0.0, 0.0);
-    glClearIndex(0.0);
+/*     glClearIndex(0.0); */
 }
 
 static void Reshape(int width, int height)
@@ -140,14 +140,14 @@ static void Draw(void)
     mapIA[0] = 1.0;
     mapIA[1] = 1.0;
     
-    glPixelMapfv(GL_PIXEL_MAP_I_TO_R, 2, mapIR);
-    glPixelMapfv(GL_PIXEL_MAP_I_TO_G, 2, mapI);
-    glPixelMapfv(GL_PIXEL_MAP_I_TO_B, 2, mapI);
-    glPixelMapfv(GL_PIXEL_MAP_I_TO_A, 2, mapIA);
-    glPixelTransferi(GL_MAP_COLOR, GL_TRUE);
+/*     glPixelMapfv(GL_PIXEL_MAP_I_TO_R, 2, mapIR); */
+/*     glPixelMapfv(GL_PIXEL_MAP_I_TO_G, 2, mapI); */
+/*     glPixelMapfv(GL_PIXEL_MAP_I_TO_B, 2, mapI); */
+/*     glPixelMapfv(GL_PIXEL_MAP_I_TO_A, 2, mapIA); */
+/*     glPixelTransferi(GL_MAP_COLOR, GL_TRUE); */
     
     SetColor(COLOR_WHITE);
-    glRasterPos3fv(boxA);
+    glRasterPos2fv(boxA);
     glPixelStorei(GL_UNPACK_ROW_LENGTH, 24);
     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 8);
     glPixelStorei(GL_UNPACK_SKIP_ROWS, 2);
@@ -162,28 +162,28 @@ static void Draw(void)
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
     SetColor(COLOR_WHITE);
-    glRasterPos3fv(boxB);
+    glRasterPos2fv(boxB);
     glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0,
 	     OpenGL_bits1);
     glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0,
 	     OpenGL_bits2);
 
     SetColor(COLOR_YELLOW);
-    glRasterPos3fv(boxC);
+    glRasterPos2fv(boxC);
     glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0,
 	     OpenGL_bits1);
     glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0,
 	     OpenGL_bits2);
 
     SetColor(COLOR_CYAN);
-    glRasterPos3fv(boxD);
+    glRasterPos2fv(boxD);
     glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0,
 	     OpenGL_bits1);
     glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0,
 	     OpenGL_bits2);
 
     SetColor(COLOR_RED);
-    glRasterPos3fv(boxE);
+    glRasterPos2fv(boxE);
     glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0,
 	     OpenGL_bits1);
     glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, OPENGL_WIDTH, 0.0, OPENGL_WIDTH, 0.0,

progs/samples/bitmap2.c

@@ -620,19 +620,19 @@ static void Init(void)
     GLint i;
 
     glClearColor(0.0, 0.0, 0.0, 0.0);
-    glClearIndex(0.0);
+/*     glClearIndex(0.0); */
 
     glPixelStorei(GL_UNPACK_LSB_FIRST, GL_TRUE);
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     for (i = 0; i < 7; i++) {
-	exp_lists[i] = glGenLists(1);
-	glNewList(exp_lists[i], GL_COMPILE);
-	    glBitmap(80, 80, 40.0, 40.0, 0.0, 0.0, exp_bits[i]);
-	glEndList();
+/* 	exp_lists[i] = glGenLists(1); */
+/* 	glNewList(exp_lists[i], GL_COMPILE); */
+/* 	    glBitmap(80, 80, 40.0, 40.0, 0.0, 0.0, exp_bits[i]); */
+/* 	glEndList(); */
     }
 
     abuse = GL_FALSE;
-    useLists = GL_TRUE;
+    useLists = GL_FALSE;
 }
 
 static void Reshape(int width, int height)
@@ -696,10 +696,10 @@ static void Draw(void)
 		SetColor(COLOR_RED);
 		break;
 	    }
-	    glRasterPos3i((j*3)%5, (j*3)%8, 0);
+	    glRasterPos2i((j*3)%5, (j*3)%8);
 
 	    if (useLists) {
-	    	glCallList(exp_lists[i]); 
+/* 	    	glCallList(exp_lists[i]);  */
 	    } else {
 		glBitmap(80, 80, 40.0, 40.0, 0.0, 0.0, exp_bits[i]);
 	    }
@@ -714,9 +714,9 @@ static void Draw(void)
 
 	for (j = 0; j < 40; j++) {
 	    SetColor(COLOR_BLACK);
-	    glRasterPos3i((j*3)%5, (j*3)%8, 0);
+	    glRasterPos2i((j*3)%5, (j*3)%8);
 	    if (useLists) {
-		glCallList(exp_lists[i]); 
+/* 		glCallList(exp_lists[i]);  */
 	    } else {
 		glBitmap(80, 80, 40.0, 40.0, 0.0, 0.0, exp_bits[i]);
 	    }

progs/samples/line.c

@@ -147,7 +147,7 @@ static void Draw(void)
 	    glVertex3fv(pntB);
 	glEnd();
 
-	glPointSize(1);
+/* 	glPointSize(1); */
 
 	SetColor(COLOR_GREEN);
 	glBegin(GL_POINTS);

progs/samples/logo.c

@@ -1,4 +1,4 @@
-/* $Id: logo.c,v 1.2 1999/12/15 13:02:09 brianp Exp $ */
+/* $Id: logo.c,v 1.3 2002/11/05 20:59:16 brianp Exp $ */
 
 /*
  * Copyright (c) 1991, 1992, 1993 Silicon Graphics, Inc.
@@ -1397,12 +1397,15 @@ static void Key(unsigned char key, int x, int y)
 	switch (polyMode) {
 	  case GL_BACK:
 	    polyMode = GL_FRONT;
+            printf("PolygonMode GL_FRONT\n");
 	    break;
 	  case GL_FRONT:
 	    polyMode = GL_FRONT_AND_BACK;
+            printf("PolygonMode GL_FRONT_AND_BACK\n");
 	    break;
 	  case GL_FRONT_AND_BACK:
 	    polyMode = GL_BACK;
+            printf("PolygonMode GL_BACK\n");
 	    break;
           default:
             break;
@@ -1455,14 +1458,17 @@ static void Key(unsigned char key, int x, int y)
 
       case 'q':
 	glDisable(GL_CULL_FACE);
+        printf("disable culling\n");
 	break;
       case 'w':
 	glEnable(GL_CULL_FACE);
 	glCullFace(GL_FRONT);
+        printf("enable front face culling\n");
 	break;
       case 'e':
 	glEnable(GL_CULL_FACE);
 	glCullFace(GL_BACK);
+        printf("enable back face culling\n");
 	break;
 
       case 'r':

progs/samples/point.c

@@ -151,7 +151,7 @@ static void Draw(void)
 	glDisable(GL_POINT_SMOOTH);
     }
 
-    glPointSize(size);
+/*     glPointSize(size); */
     if (mode) {
 	(rgb) ? glColor3f(1.0, 0.0, 0.0) : glIndexf(CI_ANTI_ALIAS_RED);
     } else {
@@ -164,7 +164,7 @@ static void Draw(void)
     glDisable(GL_POINT_SMOOTH);
     glDisable(GL_BLEND);
 
-    glPointSize(1);
+/*     glPointSize(1); */
     SetColor(COLOR_GREEN);
     glBegin(GL_POINTS);
 	glVertex3fv(point);

progs/samples/prim.c

@@ -52,27 +52,27 @@ static void Reshape(int width, int height)
     windH = (GLint)height;
 }
 
-static void RotateColorMask(void)
+static void RotateRestoreColorMask( int rotate )
 {
     static GLint rotation = 0;
     
-    rotation = (rotation + 1) & 0x3;
+    if (rotate) rotation = (rotation + 1) & 0x3;
     switch (rotation) {
       case 0:
 	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-	glIndexMask( 0xff );
+/* 	glIndexMask( 0xff ); */
 	break;
       case 1:
 	glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE);
-	glIndexMask(0xFE);
+/* 	glIndexMask(0xFE); */
 	break;
       case 2:
 	glColorMask(GL_TRUE, GL_FALSE, GL_TRUE, GL_TRUE);
-	glIndexMask(0xFD);
+/* 	glIndexMask(0xFD); */
 	break;
       case 3:
 	glColorMask(GL_TRUE, GL_TRUE, GL_FALSE, GL_TRUE);
-	glIndexMask(0xFB);
+/* 	glIndexMask(0xFB); */
 	break;
     }
 }
@@ -90,7 +90,7 @@ static void Key(unsigned char key, int x, int y)
 	mode2 = !mode2;
 	break;
       case '3':
-	RotateColorMask();
+	RotateRestoreColorMask( 1 );
 	break;
       default:
 	return;
@@ -344,7 +344,7 @@ static void Rect(void)
 {
 
     SetColor(COLOR_GREEN);
-    glRecti(-boxW/4, -boxH/4, boxW/4, boxH/4);
+/*     glRecti(-boxW/4, -boxH/4, boxW/4, boxH/4); */
 }
 
 static void PolygonFunc(void)
@@ -445,15 +445,16 @@ static void Draw(void)
     glViewport(0, 0, windW, windH);
     glDisable(GL_SCISSOR_TEST);
 
-    glPushAttrib(GL_COLOR_BUFFER_BIT);
+/*     glPushAttrib(GL_COLOR_BUFFER_BIT); */
 
     glColorMask(1, 1, 1, 1);
-    glIndexMask(~0);
+/*     glIndexMask(~0); */
 
     glClearColor(0.0, 0.0, 0.0, 0.0);
     glClear(GL_COLOR_BUFFER_BIT);
 
-    glPopAttrib();
+/*     glPopAttrib(); */
+    RotateRestoreColorMask( 0 );
 
     if (mode1) {
 	glShadeModel(GL_SMOOTH);
@@ -461,11 +462,11 @@ static void Draw(void)
 	glShadeModel(GL_FLAT);
     }
 
-    if (mode2) {
-	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-    } else {
-	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-    }
+/*     if (mode2) { */
+/* 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); */
+/*     } else { */
+/* 	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); */
+/*     } */
 
     Viewport(0, 0); Point();
     Viewport(0, 1); Lines();
@@ -478,10 +479,13 @@ static void Draw(void)
     Viewport(1, 2); Triangles();
     Viewport(1, 3); TriangleStrip();
 
+
     Viewport(2, 0); Rect();
     Viewport(2, 1); PolygonFunc();
     Viewport(2, 2); Quads();
     Viewport(2, 3); QuadStrip();
+    if (0) {
+    }
 
     glFlush();
 

progs/samples/tri.c

@@ -279,11 +279,11 @@ static void Draw(void)
 
 	if (showVerticies) {
 	    (rgb) ? glColor3fv(RGBMap[COLOR_RED]) : glIndexf(color1);
-	    glRectf(p0[0]-2, p0[1]-2, p0[0]+2, p0[1]+2);
+/* 	    glRectf(p0[0]-2, p0[1]-2, p0[0]+2, p0[1]+2); */
 	    (rgb) ? glColor3fv(RGBMap[COLOR_GREEN]) : glIndexf(color2);
-	    glRectf(p1[0]-2, p1[1]-2, p1[0]+2, p1[1]+2);
+/* 	    glRectf(p1[0]-2, p1[1]-2, p1[0]+2, p1[1]+2); */
 	    (rgb) ? glColor3fv(RGBMap[COLOR_BLUE]) : glIndexf(color3);
-	    glRectf(p2[0]-2, p2[1]-2, p2[0]+2, p2[1]+2);
+/* 	    glRectf(p2[0]-2, p2[1]-2, p2[0]+2, p2[1]+2); */
 	}
 
 	glPopMatrix();
@@ -306,7 +306,7 @@ static void Draw(void)
     glScalef(zoom, zoom, zoom);
     glRotatef(zRotation, 0,0,1);
 
-    glPointSize(10);
+/*     glPointSize(10); */
     glLineWidth(5);
     glEnable(GL_POINT_SMOOTH);
     glEnable(GL_LINE_STIPPLE);
@@ -322,7 +322,7 @@ static void Draw(void)
 	glVertex3fv(p2);
     EndPrim();
 
-    glPointSize(1);
+/*     glPointSize(1); */
     glLineWidth(1);
     glDisable(GL_POINT_SMOOTH);
     glDisable(GL_LINE_STIPPLE);

progs/tests/Makefile

@@ -1,29 +1,14 @@
 
 # Simple makefile for compiling test programs on Linux
 # These programs aren't intended to be included with the normal
-# distro as they're not too interesting but good for testing during
-# development.
+# distro.  They're not too interesting but they're good for testing.
 
 
 CC = gcc
 CFLAGS = -g -I../include
-LIBS = -L../lib -lglut -lGLU -lGL -L/usr/X11R6/lib -lX11 -lXext -lm
+LIBS = -L../lib -lGL -lglut -lm
 
-PROGS = cva \
-	dinoshade \
-	fogcoord \
-	manytex \
-	multipal \
-	projtex \
-	seccolor \
-	sharedtex \
-	texline \
-	texwrap \
-	vptest1 \
-	vptest2 \
-	vptest3 \
-	vptorus \
-	vpwarpmesh
+PROGS = miniglxtest miniglxsample manytex 
 
 
 ##### RULES #####
@@ -42,3 +27,4 @@ default: $(PROGS)
 clean:
 	rm -f $(PROGS)
 	rm -f *.o
+

progs/tests/antialias.c

@@ -0,0 +1,226 @@
+/* $Id: antialias.c,v 1.1 2002/11/08 18:30:26 brianp Exp $ */
+
+/*
+ * Test multisampling and polygon smoothing.
+ *
+ * Brian Paul
+ * 4 November 2002
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <GL/glut.h>
+
+
+static GLfloat Zrot = 0;
+static GLboolean Anim = GL_TRUE;
+static GLboolean HaveMultisample = GL_TRUE;
+
+
+static void
+PrintString(const char *s)
+{
+   while (*s) {
+      glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s);
+      s++;
+   }
+}
+
+
+static void
+Polygon( GLint verts, GLfloat radius, GLfloat z )
+{
+   int i;
+   for (i = 0; i < verts; i++) {
+      float a = (i * 2.0 * 3.14159) / verts;
+      float x = radius * cos(a);
+      float y = radius * sin(a);
+      glVertex3f(x, y, z);
+   }
+}
+
+
+static void
+DrawObject( void )
+{
+   glLineWidth(3.0);
+   glColor3f(1, 1, 1);
+   glBegin(GL_LINE_LOOP);
+   Polygon(12, 1.2, 0);
+   glEnd();
+
+   glLineWidth(1.0);
+   glColor3f(1, 1, 1);
+   glBegin(GL_LINE_LOOP);
+   Polygon(12, 1.1, 0);
+   glEnd();
+
+   glColor3f(1, 0, 0);
+   glBegin(GL_POLYGON);
+   Polygon(12, 0.4, 0.3);
+   glEnd();
+
+   glColor3f(0, 1, 0);
+   glBegin(GL_POLYGON);
+   Polygon(12, 0.6, 0.2);
+   glEnd();
+
+   glColor3f(0, 0, 1);
+   glBegin(GL_POLYGON);
+   Polygon(12, 0.8, 0.1);
+   glEnd();
+
+   glColor3f(1, 1, 1);
+   glBegin(GL_POLYGON);
+   Polygon(12, 1.0, 0);
+   glEnd();
+}
+
+
+static void
+Display( void )
+{
+   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+   glColor3f(1, 1, 1);
+   if (HaveMultisample) {
+      glRasterPos2f(-3.1, -1.6);
+      PrintString("MULTISAMPLE");
+   }
+   glRasterPos2f(-0.8, -1.6);
+   PrintString("No antialiasing");
+   glRasterPos2f(1.6, -1.6);
+   PrintString("GL_POLYGON_SMOOTH");
+
+   /* multisample */
+   if (HaveMultisample) {
+      glEnable(GL_DEPTH_TEST);
+      glEnable(GL_MULTISAMPLE_ARB);
+      glPushMatrix();
+      glTranslatef(-2.5, 0, 0);
+      glPushMatrix();
+      glRotatef(Zrot, 0, 0, 1);
+      DrawObject();
+      glPopMatrix();
+      glPopMatrix();
+      glDisable(GL_MULTISAMPLE_ARB);
+      glDisable(GL_DEPTH_TEST);
+   }
+
+   /* non-aa */
+   glEnable(GL_DEPTH_TEST);
+   glPushMatrix();
+   glTranslatef(0, 0, 0);
+   glPushMatrix();
+   glRotatef(Zrot, 0, 0, 1);
+   DrawObject();
+   glPopMatrix();
+   glPopMatrix();
+   glDisable(GL_DEPTH_TEST);
+
+   /* polygon smooth */
+   glEnable(GL_POLYGON_SMOOTH);
+   glEnable(GL_LINE_SMOOTH);
+   glEnable(GL_BLEND);
+   glPushMatrix();
+   glTranslatef(2.5, 0, 0);
+   glPushMatrix();
+   glRotatef(Zrot, 0, 0, 1);
+   DrawObject();
+   glPopMatrix();
+   glPopMatrix();
+   glDisable(GL_LINE_SMOOTH);
+   glDisable(GL_POLYGON_SMOOTH);
+   glDisable(GL_BLEND);
+
+   glutSwapBuffers();
+}
+
+
+static void
+Reshape( int width, int height )
+{
+   GLfloat ar = (float) width / (float) height;
+   glViewport( 0, 0, width, height );
+   glMatrixMode( GL_PROJECTION );
+   glLoadIdentity();
+   glOrtho(-2.0*ar, 2.0*ar, -2.0, 2.0, -1.0, 1.0);
+   glMatrixMode( GL_MODELVIEW );
+   glLoadIdentity();
+}
+
+
+static void
+Idle( void )
+{
+   Zrot = 0.01 * glutGet(GLUT_ELAPSED_TIME);
+   glutPostRedisplay();
+}
+
+
+static void
+Key( unsigned char key, int x, int y )
+{
+   const GLfloat step = 1.0;
+   (void) x;
+   (void) y;
+   switch (key) {
+      case 'a':
+         Anim = !Anim;
+         if (Anim)
+            glutIdleFunc(Idle);
+         else
+            glutIdleFunc(NULL);
+         break;
+      case 'z':
+         Zrot = (int) (Zrot - step);
+         break;
+      case 'Z':
+         Zrot = (int) (Zrot + step);
+         break;
+      case 27:
+         exit(0);
+         break;
+   }
+   glutPostRedisplay();
+}
+
+
+static void
+Init( void )
+{
+   /* GLUT imposes the four samples/pixel requirement */
+   int s;
+   glGetIntegerv(GL_SAMPLES_ARB, &s);
+   if (!glutExtensionSupported("GL_ARB_multisample") || s < 1) {
+      printf("Warning: multisample antialiasing not supported.\n");
+      HaveMultisample = GL_FALSE;
+   }
+   printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
+   printf("GL_SAMPLES_ARB = %d\n", s);
+
+   glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+   glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE);
+}
+
+
+int
+main( int argc, char *argv[] )
+{
+   glutInit( &argc, argv );
+   glutInitWindowPosition( 0, 0 );
+   glutInitWindowSize( 600, 300 );
+   glutInitDisplayMode( GLUT_RGB | GLUT_ALPHA | GLUT_DOUBLE |
+                        GLUT_DEPTH | GLUT_MULTISAMPLE );
+   glutCreateWindow(argv[0]);
+   glutReshapeFunc( Reshape );
+   glutKeyboardFunc( Key );
+   glutDisplayFunc( Display );
+   if (Anim)
+      glutIdleFunc( Idle );
+   Init();
+   glutMainLoop();
+   return 0;
+}

progs/tests/functions.py

@@ -1,56 +0,0 @@
-#!/usr/bin/env python
-
-# $Id: functions.py,v 1.1 2001/11/18 23:16:56 brianp Exp $
-
-# Helper for the getprocaddress.c test.
-
-
-import string
-
-def PrintHead():
-	print """
-static const char *functions[] = {"""
-
-
-def PrintTail():
-	print"""
-   NULL
-};
-"""
-
-
-def PrintFunctions(specFile):
-
-	# init some vars
-	prevCategory = ''
-	funcName = ''
-
-	f = open(specFile)
-	for line in f.readlines():
-
-		# split line into tokens
-		tokens = string.split(line)
-
-		if len(tokens) > 0 and line[0] != '#':
-
-			if tokens[0] == 'name':
-				if funcName != '':
-					if category != prevCategory:
-						print '   "-%s",' % category
-						prevCategory = category
-
-					print '   "gl%s",' % funcName
-				funcName = tokens[1]
-
-			elif tokens[0] == 'category':
-				category = tokens[1]
-
-			#endif
-		#endif
-	#endfor
-#enddef
-
-
-PrintHead()
-PrintFunctions("../bin/APIspec")
-PrintTail()

progs/tests/getprocaddress.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+
+# $Id: getprocaddress.py,v 1.2 2002/11/08 15:49:31 brianp Exp $
+
+# Helper for the getprocaddress.c test.
+
+
+import re, string
+
+
+def PrintHead():
+	print """
+struct name_test_pair {
+   const char *name;
+   GLboolean (*test)(void *);
+};
+   
+static struct name_test_pair functions[] = {"""
+
+
+def PrintTail():
+	print"""
+   { NULL, NULL }
+};
+"""
+
+
+def HaveTest(function):
+	testFuncs = [
+		"glActiveTextureARB",
+		"glSampleCoverageARB"
+	]
+	if function in testFuncs:
+		return 1
+	else:
+		return 0
+
+
+def FindTestFunctions():
+	"""Scan getprocaddress.c for lines that start with "test_" to find
+	extension function tests.  Return a list of names found."""
+	functions = []
+	f = open("getprocaddress.c")
+	if not f:
+		return functions
+	for line in f.readlines():
+		v = re.search("^test_([a-zA-Z0-9]+)", line)
+		if v:
+			func = v.group(1)
+			functions.append(func)
+	f.close
+	return functions
+
+
+def PrintFunctions(specFile, tests):
+
+	# init some vars
+	prevCategory = ''
+	funcName = ''
+
+	f = open(specFile)
+	for line in f.readlines():
+
+		# split line into tokens
+		tokens = string.split(line)
+
+		if len(tokens) > 0 and line[0] != '#':
+
+			if tokens[0] == 'name':
+				if funcName != '':
+					if category != prevCategory:
+						print '   { "-%s", NULL},' % category
+						prevCategory = category
+
+					if funcName in tests:
+						test = "test_%s" % funcName
+					else:
+						test = "NULL"
+					print '   { "gl%s", %s },' % (funcName, test)
+				funcName = tokens[1]
+
+			elif tokens[0] == 'category':
+				category = tokens[1]
+
+			#endif
+		#endif
+	#endfor
+#enddef
+
+
+tests = FindTestFunctions()
+PrintHead()
+PrintFunctions("../bin/APIspec", tests)
+PrintTail()
+
+

progs/tests/glfbdevtest.c

@@ -0,0 +1,478 @@
+/* $Id: glfbdevtest.c,v 1.1.4.5 2002/11/27 00:26:59 brianp Exp $ */
+
+/*
+ * Test the GLFBDev interface.   Only tested with radeonfb driver!!!!
+ */
+
+
+#include <assert.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <linux/fb.h>
+#include <linux/kd.h>
+#include <linux/vt.h>
+#include <GL/glut.h>
+#include "GL/glfbdev.h"
+
+#define DEFAULT_DEPTH 8
+
+static struct fb_fix_screeninfo FixedInfo;
+static struct fb_var_screeninfo VarInfo, OrigVarInfo;
+static int DesiredDepth = 0;
+static int OriginalVT = -1;
+static int ConsoleFD = -1;
+static int FrameBufferFD = -1;
+static caddr_t FrameBuffer = (caddr_t) -1;
+static caddr_t MMIOAddress = (caddr_t) -1;
+
+
+static void
+print_fixed_info(const struct fb_fix_screeninfo *fixed, const char *s)
+{
+   static const char *visuals[] = {
+      "MONO01", "MONO10", "TRUECOLOR", "PSEUDOCOLOR",
+      "DIRECTCOLOR", "STATIC_PSEUDOCOLOR"
+   };
+
+   printf("%s info -----------------------\n", s);
+   printf("id = %16s\n", fixed->id);
+   printf("smem_start = 0x%x\n", fixed->smem_start);
+   printf("smem_len = %d (0x%x)\n", fixed->smem_len, fixed->smem_len);
+   printf("type = 0x%x\n", fixed->type);
+   printf("type_aux = 0x%x\n", fixed->type_aux);
+   printf("visual = 0x%x (%s)\n", fixed->visual, visuals[fixed->visual]);
+   printf("xpanstep = %d\n", fixed->xpanstep);
+   printf("ypanstep = %d\n", fixed->ypanstep);
+   printf("ywrapstep = %d\n", fixed->ywrapstep);
+   printf("line_length = %d\n", fixed->line_length);
+   printf("mmio_start = 0x%x\n", fixed->mmio_start);
+   printf("mmio_len = %d (0x%x)\n", fixed->mmio_len, fixed->mmio_len);
+   printf("accel = 0x%x\n", fixed->accel);
+}
+
+
+static void
+print_var_info(const struct fb_var_screeninfo *var, const char *s)
+{
+   printf("%s info -----------------------\n", s);
+   printf("xres = %d\n", var->xres);
+   printf("yres = %d\n", var->yres);
+   printf("xres_virtual = %d\n", var->xres_virtual);
+   printf("yres_virtual = %d\n", var->yres_virtual);
+   printf("xoffset = %d\n", var->xoffset);
+   printf("yoffset = %d\n", var->yoffset);
+   printf("bits_per_pixel = %d\n", var->bits_per_pixel);
+   printf("grayscale = %d\n", var->grayscale);
+
+   printf("red.offset = %d  length = %d  msb_right = %d\n",
+          var->red.offset, var->red.length, var->red.msb_right);
+   printf("green.offset = %d  length = %d  msb_right = %d\n",
+          var->green.offset, var->green.length, var->green.msb_right);
+   printf("blue.offset = %d  length = %d  msb_right = %d\n",
+          var->blue.offset, var->blue.length, var->blue.msb_right);
+   printf("transp.offset = %d  length = %d  msb_right = %d\n",
+          var->transp.offset, var->transp.length, var->transp.msb_right);
+
+   printf("nonstd = %d\n", var->nonstd);
+   printf("activate = %d\n", var->activate);
+   printf("height = %d mm\n", var->height);
+   printf("width = %d mm\n", var->width);
+   printf("accel_flags = 0x%x\n", var->accel_flags);
+   printf("pixclock = %d\n", var->pixclock);
+   printf("left_margin = %d\n", var->left_margin);
+   printf("right_margin = %d\n", var->right_margin);
+   printf("upper_margin = %d\n", var->upper_margin);
+   printf("lower_margin = %d\n", var->lower_margin);
+   printf("hsync_len = %d\n", var->hsync_len);
+   printf("vsync_len = %d\n", var->vsync_len);
+   printf("sync = %d\n", var->sync);
+   printf("vmode = %d\n", var->vmode);
+}
+
+
+static void
+signal_handler(int signumber)
+{
+   signal(signumber, SIG_IGN); /* prevent recursion! */
+   fprintf(stderr, "error: got signal %d (exiting)\n", signumber);
+   exit(1);
+}
+
+
+static void
+initialize_fbdev( void )
+{
+   char ttystr[1000];
+   int fd, vtnumber, ttyfd;
+   int sz;
+
+   if (geteuid()) {
+      fprintf(stderr, "error: you need to be root\n");
+      exit(1);
+   }
+
+#if 1
+   /* open the framebuffer device */
+   FrameBufferFD = open("/dev/fb0", O_RDWR);
+   if (FrameBufferFD < 0) {
+      fprintf(stderr, "Error opening /dev/fb0: %s\n", strerror(errno));
+      exit(1);
+   }
+#endif
+
+   /* open /dev/tty0 and get the vt number */
+   if ((fd = open("/dev/tty0", O_WRONLY, 0)) < 0) {
+      fprintf(stderr, "error opening /dev/tty0\n");
+      exit(1);
+   }
+   if (ioctl(fd, VT_OPENQRY, &vtnumber) < 0 || vtnumber < 0) {
+      fprintf(stderr, "error: couldn't get a free vt\n");
+      exit(1);
+   }
+   close(fd);
+
+   /* open the console tty */
+   sprintf(ttystr, "/dev/tty%d", vtnumber);  /* /dev/tty1-64 */
+   ConsoleFD = open(ttystr, O_RDWR | O_NDELAY, 0);
+   if (ConsoleFD < 0) {
+      fprintf(stderr, "error couldn't open console fd\n");
+      exit(1);
+   }
+
+   /* save current vt number */
+   {
+      struct vt_stat vts;
+      if (ioctl(ConsoleFD, VT_GETSTATE, &vts) == 0)
+         OriginalVT = vts.v_active;
+   }
+
+   /* disconnect from controlling tty */
+   ttyfd = open("/dev/tty", O_RDWR);
+   if (ttyfd >= 0) {
+      ioctl(ttyfd, TIOCNOTTY, 0);
+      close(ttyfd);
+   }
+
+   /* some magic to restore the vt when we exit */
+   {
+      struct vt_mode vt;
+      if (ioctl(ConsoleFD, VT_ACTIVATE, vtnumber) != 0)
+         printf("ioctl VT_ACTIVATE: %s\n", strerror(errno));
+      if (ioctl(ConsoleFD, VT_WAITACTIVE, vtnumber) != 0)
+         printf("ioctl VT_WAITACTIVE: %s\n", strerror(errno));
+
+      if (ioctl(ConsoleFD, VT_GETMODE, &vt) < 0) {
+         fprintf(stderr, "error: ioctl VT_GETMODE: %s\n", strerror(errno));
+         exit(1);
+      }
+
+      vt.mode = VT_PROCESS;
+      vt.relsig = SIGUSR1;
+      vt.acqsig = SIGUSR1;
+      if (ioctl(ConsoleFD, VT_SETMODE, &vt) < 0) {
+         fprintf(stderr, "error: ioctl(VT_SETMODE) failed: %s\n",
+                 strerror(errno));
+         exit(1);
+      }
+   }
+
+   /* go into graphics mode */
+   if (ioctl(ConsoleFD, KDSETMODE, KD_GRAPHICS) < 0) {
+      fprintf(stderr, "error: ioctl(KDSETMODE, KD_GRAPHICS) failed: %s\n",
+              strerror(errno));
+      exit(1);
+   }
+
+
+#if 0
+   /* open the framebuffer device */
+   FrameBufferFD = open("/dev/fb0", O_RDWR);
+   if (FrameBufferFD < 0) {
+      fprintf(stderr, "Error opening /dev/fb0: %s\n", strerror(errno));
+      exit(1);
+   }
+#endif
+
+   /* Get the fixed screen info */
+   if (ioctl(FrameBufferFD, FBIOGET_FSCREENINFO, &FixedInfo)) {
+      fprintf(stderr, "error: ioctl(FBIOGET_FSCREENINFO) failed: %s\n",
+              strerror(errno));
+      exit(1);
+   }
+
+   print_fixed_info(&FixedInfo, "Fixed");
+
+
+  /* get the variable screen info */
+   if (ioctl(FrameBufferFD, FBIOGET_VSCREENINFO, &OrigVarInfo)) {
+      fprintf(stderr, "error: ioctl(FBIOGET_VSCREENINFO) failed: %s\n",
+              strerror(errno));
+      exit(1);
+   }
+
+   print_var_info(&OrigVarInfo, "Orig Var");
+
+   /* operate on a copy */
+   VarInfo = OrigVarInfo;
+
+   /* set the depth, resolution, etc */
+   DesiredDepth = 32;
+   if (DesiredDepth)
+      VarInfo.bits_per_pixel = DesiredDepth;
+
+   if (VarInfo.bits_per_pixel == 16) {
+      VarInfo.red.offset = 11;
+      VarInfo.green.offset = 5;
+      VarInfo.blue.offset = 0;
+      VarInfo.red.length = 5;
+      VarInfo.green.length = 6;
+      VarInfo.blue.length = 5;
+      VarInfo.transp.offset = 0;
+      VarInfo.transp.length = 0;
+   }
+   else if (VarInfo.bits_per_pixel == 32) {
+      VarInfo.red.offset = 16;
+      VarInfo.green.offset = 8;
+      VarInfo.blue.offset = 0;
+      VarInfo.transp.offset = 24;
+      VarInfo.red.length = 8;
+      VarInfo.green.length = 8;
+      VarInfo.blue.length = 8;
+      VarInfo.transp.length = 8;
+   }
+   /* timing values taken from /etc/fb.modes (1280x1024 @ 75Hz) */
+   VarInfo.xres_virtual = VarInfo.xres = 1280;
+   VarInfo.yres_virtual = VarInfo.yres = 1024;
+   VarInfo.pixclock = 7408;
+   VarInfo.left_margin = 248;
+   VarInfo.right_margin = 16;
+   VarInfo.upper_margin = 38;
+   VarInfo.lower_margin = 1;
+   VarInfo.hsync_len = 144;
+   VarInfo.vsync_len = 3;
+
+   VarInfo.xoffset = 0;
+   VarInfo.yoffset = 0;
+   VarInfo.nonstd = 0;
+   VarInfo.vmode &= ~FB_VMODE_YWRAP; /* turn off scrolling */
+
+   /* set new variable screen info */
+   if (ioctl(FrameBufferFD, FBIOPUT_VSCREENINFO, &VarInfo)) {
+      fprintf(stderr, "ioctl(FBIOPUT_VSCREENINFO failed): %s\n",
+              strerror(errno));
+      exit(1);
+   }
+
+   print_var_info(&VarInfo, "New Var");
+
+   if (FixedInfo.visual != FB_VISUAL_TRUECOLOR &&
+       FixedInfo.visual != FB_VISUAL_DIRECTCOLOR) {
+      fprintf(stderr, "non-TRUE/DIRECT-COLOR visuals (0x%x) not supported by this demo.\n", FixedInfo.visual);
+      exit(1);
+   }
+
+   /* initialize colormap */
+   if (FixedInfo.visual == FB_VISUAL_DIRECTCOLOR) {
+      struct fb_cmap cmap;
+      unsigned short red[256], green[256], blue[256];
+      int i;
+
+      /* we're assuming 256 entries here */
+      printf("initializing directcolor colormap\n");
+      cmap.start = 0;
+      cmap.len = 256;
+      cmap.red   = red;
+      cmap.green = green;
+      cmap.blue  = blue;
+      cmap.transp = NULL;
+      for (i = 0; i < cmap.len; i++) {
+         red[i] = green[i] = blue[i] = (i << 8) | i;
+      }
+      if (ioctl(FrameBufferFD, FBIOPUTCMAP, (void *) &cmap) < 0) {
+         fprintf(stderr, "ioctl(FBIOPUTCMAP) failed [%d]\n", i);
+      }
+   }
+
+   /*
+    * fbdev says the frame buffer is at offset zero, and the mmio region
+    * is immediately after.
+    */
+
+   /* mmap the framebuffer into our address space */
+   FrameBuffer = (caddr_t) mmap(0, /* start */
+                                FixedInfo.smem_len, /* bytes */
+                                PROT_READ | PROT_WRITE, /* prot */
+                                MAP_SHARED, /* flags */
+                                FrameBufferFD, /* fd */
+                                0 /* offset */);
+   if (FrameBuffer == (caddr_t) - 1) {
+      fprintf(stderr, "error: unable to mmap framebuffer: %s\n",
+              strerror(errno));
+      exit(1);
+   }
+   printf("FrameBuffer = %p\n", FrameBuffer);
+
+#if 1
+   /* mmap the MMIO region into our address space */
+   MMIOAddress = (caddr_t) mmap(0, /* start */
+                                FixedInfo.mmio_len, /* bytes */
+                                PROT_READ | PROT_WRITE, /* prot */
+                                MAP_SHARED, /* flags */
+                                FrameBufferFD, /* fd */
+                                FixedInfo.smem_len /* offset */);
+   if (MMIOAddress == (caddr_t) - 1) {
+      fprintf(stderr, "error: unable to mmap mmio region: %s\n",
+              strerror(errno));
+   }
+   printf("MMIOAddress = %p\n", MMIOAddress);
+
+   /* try out some simple MMIO register reads */
+   if (1)
+   {
+      typedef unsigned int CARD32;
+      typedef unsigned char CARD8;
+#define RADEON_CONFIG_MEMSIZE               0x00f8
+#define RADEON_MEM_SDRAM_MODE_REG           0x0158
+#define MMIO_IN32(base, offset) \
+	*(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset))
+#define INREG(addr)         MMIO_IN32(MMIOAddress, addr)
+      int sz, type;
+      const char *typeStr[] = {"SDR", "DDR", "64-bit SDR"};
+      sz = INREG(RADEON_CONFIG_MEMSIZE);
+      type = INREG(RADEON_MEM_SDRAM_MODE_REG);
+      printf("RADEON_CONFIG_MEMSIZE = %d (%d MB)\n", sz, sz / 1024 / 1024);
+      printf("RADEON_MEM_SDRAM_MODE_REG >> 30 = %d (%s)\n",
+             type >> 30, typeStr[type>>30]);
+   }
+#endif
+
+}
+
+
+static void
+shutdown_fbdev( void )
+{
+   struct vt_mode VT;
+
+   printf("cleaning up...\n");
+   /* restore original variable screen info */
+   if (ioctl(FrameBufferFD, FBIOPUT_VSCREENINFO, &OrigVarInfo)) {
+      fprintf(stderr, "ioctl(FBIOPUT_VSCREENINFO failed): %s\n",
+              strerror(errno));
+      exit(1);
+   }
+
+   munmap(MMIOAddress, FixedInfo.mmio_len);
+   munmap(FrameBuffer, FixedInfo.smem_len);
+   close(FrameBufferFD);
+
+   /* restore text mode */
+   ioctl(ConsoleFD, KDSETMODE, KD_TEXT);
+
+   /* set vt */
+   if (ioctl(ConsoleFD, VT_GETMODE, &VT) != -1) {
+      VT.mode = VT_AUTO;
+      ioctl(ConsoleFD, VT_SETMODE, &VT);
+   }
+
+   /* restore original vt */
+   if (OriginalVT >= 0) {
+      ioctl(ConsoleFD, VT_ACTIVATE, OriginalVT);
+      OriginalVT = -1;
+   }
+
+   close(ConsoleFD);
+}
+
+
+static void
+gltest( void )
+{
+   static const int attribs[] = {
+      GLFBDEV_DOUBLE_BUFFER,
+      GLFBDEV_DEPTH_SIZE, 16,
+      GLFBDEV_NONE
+   };
+   GLFBDevContextPtr ctx;
+   GLFBDevBufferPtr buf;
+   GLFBDevVisualPtr vis;
+   int bytes, r, g, b, a;
+   float ang;
+
+   printf("GLFBDEV_VENDOR = %s\n", glFBDevGetString(GLFBDEV_VENDOR));
+   printf("GLFBDEV_VERSION = %s\n", glFBDevGetString(GLFBDEV_VERSION));
+
+   /* framebuffer size */
+   bytes = VarInfo.xres_virtual * VarInfo.yres_virtual * VarInfo.bits_per_pixel / 8;
+
+   vis = glFBDevCreateVisual( &FixedInfo, &VarInfo, attribs );
+   assert(vis);
+
+   buf = glFBDevCreateBuffer( &FixedInfo, &VarInfo, vis, FrameBuffer, NULL, bytes );
+   assert(buf);
+
+   ctx = glFBDevCreateContext( vis, NULL );
+   assert(buf);
+
+   b = glFBDevMakeCurrent( ctx, buf, buf );
+   assert(b);
+
+   /*printf("GL_EXTENSIONS: %s\n", glGetString(GL_EXTENSIONS));*/
+   glGetIntegerv(GL_RED_BITS, &r);
+   glGetIntegerv(GL_GREEN_BITS, &g);
+   glGetIntegerv(GL_BLUE_BITS, &b);
+   glGetIntegerv(GL_ALPHA_BITS, &a);
+   printf("RED_BITS=%d GREEN_BITS=%d BLUE_BITS=%d ALPHA_BITS=%d\n",
+          r, g, b, a);
+
+   glClearColor(0.5, 0.5, 1.0, 0);
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   glFrustum(-1, 1, -1, 1, 2, 30);
+   glMatrixMode(GL_MODELVIEW);
+   glLoadIdentity();
+   glTranslatef(0, 0, -15);
+   glViewport(0, 0, VarInfo.xres_virtual, VarInfo.yres_virtual);
+   glEnable(GL_LIGHTING);
+   glEnable(GL_LIGHT0);
+   glEnable(GL_DEPTH_TEST);
+
+   for (ang = 0; ang <= 180; ang += 15) {
+      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+      glPushMatrix();
+      glRotatef(ang, 1, 0, 0);
+      glutSolidTorus(1, 3, 40, 20);
+      glPopMatrix();
+      glFBDevSwapBuffers(buf);
+   }
+
+   /* clean up */
+   b = glFBDevMakeCurrent( NULL, NULL, NULL);
+   assert(b);
+
+   glFBDevDestroyContext(ctx);
+   glFBDevDestroyBuffer(buf);
+   glFBDevDestroyVisual(vis);
+}
+
+
+int
+main( int argc, char *argv[] )
+{
+   signal(SIGUSR1, signal_handler);  /* exit if someone tries a vt switch */
+   signal(SIGSEGV, signal_handler);  /* catch segfaults */
+
+   initialize_fbdev();
+   gltest();
+   shutdown_fbdev();
+
+   return 0;
+}

progs/tests/miniglxsample.c

@@ -0,0 +1,125 @@
+
+#define USE_MINIGLX 1  /* 1 = use Mini GLX, 0 = use Xlib/GLX */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <GL/gl.h>
+
+#if USE_MINIGLX
+#include <GL/miniglx.h>
+#else
+#include <GL/glx.h>
+#include <X11/Xlib.h>
+#endif
+
+static void _subset_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+   glBegin( GL_QUADS );
+   glVertex2f( x1, y1 );
+   glVertex2f( x2, y1 );
+   glVertex2f( x2, y2 );
+   glVertex2f( x1, y2 );
+   glEnd();
+}
+
+
+/*
+ * Create a simple double-buffered RGBA window.
+ */
+static Window
+MakeWindow(Display * dpy, unsigned int width, unsigned int height)
+{
+   int visAttributes[] = {
+      GLX_RGBA,
+      GLX_RED_SIZE, 1,
+      GLX_GREEN_SIZE, 1,
+      GLX_BLUE_SIZE, 1,
+      GLX_DOUBLEBUFFER,
+      None
+   };
+   XSetWindowAttributes attr;
+   unsigned long attrMask;
+   Window root;
+   Window win;
+   GLXContext ctx;
+   XVisualInfo *visinfo;
+
+   root = RootWindow(dpy, 0);
+
+   /* Choose GLX visual / pixel format */
+   visinfo = glXChooseVisual(dpy, 0, visAttributes);
+   if (!visinfo) {
+      printf("Error: couldn't get an RGB, Double-buffered visual\n");
+      exit(1);
+   }
+
+   /* Create the window */
+   attr.background_pixel = 0;
+   attr.border_pixel = 0;
+   attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
+   attrMask = CWBackPixel | CWBorderPixel | CWColormap;
+   win = XCreateWindow(dpy, root, 0, 0, width, height,
+		       0, visinfo->depth, InputOutput,
+		       visinfo->visual, attrMask, &attr);
+   if (!win) {
+      printf("Error: XCreateWindow failed\n");
+      exit(1);
+   }
+
+   /* Display the window */
+   XMapWindow(dpy, win);
+
+   /* Create GLX rendering context */
+   ctx = glXCreateContext(dpy, visinfo, NULL, True);
+   if (!ctx) {
+      printf("Error: glXCreateContext failed\n");
+      exit(1);
+   }
+
+   /* Bind the rendering context and window */
+   glXMakeCurrent(dpy, win, ctx);
+
+   return win;
+}
+
+
+/*
+ * Draw a few frames of a rotating square.
+ */
+static void
+DrawFrames(Display * dpy, Window win)
+{
+   int angle;
+   glShadeModel(GL_FLAT);
+   glClearColor(0.5, 0.5, 0.5, 1.0);
+   for (angle = 0; angle < 360; angle += 10) {
+      glClear(GL_COLOR_BUFFER_BIT);
+      glColor3f(1.0, 1.0, 0.0);
+      glPushMatrix();
+      glRotatef(angle, 0, 0, 1);
+      _subset_Rectf(-0.8, -0.8, 0.8, 0.8);
+      glPopMatrix();
+      glXSwapBuffers(dpy, win);
+      sleep(1);
+   }
+}
+
+
+int
+main(int argc, char *argv[])
+{
+   Display *dpy;
+   Window win;
+
+   dpy = XOpenDisplay(NULL);
+   if (!dpy) {
+      printf("Error: XOpenDisplay failed\n");
+      return 1;
+   }
+
+   win = MakeWindow(dpy, 300, 300);
+
+   DrawFrames(dpy, win);
+
+   return 0;
+}

progs/tests/miniglxtest.c

@@ -0,0 +1,197 @@
+/* $Id: miniglxtest.c,v 1.1.4.7 2003/02/21 22:18:24 keithw Exp $ */
+
+/*
+ * Test the mini GLX interface.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <GL/gl.h>
+#define USE_MINI_GLX 1
+#if USE_MINI_GLX
+#include <GL/miniglx.h>
+#else
+#include <GL/glx.h>
+#endif
+
+#define FRONTBUFFER 1
+#define NR          6
+#define DO_SLEEPS   1
+#define NR_DISPLAYS 2
+
+GLXContext ctx;
+
+
+static void _subset_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+   glBegin( GL_QUADS );
+   glVertex2f( x1, y1 );
+   glVertex2f( x2, y1 );
+   glVertex2f( x2, y2 );
+   glVertex2f( x1, y2 );
+   glEnd();
+}
+
+
+
+static void redraw( Display *dpy, Window w, int rot )
+{
+   printf("Redraw event\n");
+
+#if FRONTBUFFER
+    glDrawBuffer( GL_FRONT ); 
+#else
+/*     glDrawBuffer( GL_BACK );    */
+#endif
+
+   glClearColor( rand()/(float)RAND_MAX, 
+		 rand()/(float)RAND_MAX, 
+		 rand()/(float)RAND_MAX,
+		 1);
+
+   glClear( GL_COLOR_BUFFER_BIT ); 
+
+#if 1
+   glColor3f( rand()/(float)RAND_MAX, 
+	      rand()/(float)RAND_MAX, 
+	      rand()/(float)RAND_MAX );
+   glPushMatrix();
+   glRotatef(rot, 0, 0, 1);
+   glScalef(.5, .5, .5);
+   _subset_Rectf( -1, -1, 1, 1 );
+   glPopMatrix();
+#endif
+
+#if FRONTBUFFER
+   glFlush();
+#else
+   glXSwapBuffers( dpy, w ); 
+#endif
+   glFinish();
+}
+
+
+static Window make_rgb_db_window( Display *dpy,
+				  unsigned int width, unsigned int height )
+{
+   int attrib[] = { GLX_RGBA,
+		    GLX_RED_SIZE, 1,
+		    GLX_GREEN_SIZE, 1,
+		    GLX_BLUE_SIZE, 1,
+#if !FRONT_BUFFER
+ 		    GLX_DOUBLEBUFFER, 
+#endif
+		    None };
+   int scrnum;
+   XSetWindowAttributes attr;
+   unsigned long mask;
+   Window root;
+   Window win;
+   XVisualInfo *visinfo;
+
+   scrnum = 0;
+   root = RootWindow( dpy, scrnum );
+
+   visinfo = glXChooseVisual( dpy, scrnum, attrib );
+   if (!visinfo) {
+      printf("Error: couldn't get an RGB, Double-buffered visual\n");
+      exit(1);
+   }
+
+   ctx = glXCreateContext( dpy, visinfo, NULL, True );
+   if (!ctx) {
+      printf("Error: glXCreateContext failed\n");
+      exit(1);
+   }
+
+   /* window attributes */
+   attr.background_pixel = 0;
+   attr.border_pixel = 0;
+   attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
+   attr.event_mask = StructureNotifyMask | ExposureMask;
+   mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+
+   win = XCreateWindow( dpy, root, 0, 0, width, height,
+		        0, visinfo->depth, InputOutput,
+		        visinfo->visual, mask, &attr );
+   if (!win) {
+      printf("Error: XCreateWindow failed\n");
+      exit(1);
+   }
+
+   glXMakeCurrent( dpy, win, ctx );
+
+   return win;
+}
+
+
+static void event_loop( Display *dpy, Window win )
+{
+   int i;
+
+   printf("Hang on... drawing %d frames\n", NR);
+   for (i = 0; i < NR; i++) {
+      redraw( dpy, win, i*10 );
+      if (DO_SLEEPS) {
+	 printf("sleep(1)\n");   
+	 sleep(1);  
+      }
+   }
+}
+
+
+int foo( )
+{
+   Display *dpy;
+   Window win;
+
+   dpy = XOpenDisplay(NULL);
+   if (!dpy) {
+      printf("Error: XOpenDisplay failed\n");
+      return 1;
+   }
+
+   win = make_rgb_db_window( dpy, 800, 600);
+
+   srand(getpid());
+
+   glShadeModel( GL_FLAT );
+   glClearColor( 0.5, 0.5, 0.5, 1.0 );
+
+   XMapWindow( dpy, win );
+
+#if !USE_MINI_GLX
+   {
+      XEvent e;
+      while (1) {
+	 XNextEvent( dpy, &e );
+	 if (e.type == MapNotify && e.xmap.window == win) {
+	    break;
+	 }
+      }
+   }
+#endif
+
+
+   event_loop( dpy, win );
+
+   glXDestroyContext( dpy, ctx );
+   XDestroyWindow( dpy, win );
+
+   XCloseDisplay( dpy );
+
+   return 0;
+}
+
+
+int main()
+{
+   int i;
+   for (i = 0 ; i < NR_DISPLAYS ; i++) {
+      if (foo() != 0)
+	 break;
+   }
+
+   return 0;
+}

progs/tests/stencilwrap.c

@@ -0,0 +1,147 @@
+/* Test GL_EXT_stencil_wrap extension.
+ * This is by no means complete, just a quick check.
+ *
+ * Brian Paul  30 October 2002
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <GL/glut.h>
+
+
+static void RunTest(void)
+{
+   const GLenum prim = GL_LINES;
+   GLubyte val;
+   int bits, max, i;
+
+   glGetIntegerv(GL_STENCIL_BITS, &bits);
+   max = (1 << bits) - 1;
+
+   glClearStencil(0);
+   glEnable(GL_STENCIL_TEST);
+   glStencilFunc(GL_ALWAYS, 0, ~0);
+
+   /* test GL_INCR (saturation) */
+   glClear(GL_STENCIL_BUFFER_BIT);
+   glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
+   printf("Testing GL_INCR...\n");
+   for (i = 1; i < max+10; i++) {
+      int expected = (i > max) ? max : i;
+      glBegin(prim);
+      glVertex2f(0.5, 0.5);      glVertex2f(9.5, 0.5);
+      glEnd();
+      glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val);
+      assert(val == expected);
+   }
+   printf("OK!\n");
+
+   /* test GL_INCR_WRAP_EXT (wrap around) */
+   glClear(GL_STENCIL_BUFFER_BIT);
+   glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
+   printf("Testing GL_INCR_WRAP_EXT...\n");
+   for (i = 1; i < max+10; i++) {
+      int expected = i % (max + 1);
+      glBegin(prim);
+      glVertex2f(0.5, 0.5);      glVertex2f(9.5, 0.5);
+      glEnd();
+      glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val);
+      assert(val == expected);
+   }
+   printf("OK!\n");
+
+   glClearStencil(max);
+
+   /* test GL_INCR (saturation) */
+   glClear(GL_STENCIL_BUFFER_BIT);
+   glStencilOp(GL_KEEP, GL_KEEP, GL_DECR);
+   printf("Testing GL_DECR...\n");
+   for (i = max-1; i > -10; i--) {
+      int expected = (i < 0) ? 0 : i;
+      glBegin(prim);
+      glVertex2f(0.5, 0.5);      glVertex2f(9.5, 0.5);
+      glEnd();
+      glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val);
+      assert(val == expected);
+   }
+   printf("OK!\n");
+
+   /* test GL_INCR_WRAP_EXT (wrap-around) */
+   glClear(GL_STENCIL_BUFFER_BIT);
+   glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
+   printf("Testing GL_DECR_WRAP_EXT...\n");
+   for (i = max-1; i > -10; i--) {
+      int expected = (i < 0) ? max + i + 1: i;
+      glBegin(prim);
+      glVertex2f(0.5, 0.5);      glVertex2f(9.5, 0.5);
+      glEnd();
+      glReadPixels(0, 0, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, &val);
+      assert(val == expected);
+   }
+   printf("OK!\n");
+
+   glDisable(GL_STENCIL_TEST);
+}
+
+
+static void Display( void )
+{
+   glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+   RunTest();
+
+   glutSwapBuffers();
+}
+
+
+static void Reshape( int width, int height )
+{
+   glViewport( 0, 0, width, height );
+   glMatrixMode( GL_PROJECTION );
+   glLoadIdentity();
+   glOrtho(0, width, 0, height, -1, 1);
+   glMatrixMode( GL_MODELVIEW );
+   glLoadIdentity();
+}
+
+
+static void Key( unsigned char key, int x, int y )
+{
+   (void) x;
+   (void) y;
+   switch (key) {
+      case 27:
+         exit(0);
+         break;
+   }
+   glutPostRedisplay();
+}
+
+
+static void Init( void )
+{
+   printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
+   printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
+   if (!glutExtensionSupported("GL_EXT_stencil_wrap")) {
+      printf("Sorry, GL_EXT_stencil_wrap not supported.\n");
+      exit(1);
+   }
+}
+
+
+int main( int argc, char *argv[] )
+{
+   glutInit( &argc, argv );
+   glutInitWindowPosition( 0, 0 );
+   glutInitWindowSize( 400, 400 );
+   glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_STENCIL );
+   glutCreateWindow(argv[0]);
+   glutReshapeFunc( Reshape );
+   glutKeyboardFunc( Key );
+   glutDisplayFunc( Display );
+   Init();
+   glutMainLoop();
+   return 0;
+}

progs/xdemos/Makefile

@@ -0,0 +1,35 @@
+
+# Simple makefile for compiling test programs on Linux
+# These programs aren't intended to be included with the normal
+# distro.  They're not too interesting but they're good for testing.
+
+
+CC = gcc
+CFLAGS = -g -I../include
+LIBS = -L../lib -lGL -lm
+
+PROGS = glxgears
+
+
+##### RULES #####
+
+.SUFFIXES:
+.SUFFIXES: .c
+
+.c:
+	$(CC) $(CFLAGS) $< $(LIBS) -o $@
+
+
+
+
+##### TARGETS #####
+
+default: $(PROGS)
+
+clean:
+	rm -f $(PROGS)
+	rm -f *.o
+
+
+
+

progs/xdemos/glxgears.c

@@ -33,10 +33,16 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <GL/gl.h>
+#define USE_MINI_GLX 1
+#if USE_MINI_GLX
+#include <GL/miniglx.h>
+#else
 #include <X11/Xlib.h>
 #include <X11/keysym.h>
-#include <GL/gl.h>
 #include <GL/glx.h>
+#endif
+
 
 
 #define BENCHMARK
@@ -346,13 +352,18 @@ make_window( Display *dpy, const char *name,
    attr.background_pixel = 0;
    attr.border_pixel = 0;
    attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
-   attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
+   attr.event_mask = StructureNotifyMask | ExposureMask 
+#if !USE_MINI_GLX
+      | KeyPressMask
+#endif
+      ;
    mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
 
    win = XCreateWindow( dpy, root, 0, 0, width, height,
 		        0, visinfo->depth, InputOutput,
 		        visinfo->visual, mask, &attr );
 
+#if !USE_MINI_GLX
    /* set hints and properties */
    {
       XSizeHints sizehints;
@@ -365,6 +376,7 @@ make_window( Display *dpy, const char *name,
       XSetStandardProperties(dpy, win, name, name,
                               None, (char **)NULL, 0, &sizehints);
    }
+#endif
 
    ctx = glXCreateContext( dpy, visinfo, NULL, True );
    if (!ctx) {
@@ -382,7 +394,12 @@ make_window( Display *dpy, const char *name,
 static void
 event_loop(Display *dpy, Window win)
 {
+#if USE_MINI_GLX
+   reshape(300, 300);
+#endif
+
    while (1) {
+#if !USE_MINI_GLX
       while (XPending(dpy) > 0) {
          XEvent event;
          XNextEvent(dpy, &event);
@@ -421,6 +438,7 @@ event_loop(Display *dpy, Window win)
             }
          }
       }
+#endif
 
       /* next frame */
       angle += 2.0;

progs/xdemos/glxinfo.c

@@ -1,4 +1,4 @@
-/* $Id: glxinfo.c,v 1.20 2002/10/14 13:57:23 brianp Exp $ */
+/* $Id: glxinfo.c,v 1.21 2002/11/04 16:24:18 brianp Exp $ */
 
 /*
  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
@@ -422,9 +422,17 @@ get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
      glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
    }
 
-   /* multisample tests not implemented yet */
-   attribs->numSamples = 0;
-   attribs->numMultisample = 0;
+   /* multisample attribs */
+#ifdef GLX_ARB_multisample
+   if (strstr("GLX_ARB_multisample", ext) == 0) {
+      glXGetConfig(dpy, vInfo, GLX_SAMPLE_BUFFERS_ARB, &attribs->numMultisample);
+      glXGetConfig(dpy, vInfo, GLX_SAMPLES_ARB, &attribs->numSamples);
+   }
+#endif
+   else {
+      attribs->numSamples = 0;
+      attribs->numMultisample = 0;
+   }
 
 #if defined(GLX_EXT_visual_rating)
    if (ext && strstr(ext, "GLX_EXT_visual_rating")) {

src/dri-es/Makefile

@@ -0,0 +1,37 @@
+# $Id: Makefile,v 1.1.2.2 2003/03/04 17:29:55 keithw Exp $
+
+# Mesa 3-D graphics library
+# Version:  5.0
+# Copyright (C) 1995-2002  Brian Paul
+
+
+
+MESA = ../..
+default: dri.a
+include $(MESA)/Makefile.include
+
+INCLUDES = -I/usr/X11R6/include -I/usr/X11R6/include/X11/extensions -I$(MESA)/include -I. -I..
+DEFINES = 
+
+C_SOURCES = dri_glx.c \
+	    dri_util.c \
+	    xf86drm.c \
+	    xf86drmHash.c \
+	    xf86drmRandom.c \
+	    xf86drmSL.c
+
+ASM_SOURCES = 
+
+OBJECTS = $(C_SOURCES:.c=.o) \
+	  $(ASM_SOURCES:.S=.o) 
+
+
+
+##### TARGETS #####
+
+dri.a: $(OBJECTS) Makefile
+	rm -f $@ && ar rcv $@ $(OBJECTS) && ranlib $@
+
+##### DEPENDENCIES #####
+
+-include $(C_SOURCES:.c=.d)

src/dri-es/dri_glx.c

@@ -0,0 +1,472 @@
+/**************************************************************************
+
+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.10 2001/08/27 17:40:57 dawes Exp $ */
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kevin@precisioninsight.com>
+ *   Brian Paul <brian@precisioninsight.com>
+ *
+ */
+
+
+#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>
+
+
+#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");
+         if (!driver->createScreenFunc) {
+            /* If the driver doesn't have this symbol then something's
+             * really, really wrong.
+             */
+            ErrorMessageF("__driCreateScreen() not defined in %s_dri.so!\n",
+                          driverName);
+            Xfree(driver);
+            dlclose(handle);
+            continue;
+         }
+         driver->registerExtensionsFunc = (RegisterExtensionsFunc)
+            dlsym(handle, "__driRegisterExtensions");
+         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");
+      return False;
+   }
+   if (!directCapable) {
+      ErrorMessageF("XF86DRIQueryDirectRenderingCapable returned false");
+      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)) {
+      return OpenDriver(driverName);
+   }
+   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 library handles */
+    pdpyp->libraryHandles = (void **) Xmalloc(numScreens * sizeof(void*));
+    if (!pdpyp->libraryHandles) {
+       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;
+       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.
+     */
+    __glXRegisterExtensions();
+    for (scrn = 0; scrn < numScreens; scrn++) {
+        __DRIdriver *driver = driGetDriver(dpy, scrn);
+        if (driver) {
+           pdisp->createScreen[scrn] = driver->createScreenFunc;
+           pdpyp->libraryHandles[scrn] = driver->handle;
+        }
+        else {
+           pdisp->createScreen[scrn] = DummyCreateScreen;
+           pdpyp->libraryHandles[scrn] = NULL;
+        }
+    }
+#endif
+
+    return (void *)pdpyp;
+}
+
+
+
+/*
+** Here we'll query the DRI driver for each screen and let each
+** driver register its GL extension functions.  We only have to
+** do this once.
+**
+** In older versions of libGL (prior to October 2002) we _always_
+** called this function during libGL start-up.  Now, we only call
+** it from glXGetProcAddress() as a last resort.
+**
+** Two key things changed along the way:
+** 1. _glapi_get_proc_address() now generates new dispatch stub functions
+**    anytime it gets an unknown "gl*" function name.  I.e. we always return
+**    a valid function address and later patch it up to use the correct
+**    dispatch offset.
+** 2. The GL API dispatch table is a fixed size (with plenty of extra slots).
+**    This means we don't have to register all new functions before we create
+**    the first dispatch table.
+*/
+void
+__glXRegisterExtensions(void)
+{
+#ifndef BUILT_IN_DRI_DRIVER
+   static GLboolean alreadyCalled = GL_FALSE;
+   int displayNum, maxDisplays;
+
+   if (alreadyCalled)
+      return;
+   alreadyCalled = GL_TRUE;
+
+   if (getenv("LIBGL_MULTIHEAD")) {
+      /* we'd like to always take this path but doing so causes a second
+       * or more of delay while the XOpenDisplay() function times out.
+       */
+      maxDisplays = 10;  /* infinity, really */
+   }
+   else {
+      /* just open the :0 display */
+      maxDisplays = 1;
+   }
+
+   for (displayNum = 0; displayNum < maxDisplays; displayNum++) {
+      char displayName[200];
+      Display *dpy;
+      snprintf(displayName, 199, ":%d.0", displayNum);
+      dpy = XOpenDisplay(displayName);
+      if (dpy) {
+         const int numScreens = ScreenCount(dpy);
+         int screenNum;
+         for (screenNum = 0; screenNum < numScreens; screenNum++) {
+            __DRIdriver *driver = driGetDriver(dpy, screenNum);
+            if (driver && driver->registerExtensionsFunc) {
+               (*driver->registerExtensionsFunc)();
+            }
+         }
+         XCloseDisplay(dpy);
+      }
+      else {
+         break;
+      }
+   }
+#endif
+}
+
+

src/dri-es/dri_glx.h

@@ -0,0 +1,59 @@
+/**************************************************************************
+
+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_
+
+
+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 /* _DRI_GLX_H_ */

src/dri-es/dri_util.h

@@ -0,0 +1,375 @@
+/* $XFree86$ */
+/**************************************************************************
+
+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>
+ */
+
+/*
+ * This module acts as glue between GLX and the actual hardware driver.
+ * A DRI driver doesn't really _have_ to use any of this - it's optional.
+ * But, some useful stuff is done here that otherwise would have to be
+ * duplicated in most drivers.
+ * 
+ * Basically, these utility functions take care of some of the dirty details
+ * of screen initialization, context creation, context binding, DRM setup,
+ * etc.
+ *
+ * These functions are compiled into each DRI driver so libGL.so knows
+ * nothing about them.
+ *
+ * Look for more comments in the dri_util.c file.
+ */
+
+
+
+#ifndef _DRI_UTIL_H_
+#define _DRI_UTIL_H_
+
+#define CAPI  /* XXX this should be globally defined somewhere */
+
+#include "glxclient.h"           /* for GLXDrawable */
+#include "xf86dri.h"             /* for XF86DRIClipRectPtr */
+#include "sarea.h"               /* for XF86DRISAREAPtr */
+#include "GL/internal/glcore.h"  /* for __GLcontextModes */
+
+
+typedef struct __DRIdisplayPrivateRec  __DRIdisplayPrivate;
+typedef struct __DRIscreenPrivateRec   __DRIscreenPrivate;
+typedef struct __DRIcontextPrivateRec  __DRIcontextPrivate;
+typedef struct __DRIdrawablePrivateRec __DRIdrawablePrivate;
+
+
+#define DRI_VALIDATE_DRAWABLE_INFO_ONCE(pDrawPriv)              \
+    do {                                                        \
+	if (*(pDrawPriv->pStamp) != pDrawPriv->lastStamp) {     \
+	    __driUtilUpdateDrawableInfo(pDrawPriv);             \
+	}                                                       \
+    } while (0)
+
+
+#define DRI_VALIDATE_DRAWABLE_INFO(psp, pdp)                            \
+do {                                                                    \
+    while (*(pdp->pStamp) != pdp->lastStamp) {                          \
+	DRM_UNLOCK(psp->fd, &psp->pSAREA->lock,                         \
+		   pdp->driContextPriv->hHWContext);                    \
+                                                                        \
+	DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);     \
+	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \
+	DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);   \
+                                                                        \
+	DRM_LIGHT_LOCK(psp->fd, &psp->pSAREA->lock,                     \
+		       pdp->driContextPriv->hHWContext);                \
+    }                                                                   \
+} while (0)
+
+
+/* Each DRI driver must have one of these structs with all the pointers
+ * set to appropriate functions within the driver.
+ * When glXCreateContext is called, for example, it'll call a helper
+ * function dri_util.c which in turn will jump through the CreateContext
+ * pointer in this structure.
+ */
+struct __DriverAPIRec {
+    GLboolean (*InitDriver)(__DRIscreenPrivate *driScrnPriv);
+    void (*DestroyScreen)(__DRIscreenPrivate *driScrnPriv);
+    GLboolean (*CreateContext)(const __GLcontextModes *glVis,
+                               __DRIcontextPrivate *driContextPriv,
+                               void *sharedContextPrivate);
+    void (*DestroyContext)(__DRIcontextPrivate *driContextPriv);
+    GLboolean (*CreateBuffer)(__DRIscreenPrivate *driScrnPriv,
+                              __DRIdrawablePrivate *driDrawPriv,
+                              const __GLcontextModes *glVis,
+                              GLboolean pixmapBuffer);
+    void (*DestroyBuffer)(__DRIdrawablePrivate *driDrawPriv);
+    void (*SwapBuffers)(__DRIdrawablePrivate *driDrawPriv);
+    GLboolean (*MakeCurrent)(__DRIcontextPrivate *driContextPriv,
+                             __DRIdrawablePrivate *driDrawPriv,
+                             __DRIdrawablePrivate *driReadPriv);
+    GLboolean (*UnbindContext)(__DRIcontextPrivate *driContextPriv);
+    GLboolean (*OpenFullScreen)(__DRIcontextPrivate *driContextPriv);
+    GLboolean (*CloseFullScreen)(__DRIcontextPrivate *driContextPriv);
+};
+
+
+struct __DRIdrawablePrivateRec {
+    /*
+    ** Kernel drawable handle (not currently used).
+    */
+    drmDrawable hHWDrawable;
+
+    /*
+    ** Driver's private drawable information.  This structure is opaque.
+    */
+    void *driverPrivate;
+
+    /*
+    ** X's drawable ID associated with this private drawable.
+    */
+    GLXDrawable draw;
+
+    /*
+    ** Reference count for number of context's currently bound to this
+    ** drawable.  Once the refcount reaches 0, the drawable can be
+    ** destroyed.  This behavior will change with GLX 1.3.
+    */
+    int refcount;
+
+    /*
+    ** Index of this drawable's information in the SAREA.
+    */
+    unsigned int index;
+
+    /*
+    ** Pointer to the "drawable has changed ID" stamp in the SAREA.
+    */
+    unsigned int *pStamp;
+
+    /*
+    ** Last value of the stamp.  If this differs from the value stored
+    ** at *pStamp, then the drawable information has been modified by
+    ** the X server, and the drawable information (below) should be
+    ** retrieved from the X server.
+    */
+    unsigned int lastStamp;
+
+    /*
+    ** Drawable information used in software fallbacks.
+    */
+    int x;
+    int y;
+    int w;
+    int h;
+    int numClipRects;
+    XF86DRIClipRectPtr pClipRects;
+
+    /*
+    ** Information about the back and depthbuffer where different
+    ** from above.
+    */
+    int backX;
+    int backY;
+    int backClipRectType;
+    int numBackClipRects;
+    XF86DRIClipRectPtr pBackClipRects;
+
+    /*
+    ** Pointer to context to which this drawable is currently bound.
+    */
+    __DRIcontextPrivate *driContextPriv;
+
+    /*
+    ** Pointer to screen on which this drawable was created.
+    */
+    __DRIscreenPrivate *driScreenPriv;
+
+    /*
+    ** Basically just need these for when the locking code needs to call
+    ** __driUtilUpdateDrawableInfo() which calls XF86DRIGetDrawableInfo().
+    */
+    Display *display;
+    int screen;
+
+    /*
+    ** Called via glXSwapBuffers().
+    */
+    void (*swapBuffers)( __DRIdrawablePrivate *dPriv );
+};
+
+struct __DRIcontextPrivateRec {
+    /*
+    ** Kernel context handle used to access the device lock.
+    */
+    XID contextID;
+
+    /*
+    ** Kernel context handle used to access the device lock.
+    */
+    drmContext hHWContext;
+
+    /*
+    ** Device driver's private context data.  This structure is opaque.
+    */
+    void *driverPrivate;
+
+    /*
+    ** This context's display pointer.
+    */
+    Display *display;
+
+    /*
+    ** Pointer to drawable currently bound to this context.
+    */
+    __DRIdrawablePrivate *driDrawablePriv;
+
+    /*
+    ** Pointer to screen on which this context was created.
+    */
+    __DRIscreenPrivate *driScreenPriv;
+};
+
+struct __DRIscreenPrivateRec {
+    /*
+    ** Display for this screen
+    */
+    Display *display;
+
+    /*
+    ** Current screen's number
+    */
+    int myNum;
+
+    /*
+    ** Callback functions into the hardware-specific DRI driver code.
+    */
+    struct __DriverAPIRec DriverAPI;
+
+    /*
+    ** DDX / 2D driver version information.
+    */
+    int ddxMajor;
+    int ddxMinor;
+    int ddxPatch;
+
+    /*
+    ** DRI X extension version information.
+    */
+    int driMajor;
+    int driMinor;
+    int driPatch;
+
+    /*
+    ** DRM (kernel module) version information.
+    */
+    int drmMajor;
+    int drmMinor;
+    int drmPatch;
+
+    /*
+    ** ID used when the client sets the drawable lock.  The X server
+    ** uses this value to detect if the client has died while holding
+    ** the drawable lock.
+    */
+    int drawLockID;
+
+    /*
+    ** File descriptor returned when the kernel device driver is opened.
+    ** It is used to:
+    **   - authenticate client to kernel
+    **   - map the frame buffer, SAREA, etc.
+    **   - close the kernel device driver
+    */
+    int fd;
+
+    /*
+    ** SAREA pointer used to access:
+    **   - the device lock
+    **   - the device-independent per-drawable and per-context(?) information
+    */
+    XF86DRISAREAPtr pSAREA;
+
+    /*
+    ** Direct frame buffer access information used for software
+    ** fallbacks.
+    */
+    unsigned char *pFB;
+    int fbSize;
+    int fbOrigin;
+    int fbStride;
+    int fbWidth;
+    int fbHeight;
+    int fbBPP;
+
+    /*
+    ** Device-dependent private information (stored in the SAREA).  This
+    ** data is accessed by the client driver only.
+    */
+    void *pDevPriv;
+    int devPrivSize;
+
+    /*
+    ** Dummy context to which drawables are bound when not bound to any
+    ** other context. A dummy hHWContext is created for this context,
+    ** and is used by the GL core when a HW lock is required but the
+    ** drawable is not currently bound (e.g., potentially during a
+    ** SwapBuffers request).  The dummy context is created when the
+    ** first "real" context is created on this screen.
+    */
+    __DRIcontextPrivate dummyContextPriv;
+
+    /*
+    ** Hash table to hold the drawable information for this screen.
+    */
+    void *drawHash;
+
+    /*
+    ** Device-dependent private information (not stored in the SAREA).
+    ** This pointer is never touched by the DRI layer.
+    */
+    void *private;
+
+    /* If we're in full screen mode (via DRIOpenFullScreen), this points
+       to the drawable that was bound.  Otherwise, this is NULL. */
+    __DRIdrawablePrivate *fullscreen;
+
+    /*
+    ** Number of visuals (configs) for this screen, and a pointer to them.
+    */
+    int numConfigs;
+    __GLXvisualConfig *configs;
+};
+
+
+
+extern void
+__driUtilMessage(const char *f, ...);
+
+
+extern void
+__driUtilUpdateDrawableInfo(__DRIdrawablePrivate *pdp);
+
+
+extern __DRIscreenPrivate *
+__driUtilCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
+                      int numConfigs, __GLXvisualConfig *config,
+                      const struct __DriverAPIRec *driverAPI);
+
+/* This must be implemented in each driver */
+extern void *
+__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
+                  int numConfigs, __GLXvisualConfig *config);
+
+
+/* This is optionally implemented in each driver */
+extern void
+__driRegisterExtensions( void );
+
+
+#endif /* _DRI_UTIL_H_ */

src/dri-es/drm.h

@@ -0,0 +1,474 @@
+/* drm.h -- Header for Direct Rendering Manager -*- linux-c -*-
+ * Created: Mon Jan  4 10:05:05 1999 by faith@precisioninsight.com
+ *
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEMS 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:
+ *    Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ * Acknowledgements:
+ * Dec 1999, Richard Henderson <rth@twiddle.net>, move to generic cmpxchg.
+ *
+ */
+
+#ifndef _DRM_H_
+#define _DRM_H_
+
+#if defined(__linux__)
+#include <linux/config.h>
+#include <asm/ioctl.h>		/* For _IO* macros */
+#define DRM_IOCTL_NR(n)		_IOC_NR(n)
+#define DRM_IOC_VOID		_IOC_NONE
+#define DRM_IOC_READ		_IOC_READ
+#define DRM_IOC_WRITE		_IOC_WRITE
+#define DRM_IOC_READWRITE	_IOC_READ|_IOC_WRITE
+#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
+#elif defined(__FreeBSD__) || defined(__NetBSD__)
+#if defined(__FreeBSD__) && defined(XFree86Server)
+/* Prevent name collision when including sys/ioccom.h */
+#undef ioctl
+#include <sys/ioccom.h>
+#define ioctl(a,b,c)		xf86ioctl(a,b,c)
+#else
+#include <sys/ioccom.h>
+#endif /* __FreeBSD__ && xf86ioctl */
+#define DRM_IOCTL_NR(n)		((n) & 0xff)
+#define DRM_IOC_VOID		IOC_VOID
+#define DRM_IOC_READ		IOC_OUT
+#define DRM_IOC_WRITE		IOC_IN
+#define DRM_IOC_READWRITE	IOC_INOUT
+#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
+#endif
+
+#define XFREE86_VERSION(major,minor,patch,snap) \
+		((major << 16) | (minor << 8) | patch)
+
+#ifndef CONFIG_XFREE86_VERSION
+#define CONFIG_XFREE86_VERSION XFREE86_VERSION(4,1,0,0)
+#endif
+
+#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
+#define DRM_PROC_DEVICES "/proc/devices"
+#define DRM_PROC_MISC	 "/proc/misc"
+#define DRM_PROC_DRM	 "/proc/drm"
+#define DRM_DEV_DRM	 "/dev/drm"
+#define DRM_DEV_MODE	 (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
+#define DRM_DEV_UID	 0
+#define DRM_DEV_GID	 0
+#endif
+
+#if CONFIG_XFREE86_VERSION >= XFREE86_VERSION(4,1,0,0)
+#define DRM_MAJOR       226
+#define DRM_MAX_MINOR   15
+#endif
+#define DRM_NAME	"drm"	  /* Name in kernel, /dev, and /proc	    */
+#define DRM_MIN_ORDER	5	  /* At least 2^5 bytes = 32 bytes	    */
+#define DRM_MAX_ORDER	22	  /* Up to 2^22 bytes = 4MB		    */
+#define DRM_RAM_PERCENT 10	  /* How much system ram can we lock?	    */
+
+#define _DRM_LOCK_HELD	0x80000000 /* Hardware lock is held		    */
+#define _DRM_LOCK_CONT	0x40000000 /* Hardware lock is contended	    */
+#define _DRM_LOCK_IS_HELD(lock)	   ((lock) & _DRM_LOCK_HELD)
+#define _DRM_LOCK_IS_CONT(lock)	   ((lock) & _DRM_LOCK_CONT)
+#define _DRM_LOCKING_CONTEXT(lock) ((lock) & ~(_DRM_LOCK_HELD|_DRM_LOCK_CONT))
+
+typedef unsigned long drm_handle_t;
+typedef unsigned int  drm_context_t;
+typedef unsigned int  drm_drawable_t;
+typedef unsigned int  drm_magic_t;
+
+/* Warning: If you change this structure, make sure you change
+ * XF86DRIClipRectRec in the server as well */
+
+/* KW: Actually it's illegal to change either for
+ * backwards-compatibility reasons.
+ */
+
+typedef struct drm_clip_rect {
+	unsigned short	x1;
+	unsigned short	y1;
+	unsigned short	x2;
+	unsigned short	y2;
+} drm_clip_rect_t;
+
+typedef struct drm_tex_region {
+	unsigned char	next;
+	unsigned char	prev;
+	unsigned char	in_use;
+	unsigned char	padding;
+	unsigned int	age;
+} drm_tex_region_t;
+
+typedef struct drm_version {
+	int    version_major;	  /* Major version			    */
+	int    version_minor;	  /* Minor version			    */
+	int    version_patchlevel;/* Patch level			    */
+	size_t name_len;	  /* Length of name buffer		    */
+	char   *name;		  /* Name of driver			    */
+	size_t date_len;	  /* Length of date buffer		    */
+	char   *date;		  /* User-space buffer to hold date	    */
+	size_t desc_len;	  /* Length of desc buffer		    */
+	char   *desc;		  /* User-space buffer to hold desc	    */
+} drm_version_t;
+
+typedef struct drm_unique {
+	size_t unique_len;	  /* Length of unique			    */
+	char   *unique;		  /* Unique name for driver instantiation   */
+} drm_unique_t;
+
+typedef struct drm_list {
+	int		 count;	  /* Length of user-space structures	    */
+	drm_version_t	 *version;
+} drm_list_t;
+
+typedef struct drm_block {
+	int		 unused;
+} drm_block_t;
+
+typedef struct drm_control {
+	enum {
+		DRM_ADD_COMMAND,
+		DRM_RM_COMMAND,
+		DRM_INST_HANDLER,
+		DRM_UNINST_HANDLER
+	}		 func;
+	int		 irq;
+} drm_control_t;
+
+typedef enum drm_map_type {
+	_DRM_FRAME_BUFFER   = 0,  /* WC (no caching), no core dump	    */
+	_DRM_REGISTERS	    = 1,  /* no caching, no core dump		    */
+	_DRM_SHM	    = 2,  /* shared, cached			    */
+	_DRM_AGP            = 3,  /* AGP/GART                               */
+	_DRM_SCATTER_GATHER = 4	  /* Scatter/gather memory for PCI DMA      */
+} drm_map_type_t;
+
+typedef enum drm_map_flags {
+	_DRM_RESTRICTED	     = 0x01, /* Cannot be mapped to user-virtual    */
+	_DRM_READ_ONLY	     = 0x02,
+	_DRM_LOCKED	     = 0x04, /* shared, cached, locked		    */
+	_DRM_KERNEL	     = 0x08, /* kernel requires access		    */
+	_DRM_WRITE_COMBINING = 0x10, /* use write-combining if available    */
+	_DRM_CONTAINS_LOCK   = 0x20, /* SHM page that contains lock	    */
+	_DRM_REMOVABLE	     = 0x40  /* Removable mapping		    */
+} drm_map_flags_t;
+
+typedef struct drm_ctx_priv_map {
+	unsigned int	ctx_id;  /* Context requesting private mapping */
+	void		*handle; /* Handle of map */
+} drm_ctx_priv_map_t;
+
+typedef struct drm_map {
+	unsigned long	offset;	 /* Requested physical address (0 for SAREA)*/
+	unsigned long	size;	 /* Requested physical size (bytes)	    */
+	drm_map_type_t	type;	 /* Type of memory to map		    */
+	drm_map_flags_t flags;	 /* Flags				    */
+	void		*handle; /* User-space: "Handle" to pass to mmap    */
+				 /* Kernel-space: kernel-virtual address    */
+	int		mtrr;	 /* MTRR slot used			    */
+				 /* Private data			    */
+} drm_map_t;
+
+typedef struct drm_client {
+	int		idx;	/* Which client desired?                    */
+	int		auth;	/* Is client authenticated?                 */
+	unsigned long	pid;	/* Process id                               */
+	unsigned long	uid;	/* User id                                  */
+	unsigned long	magic;	/* Magic                                    */
+	unsigned long	iocs;	/* Ioctl count                              */
+} drm_client_t;
+
+typedef enum {
+	_DRM_STAT_LOCK,
+	_DRM_STAT_OPENS,
+	_DRM_STAT_CLOSES,
+	_DRM_STAT_IOCTLS,
+	_DRM_STAT_LOCKS,
+	_DRM_STAT_UNLOCKS,
+	_DRM_STAT_VALUE,	/* Generic value                      */
+	_DRM_STAT_BYTE,		/* Generic byte counter (1024bytes/K) */
+	_DRM_STAT_COUNT,	/* Generic non-byte counter (1000/k)  */
+
+	_DRM_STAT_IRQ,		/* IRQ */
+	_DRM_STAT_PRIMARY,	/* Primary DMA bytes */
+	_DRM_STAT_SECONDARY,	/* Secondary DMA bytes */
+	_DRM_STAT_DMA,		/* DMA */
+	_DRM_STAT_SPECIAL,	/* Special DMA (e.g., priority or polled) */
+	_DRM_STAT_MISSED	/* Missed DMA opportunity */
+
+				/* Add to the *END* of the list */
+} drm_stat_type_t;
+
+typedef struct drm_stats {
+	unsigned long count;
+	struct {
+		unsigned long   value;
+		drm_stat_type_t type;
+	} data[15];
+} drm_stats_t;
+
+typedef enum drm_lock_flags {
+	_DRM_LOCK_READY	     = 0x01, /* Wait until hardware is ready for DMA */
+	_DRM_LOCK_QUIESCENT  = 0x02, /* Wait until hardware quiescent	     */
+	_DRM_LOCK_FLUSH	     = 0x04, /* Flush this context's DMA queue first */
+	_DRM_LOCK_FLUSH_ALL  = 0x08, /* Flush all DMA queues first	     */
+				/* These *HALT* flags aren't supported yet
+				   -- they will be used to support the
+				   full-screen DGA-like mode. */
+	_DRM_HALT_ALL_QUEUES = 0x10, /* Halt all current and future queues   */
+	_DRM_HALT_CUR_QUEUES = 0x20  /* Halt all current queues		     */
+} drm_lock_flags_t;
+
+typedef struct drm_lock {
+	int		 context;
+	drm_lock_flags_t flags;
+} drm_lock_t;
+
+typedef enum drm_dma_flags {	      /* These values *MUST* match xf86drm.h */
+				      /* Flags for DMA buffer dispatch	     */
+	_DRM_DMA_BLOCK	      = 0x01, /* Block until buffer dispatched.
+					 Note, the buffer may not yet have
+					 been processed by the hardware --
+					 getting a hardware lock with the
+					 hardware quiescent will ensure
+					 that the buffer has been
+					 processed.			     */
+	_DRM_DMA_WHILE_LOCKED = 0x02, /* Dispatch while lock held	     */
+	_DRM_DMA_PRIORITY     = 0x04, /* High priority dispatch		     */
+
+				      /* Flags for DMA buffer request	     */
+	_DRM_DMA_WAIT	      = 0x10, /* Wait for free buffers		     */
+	_DRM_DMA_SMALLER_OK   = 0x20, /* Smaller-than-requested buffers ok   */
+	_DRM_DMA_LARGER_OK    = 0x40  /* Larger-than-requested buffers ok    */
+} drm_dma_flags_t;
+
+typedef struct drm_buf_desc {
+	int	      count;	 /* Number of buffers of this size	     */
+	int	      size;	 /* Size in bytes			     */
+	int	      low_mark;	 /* Low water mark			     */
+	int	      high_mark; /* High water mark			     */
+	enum {
+		_DRM_PAGE_ALIGN = 0x01, /* Align on page boundaries for DMA  */
+		_DRM_AGP_BUFFER = 0x02, /* Buffer is in agp space            */
+		_DRM_SG_BUFFER  = 0x04  /* Scatter/gather memory buffer      */
+	}	      flags;
+	unsigned long agp_start; /* Start address of where the agp buffers
+				  * are in the agp aperture */
+} drm_buf_desc_t;
+
+typedef struct drm_buf_info {
+	int	       count;	/* Entries in list			     */
+	drm_buf_desc_t *list;
+} drm_buf_info_t;
+
+typedef struct drm_buf_free {
+	int	       count;
+	int	       *list;
+} drm_buf_free_t;
+
+typedef struct drm_buf_pub {
+	int		  idx;	       /* Index into master buflist	     */
+	int		  total;       /* Buffer size			     */
+	int		  used;	       /* Amount of buffer in use (for DMA)  */
+	void		  *address;    /* Address of buffer		     */
+} drm_buf_pub_t;
+
+typedef struct drm_buf_map {
+	int	      count;	/* Length of buflist			    */
+	void	      *virtual;	/* Mmaped area in user-virtual		    */
+	drm_buf_pub_t *list;	/* Buffer information			    */
+} drm_buf_map_t;
+
+typedef struct drm_dma {
+				/* Indices here refer to the offset into
+				   buflist in drm_buf_get_t.  */
+	int		context;	  /* Context handle		    */
+	int		send_count;	  /* Number of buffers to send	    */
+	int		*send_indices;	  /* List of handles to buffers	    */
+	int		*send_sizes;	  /* Lengths of data to send	    */
+	drm_dma_flags_t flags;		  /* Flags			    */
+	int		request_count;	  /* Number of buffers requested    */
+	int		request_size;	  /* Desired size for buffers	    */
+	int		*request_indices; /* Buffer information		    */
+	int		*request_sizes;
+	int		granted_count;	  /* Number of buffers granted	    */
+} drm_dma_t;
+
+typedef enum {
+	_DRM_CONTEXT_PRESERVED = 0x01,
+	_DRM_CONTEXT_2DONLY    = 0x02
+} drm_ctx_flags_t;
+
+typedef struct drm_ctx {
+	drm_context_t	handle;
+	drm_ctx_flags_t flags;
+} drm_ctx_t;
+
+typedef struct drm_ctx_res {
+	int		count;
+	drm_ctx_t	*contexts;
+} drm_ctx_res_t;
+
+typedef struct drm_draw {
+	drm_drawable_t	handle;
+} drm_draw_t;
+
+typedef struct drm_auth {
+	drm_magic_t	magic;
+} drm_auth_t;
+
+typedef struct drm_irq_busid {
+	int irq;
+	int busnum;
+	int devnum;
+	int funcnum;
+} drm_irq_busid_t;
+
+typedef enum {
+    _DRM_VBLANK_ABSOLUTE = 0x0,		/* Wait for specific vblank sequence number */
+    _DRM_VBLANK_RELATIVE = 0x1,		/* Wait for given number of vblanks */
+    _DRM_VBLANK_SIGNAL   = 0x40000000	/* Send signal instead of blocking */
+} drm_vblank_seq_type_t;
+
+#define _DRM_VBLANK_FLAGS_MASK _DRM_VBLANK_SIGNAL
+
+struct drm_wait_vblank_request {
+	drm_vblank_seq_type_t type;
+	unsigned int sequence;
+	unsigned long signal;
+};
+
+struct drm_wait_vblank_reply {
+	drm_vblank_seq_type_t type;
+	unsigned int sequence;
+	long tval_sec;
+	long tval_usec;
+};
+
+typedef union drm_wait_vblank {
+	struct drm_wait_vblank_request request;
+	struct drm_wait_vblank_reply reply;
+} drm_wait_vblank_t;
+
+typedef struct drm_agp_mode {
+	unsigned long mode;
+} drm_agp_mode_t;
+
+				/* For drm_agp_alloc -- allocated a buffer */
+typedef struct drm_agp_buffer {
+	unsigned long size;	/* In bytes -- will round to page boundary */
+	unsigned long handle;	/* Used for BIND/UNBIND ioctls */
+	unsigned long type;     /* Type of memory to allocate  */
+        unsigned long physical; /* Physical used by i810       */
+} drm_agp_buffer_t;
+
+				/* For drm_agp_bind */
+typedef struct drm_agp_binding {
+	unsigned long handle;   /* From drm_agp_buffer */
+	unsigned long offset;	/* In bytes -- will round to page boundary */
+} drm_agp_binding_t;
+
+typedef struct drm_agp_info {
+	int            agp_version_major;
+	int            agp_version_minor;
+	unsigned long  mode;
+	unsigned long  aperture_base;  /* physical address */
+	unsigned long  aperture_size;  /* bytes */
+	unsigned long  memory_allowed; /* bytes */
+	unsigned long  memory_used;
+
+				/* PCI information */
+	unsigned short id_vendor;
+	unsigned short id_device;
+} drm_agp_info_t;
+
+typedef struct drm_scatter_gather {
+	unsigned long size;	/* In bytes -- will round to page boundary */
+	unsigned long handle;	/* Used for mapping / unmapping */
+} drm_scatter_gather_t;
+
+#define DRM_IOCTL_BASE			'd'
+#define DRM_IO(nr)			_IO(DRM_IOCTL_BASE,nr)
+#define DRM_IOR(nr,type)		_IOR(DRM_IOCTL_BASE,nr,type)
+#define DRM_IOW(nr,type)		_IOW(DRM_IOCTL_BASE,nr,type)
+#define DRM_IOWR(nr,type)		_IOWR(DRM_IOCTL_BASE,nr,type)
+
+#define DRM_IOCTL_VERSION		DRM_IOWR(0x00, drm_version_t)
+#define DRM_IOCTL_GET_UNIQUE		DRM_IOWR(0x01, drm_unique_t)
+#define DRM_IOCTL_GET_MAGIC		DRM_IOR( 0x02, drm_auth_t)
+#define DRM_IOCTL_IRQ_BUSID		DRM_IOWR(0x03, drm_irq_busid_t)
+#define DRM_IOCTL_GET_MAP               DRM_IOWR(0x04, drm_map_t)
+#define DRM_IOCTL_GET_CLIENT            DRM_IOWR(0x05, drm_client_t)
+#define DRM_IOCTL_GET_STATS             DRM_IOR( 0x06, drm_stats_t)
+
+#define DRM_IOCTL_SET_UNIQUE		DRM_IOW( 0x10, drm_unique_t)
+#define DRM_IOCTL_AUTH_MAGIC		DRM_IOW( 0x11, drm_auth_t)
+#define DRM_IOCTL_BLOCK			DRM_IOWR(0x12, drm_block_t)
+#define DRM_IOCTL_UNBLOCK		DRM_IOWR(0x13, drm_block_t)
+#define DRM_IOCTL_CONTROL		DRM_IOW( 0x14, drm_control_t)
+#define DRM_IOCTL_ADD_MAP		DRM_IOWR(0x15, drm_map_t)
+#define DRM_IOCTL_ADD_BUFS		DRM_IOWR(0x16, drm_buf_desc_t)
+#define DRM_IOCTL_MARK_BUFS		DRM_IOW( 0x17, drm_buf_desc_t)
+#define DRM_IOCTL_INFO_BUFS		DRM_IOWR(0x18, drm_buf_info_t)
+#define DRM_IOCTL_MAP_BUFS		DRM_IOWR(0x19, drm_buf_map_t)
+#define DRM_IOCTL_FREE_BUFS		DRM_IOW( 0x1a, drm_buf_free_t)
+
+#define DRM_IOCTL_RM_MAP		DRM_IOW( 0x1b, drm_map_t)
+
+#define DRM_IOCTL_SET_SAREA_CTX		DRM_IOW( 0x1c, drm_ctx_priv_map_t)
+#define DRM_IOCTL_GET_SAREA_CTX 	DRM_IOWR(0x1d, drm_ctx_priv_map_t)
+
+#define DRM_IOCTL_ADD_CTX		DRM_IOWR(0x20, drm_ctx_t)
+#define DRM_IOCTL_RM_CTX		DRM_IOWR(0x21, drm_ctx_t)
+#define DRM_IOCTL_MOD_CTX		DRM_IOW( 0x22, drm_ctx_t)
+#define DRM_IOCTL_GET_CTX		DRM_IOWR(0x23, drm_ctx_t)
+#define DRM_IOCTL_SWITCH_CTX		DRM_IOW( 0x24, drm_ctx_t)
+#define DRM_IOCTL_NEW_CTX		DRM_IOW( 0x25, drm_ctx_t)
+#define DRM_IOCTL_RES_CTX		DRM_IOWR(0x26, drm_ctx_res_t)
+#define DRM_IOCTL_ADD_DRAW		DRM_IOWR(0x27, drm_draw_t)
+#define DRM_IOCTL_RM_DRAW		DRM_IOWR(0x28, drm_draw_t)
+#define DRM_IOCTL_DMA			DRM_IOWR(0x29, drm_dma_t)
+#define DRM_IOCTL_LOCK			DRM_IOW( 0x2a, drm_lock_t)
+#define DRM_IOCTL_UNLOCK		DRM_IOW( 0x2b, drm_lock_t)
+#define DRM_IOCTL_FINISH		DRM_IOW( 0x2c, drm_lock_t)
+
+#define DRM_IOCTL_AGP_ACQUIRE		DRM_IO(  0x30)
+#define DRM_IOCTL_AGP_RELEASE		DRM_IO(  0x31)
+#define DRM_IOCTL_AGP_ENABLE		DRM_IOW( 0x32, drm_agp_mode_t)
+#define DRM_IOCTL_AGP_INFO		DRM_IOR( 0x33, drm_agp_info_t)
+#define DRM_IOCTL_AGP_ALLOC		DRM_IOWR(0x34, drm_agp_buffer_t)
+#define DRM_IOCTL_AGP_FREE		DRM_IOW( 0x35, drm_agp_buffer_t)
+#define DRM_IOCTL_AGP_BIND		DRM_IOW( 0x36, drm_agp_binding_t)
+#define DRM_IOCTL_AGP_UNBIND		DRM_IOW( 0x37, drm_agp_binding_t)
+
+#define DRM_IOCTL_SG_ALLOC		DRM_IOW( 0x38, drm_scatter_gather_t)
+#define DRM_IOCTL_SG_FREE		DRM_IOW( 0x39, drm_scatter_gather_t)
+
+#define DRM_IOCTL_WAIT_VBLANK		DRM_IOWR(0x3a, drm_wait_vblank_t)
+
+/* Device specfic ioctls should only be in their respective headers
+ * The device specific ioctl range is 0x40 to 0x79.                  */
+#define DRM_COMMAND_BASE                0x40
+
+#endif

src/dri-es/extutil.h

@@ -0,0 +1,224 @@
+/*
+ * $Xorg: extutil.h,v 1.4 2001/02/09 02:03:24 xorgcvs Exp $
+ *
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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 THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ * Author:  Jim Fulton, MIT The Open Group
+ * 
+ *                     Xlib Extension-Writing Utilities
+ *
+ * This package contains utilities for writing the client API for various
+ * protocol extensions.  THESE INTERFACES ARE NOT PART OF THE X STANDARD AND
+ * ARE SUBJECT TO CHANGE!
+ */
+/* $XFree86: xc/include/extensions/extutil.h,v 1.9 2001/12/14 19:53:28 dawes Exp $ */
+
+#ifndef _EXTUTIL_H_
+#define _EXTUTIL_H_
+
+#include <X11/extensions/Xext.h>
+
+/*
+ * We need to keep a list of open displays since the Xlib display list isn't
+ * public.  We also have to per-display info in a separate block since it isn't
+ * stored directly in the Display structure.
+ */
+typedef struct _XExtDisplayInfo {
+    struct _XExtDisplayInfo *next;	/* keep a linked list */
+    Display *display;			/* which display this is */
+    XExtCodes *codes;			/* the extension protocol codes */
+    XPointer data;			/* extra data for extension to use */
+} XExtDisplayInfo;
+
+typedef struct _XExtensionInfo {
+    XExtDisplayInfo *head;		/* start of list */
+    XExtDisplayInfo *cur;		/* most recently used */
+    int ndisplays;			/* number of displays */
+} XExtensionInfo;
+
+typedef struct _XExtensionHooks {
+    int (*create_gc)(
+#if NeedNestedPrototypes
+	      Display*			/* display */,
+	      GC			/* gc */,
+	      XExtCodes*		/* codes */
+#endif
+);
+    int (*copy_gc)(
+#if NeedNestedPrototypes
+	      Display*			/* display */,
+              GC			/* gc */,
+              XExtCodes*		/* codes */
+#endif
+);
+    int (*flush_gc)(
+#if NeedNestedPrototypes
+	      Display*			/* display */,
+              GC			/* gc */,
+              XExtCodes*		/* codes */
+#endif
+);
+    int (*free_gc)(
+#if NeedNestedPrototypes
+	      Display*			/* display */,
+              GC			/* gc */,
+              XExtCodes*		/* codes */
+#endif
+);
+    int (*create_font)(
+#if NeedNestedPrototypes
+	      Display*			/* display */,
+              XFontStruct*		/* fs */,
+              XExtCodes*		/* codes */
+#endif
+);
+    int (*free_font)(
+#if NeedNestedPrototypes
+	      Display*			/* display */,
+              XFontStruct*		/* fs */,
+              XExtCodes*		/* codes */
+#endif
+);
+    int (*close_display)(
+#if NeedNestedPrototypes
+	      Display*			/* display */,
+              XExtCodes*		/* codes */
+#endif
+);
+    Bool (*wire_to_event)(
+#if NeedNestedPrototypes
+	       Display*			/* display */,
+               XEvent*			/* re */,
+               xEvent*			/* event */
+#endif
+);
+    Status (*event_to_wire)(
+#if NeedNestedPrototypes
+	      Display*			/* display */,
+              XEvent*			/* re */,
+              xEvent*			/* event */
+#endif
+);
+    int (*error)(
+#if NeedNestedPrototypes
+	      Display*			/* display */,
+              xError*			/* err */,
+              XExtCodes*		/* codes */,
+              int*			/* ret_code */
+#endif
+);
+    char *(*error_string)(
+#if NeedNestedPrototypes
+	        Display*		/* display */,
+                int			/* code */,
+                XExtCodes*		/* codes */,
+                char*			/* buffer */,
+                int			/* nbytes */
+#endif
+);
+} XExtensionHooks;
+
+extern XExtensionInfo *XextCreateExtension(
+#if NeedFunctionPrototypes
+    void
+#endif
+);
+extern void XextDestroyExtension(
+#if NeedFunctionPrototypes
+    XExtensionInfo*	/* info */
+#endif
+);
+extern XExtDisplayInfo *XextAddDisplay(
+#if NeedFunctionPrototypes
+    XExtensionInfo*	/* extinfo */,
+    Display*		/* dpy */,
+    char*		/* ext_name */,
+    XExtensionHooks*	/* hooks */,
+    int			/* nevents */,
+    XPointer		/* data */
+#endif
+);
+extern int XextRemoveDisplay(
+#if NeedFunctionPrototypes
+    XExtensionInfo*	/* extinfo */,
+    Display*		/* dpy */
+#endif
+);
+extern XExtDisplayInfo *XextFindDisplay(
+#if NeedFunctionPrototypes
+    XExtensionInfo*	/* extinfo */,
+    Display*		/* dpy */
+#endif
+);
+
+#define XextHasExtension(i) ((i) && ((i)->codes))
+#define XextCheckExtension(dpy,i,name,val) \
+  if (!XextHasExtension(i)) { XMissingExtension (dpy, name); return val; }
+#define XextSimpleCheckExtension(dpy,i,name) \
+  if (!XextHasExtension(i)) { XMissingExtension (dpy, name); return; }
+
+
+/*
+ * helper macros to generate code that is common to all extensions; caller
+ * should prefix it with static if extension source is in one file; this
+ * could be a utility function, but have to stack 6 unused arguments for 
+ * something that is called many, many times would be bad.
+ */
+#define XEXT_GENERATE_FIND_DISPLAY(proc,extinfo,extname,hooks,nev,data) \
+XExtDisplayInfo *proc (Display *dpy) \
+{ \
+    XExtDisplayInfo *dpyinfo; \
+    if (!extinfo) { if (!(extinfo = XextCreateExtension())) return NULL; } \
+    if (!(dpyinfo = XextFindDisplay (extinfo, dpy))) \
+      dpyinfo = XextAddDisplay (extinfo,dpy,extname,hooks,nev,data); \
+    return dpyinfo; \
+}
+
+#define XEXT_FIND_DISPLAY_PROTO(proc) \
+	XExtDisplayInfo *proc(Display *dpy)
+
+#define XEXT_GENERATE_CLOSE_DISPLAY(proc,extinfo) \
+int proc (Display *dpy, XExtCodes *codes) \
+{ \
+    return XextRemoveDisplay (extinfo, dpy); \
+}
+
+#define XEXT_CLOSE_DISPLAY_PROTO(proc) \
+	int proc(Display *dpy, XExtCodes *codes)
+
+#define XEXT_GENERATE_ERROR_STRING(proc,extname,nerr,errl) \
+char *proc (Display *dpy, int code, XExtCodes *codes, char *buf, int n) \
+{  \
+    code -= codes->first_error;  \
+    if (code >= 0 && code < nerr) { \
+	char tmp[256]; \
+	sprintf (tmp, "%s.%d", extname, code); \
+	XGetErrorDatabaseText (dpy, "XProtoError", tmp, errl[code], buf, n); \
+	return buf; \
+    } \
+    return (char *)0; \
+}
+
+#define XEXT_ERROR_STRING_PROTO(proc) \
+	char *proc(Display *dpy, int code, XExtCodes *codes, char *buf, int n)
+#endif

src/dri-es/glxclient.h

@@ -0,0 +1,678 @@
+/*
+** 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.14 2002/02/22 21:32:53 dawes Exp $ */
+
+/*
+ * Direct rendering support added by Precision Insight, Inc.
+ *
+ * Authors:
+ *   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 <string.h>
+#include <stdlib.h>
+#include "GL/glxint.h"
+#include "GL/glxproto.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	2
+
+#define __GL_BOOLEAN_ARRAY	(GL_BYTE - 1)
+
+#define __GLX_MAX_TEXTURE_UNITS 32
+
+typedef struct __GLXcontextRec __GLXcontext;
+typedef struct __GLXdisplayPrivateRec __GLXdisplayPrivate;
+typedef struct _glapi_table __GLapi;
+
+/************************************************************************/
+
+
+/*
+** The following structures define the interface between the GLX client
+** side library and the DRI (direct rendering infrastructure).
+*/
+typedef struct __DRIdisplayRec  __DRIdisplay;
+typedef struct __DRIscreenRec   __DRIscreen;
+typedef struct __DRIcontextRec  __DRIcontext;
+typedef struct __DRIdrawableRec __DRIdrawable;
+typedef struct __DRIdriverRec   __DRIdriver;
+
+extern __DRIscreen *__glXFindDRIScreen(Display *dpy, int scrn);
+
+/*
+** Display dependent methods.  This structure is initialized during the
+** 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.
+    */
+    void *(**createScreen)(Display *dpy, int scrn, __DRIscreen *psc,
+			  int numConfigs, __GLXvisualConfig *config);
+
+    /*
+    ** Opaque pointer to private per display direct rendering data.
+    ** NULL if direct rendering is not supported on this display.  Never
+    ** dereferenced in libGL.
+    */
+    void *private;
+};
+
+/*
+** Screen dependent methods.  This structure is initialized during the
+** (*createScreen)() call.
+*/
+struct __DRIscreenRec {
+    /*
+    ** Method to destroy the private DRI screen data.
+    */
+    void (*destroyScreen)(Display *dpy, int scrn, void *screenPrivate);
+
+    /*
+    ** Method to create the private DRI context data and initialize the
+    ** context dependent methods.
+    */
+    void *(*createContext)(Display *dpy, XVisualInfo *vis, void *sharedPrivate,
+			   __DRIcontext *pctx);
+
+    /*
+    ** Method to create the private DRI drawable data and initialize the
+    ** drawable dependent methods.
+    */
+    void *(*createDrawable)(Display *dpy, int scrn, GLXDrawable draw,
+			    VisualID vid, __DRIdrawable *pdraw);
+
+    /*
+    ** Method to return a pointer to the DRI drawable data.
+    */
+    __DRIdrawable *(*getDrawable)(Display *dpy, GLXDrawable draw,
+				  void *drawablePrivate);
+
+    /*
+    ** XXX in the future, implement this:
+    void *(*createPBuffer)(Display *dpy, int scrn, GLXPbuffer pbuffer,
+			   GLXFBConfig config, __DRIdrawable *pdraw);
+    **/
+
+    /*
+    ** Opaque pointer to private per screen direct rendering data.  NULL
+    ** if direct rendering is not supported on this screen.  Never
+    ** dereferenced in libGL.
+    */
+    void *private;
+};
+
+/*
+** Context dependent methods.  This structure is initialized during the
+** (*createContext)() call.
+*/
+struct __DRIcontextRec {
+    /*
+    ** Method to destroy the private DRI context data.
+    */
+    void (*destroyContext)(Display *dpy, int scrn, void *contextPrivate);
+
+    /*
+    ** Method to bind a DRI drawable to a DRI graphics context.
+    ** XXX in the future, also pass a 'read' GLXDrawable for
+    ** glXMakeCurrentReadSGI() and GLX 1.3's glXMakeContextCurrent().
+    */
+    Bool (*bindContext)(Display *dpy, int scrn, GLXDrawable draw,
+			GLXContext gc);
+
+    /*
+    ** Method to unbind a DRI drawable to a DRI graphics context.
+    */
+    Bool (*unbindContext)(Display *dpy, int scrn, GLXDrawable draw,
+			  GLXContext gc, int will_rebind);
+
+    /*
+    ** Opaque pointer to private per context direct rendering data.
+    ** NULL if direct rendering is not supported on the display or
+    ** screen used to create this context.  Never dereferenced in libGL.
+    */
+    void *private;
+};
+
+/*
+** Drawable dependent methods.  This structure is initialized during the
+** (*createDrawable)() call.  createDrawable() is not called by libGL at
+** this time.  It's currently used via the dri_util.c utility code instead.
+*/
+struct __DRIdrawableRec {
+    /*
+    ** Method to destroy the private DRI drawable data.
+    */
+    void (*destroyDrawable)(Display *dpy, void *drawablePrivate);
+
+    /*
+    ** Method to swap the front and back buffers.
+    */
+    void (*swapBuffers)(Display *dpy, void *drawablePrivate);
+
+    /*
+    ** Opaque pointer to private per drawable direct rendering data.
+    ** NULL if direct rendering is not supported on the display or
+    ** screen used to create this drawable.  Never dereferenced in libGL.
+    */
+    void *private;
+};
+
+
+typedef void *(*CreateScreenFunc)(Display *dpy, int scrn, __DRIscreen *psc,
+                                  int numConfigs, __GLXvisualConfig *config);
+
+typedef void *(*RegisterExtensionsFunc)(void);
+
+/*
+** We keep a linked list of these structures, one per DRI device driver.
+*/
+struct __DRIdriverRec {
+   const char *name;
+   void *handle;
+   CreateScreenFunc createScreenFunc;
+   RegisterExtensionsFunc registerExtensionsFunc;
+   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 );
+
+/************************************************************************/
+
+#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;
+
+typedef struct __GLXvertexArrayPointerStateRec {
+    GLboolean enable;
+    void (*proc)(const void *);
+    const GLubyte *ptr;
+    GLsizei skip;
+    GLint size;
+    GLenum type;
+    GLsizei stride;
+} __GLXvertexArrayPointerState;
+
+typedef struct __GLXvertArrayStateRec {
+    __GLXvertexArrayPointerState vertex;
+    __GLXvertexArrayPointerState normal;
+    __GLXvertexArrayPointerState color;
+    __GLXvertexArrayPointerState index;
+    __GLXvertexArrayPointerState texCoord[__GLX_MAX_TEXTURE_UNITS];
+    __GLXvertexArrayPointerState edgeFlag;
+    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;
+} __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 {
+    /*
+    ** 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
+    ** __glXFlushRenderBuffer.  "pc" is the next location in the buffer
+    ** to be filled.  "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 shareList context.
+    */
+    XID share_xid;
+
+    /*
+    ** Visual id.
+    */
+    VisualID vid;
+
+    /*
+    ** screen number.
+    */
+    GLint screen;
+
+    /*
+    ** 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., Render, RenderLarge,
+    ** WaitX, WaitGL, UseXFont, and MakeCurrent (for the old context)).
+    */
+    GLXContextTag currentContextTag;
+
+    /*
+    ** The rendering mode is kept on the client as well as the server.
+    ** When glRenderMode() is called, the buffer associated with the
+    ** previous rendering mode (feedback or select) is filled.
+    */
+    GLenum renderMode;
+    GLfloat *feedbackBuf;
+    GLuint *selectBuf;
+
+    /*
+    ** This is 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 oldImage getting it
+    ** ready for transport to the server.
+    */
+    void (*fillImage)(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+		      GLenum, const GLvoid*, GLubyte*, GLubyte*);
+
+    /*
+    ** Client side attribs.
+    */
+    __GLXattribute state;
+    __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;
+
+    /*
+    ** dpy of current display for this context. Will be 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.
+    */
+    GLXDrawable currentDrawable;
+
+    /*
+    ** 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;
+
+    /*
+    ** Per context direct rendering interface functions and data.
+    */
+    __DRIcontext driContext;
+};
+
+#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
+** 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 {
+    __GLXvisualConfig *configs;
+    int numConfigs;
+    const char *serverGLXexts;
+    char *effectiveGLXexts;
+
+    /*
+    ** Per screen direct rendering interface functions and data.
+    */
+    __DRIscreen driScreen;
+} __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 majorOpcode is common to all connections to the same server.
+    ** It is also copied into the context structure.
+    */
+    int majorOpcode;
+
+    /*
+    ** Major and minor version returned by the server during initialization.
+    */
+    int majorVersion, minorVersion;
+
+    /* 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.
+    */
+    char *serverGLXvendor;
+    char *serverGLXversion;
+
+    /*
+    ** Configurations of visuals for all screens on this display.
+    ** Also, per screen data which now includes the server GLX_EXTENSION
+    ** string.
+    */
+    __GLXscreenConfigs *screenConfigs;
+
+    /*
+    ** Per display direct rendering interface functions and data.
+    */
+    __DRIdisplay driDisplay;
+};
+
+void __glXFreeContext(__GLXcontext*);
+
+extern GLubyte *__glXFlushRenderBuffer(__GLXcontext*, GLubyte*);
+
+extern void __glXSendLargeCommand(__GLXcontext *, const GLvoid *, GLint,
+				  const GLvoid *, GLint);
+
+/* Initialize the GLX extension for dpy */
+extern __GLXdisplayPrivate *__glXInitialize(Display*);
+
+/* Query drivers for dynamically registered extensions */
+extern void __glXRegisterExtensions(void);
+
+/* Functions for extending the GLX API: */
+extern void *__glXRegisterGLXFunction(const char *funcName, void *funcAddr);
+extern void __glXRegisterGLXExtensionString(const char *extName);
+
+
+/************************************************************************/
+
+extern int __glXDebug;
+
+/* This is per-thread storage in an MT environment */
+#if 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(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 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 char *__glXstrdup(const char *str);
+
+extern int __glXGetInternalVersion(void);
+
+extern Bool __glXWindowExists(Display *dpy, GLXDrawable draw);
+
+#endif /* !__GLX_client_h__ */

src/dri-es/sarea.h

@@ -0,0 +1,80 @@
+/* $XFree86: xc/programs/Xserver/GL/dri/sarea.h,v 1.10 2001/10/04 18:28:20 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 <kevin@precisioninsight.com>
+ *   Jens Owen <jens@tungstengraphics.com>
+ *   Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ */
+
+#ifndef _SAREA_H_
+#define _SAREA_H_
+
+#include "xf86drm.h"
+
+/* SAREA area needs to be at least a page */
+#if defined(__alpha__)
+#define SAREA_MAX 			0x2000
+#elif defined(__ia64__)
+#define SAREA_MAX			0x10000		/* 64kB */
+#else
+/* Intel 830M driver needs at least 8k SAREA */
+#define SAREA_MAX			0x2000
+#endif
+
+#define SAREA_MAX_DRAWABLES 		256
+
+#define SAREA_DRAWABLE_CLAIMED_ENTRY	0x80000000
+
+typedef struct _XF86DRISAREADrawable {
+    unsigned int	stamp;
+    unsigned int	flags;
+} XF86DRISAREADrawableRec, *XF86DRISAREADrawablePtr;
+
+typedef struct _XF86DRISAREAFrame {
+    unsigned int        x;
+    unsigned int        y;
+    unsigned int        width;
+    unsigned int        height;
+    unsigned int        fullscreen;
+} XF86DRISAREAFrameRec, *XF86DRISAREAFramePtr;
+
+typedef struct _XF86DRISAREA {
+    /* first thing is always the drm locking structure */
+    drmLock			lock;
+		/* NOT_DONE: Use readers/writer lock for drawable_lock */
+    drmLock			drawable_lock;
+    XF86DRISAREADrawableRec	drawableTable[SAREA_MAX_DRAWABLES];
+    XF86DRISAREAFrameRec        frame;
+    drmContext			dummy_context;
+} XF86DRISAREARec, *XF86DRISAREAPtr;
+
+#endif

src/dri-es/xf86dri.h

@@ -0,0 +1,227 @@
+/* $XFree86: xc/lib/GL/dri/xf86dri.h,v 1.7 2000/12/07 20:26:02 dawes 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>
+ *
+ */
+
+#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
+#define X_XF86DRICloseFullScreen                13
+
+#define XF86DRINumberEvents		0
+
+#define XF86DRIClientNotLocal		0
+#define XF86DRIOperationNotSupported	1
+#define XF86DRINumberErrors		(XF86DRIOperationNotSupported + 1)
+
+/* Warning : Do not change XF86DRIClipRect without changing the kernel 
+ * structure! */
+typedef struct _XF86DRIClipRect {
+    unsigned short	x1; /* Upper left: inclusive */
+    unsigned short	y1;
+    unsigned short	x2; /* Lower right: exclusive */
+    unsigned short	y2;
+} XF86DRIClipRectRec, *XF86DRIClipRectPtr;
+
+#ifndef _XF86DRI_SERVER_
+
+_XFUNCPROTOBEGIN
+
+Bool XF86DRIQueryExtension(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int*		/* event_base */,
+    int*		/* error_base */
+#endif
+);
+
+Bool XF86DRIQueryVersion(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int*		/* majorVersion */,
+    int*		/* minorVersion */,
+    int*		/* patchVersion */
+#endif
+);
+
+Bool XF86DRIQueryDirectRenderingCapable(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    Bool*		/* isCapable */
+#endif
+);
+
+Bool XF86DRIOpenConnection(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    drmHandlePtr	/* hSAREA */,
+    char**		/* busIDString */
+#endif
+);
+
+Bool XF86DRIAuthConnection(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    drmMagic            /* magic */
+#endif
+);
+
+Bool XF86DRICloseConnection(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */
+#endif
+);
+
+Bool XF86DRIGetClientDriverName(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    int*		/* ddxDriverMajorVersion */,
+    int*		/* ddxDriverMinorVersion */,
+    int*		/* ddxDriverPatchVersion */,
+    char**		/* clientDriverName */
+#endif
+);
+
+Bool XF86DRICreateContext(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    Visual*		/* visual */,
+    XID*		/* ptr to returned context id */,
+    drmContextPtr	/* hHWContext */
+#endif
+);
+
+Bool XF86DRIDestroyContext(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    XID 	        /* context id */
+#endif
+);
+
+Bool XF86DRICreateDrawable(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    Drawable		/* drawable */,
+    drmDrawablePtr 	/* hHWDrawable */
+#endif
+);
+
+Bool XF86DRIDestroyDrawable(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    Drawable 		/* drawable */
+#endif
+);
+
+Bool XF86DRIGetDrawableInfo(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    Drawable 		/* drawable */,
+    unsigned int*	/* index */,
+    unsigned int*	/* stamp */,
+    int*		/* X */,
+    int*		/* Y */,
+    int*		/* W */,
+    int*		/* H */,
+    int*		/* numClipRects */,
+    XF86DRIClipRectPtr*,/* pClipRects */
+    int*		/* backX */,
+    int*		/* backY */,
+    int*		/* numBackClipRects */,
+    XF86DRIClipRectPtr*	/* pBackClipRects */    
+#endif
+);
+
+Bool XF86DRIGetDeviceInfo(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int			/* screen */,
+    drmHandlePtr	/* hFrameBuffer */,
+    int*		/* fbOrigin */,
+    int*		/* fbSize */,
+    int*		/* fbStride */,
+    int*		/* devPrivateSize */,
+    void**		/* pDevPrivate */
+#endif
+);
+
+Bool XF86DRIOpenFullScreen(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int                 /* screen */,
+    Drawable 		/* drawable */
+#endif
+);
+
+Bool XF86DRICloseFullScreen(
+#if NeedFunctionPrototypes
+    Display*		/* dpy */,
+    int                 /* screen */,
+    Drawable 		/* drawable */
+#endif
+);
+
+_XFUNCPROTOEND
+
+#endif /* _XF86DRI_SERVER_ */
+
+#endif /* _XF86DRI_H_ */
+

src/dri-es/xf86dristr.h

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

src/dri-es/xf86drm.h

@@ -0,0 +1,607 @@
+/* xf86drm.h -- OS-independent header for DRM user-level library interface
+ * Created: Tue Jan  5 08:17:23 1999 by faith@precisioninsight.com
+ *
+ * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * 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 (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 NONINFRINGEMENT.  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.
+ *
+ * Author: Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ * $XFree86: xc/programs/Xserver/hw/xfree86/os-support/xf86drm.h,v 1.17 2002/10/16 01:26:48 dawes Exp $
+ *
+ */
+
+#ifndef _XF86DRM_H_
+#define _XF86DRM_H_
+
+				/* Defaults, if nothing set in xf86config */
+#define DRM_DEV_UID	 0
+#define DRM_DEV_GID	 0
+/* Default /dev/dri directory permissions 0755 */
+#define DRM_DEV_DIRMODE	 	\
+	(S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
+#define DRM_DEV_MODE	 (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
+
+#define DRM_DIR_NAME  "/dev/dri"
+#define DRM_DEV_NAME  "%s/card%d"
+#define DRM_PROC_NAME "/proc/dri/" /* For backware Linux compatibility */
+
+#define DRM_ERR_NO_DEVICE  (-1001)
+#define DRM_ERR_NO_ACCESS  (-1002)
+#define DRM_ERR_NOT_ROOT   (-1003)
+#define DRM_ERR_INVALID    (-1004)
+#define DRM_ERR_NO_FD      (-1005)
+
+typedef unsigned long drmHandle,   *drmHandlePtr;   /* To mapped regions    */
+typedef unsigned int  drmSize,     *drmSizePtr;	    /* For mapped regions   */
+typedef void          *drmAddress, **drmAddressPtr; /* For mapped regions   */
+typedef unsigned int  drmContext,  *drmContextPtr;  /* GLXContext handle    */
+typedef unsigned int  drmDrawable, *drmDrawablePtr; /* Unused               */
+typedef unsigned int  drmMagic,    *drmMagicPtr;    /* Magic for auth       */
+
+typedef struct _drmVersion {
+    int     version_major;        /* Major version                          */
+    int     version_minor;        /* Minor version                          */
+    int     version_patchlevel;   /* Patch level                            */
+    int     name_len; 	          /* Length of name buffer                  */
+    char    *name;	          /* Name of driver                         */
+    int     date_len;             /* Length of date buffer                  */
+    char    *date;                /* User-space buffer to hold date         */
+    int     desc_len;	          /* Length of desc buffer                  */
+    char    *desc;                /* User-space buffer to hold desc         */
+} drmVersion, *drmVersionPtr;
+
+typedef struct _drmStats {
+    unsigned long count;	     /* Number of data                      */
+    struct {
+	unsigned long value;	     /* Value from kernel                   */
+	const char    *long_format;  /* Suggested format for long_name      */
+	const char    *long_name;    /* Long name for value                 */
+	const char    *rate_format;  /* Suggested format for rate_name      */
+	const char    *rate_name;    /* Short name for value per second     */
+	int           isvalue;       /* True if value (vs. counter)         */
+	const char    *mult_names;   /* Multiplier names (e.g., "KGM")      */
+	int           mult;          /* Multiplier value (e.g., 1024)       */
+	int           verbose;       /* Suggest only in verbose output      */
+    } data[15];
+} drmStatsT;
+
+
+				/* All of these enums *MUST* match with the
+                                   kernel implementation -- so do *NOT*
+                                   change them!  (The drmlib implementation
+                                   will just copy the flags instead of
+                                   translating them.) */
+typedef enum {
+    DRM_FRAME_BUFFER    = 0,      /* WC, no caching, no core dump           */
+    DRM_REGISTERS       = 1,      /* no caching, no core dump               */
+    DRM_SHM             = 2,      /* shared, cached                         */
+    DRM_AGP             = 3,	  /* AGP/GART                               */
+    DRM_SCATTER_GATHER  = 4	  /* PCI scatter/gather                     */
+} drmMapType;
+
+typedef enum {
+    DRM_RESTRICTED      = 0x0001, /* Cannot be mapped to client-virtual     */
+    DRM_READ_ONLY       = 0x0002, /* Read-only in client-virtual            */
+    DRM_LOCKED          = 0x0004, /* Physical pages locked                  */
+    DRM_KERNEL          = 0x0008, /* Kernel requires access                 */
+    DRM_WRITE_COMBINING = 0x0010, /* Use write-combining, if available      */
+    DRM_CONTAINS_LOCK   = 0x0020, /* SHM page that contains lock            */
+    DRM_REMOVABLE	= 0x0040  /* Removable mapping			    */
+} drmMapFlags;
+
+typedef enum {			 /* These values *MUST* match drm.h         */
+				 /* Flags for DMA buffer dispatch           */
+    DRM_DMA_BLOCK        = 0x01, /* Block until buffer dispatched.  Note,
+				     the buffer may not yet have been
+				     processed by the hardware -- getting a
+				     hardware lock with the hardware
+				     quiescent will ensure that the buffer
+				     has been processed.                    */
+    DRM_DMA_WHILE_LOCKED = 0x02, /* Dispatch while lock held                */
+    DRM_DMA_PRIORITY     = 0x04, /* High priority dispatch                  */
+
+				 /* Flags for DMA buffer request            */
+    DRM_DMA_WAIT         = 0x10, /* Wait for free buffers                   */
+    DRM_DMA_SMALLER_OK   = 0x20, /* Smaller-than-requested buffers ok       */
+    DRM_DMA_LARGER_OK    = 0x40  /* Larger-than-requested buffers ok        */
+} drmDMAFlags;
+
+typedef enum {
+    DRM_PAGE_ALIGN       = 0x01,
+    DRM_AGP_BUFFER       = 0x02,
+    DRM_SG_BUFFER        = 0x04
+} drmBufDescFlags;
+
+typedef enum {
+    DRM_LOCK_READY      = 0x01, /* Wait until hardware is ready for DMA */
+    DRM_LOCK_QUIESCENT  = 0x02, /* Wait until hardware quiescent        */
+    DRM_LOCK_FLUSH      = 0x04, /* Flush this context's DMA queue first */
+    DRM_LOCK_FLUSH_ALL  = 0x08, /* Flush all DMA queues first           */
+				/* These *HALT* flags aren't supported yet
+                                   -- they will be used to support the
+                                   full-screen DGA-like mode. */
+    DRM_HALT_ALL_QUEUES = 0x10, /* Halt all current and future queues   */
+    DRM_HALT_CUR_QUEUES = 0x20  /* Halt all current queues              */
+} drmLockFlags;
+
+typedef enum {
+    DRM_CONTEXT_PRESERVED = 0x01, /* This context is preserved and
+				     never swapped. */
+    DRM_CONTEXT_2DONLY    = 0x02  /* This context is for 2D rendering only. */
+} drmContextFlags, *drmContextFlagsPtr;
+
+typedef struct _drmBufDesc {
+    int              count;	  /* Number of buffers of this size         */
+    int              size;	  /* Size in bytes                          */
+    int              low_mark;	  /* Low water mark                         */
+    int              high_mark;	  /* High water mark                        */
+} drmBufDesc, *drmBufDescPtr;
+
+typedef struct _drmBufInfo {
+    int              count;	  /* Number of buffers described in list    */
+    drmBufDescPtr    list;	  /* List of buffer descriptions            */
+} drmBufInfo, *drmBufInfoPtr;
+
+typedef struct _drmBuf {
+    int              idx;	  /* Index into master buflist              */
+    int              total;	  /* Buffer size                            */
+    int              used;	  /* Amount of buffer in use (for DMA)      */
+    drmAddress       address;	  /* Address                                */
+} drmBuf, *drmBufPtr;
+
+typedef struct _drmBufMap {
+    int              count;	  /* Number of buffers mapped               */
+    drmBufPtr        list;	  /* Buffers                                */
+} drmBufMap, *drmBufMapPtr;
+
+typedef struct _drmLock {
+    volatile unsigned int lock;
+    char                      padding[60];
+    /* This is big enough for most current (and future?) architectures:
+       DEC Alpha:              32 bytes
+       Intel Merced:           ?
+       Intel P5/PPro/PII/PIII: 32 bytes
+       Intel StrongARM:        32 bytes
+       Intel i386/i486:        16 bytes
+       MIPS:                   32 bytes (?)
+       Motorola 68k:           16 bytes
+       Motorola PowerPC:       32 bytes
+       Sun SPARC:              32 bytes
+    */
+} drmLock, *drmLockPtr;
+
+typedef struct _drmDMAReq {
+				  /* Indices here refer to the offset into
+				     list in drmBufInfo                     */
+    drmContext    context;  	  /* Context handle                         */
+    int           send_count;     /* Number of buffers to send              */
+    int           *send_list;     /* List of handles to buffers             */
+    int           *send_sizes;    /* Lengths of data to send, in bytes      */
+    drmDMAFlags   flags;          /* Flags                                  */
+    int           request_count;  /* Number of buffers requested            */
+    int           request_size;	  /* Desired size of buffers requested      */
+    int           *request_list;  /* Buffer information                     */
+    int           *request_sizes; /* Minimum acceptable sizes               */
+    int           granted_count;  /* Number of buffers granted at this size */
+} drmDMAReq, *drmDMAReqPtr;
+
+typedef struct _drmRegion {
+    drmHandle     handle;
+    unsigned int  offset;
+    drmSize       size;
+    drmAddress    map;
+} drmRegion, *drmRegionPtr;
+
+typedef struct _drmTextureRegion {
+    unsigned char next;
+    unsigned char prev;
+    unsigned char in_use;
+    unsigned char padding;	/* Explicitly pad this out                 */
+    unsigned int  age;
+} drmTextureRegion, *drmTextureRegionPtr;
+
+
+typedef struct _drmClipRect {
+    unsigned short	x1; /* Upper left: inclusive */
+    unsigned short	y1;
+    unsigned short	x2; /* Lower right: exclusive */
+    unsigned short	y2;
+} drmClipRect, *drmClipRectPtr;
+
+
+typedef enum {
+    DRM_VBLANK_ABSOLUTE = 0x0,		/* Wait for specific vblank sequence number */
+    DRM_VBLANK_RELATIVE = 0x1,		/* Wait for given number of vblanks */
+    DRM_VBLANK_SIGNAL   = 0x40000000	/* Send signal instead of blocking */
+} drmVBlankSeqType;
+
+typedef struct _drmVBlankReq {
+	drmVBlankSeqType type;
+	unsigned int sequence;
+	unsigned long signal;
+} drmVBlankReq, *drmVBlankReqPtr;
+
+typedef struct _drmVBlankReply {
+	drmVBlankSeqType type;
+	unsigned int sequence;
+	long tval_sec;
+	long tval_usec;
+} drmVBlankReply, *drmVBlankReplyPtr;
+
+typedef union _drmVBlank {
+	drmVBlankReq request;
+	drmVBlankReply reply;
+} drmVBlank, *drmVBlankPtr;
+
+
+
+#define __drm_dummy_lock(lock) (*(__volatile__ unsigned int *)lock)
+
+#define DRM_LOCK_HELD  0x80000000 /* Hardware lock is held                 */
+#define DRM_LOCK_CONT  0x40000000 /* Hardware lock is contended            */
+
+#if __GNUC__ >= 2
+# if defined(__i386) || defined(__x86_64__)
+				/* Reflect changes here to drmP.h */
+#define DRM_CAS(lock,old,new,__ret)                                    \
+	do {                                                           \
+                int __dummy;	/* Can't mark eax as clobbered */      \
+		__asm__ __volatile__(                                  \
+			"lock ; cmpxchg %4,%1\n\t"                     \
+                        "setnz %0"                                     \
+			: "=d" (__ret),                                \
+   			  "=m" (__drm_dummy_lock(lock)),               \
+                          "=a" (__dummy)                               \
+			: "2" (old),                                   \
+			  "r" (new));                                  \
+	} while (0)
+
+#elif defined(__alpha__)
+
+#define	DRM_CAS(lock, old, new, ret) 		\
+ 	do {					\
+ 		int old32;                      \
+ 		int cur32;			\
+ 		__asm__ __volatile__(		\
+ 		"       mb\n"			\
+ 		"       zap   %4, 0xF0, %0\n"   \
+ 		"       ldl_l %1, %2\n"		\
+ 		"       zap   %1, 0xF0, %1\n"   \
+                "       cmpeq %0, %1, %1\n"	\
+                "       beq   %1, 1f\n"		\
+ 		"       bis   %5, %5, %1\n"	\
+                "       stl_c %1, %2\n"		\
+                "1:     xor   %1, 1, %1\n"	\
+                "       stl   %1, %3"		\
+                : "+r" (old32),                 \
+		  "+&r" (cur32),		\
+                   "=m" (__drm_dummy_lock(lock)),\
+                   "=m" (ret)			\
+ 		: "r" (old),			\
+ 		  "r" (new));			\
+ 	} while(0)
+
+#elif defined(__sparc__)
+
+#define DRM_CAS(lock,old,new,__ret)				\
+do {	register unsigned int __old __asm("o0");		\
+	register unsigned int __new __asm("o1");		\
+	register volatile unsigned int *__lock __asm("o2");	\
+	__old = old;						\
+	__new = new;						\
+	__lock = (volatile unsigned int *)lock;			\
+	__asm__ __volatile__(					\
+		/*"cas [%2], %3, %0"*/				\
+		".word 0xd3e29008\n\t"				\
+		/*"membar #StoreStore | #StoreLoad"*/		\
+		".word 0x8143e00a"				\
+		: "=&r" (__new)					\
+		: "0" (__new),					\
+		  "r" (__lock),					\
+		  "r" (__old)					\
+		: "memory");					\
+	__ret = (__new != __old);				\
+} while(0)
+
+#elif defined(__ia64__)
+
+#if 0
+/* this currently generates bad code (missing stop bits)... */
+#include <ia64intrin.h>
+
+#define DRM_CAS(lock,old,new,__ret)					      \
+	do {								      \
+		__ret = (__sync_val_compare_and_swap(&__drm_dummy_lock(lock), \
+						     (old), (new))	      \
+			 != (old));					      \
+	} while (0)
+
+#else
+#define DRM_CAS(lock,old,new,__ret)					  \
+	do {								  \
+		unsigned int __result, __old = (old);			  \
+		__asm__ __volatile__(					  \
+			"mf\n"						  \
+			"mov ar.ccv=%2\n"				  \
+			";;\n"						  \
+			"cmpxchg4.acq %0=%1,%3,ar.ccv"			  \
+			: "=r" (__result), "=m" (__drm_dummy_lock(lock))  \
+			: "r" (__old), "r" (new)			  \
+			: "memory");					  \
+		__ret = (__result) != (__old);				  \
+	} while (0)
+
+#endif
+
+#elif defined(__powerpc__)
+
+#define DRM_CAS(lock,old,new,__ret)			\
+	do {						\
+		__asm__ __volatile__(			\
+			"sync;"				\
+			"0:    lwarx %0,0,%1;"		\
+			"      xor. %0,%3,%0;"		\
+			"      bne 1f;"			\
+			"      stwcx. %2,0,%1;"		\
+			"      bne- 0b;"		\
+			"1:    "			\
+			"sync;"				\
+		: "=&r"(__ret)				\
+		: "r"(lock), "r"(new), "r"(old)		\
+		: "cr0", "memory");			\
+	} while (0)
+
+#endif /* architecture */
+#endif /* __GNUC__ >= 2 */
+
+#ifndef DRM_CAS
+#define DRM_CAS(lock,old,new,ret) do { ret=1; } while (0) /* FAST LOCK FAILS */
+#endif
+
+#if defined(__alpha__) || defined(__powerpc__)
+#define DRM_CAS_RESULT(_result)		int _result
+#else
+#define DRM_CAS_RESULT(_result)		char _result
+#endif
+
+#define DRM_LIGHT_LOCK(fd,lock,context)                                \
+	do {                                                           \
+                DRM_CAS_RESULT(__ret);                                 \
+		DRM_CAS(lock,context,DRM_LOCK_HELD|context,__ret);     \
+                if (__ret) drmGetLock(fd,context,0);                   \
+        } while(0)
+
+				/* This one counts fast locks -- for
+                                   benchmarking only. */
+#define DRM_LIGHT_LOCK_COUNT(fd,lock,context,count)                    \
+	do {                                                           \
+                DRM_CAS_RESULT(__ret);                                 \
+		DRM_CAS(lock,context,DRM_LOCK_HELD|context,__ret);     \
+                if (__ret) drmGetLock(fd,context,0);                   \
+                else       ++count;                                    \
+        } while(0)
+
+#define DRM_LOCK(fd,lock,context,flags)                                \
+	do {                                                           \
+		if (flags) drmGetLock(fd,context,flags);               \
+		else       DRM_LIGHT_LOCK(fd,lock,context);            \
+	} while(0)
+
+#define DRM_UNLOCK(fd,lock,context)                                    \
+	do {                                                           \
+                DRM_CAS_RESULT(__ret);                                 \
+		DRM_CAS(lock,DRM_LOCK_HELD|context,context,__ret);     \
+                if (__ret) drmUnlock(fd,context);                      \
+        } while(0)
+
+				/* Simple spin locks */
+#define DRM_SPINLOCK(spin,val)                                         \
+	do {                                                           \
+            DRM_CAS_RESULT(__ret);                                     \
+	    do {                                                       \
+		DRM_CAS(spin,0,val,__ret);                             \
+		if (__ret) while ((spin)->lock);                       \
+	    } while (__ret);                                           \
+	} while(0)
+
+#define DRM_SPINLOCK_TAKE(spin,val)                                    \
+	do {                                                           \
+            DRM_CAS_RESULT(__ret);                                     \
+            int  cur;                                                  \
+	    do {                                                       \
+                cur = (*spin).lock;                                    \
+		DRM_CAS(spin,cur,val,__ret);                           \
+	    } while (__ret);                                           \
+	} while(0)
+
+#define DRM_SPINLOCK_COUNT(spin,val,count,__ret)                       \
+	do {                                                           \
+            int  __i;                                                  \
+            __ret = 1;                                                 \
+            for (__i = 0; __ret && __i < count; __i++) {               \
+		DRM_CAS(spin,0,val,__ret);                             \
+		if (__ret) for (;__i < count && (spin)->lock; __i++);  \
+	    }                                                          \
+	} while(0)
+
+#define DRM_SPINUNLOCK(spin,val)                                       \
+	do {                                                           \
+            DRM_CAS_RESULT(__ret);                                     \
+            if ((*spin).lock == val) { /* else server stole lock */    \
+	        do {                                                   \
+		    DRM_CAS(spin,val,0,__ret);                         \
+	        } while (__ret);                                       \
+            }                                                          \
+	} while(0)
+
+/* General user-level programmer's API: unprivileged */
+extern int           drmAvailable(void);
+extern int           drmOpen(const char *name, const char *busid);
+extern int           drmClose(int fd);
+extern drmVersionPtr drmGetVersion(int fd);
+extern drmVersionPtr drmGetLibVersion(int fd);
+extern void          drmFreeVersion(drmVersionPtr);
+extern int           drmGetMagic(int fd, drmMagicPtr magic);
+extern char          *drmGetBusid(int fd);
+extern int           drmGetInterruptFromBusID(int fd, int busnum, int devnum,
+					      int funcnum);
+extern int           drmGetMap(int fd, int idx, drmHandle *offset,
+			       drmSize *size, drmMapType *type,
+			       drmMapFlags *flags, drmHandle *handle,
+			       int *mtrr);
+extern int           drmGetClient(int fd, int idx, int *auth, int *pid,
+				  int *uid, unsigned long *magic,
+				  unsigned long *iocs);
+extern int           drmGetStats(int fd, drmStatsT *stats);
+extern int           drmCommandNone(int fd, unsigned long drmCommandIndex);
+extern int           drmCommandRead(int fd, unsigned long drmCommandIndex,
+                                    void *data, unsigned long size);
+extern int           drmCommandWrite(int fd, unsigned long drmCommandIndex,
+                                     void *data, unsigned long size);
+extern int           drmCommandWriteRead(int fd, unsigned long drmCommandIndex,
+                                         void *data, unsigned long size);
+
+/* General user-level programmer's API: X server (root) only  */
+extern void          drmFreeBusid(const char *busid);
+extern int           drmSetBusid(int fd, const char *busid);
+extern int           drmAuthMagic(int fd, drmMagic magic);
+extern int           drmAddMap(int fd,
+			       drmHandle offset,
+			       drmSize size,
+			       drmMapType type,
+			       drmMapFlags flags,
+			       drmHandlePtr handle);
+extern int	     drmRmMap(int fd, drmHandle handle);
+extern int	     drmAddContextPrivateMapping(int fd, drmContext ctx_id,
+						 drmHandle handle);
+
+extern int           drmAddBufs(int fd, int count, int size,
+				drmBufDescFlags flags,
+				int agp_offset);
+extern int           drmMarkBufs(int fd, double low, double high);
+extern int           drmCreateContext(int fd, drmContextPtr handle);
+extern int           drmSetContextFlags(int fd, drmContext context,
+					drmContextFlags flags);
+extern int           drmGetContextFlags(int fd, drmContext context,
+					drmContextFlagsPtr flags);
+extern int           drmAddContextTag(int fd, drmContext context, void *tag);
+extern int           drmDelContextTag(int fd, drmContext context);
+extern void          *drmGetContextTag(int fd, drmContext context);
+extern drmContextPtr drmGetReservedContextList(int fd, int *count);
+extern void          drmFreeReservedContextList(drmContextPtr);
+extern int           drmSwitchToContext(int fd, drmContext context);
+extern int           drmDestroyContext(int fd, drmContext handle);
+extern int           drmCreateDrawable(int fd, drmDrawablePtr handle);
+extern int           drmDestroyDrawable(int fd, drmDrawable handle);
+extern int           drmCtlInstHandler(int fd, int irq);
+extern int           drmCtlUninstHandler(int fd);
+extern int           drmInstallSIGIOHandler(int fd,
+					    void (*f)(int fd,
+						      void *oldctx,
+						      void *newctx));
+extern int           drmRemoveSIGIOHandler(int fd);
+
+/* General user-level programmer's API: authenticated client and/or X */
+extern int           drmMap(int fd,
+			    drmHandle handle,
+			    drmSize size,
+			    drmAddressPtr address);
+extern int           drmUnmap(drmAddress address, drmSize size);
+extern drmBufInfoPtr drmGetBufInfo(int fd);
+extern drmBufMapPtr  drmMapBufs(int fd);
+extern int           drmUnmapBufs(drmBufMapPtr bufs);
+extern int           drmDMA(int fd, drmDMAReqPtr request);
+extern int           drmFreeBufs(int fd, int count, int *list);
+extern int           drmGetLock(int fd,
+			        drmContext context,
+			        drmLockFlags flags);
+extern int           drmUnlock(int fd, drmContext context);
+extern int           drmFinish(int fd, int context, drmLockFlags flags);
+extern int	     drmGetContextPrivateMapping(int fd, drmContext ctx_id, 
+						 drmHandlePtr handle);
+
+/* AGP/GART support: X server (root) only */
+extern int           drmAgpAcquire(int fd);
+extern int           drmAgpRelease(int fd);
+extern int           drmAgpEnable(int fd, unsigned long mode);
+extern int           drmAgpAlloc(int fd, unsigned long size,
+				 unsigned long type, unsigned long *address,
+				 unsigned long *handle);
+extern int           drmAgpFree(int fd, unsigned long handle);
+extern int 	     drmAgpBind(int fd, unsigned long handle,
+				unsigned long offset);
+extern int           drmAgpUnbind(int fd, unsigned long handle);
+
+/* AGP/GART info: authenticated client and/or X */
+extern int           drmAgpVersionMajor(int fd);
+extern int           drmAgpVersionMinor(int fd);
+extern unsigned long drmAgpGetMode(int fd);
+extern unsigned long drmAgpBase(int fd); /* Physical location */
+extern unsigned long drmAgpSize(int fd); /* Bytes */
+extern unsigned long drmAgpMemoryUsed(int fd);
+extern unsigned long drmAgpMemoryAvail(int fd);
+extern unsigned int  drmAgpVendorId(int fd);
+extern unsigned int  drmAgpDeviceId(int fd);
+
+/* PCI scatter/gather support: X server (root) only */
+extern int           drmScatterGatherAlloc(int fd, unsigned long size,
+					   unsigned long *handle);
+extern int           drmScatterGatherFree(int fd, unsigned long handle);
+
+extern int           drmWaitVBlank(int fd, drmVBlankPtr vbl);
+
+/* Support routines */
+extern int           drmError(int err, const char *label);
+extern void          *drmMalloc(int size);
+extern void          drmFree(void *pt);
+
+/* Hash table routines */
+extern void *drmHashCreate(void);
+extern int  drmHashDestroy(void *t);
+extern int  drmHashLookup(void *t, unsigned long key, void **value);
+extern int  drmHashInsert(void *t, unsigned long key, void *value);
+extern int  drmHashDelete(void *t, unsigned long key);
+extern int  drmHashFirst(void *t, unsigned long *key, void **value);
+extern int  drmHashNext(void *t, unsigned long *key, void **value);
+
+/* PRNG routines */
+extern void          *drmRandomCreate(unsigned long seed);
+extern int           drmRandomDestroy(void *state);
+extern unsigned long drmRandom(void *state);
+extern double        drmRandomDouble(void *state);
+
+/* Skip list routines */
+
+extern void *drmSLCreate(void);
+extern int  drmSLDestroy(void *l);
+extern int  drmSLLookup(void *l, unsigned long key, void **value);
+extern int  drmSLInsert(void *l, unsigned long key, void *value);
+extern int  drmSLDelete(void *l, unsigned long key);
+extern int  drmSLNext(void *l, unsigned long *key, void **value);
+extern int  drmSLFirst(void *l, unsigned long *key, void **value);
+extern void drmSLDump(void *l);
+extern int  drmSLLookupNeighbors(void *l, unsigned long key,
+				 unsigned long *prev_key, void **prev_value,
+				 unsigned long *next_key, void **next_value);
+
+#endif

src/dri-es/xf86drmHash.c

@@ -0,0 +1,435 @@
+/* xf86drmHash.c -- Small hash table support for integer -> integer mapping
+ * Created: Sun Apr 18 09:35:45 1999 by faith@precisioninsight.com
+ *
+ * Copyright 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, 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 (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 NONINFRINGEMENT.  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: Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ * $XFree86: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/xf86drmHash.c,v 1.4 2001/03/21 18:08:54 dawes Exp $
+ *
+ * DESCRIPTION
+ *
+ * This file contains a straightforward implementation of a fixed-sized
+ * hash table using self-organizing linked lists [Knuth73, pp. 398-399] for
+ * collision resolution.  There are two potentially interesting things
+ * about this implementation:
+ *
+ * 1) The table is power-of-two sized.  Prime sized tables are more
+ * traditional, but do not have a significant advantage over power-of-two
+ * sized table, especially when double hashing is not used for collision
+ * resolution.
+ *
+ * 2) The hash computation uses a table of random integers [Hanson97,
+ * pp. 39-41].
+ *
+ * FUTURE ENHANCEMENTS
+ *
+ * With a table size of 512, the current implementation is sufficient for a
+ * few hundred keys.  Since this is well above the expected size of the
+ * tables for which this implementation was designed, the implementation of
+ * dynamic hash tables was postponed until the need arises.  A common (and
+ * naive) approach to dynamic hash table implementation simply creates a
+ * new hash table when necessary, rehashes all the data into the new table,
+ * and destroys the old table.  The approach in [Larson88] is superior in
+ * two ways: 1) only a portion of the table is expanded when needed,
+ * distributing the expansion cost over several insertions, and 2) portions
+ * of the table can be locked, enabling a scalable thread-safe
+ * implementation.
+ *
+ * REFERENCES
+ *
+ * [Hanson97] David R. Hanson.  C Interfaces and Implementations:
+ * Techniques for Creating Reusable Software.  Reading, Massachusetts:
+ * Addison-Wesley, 1997.
+ *
+ * [Knuth73] Donald E. Knuth. The Art of Computer Programming.  Volume 3:
+ * Sorting and Searching.  Reading, Massachusetts: Addison-Wesley, 1973.
+ *
+ * [Larson88] Per-Ake Larson. "Dynamic Hash Tables".  CACM 31(4), April
+ * 1988, pp. 446-457.
+ *
+ */
+
+#define HASH_MAIN 0
+
+#if HASH_MAIN
+# include <stdio.h>
+# include <stdlib.h>
+#else
+# include "xf86drm.h"
+# ifdef XFree86LOADER
+#  include "xf86.h"
+#  include "xf86_ansic.h"
+# else
+#  include <stdio.h>
+#  include <stdlib.h>
+# endif
+#endif
+
+#define N(x)  drm##x
+
+#define HASH_MAGIC 0xdeadbeef
+#define HASH_DEBUG 0
+#define HASH_SIZE  512		/* Good for about 100 entries */
+				/* If you change this value, you probably
+                                   have to change the HashHash hashing
+                                   function! */
+
+#if HASH_MAIN
+#define HASH_ALLOC malloc
+#define HASH_FREE  free
+#define HASH_RANDOM_DECL
+#define HASH_RANDOM_INIT(seed)  srandom(seed)
+#define HASH_RANDOM             random()
+#else
+#define HASH_ALLOC drmMalloc
+#define HASH_FREE  drmFree
+#define HASH_RANDOM_DECL        void *state
+#define HASH_RANDOM_INIT(seed)  state = drmRandomCreate(seed)
+#define HASH_RANDOM             drmRandom(state)
+
+#endif
+
+typedef struct HashBucket {
+    unsigned long     key;
+    void              *value;
+    struct HashBucket *next;
+} HashBucket, *HashBucketPtr;
+
+typedef struct HashTable {
+    unsigned long    magic;
+    unsigned long    entries;
+    unsigned long    hits;	/* At top of linked list */
+    unsigned long    partials;	/* Not at top of linked list */
+    unsigned long    misses;	/* Not in table */
+    HashBucketPtr    buckets[HASH_SIZE];
+    int              p0;
+    HashBucketPtr    p1;
+} HashTable, *HashTablePtr;
+
+#if HASH_MAIN
+extern void *N(HashCreate)(void);
+extern int  N(HashDestroy)(void *t);
+extern int  N(HashLookup)(void *t, unsigned long key, unsigned long *value);
+extern int  N(HashInsert)(void *t, unsigned long key, unsigned long value);
+extern int  N(HashDelete)(void *t, unsigned long key);
+#endif
+
+static unsigned long HashHash(unsigned long key)
+{
+    unsigned long        hash = 0;
+    unsigned long        tmp  = key;
+    static int           init = 0;
+    static unsigned long scatter[256];
+    int                  i;
+
+    if (!init) {
+	HASH_RANDOM_DECL;
+	HASH_RANDOM_INIT(37);
+	for (i = 0; i < 256; i++) scatter[i] = HASH_RANDOM;
+	++init;
+    }
+
+    while (tmp) {
+	hash = (hash << 1) + scatter[tmp & 0xff];
+	tmp >>= 8;
+    }
+
+    hash %= HASH_SIZE;
+#if HASH_DEBUG
+    printf( "Hash(%d) = %d\n", key, hash);
+#endif
+    return hash;
+}
+
+void *N(HashCreate)(void)
+{
+    HashTablePtr table;
+    int          i;
+
+    table           = HASH_ALLOC(sizeof(*table));
+    if (!table) return NULL;
+    table->magic    = HASH_MAGIC;
+    table->entries  = 0;
+    table->hits     = 0;
+    table->partials = 0;
+    table->misses   = 0;
+
+    for (i = 0; i < HASH_SIZE; i++) table->buckets[i] = NULL;
+    return table;
+}
+
+int N(HashDestroy)(void *t)
+{
+    HashTablePtr  table = (HashTablePtr)t;
+    HashBucketPtr bucket;
+    HashBucketPtr next;
+    int           i;
+
+    if (table->magic != HASH_MAGIC) return -1; /* Bad magic */
+
+    for (i = 0; i < HASH_SIZE; i++) {
+	for (bucket = table->buckets[i]; bucket;) {
+	    next = bucket->next;
+	    HASH_FREE(bucket);
+	    bucket = next;
+	}
+    }
+    HASH_FREE(table);
+    return 0;
+}
+
+/* Find the bucket and organize the list so that this bucket is at the
+   top. */
+
+static HashBucketPtr HashFind(HashTablePtr table,
+			      unsigned long key, unsigned long *h)
+{
+    unsigned long hash = HashHash(key);
+    HashBucketPtr prev = NULL;
+    HashBucketPtr bucket;
+
+    if (h) *h = hash;
+
+    for (bucket = table->buckets[hash]; bucket; bucket = bucket->next) {
+	if (bucket->key == key) {
+	    if (prev) {
+				/* Organize */
+		prev->next           = bucket->next;
+		bucket->next         = table->buckets[hash];
+		table->buckets[hash] = bucket;
+		++table->partials;
+	    } else {
+		++table->hits;
+	    }
+	    return bucket;
+	}
+	prev = bucket;
+    }
+    ++table->misses;
+    return NULL;
+}
+
+int N(HashLookup)(void *t, unsigned long key, void **value)
+{
+    HashTablePtr  table = (HashTablePtr)t;
+    HashBucketPtr bucket;
+
+    if (!table || table->magic != HASH_MAGIC) return -1; /* Bad magic */
+
+    bucket = HashFind(table, key, NULL);
+    if (!bucket) return 1;	/* Not found */
+    *value = bucket->value;
+    return 0;			/* Found */
+}
+
+int N(HashInsert)(void *t, unsigned long key, void *value)
+{
+    HashTablePtr  table = (HashTablePtr)t;
+    HashBucketPtr bucket;
+    unsigned long hash;
+
+    if (table->magic != HASH_MAGIC) return -1; /* Bad magic */
+
+    if (HashFind(table, key, &hash)) return 1; /* Already in table */
+
+    bucket               = HASH_ALLOC(sizeof(*bucket));
+    if (!bucket) return -1;	/* Error */
+    bucket->key          = key;
+    bucket->value        = value;
+    bucket->next         = table->buckets[hash];
+    table->buckets[hash] = bucket;
+#if HASH_DEBUG
+    printf("Inserted %d at %d/%p\n", key, hash, bucket);
+#endif
+    return 0;			/* Added to table */
+}
+
+int N(HashDelete)(void *t, unsigned long key)
+{
+    HashTablePtr  table = (HashTablePtr)t;
+    unsigned long hash;
+    HashBucketPtr bucket;
+
+    if (table->magic != HASH_MAGIC) return -1; /* Bad magic */
+
+    bucket = HashFind(table, key, &hash);
+
+    if (!bucket) return 1;	/* Not found */
+
+    table->buckets[hash] = bucket->next;
+    HASH_FREE(bucket);
+    return 0;
+}
+
+int N(HashNext)(void *t, unsigned long *key, void **value)
+{
+    HashTablePtr  table = (HashTablePtr)t;
+
+    for (; table->p0 < HASH_SIZE;
+	 ++table->p0, table->p1 = table->buckets[table->p0]) {
+	if (table->p1) {
+	    *key       = table->p1->key;
+	    *value     = table->p1->value;
+	    table->p1  = table->p1->next;
+	    return 1;
+	}
+    }
+    return 0;
+}
+
+int N(HashFirst)(void *t, unsigned long *key, void **value)
+{
+    HashTablePtr  table = (HashTablePtr)t;
+
+    if (table->magic != HASH_MAGIC) return -1; /* Bad magic */
+
+    table->p0 = 0;
+    table->p1 = table->buckets[0];
+    return N(HashNext)(table, key, value);
+}
+
+#if HASH_MAIN
+#define DIST_LIMIT 10
+static int dist[DIST_LIMIT];
+
+static void clear_dist(void) {
+    int i;
+
+    for (i = 0; i < DIST_LIMIT; i++) dist[i] = 0;
+}
+
+static int count_entries(HashBucketPtr bucket)
+{
+    int count = 0;
+
+    for (; bucket; bucket = bucket->next) ++count;
+    return count;
+}
+
+static void update_dist(int count)
+{
+    if (count >= DIST_LIMIT) ++dist[DIST_LIMIT-1];
+    else                     ++dist[count];
+}
+
+static void compute_dist(HashTablePtr table)
+{
+    int           i;
+    HashBucketPtr bucket;
+
+    printf("Entries = %ld, hits = %ld, partials = %ld, misses = %ld\n",
+	   table->entries, table->hits, table->partials, table->misses);
+    clear_dist();
+    for (i = 0; i < HASH_SIZE; i++) {
+	bucket = table->buckets[i];
+	update_dist(count_entries(bucket));
+    }
+    for (i = 0; i < DIST_LIMIT; i++) {
+	if (i != DIST_LIMIT-1) printf("%5d %10d\n", i, dist[i]);
+	else                   printf("other %10d\n", dist[i]);
+    }
+}
+
+static void check_table(HashTablePtr table,
+			unsigned long key, unsigned long value)
+{
+    unsigned long retval  = 0;
+    int           retcode = N(HashLookup)(table, key, &retval);
+
+    switch (retcode) {
+    case -1:
+	printf("Bad magic = 0x%08lx:"
+	       " key = %lu, expected = %lu, returned = %lu\n",
+	       table->magic, key, value, retval);
+	break;
+    case 1:
+	printf("Not found: key = %lu, expected = %lu returned = %lu\n",
+	       key, value, retval);
+	break;
+    case 0:
+	if (value != retval)
+	    printf("Bad value: key = %lu, expected = %lu, returned = %lu\n",
+		   key, value, retval);
+	break;
+    default:
+	printf("Bad retcode = %d: key = %lu, expected = %lu, returned = %lu\n",
+	       retcode, key, value, retval);
+	break;
+    }
+}
+
+int main(void)
+{
+    HashTablePtr table;
+    int          i;
+
+    printf("\n***** 256 consecutive integers ****\n");
+    table = N(HashCreate)();
+    for (i = 0; i < 256; i++) N(HashInsert)(table, i, i);
+    for (i = 0; i < 256; i++) check_table(table, i, i);
+    for (i = 256; i >= 0; i--) check_table(table, i, i);
+    compute_dist(table);
+    N(HashDestroy)(table);
+
+    printf("\n***** 1024 consecutive integers ****\n");
+    table = N(HashCreate)();
+    for (i = 0; i < 1024; i++) N(HashInsert)(table, i, i);
+    for (i = 0; i < 1024; i++) check_table(table, i, i);
+    for (i = 1024; i >= 0; i--) check_table(table, i, i);
+    compute_dist(table);
+    N(HashDestroy)(table);
+
+    printf("\n***** 1024 consecutive page addresses (4k pages) ****\n");
+    table = N(HashCreate)();
+    for (i = 0; i < 1024; i++) N(HashInsert)(table, i*4096, i);
+    for (i = 0; i < 1024; i++) check_table(table, i*4096, i);
+    for (i = 1024; i >= 0; i--) check_table(table, i*4096, i);
+    compute_dist(table);
+    N(HashDestroy)(table);
+
+    printf("\n***** 1024 random integers ****\n");
+    table = N(HashCreate)();
+    srandom(0xbeefbeef);
+    for (i = 0; i < 1024; i++) N(HashInsert)(table, random(), i);
+    srandom(0xbeefbeef);
+    for (i = 0; i < 1024; i++) check_table(table, random(), i);
+    srandom(0xbeefbeef);
+    for (i = 0; i < 1024; i++) check_table(table, random(), i);
+    compute_dist(table);
+    N(HashDestroy)(table);
+
+    printf("\n***** 5000 random integers ****\n");
+    table = N(HashCreate)();
+    srandom(0xbeefbeef);
+    for (i = 0; i < 5000; i++) N(HashInsert)(table, random(), i);
+    srandom(0xbeefbeef);
+    for (i = 0; i < 5000; i++) check_table(table, random(), i);
+    srandom(0xbeefbeef);
+    for (i = 0; i < 5000; i++) check_table(table, random(), i);
+    compute_dist(table);
+    N(HashDestroy)(table);
+
+    return 0;
+}
+#endif

src/dri-es/xf86drmRandom.c

@@ -0,0 +1,219 @@
+/* xf86drmRandom.c -- "Minimal Standard" PRNG Implementation
+ * Created: Mon Apr 19 08:28:13 1999 by faith@precisioninsight.com
+ *
+ * Copyright 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, 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 (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 NONINFRINGEMENT.  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: Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ * $XFree86: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/xf86drmRandom.c,v 1.4 2000/06/17 00:03:34 martin Exp $
+ *
+ * DESCRIPTION
+ *
+ * This file contains a simple, straightforward implementation of the Park
+ * & Miller "Minimal Standard" PRNG [PM88, PMS93], which is a Lehmer
+ * multiplicative linear congruential generator (MLCG) with a period of
+ * 2^31-1.
+ *
+ * This implementation is intended to provide a reliable, portable PRNG
+ * that is suitable for testing a hash table implementation and for
+ * implementing skip lists.
+ *
+ * FUTURE ENHANCEMENTS
+ *
+ * If initial seeds are not selected randomly, two instances of the PRNG
+ * can be correlated.  [Knuth81, pp. 32-33] describes a shuffling technique
+ * that can eliminate this problem.
+ *
+ * If PRNGs are used for simulation, the period of the current
+ * implementation may be too short.  [LE88] discusses methods of combining
+ * MLCGs to produce much longer periods, and suggests some alternative
+ * values for A and M.  [LE90 and Sch92] also provide information on
+ * long-period PRNGs.
+ *
+ * REFERENCES
+ *
+ * [Knuth81] Donald E. Knuth. The Art of Computer Programming.  Volume 2:
+ * Seminumerical Algorithms.  Reading, Massachusetts: Addison-Wesley, 1981.
+ *
+ * [LE88] Pierre L'Ecuyer. "Efficient and Portable Combined Random Number
+ * Generators".  CACM 31(6), June 1988, pp. 742-774.
+ *
+ * [LE90] Pierre L'Ecuyer. "Random Numbers for Simulation". CACM 33(10,
+ * October 1990, pp. 85-97.
+ *
+ * [PM88] Stephen K. Park and Keith W. Miller. "Random Number Generators:
+ * Good Ones are Hard to Find". CACM 31(10), October 1988, pp. 1192-1201.
+ *
+ * [Sch92] Bruce Schneier. "Pseudo-Ransom Sequence Generator for 32-Bit
+ * CPUs".  Dr. Dobb's Journal 17(2), February 1992, pp. 34, 37-38, 40.
+ *
+ * [PMS93] Stephen K. Park, Keith W. Miller, and Paul K. Stockmeyer.  In
+ * "Technical Correspondence: Remarks on Choosing and Implementing Random
+ * Number Generators". CACM 36(7), July 1993, pp. 105-110.
+ *
+ */
+
+#define RANDOM_MAIN 0
+
+#if RANDOM_MAIN
+# include <stdio.h>
+# include <stdlib.h>
+#else
+# include "xf86drm.h"
+# ifdef XFree86LOADER
+#  include "xf86.h"
+#  include "xf86_ansic.h"
+# else
+#  include <stdio.h>
+#  include <stdlib.h>
+# endif
+#endif
+
+#define N(x)  drm##x
+
+#define RANDOM_MAGIC 0xfeedbeef
+#define RANDOM_DEBUG 0
+
+#if RANDOM_MAIN
+#define RANDOM_ALLOC malloc
+#define RANDOM_FREE  free
+#else
+#define RANDOM_ALLOC drmMalloc
+#define RANDOM_FREE  drmFree
+#endif
+
+typedef struct RandomState {
+    unsigned long magic;
+    unsigned long a;
+    unsigned long m;
+    unsigned long q;		/* m div a */
+    unsigned long r;		/* m mod a */
+    unsigned long check;
+    long          seed;
+} RandomState;
+
+#if RANDOM_MAIN
+extern void          *N(RandomCreate)(unsigned long seed);
+extern int           N(RandomDestroy)(void *state);
+extern unsigned long N(Random)(void *state);
+extern double        N(RandomDouble)(void *state);
+#endif
+
+void *N(RandomCreate)(unsigned long seed)
+{
+    RandomState  *state;
+
+    state           = RANDOM_ALLOC(sizeof(*state));
+    if (!state) return NULL;
+    state->magic    = RANDOM_MAGIC;
+#if 0
+				/* Park & Miller, October 1988 */
+    state->a        = 16807;
+    state->m        = 2147483647;
+    state->check    = 1043618065; /* After 10000 iterations */
+#else
+				/* Park, Miller, and Stockmeyer, July 1993 */
+    state->a        = 48271;
+    state->m        = 2147483647;
+    state->check    = 399268537; /* After 10000 iterations */
+#endif
+    state->q        = state->m / state->a;
+    state->r        = state->m % state->a;
+
+    state->seed     = seed;
+				/* Check for illegal boundary conditions,
+                                   and choose closest legal value. */
+    if (state->seed <= 0)        state->seed = 1;
+    if (state->seed >= state->m) state->seed = state->m - 1;
+
+    return state;
+}
+
+int N(RandomDestroy)(void *state)
+{
+    RANDOM_FREE(state);
+    return 0;
+}
+
+unsigned long N(Random)(void *state)
+{
+    RandomState   *s = (RandomState *)state;
+    long          hi;
+    long          lo;
+
+    hi      = s->seed / s->q;
+    lo      = s->seed % s->q;
+    s->seed = s->a * lo - s->r * hi;
+    if (s->seed <= 0) s->seed += s->m;
+
+    return s->seed;
+}
+
+double N(RandomDouble)(void *state)
+{
+    RandomState *s = (RandomState *)state;
+    
+    return (double)N(Random)(state)/(double)s->m;
+}
+
+#if RANDOM_MAIN
+static void check_period(long seed)
+{
+    unsigned long count = 0;
+    unsigned long initial;
+    void          *state;
+    
+    state = N(RandomCreate)(seed);
+    initial = N(Random)(state);
+    ++count;
+    while (initial != N(Random)(state)) {
+	if (!++count) break;
+    }
+    printf("With seed of %10ld, period = %10lu (0x%08lx)\n",
+	   seed, count, count);
+    N(RandomDestroy)(state);
+}
+
+int main(void)
+{
+    RandomState   *state;
+    int           i;
+    unsigned long rand;
+
+    state = N(RandomCreate)(1);
+    for (i = 0; i < 10000; i++) {
+	rand = N(Random)(state);
+    }
+    printf("After 10000 iterations: %lu (%lu expected): %s\n",
+	   rand, state->check,
+	   rand - state->check ? "*INCORRECT*" : "CORRECT");
+    N(RandomDestroy)(state);
+
+    printf("Checking periods...\n");
+    check_period(1);
+    check_period(2);
+    check_period(31415926);
+    
+    return 0;
+}
+#endif

src/dri-es/xf86drmSL.c

@@ -0,0 +1,490 @@
+/* xf86drmSL.c -- Skip list support
+ * Created: Mon May 10 09:28:13 1999 by faith@precisioninsight.com
+ *
+ * Copyright 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, 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 (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 NONINFRINGEMENT.  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: Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ * $XFree86: xc/programs/Xserver/hw/xfree86/os-support/linux/drm/xf86drmSL.c,v 1.3 2000/06/17 00:03:34 martin Exp $
+ *
+ * DESCRIPTION
+ *
+ * This file contains a straightforward skip list implementation.n
+ *
+ * FUTURE ENHANCEMENTS
+ *
+ * REFERENCES
+ *
+ * [Pugh90] William Pugh.  Skip Lists: A Probabilistic Alternative to
+ * Balanced Trees. CACM 33(6), June 1990, pp. 668-676.
+ *
+ */
+
+#define SL_MAIN 0
+
+#if SL_MAIN
+# include <stdio.h>
+# include <stdlib.h>
+#  include <sys/time.h>
+#else
+# include "xf86drm.h"
+# ifdef XFree86LOADER
+#  include "xf86.h"
+#  include "xf86_ansic.h"
+# else
+#  include <stdio.h>
+#  include <stdlib.h>
+# endif
+#endif
+
+#define N(x)  drm##x
+
+#define SL_LIST_MAGIC  0xfacade00LU
+#define SL_ENTRY_MAGIC 0x00fab1edLU
+#define SL_FREED_MAGIC 0xdecea5edLU
+#define SL_MAX_LEVEL   16
+#define SL_DEBUG       0
+#define SL_RANDOM_SEED 0xc01055a1LU
+
+#if SL_MAIN
+#define SL_ALLOC malloc
+#define SL_FREE  free
+#define SL_RANDOM_DECL        static int state = 0;
+#define SL_RANDOM_INIT(seed)  if (!state) { srandom(seed); ++state; }
+#define SL_RANDOM             random()
+#else
+#define SL_ALLOC drmMalloc
+#define SL_FREE  drmFree
+#define SL_RANDOM_DECL        static void *state = NULL
+#define SL_RANDOM_INIT(seed)  if (!state) state = drmRandomCreate(seed)
+#define SL_RANDOM             drmRandom(state)
+
+#endif
+
+typedef struct SLEntry {
+    unsigned long     magic;	   /* SL_ENTRY_MAGIC */
+    unsigned long     key;
+    void              *value;
+    int               levels;
+    struct SLEntry    *forward[1]; /* variable sized array */
+} SLEntry, *SLEntryPtr;
+
+typedef struct SkipList {
+    unsigned long    magic;	/* SL_LIST_MAGIC */
+    int              level;
+    int              count;
+    SLEntryPtr       head;
+    SLEntryPtr       p0;	/* Position for iteration */
+} SkipList, *SkipListPtr;
+
+#if SL_MAIN
+extern void *N(SLCreate)(void);
+extern int  N(SLDestroy)(void *l);
+extern int  N(SLLookup)(void *l, unsigned long key, void **value);
+extern int  N(SLInsert)(void *l, unsigned long key, void *value);
+extern int  N(SLDelete)(void *l, unsigned long key);
+extern int  N(SLNext)(void *l, unsigned long *key, void **value);
+extern int  N(SLFirst)(void *l, unsigned long *key, void **value);
+extern void N(SLDump)(void *l);
+extern int  N(SLLookupNeighbors)(void *l, unsigned long key,
+				 unsigned long *prev_key, void **prev_value,
+				 unsigned long *next_key, void **next_value);
+#endif
+
+static SLEntryPtr SLCreateEntry(int max_level, unsigned long key, void *value)
+{
+    SLEntryPtr entry;
+    
+    if (max_level < 0 || max_level > SL_MAX_LEVEL) max_level = SL_MAX_LEVEL;
+
+    entry         = SL_ALLOC(sizeof(*entry)
+			     + (max_level + 1) * sizeof(entry->forward[0]));
+    if (!entry) return NULL;
+    entry->magic  = SL_ENTRY_MAGIC;
+    entry->key    = key;
+    entry->value  = value;
+    entry->levels = max_level + 1;
+
+    return entry;
+}
+
+static int SLRandomLevel(void)
+{
+    int level = 1;
+    SL_RANDOM_DECL;
+
+    SL_RANDOM_INIT(SL_RANDOM_SEED);
+    
+    while ((SL_RANDOM & 0x01) && level < SL_MAX_LEVEL) ++level;
+    return level;
+}
+
+void *N(SLCreate)(void)
+{
+    SkipListPtr  list;
+    int          i;
+
+    list           = SL_ALLOC(sizeof(*list));
+    if (!list) return NULL;
+    list->magic    = SL_LIST_MAGIC;
+    list->level    = 0;
+    list->head     = SLCreateEntry(SL_MAX_LEVEL, 0, NULL);
+    list->count    = 0;
+
+    for (i = 0; i <= SL_MAX_LEVEL; i++) list->head->forward[i] = NULL;
+    
+    return list;
+}
+
+int N(SLDestroy)(void *l)
+{
+    SkipListPtr   list  = (SkipListPtr)l;
+    SLEntryPtr    entry;
+    SLEntryPtr    next;
+
+    if (list->magic != SL_LIST_MAGIC) return -1; /* Bad magic */
+
+    for (entry = list->head; entry; entry = next) {
+	if (entry->magic != SL_ENTRY_MAGIC) return -1; /* Bad magic */
+	next         = entry->forward[0];
+	entry->magic = SL_FREED_MAGIC;
+	SL_FREE(entry);
+    }
+
+    list->magic = SL_FREED_MAGIC;
+    SL_FREE(list);
+    return 0;
+}
+
+static SLEntryPtr SLLocate(void *l, unsigned long key, SLEntryPtr *update)
+{
+    SkipListPtr   list  = (SkipListPtr)l;
+    SLEntryPtr    entry;
+    int           i;
+
+    if (list->magic != SL_LIST_MAGIC) return NULL;
+
+    for (i = list->level, entry = list->head; i >= 0; i--) {
+	while (entry->forward[i] && entry->forward[i]->key < key)
+	    entry = entry->forward[i];
+	update[i] = entry;
+    }
+
+    return entry->forward[0];
+}
+
+int N(SLInsert)(void *l, unsigned long key, void *value)
+{
+    SkipListPtr   list  = (SkipListPtr)l;
+    SLEntryPtr    entry;
+    SLEntryPtr    update[SL_MAX_LEVEL + 1];
+    int           level;
+    int           i;
+
+    if (list->magic != SL_LIST_MAGIC) return -1; /* Bad magic */
+
+    entry = SLLocate(list, key, update);
+
+    if (entry && entry->key == key) return 1; /* Already in list */
+
+
+    level = SLRandomLevel();
+    if (level > list->level) {
+	level = ++list->level;
+	update[level] = list->head;
+    }
+
+    entry = SLCreateEntry(level, key, value);
+
+				/* Fix up forward pointers */
+    for (i = 0; i <= level; i++) {
+	entry->forward[i]     = update[i]->forward[i];
+	update[i]->forward[i] = entry;
+    }
+
+    ++list->count;
+    return 0;			/* Added to table */
+}
+
+int N(SLDelete)(void *l, unsigned long key)
+{
+    SkipListPtr   list = (SkipListPtr)l;
+    SLEntryPtr    update[SL_MAX_LEVEL + 1];
+    SLEntryPtr    entry;
+    int           i;
+
+    if (list->magic != SL_LIST_MAGIC) return -1; /* Bad magic */
+
+    entry = SLLocate(list, key, update);
+
+    if (!entry || entry->key != key) return 1; /* Not found */
+
+				/* Fix up forward pointers */
+    for (i = 0; i <= list->level; i++) {
+	if (update[i]->forward[i] == entry)
+	    update[i]->forward[i] = entry->forward[i];
+    }
+
+    entry->magic = SL_FREED_MAGIC;
+    SL_FREE(entry);
+
+    while (list->level && !list->head->forward[list->level]) --list->level;
+    --list->count;
+    return 0;
+}
+
+int N(SLLookup)(void *l, unsigned long key, void **value)
+{
+    SkipListPtr   list = (SkipListPtr)l;
+    SLEntryPtr    update[SL_MAX_LEVEL + 1];
+    SLEntryPtr    entry;
+
+    entry = SLLocate(list, key, update);
+
+    if (entry && entry->key == key) {
+	*value = entry;
+	return 0;
+    }
+    *value = NULL;
+    return -1;
+}
+
+int N(SLLookupNeighbors)(void *l, unsigned long key,
+			 unsigned long *prev_key, void **prev_value,
+			 unsigned long *next_key, void **next_value)
+{
+    SkipListPtr   list = (SkipListPtr)l;
+    SLEntryPtr    update[SL_MAX_LEVEL + 1];
+    SLEntryPtr    entry;
+    int           retcode = 0;
+
+    entry = SLLocate(list, key, update);
+
+    *prev_key   = *next_key   = key;
+    *prev_value = *next_value = NULL;
+	
+    if (update[0]) {
+	*prev_key   = update[0]->key;
+	*prev_value = update[0]->value;
+	++retcode;
+	if (update[0]->forward[0]) {
+	    *next_key   = update[0]->forward[0]->key;
+	    *next_value = update[0]->forward[0]->value;
+	    ++retcode;
+	}
+    }
+    return retcode;
+}
+
+int N(SLNext)(void *l, unsigned long *key, void **value)
+{
+    SkipListPtr   list = (SkipListPtr)l;
+    SLEntryPtr    entry;
+    
+    if (list->magic != SL_LIST_MAGIC) return -1; /* Bad magic */
+
+    entry    = list->p0;
+
+    if (entry) {
+	list->p0 = entry->forward[0];
+	*key     = entry->key;
+	*value   = entry->value;
+	return 1;
+    }
+    list->p0 = NULL;
+    return 0;
+}
+
+int N(SLFirst)(void *l, unsigned long *key, void **value)
+{
+    SkipListPtr   list = (SkipListPtr)l;
+    
+    if (list->magic != SL_LIST_MAGIC) return -1; /* Bad magic */
+    
+    list->p0 = list->head->forward[0];
+    return N(SLNext)(list, key, value);
+}
+
+/* Dump internal data structures for debugging. */
+void N(SLDump)(void *l)
+{
+    SkipListPtr   list = (SkipListPtr)l;
+    SLEntryPtr    entry;
+    int           i;
+    
+    if (list->magic != SL_LIST_MAGIC) {
+	printf("Bad magic: 0x%08lx (expected 0x%08lx)\n",
+	       list->magic, SL_LIST_MAGIC);
+	return;
+    }
+
+    printf("Level = %d, count = %d\n", list->level, list->count);
+    for (entry = list->head; entry; entry = entry->forward[0]) {
+	if (entry->magic != SL_ENTRY_MAGIC) {
+	    printf("Bad magic: 0x%08lx (expected 0x%08lx)\n",
+		   list->magic, SL_ENTRY_MAGIC);
+	}
+	printf("\nEntry %p <0x%08lx, %p> has %2d levels\n",
+	       entry, entry->key, entry->value, entry->levels);
+	for (i = 0; i < entry->levels; i++) {
+	    if (entry->forward[i]) {
+		printf("   %2d: %p <0x%08lx, %p>\n",
+		       i,
+		       entry->forward[i],
+		       entry->forward[i]->key,
+		       entry->forward[i]->value);
+	    } else {
+		printf("   %2d: %p\n", i, entry->forward[i]);
+	    }
+	}
+    }
+}
+
+#if SL_MAIN
+static void print(SkipListPtr list)
+{
+    unsigned long key;
+    void          *value;
+    
+    if (N(SLFirst)(list, &key, &value)) {
+	do {
+	    printf("key = %5lu, value = %p\n", key, value);
+	} while (N(SLNext)(list, &key, &value));
+    }
+}
+
+static double do_time(int size, int iter)
+{
+    SkipListPtr    list;
+    int            i, j;
+    unsigned long  keys[1000000];
+    unsigned long  previous;
+    unsigned long  key;
+    void           *value;
+    struct timeval start, stop;
+    double         usec;
+    SL_RANDOM_DECL;
+
+    SL_RANDOM_INIT(12345);
+    
+    list = N(SLCreate)();
+
+    for (i = 0; i < size; i++) {
+	keys[i] = SL_RANDOM;
+	N(SLInsert)(list, keys[i], NULL);
+    }
+
+    previous = 0;
+    if (N(SLFirst)(list, &key, &value)) {
+	do {
+	    if (key <= previous) {
+		printf( "%lu !< %lu\n", previous, key);
+	    }
+	    previous = key;
+	} while (N(SLNext)(list, &key, &value));
+    }
+    
+    gettimeofday(&start, NULL);
+    for (j = 0; j < iter; j++) {
+	for (i = 0; i < size; i++) {
+	    if (N(SLLookup)(list, keys[i], &value))
+		printf("Error %lu %d\n", keys[i], i);
+	}
+    }
+    gettimeofday(&stop, NULL);
+    
+    usec = (double)(stop.tv_sec * 1000000 + stop.tv_usec
+		    - start.tv_sec * 1000000 - start.tv_usec) / (size * iter);
+    
+    printf("%0.2f microseconds for list length %d\n", usec, size);
+
+    N(SLDestroy)(list);
+    
+    return usec;
+}
+
+static void print_neighbors(void *list, unsigned long key)
+{
+    unsigned long prev_key = 0;
+    unsigned long next_key = 0;
+    void          *prev_value;
+    void          *next_value;
+    int           retval;
+
+    retval = drmSLLookupNeighbors(list, key,
+				  &prev_key, &prev_value,
+				  &next_key, &next_value);
+    printf("Neighbors of %5lu: %d %5lu %5lu\n",
+	   key, retval, prev_key, next_key);
+}
+
+int main(void)
+{
+    SkipListPtr    list;
+    double         usec, usec2, usec3, usec4;
+
+    list = N(SLCreate)();
+    printf( "list at %p\n", list);
+
+    print(list);
+    printf("\n==============================\n\n");
+
+    N(SLInsert)(list, 123, NULL);
+    N(SLInsert)(list, 213, NULL);
+    N(SLInsert)(list, 50, NULL);
+    print(list);
+    printf("\n==============================\n\n");
+    
+    print_neighbors(list, 0);
+    print_neighbors(list, 50);
+    print_neighbors(list, 51);
+    print_neighbors(list, 123);
+    print_neighbors(list, 200);
+    print_neighbors(list, 213);
+    print_neighbors(list, 256);
+    printf("\n==============================\n\n");    
+    
+    N(SLDelete)(list, 50);
+    print(list);
+    printf("\n==============================\n\n");
+
+    N(SLDump)(list);
+    N(SLDestroy)(list);
+    printf("\n==============================\n\n");
+
+    usec  = do_time(100, 10000);
+    usec2 = do_time(1000, 500);
+    printf("Table size increased by %0.2f, search time increased by %0.2f\n",
+	   1000.0/100.0, usec2 / usec);
+    
+    usec3 = do_time(10000, 50);
+    printf("Table size increased by %0.2f, search time increased by %0.2f\n",
+	   10000.0/100.0, usec3 / usec);
+    
+    usec4 = do_time(100000, 4);
+    printf("Table size increased by %0.2f, search time increased by %0.2f\n",
+	   100000.0/100.0, usec4 / usec);
+
+    return 0;
+}
+#endif

src/glu/sgi/libnurbs/interface/glcurveval.cc

@@ -35,8 +35,8 @@
 /*
  * glcurveval.c++
  *
- * $Date: 2001/08/07 17:34:10 $ $Revision: 1.3 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/interface/glcurveval.cc,v 1.3 2001/08/07 17:34:10 brianp Exp $
+ * $Date: 2002/11/01 23:45:30 $ $Revision: 1.4 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/interface/glcurveval.cc,v 1.4 2002/11/01 23:45:30 brianp Exp $
  */
 
 /* Polynomial Evaluator Interface */
@@ -149,9 +149,9 @@ OpenGLCurveEvaluator::mapgrid1f(long nu, REAL u0, REAL u1)
 {
   if(output_triangles)
     {
-      global_grid_u0 = u0;
-      global_grid_u1 = u1;
-      global_grid_nu = nu;
+      global_grid_u0 = (int) u0;
+      global_grid_u1 = (int) u1;
+      global_grid_nu = (int) nu;
     }
   else
     glMapGrid1f((GLint) nu, (GLfloat) u0, (GLfloat) u1);

src/glu/sgi/libnurbs/internals/arc.cc

@@ -35,8 +35,8 @@
 /*
  * arc.c++
  *
- * $Date: 2001/03/17 00:25:40 $ $Revision: 1.1 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/arc.cc,v 1.1 2001/03/17 00:25:40 brianp Exp $
+ * $Date: 2002/11/01 23:35:07 $ $Revision: 1.2 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/arc.cc,v 1.2 2002/11/01 23:35:07 brianp Exp $
  */
 
 #include <stdio.h>
@@ -332,7 +332,7 @@ Arc::check( void )
 
 inline long tooclose( REAL x, REAL y )
 {
-    return (abs(x-y) < TOL) ?  1 : 0;
+    return (glu_abs(x-y) < TOL) ?  1 : 0;
 }
 
 

src/glu/sgi/libnurbs/internals/arctess.cc

@@ -35,8 +35,8 @@
 /*
  * arctessellator.c++
  *
- * $Date: 2001/03/17 00:25:40 $ $Revision: 1.1 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/arctess.cc,v 1.1 2001/03/17 00:25:40 brianp Exp $
+ * $Date: 2002/11/01 23:35:07 $ $Revision: 1.2 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/arctess.cc,v 1.2 2002/11/01 23:35:07 brianp Exp $
  */
 
 #include "glimports.h"
@@ -247,8 +247,8 @@ ArcTessellator::pwl( Arc *arc, REAL s1, REAL s2, REAL t1, REAL t2, REAL rate )
 
 /*    if(rate <= 0.06) rate = 0.06;*/
 
-    int snsteps = 1 + (int) (abs(s2 - s1) / rate );
-    int tnsteps = 1 + (int) (abs(t2 - t1) / rate );
+    int snsteps = 1 + (int) (glu_abs(s2 - s1) / rate );
+    int tnsteps = 1 + (int) (glu_abs(t2 - t1) / rate );
     int nsteps = max(1,max( snsteps, tnsteps ));
 
     REAL sstepsize = (s2 - s1) / (REAL) nsteps;
@@ -395,8 +395,8 @@ ArcTessellator::tessellateNonlinear( Arc *arc, REAL geo_stepsize, REAL arc_steps
             vert->param[0] = u/w;
     	    vert->param[1] = v/w;
 #ifndef NOELIMINATION
-	    REAL ds = abs(vert[0].param[0] - vert[-1].param[0]);
-	    REAL dt = abs(vert[0].param[1] - vert[-1].param[1]);
+	    REAL ds = glu_abs(vert[0].param[0] - vert[-1].param[0]);
+	    REAL dt = glu_abs(vert[0].param[1] - vert[-1].param[1]);
 	    int canremove = (ds<geo_stepsize && dt<geo_stepsize) ? 1 : 0;
 	    REAL ods=0.0, odt=0.0;
 
@@ -454,8 +454,8 @@ ArcTessellator::tessellateNonlinear( Arc *arc, REAL geo_stepsize, REAL arc_steps
             vert->param[0] = u;
 	    vert->param[1] = v;
 #ifndef NOELIMINATION
-	    REAL ds = abs(vert[0].param[0] - vert[-1].param[0]);
-	    REAL dt = abs(vert[0].param[1] - vert[-1].param[1]);
+	    REAL ds = glu_abs(vert[0].param[0] - vert[-1].param[0]);
+	    REAL dt = glu_abs(vert[0].param[1] - vert[-1].param[1]);
 	    int canremove = (ds<geo_stepsize && dt<geo_stepsize) ? 1 : 0;
 	    REAL ods=0.0, odt=0.0;
 

src/glu/sgi/libnurbs/internals/ccw.cc

@@ -35,8 +35,8 @@
 /*
  * ccw.c++
  *
- * $Date: 2001/03/17 00:25:40 $ $Revision: 1.1 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/ccw.cc,v 1.1 2001/03/17 00:25:40 brianp Exp $
+ * $Date: 2002/11/01 23:35:07 $ $Revision: 1.2 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/ccw.cc,v 1.2 2002/11/01 23:35:07 brianp Exp $
  */
 
 #include "glimports.h"
@@ -562,6 +562,6 @@ int
 Subdivider::ccw( TrimVertex *a, TrimVertex *b, TrimVertex *c )
 {
     REAL d = det3( a, b, c );
-    if( abs(d) < 0.0001 ) return -1;
+    if( glu_abs(d) < 0.0001 ) return -1;
     return (d < 0.0) ? 0 : 1;
 }

src/glu/sgi/libnurbs/internals/patch.cc

@@ -35,8 +35,8 @@
 /*
  * patch.c++
  *
- * $Date: 2001/08/13 16:52:18 $ $Revision: 1.2 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/patch.cc,v 1.2 2001/08/13 16:52:18 brianp Exp $
+ * $Date: 2002/11/01 23:35:07 $ $Revision: 1.3 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/patch.cc,v 1.3 2002/11/01 23:35:07 brianp Exp $
  */
 
 #include <stdio.h>
@@ -49,7 +49,7 @@
 #include "mapdesc.h"
 #include "quilt.h"
 #include "nurbsconsts.h"
-#include "simplemath.h" //for abs function in ::singleStep();
+#include "simplemath.h" //for glu_abs function in ::singleStep();
 
 
 /*--------------------------------------------------------------------------
@@ -464,7 +464,7 @@ Patch::getstepsize( void )
 void
 Patchspec::singleStep()
 {
-    stepsize =  sidestep[0] =  sidestep[1] = abs(range[2]);
+    stepsize =  sidestep[0] =  sidestep[1] = glu_abs(range[2]);
 }
 
 void 

src/glu/sgi/libnurbs/internals/quilt.cc

@@ -35,8 +35,8 @@
 /*
  * quilt.c++
  *
- * $Date: 2001/03/17 00:25:41 $ $Revision: 1.1 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/quilt.cc,v 1.1 2001/03/17 00:25:41 brianp Exp $
+ * $Date: 2002/11/01 23:35:07 $ $Revision: 1.2 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/quilt.cc,v 1.2 2002/11/01 23:35:07 brianp Exp $
  */
 
 #include "glimports.h"
@@ -48,7 +48,7 @@
 #include "flist.h"
 #include "knotvector.h"
 #include "patchlist.h"
-#include "math.h"     //fabs()
+#include "math.h"     //fglu_abs()
 #include "simplemath.h" //min()
 
 /* local preprocessor definitions */
@@ -265,8 +265,8 @@ Quilt::findSampleRates( Flist& slist, Flist& tlist )
 	    patchlist.getstepsize();
 	    
 	    {
-	    float edge_len_s = min(fabs(ptb[0]-pta[0]),1.0);
-	    float edge_len_t = min(fabs(ptb[1]-pta[1]),1.0);
+	    float edge_len_s = min(glu_abs(ptb[0]-pta[0]),1.0);
+	    float edge_len_t = min(glu_abs(ptb[1]-pta[1]),1.0);
 
 	    if( patchlist.getStepsize(0)/edge_len_s < qspec[0].step_size ) 
 	       qspec[0].step_size = patchlist.getStepsize(0)/edge_len_s;

src/glu/sgi/libnurbs/internals/reader.cc

@@ -35,8 +35,8 @@
 /*
  *  reader.c++
  *
- * $Date: 2001/03/17 00:25:41 $ $Revision: 1.1 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/reader.cc,v 1.1 2001/03/17 00:25:41 brianp Exp $
+ * $Date: 2002/11/01 23:35:07 $ $Revision: 1.2 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/reader.cc,v 1.2 2002/11/01 23:35:07 brianp Exp $
  */
 
 #include <stdio.h>
@@ -55,7 +55,7 @@
 #define ELIMINATE_REDUNDANT_POINTS 
 
 #ifdef  ELIMINATE_REDUNDANT_POINTS 
-#define equal(x,y) ( abs(x-y) <= 0.00001)
+#define equal(x,y) ( glu_abs(x-y) <= 0.00001)
 #endif
 
 #ifdef ELIMINATE_REDUNDANT_POINTS 

src/glu/sgi/libnurbs/internals/simplemath.h

@@ -35,8 +35,8 @@
 /*
  * simplemath.h
  *
- * $Date: 2001/03/17 00:25:41 $ $Revision: 1.1 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/simplemath.h,v 1.1 2001/03/17 00:25:41 brianp Exp $
+ * $Date: 2002/11/01 23:35:07 $ $Revision: 1.2 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/simplemath.h,v 1.2 2002/11/01 23:35:07 brianp Exp $
  */
 
 #ifndef __glusimplemath_h_
@@ -51,6 +51,6 @@ inline REAL
 min( REAL x, REAL y ) { return ( x > y ) ? y : x; }
 
 inline REAL 
-abs( REAL x ) { return ( x < 0.0 ) ? -x : x; }
+glu_abs( REAL x ) { return ( x < 0.0 ) ? -x : x; }
 
 #endif /* __glusimplemath_h_ */

src/glu/sgi/libnurbs/internals/slicer.cc

@@ -35,8 +35,8 @@
 /*
  * slicer.c++
  *
- * $Date: 2002/06/30 16:58:11 $ $Revision: 1.3 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/slicer.cc,v 1.3 2002/06/30 16:58:11 brianp Exp $
+ * $Date: 2002/11/01 23:35:07 $ $Revision: 1.4 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/slicer.cc,v 1.4 2002/11/01 23:35:07 brianp Exp $
  */
 
 #include <stdlib.h>
@@ -50,6 +50,7 @@
 #include "backend.h"
 #include "arc.h"
 #include "gridtrimvertex.h"
+#include "simplemath.h"
 #include "trimvertex.h"
 #include "varray.h"
 
@@ -81,7 +82,7 @@ Int num_quads = 0;
 
 #define max(a,b) ((a>b)? a:b)
 #define ZERO 0.00001 /*determing whether a loop is a rectngle or not*/
-#define equalRect(a,b) ((fabs(a-b) <= ZERO)? 1:0) //only used in tessellating a rectangle
+#define equalRect(a,b) ((glu_abs(a-b) <= ZERO)? 1:0) //only used in tessellating a rectangle
 
 static Int is_Convex(Arc_ptr loop)
 {
@@ -233,23 +234,23 @@ printf("loop->tail=(%f,%f)\n", loop->tail()[0], loop->tail()[1]);
 printf("loop->head=(%f,%f)\n", loop->head()[0], loop->head()[1]);
 printf("loop->next->tail=(%f,%f)\n", loop->next->tail()[0], loop->next->tail()[1]);
 printf("loop->next->head=(%f,%f)\n", loop->next->head()[0], loop->next->head()[1]);
-if(fabs(loop->tail()[0] - loop->head()[0])<0.000001)
+if(fglu_abs(loop->tail()[0] - loop->head()[0])<0.000001)
 	printf("equal 1\n");
 if(loop->next->tail()[1] == loop->next->head()[1])
 	printf("equal 2\n");
 */
 
-  if( (fabs(loop->tail()[0] - loop->head()[0])<=ZERO) && 
-      (fabs(loop->next->tail()[1] - loop->next->head()[1])<=ZERO) &&
-      (fabs(loop->prev->tail()[1] - loop->prev->head()[1])<=ZERO) &&
-      (fabs(loop->prev->prev->tail()[0] - loop->prev->prev->head()[0])<=ZERO)
+  if( (glu_abs(loop->tail()[0] - loop->head()[0])<=ZERO) && 
+      (glu_abs(loop->next->tail()[1] - loop->next->head()[1])<=ZERO) &&
+      (glu_abs(loop->prev->tail()[1] - loop->prev->head()[1])<=ZERO) &&
+      (glu_abs(loop->prev->prev->tail()[0] - loop->prev->prev->head()[0])<=ZERO)
      )
     return 1;
   else if
-    ( (fabs(loop->tail()[1] - loop->head()[1]) <= ZERO) && 
-      (fabs(loop->next->tail()[0] - loop->next->head()[0]) <= ZERO) &&
-      (fabs(loop->prev->tail()[0] - loop->prev->head()[0]) <= ZERO) &&
-      (fabs(loop->prev->prev->tail()[1] - loop->prev->prev->head()[1]) <= ZERO)
+    ( (glu_abs(loop->tail()[1] - loop->head()[1]) <= ZERO) && 
+      (glu_abs(loop->next->tail()[0] - loop->next->head()[0]) <= ZERO) &&
+      (glu_abs(loop->prev->tail()[0] - loop->prev->head()[0]) <= ZERO) &&
+      (glu_abs(loop->prev->prev->tail()[1] - loop->prev->prev->head()[1]) <= ZERO)
      )
       return 1;
   else

src/glu/sgi/libnurbs/internals/varray.cc

@@ -35,8 +35,8 @@
 /*
  * varray.c++
  *
- * $Date: 2001/03/17 00:25:41 $ $Revision: 1.1 $
- * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/varray.cc,v 1.1 2001/03/17 00:25:41 brianp Exp $
+ * $Date: 2002/11/01 23:35:07 $ $Revision: 1.2 $
+ * $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/internals/varray.cc,v 1.2 2002/11/01 23:35:07 brianp Exp $
  */
 
 #include "glimports.h"
@@ -44,7 +44,7 @@
 #include "mystdio.h"
 #include "varray.h"
 #include "arc.h"
-#include "math.h"         // fabs()
+#include "simplemath.h"         // glu_abs()
 
 #define TINY 0.0001
 inline long sgn( REAL x ) 
@@ -114,9 +114,9 @@ Varray::init( REAL delta, Arc_ptr toparc, Arc_ptr botarc )
 	    update( right, rdir, right->tail()[1] );
 	    break;
 	case 0:
-	    if( fabs(left->tail()[1] - botarc->tail()[1]) < TINY) goto end;
-            if( fabs(left->tail()[0]-right->prev->tail()[0]) < TINY &&
-                fabs(left->tail()[1]-right->prev->tail()[1]) < TINY) goto end;
+	    if( glu_abs(left->tail()[1] - botarc->tail()[1]) < TINY) goto end;
+            if( glu_abs(left->tail()[0]-right->prev->tail()[0]) < TINY &&
+                glu_abs(left->tail()[1]-right->prev->tail()[1]) < TINY) goto end;
 	    left = left->next;
 	    break;
  	}

src/glu/sgi/libnurbs/nurbtess/sampleMonoPoly.cc

@@ -31,10 +31,10 @@
 ** published by SGI, but has not been independently verified as being
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date: 2001/03/17 00:25:41 $ $Revision: 1.1 $
+** $Date: 2002/11/08 17:38:13 $ $Revision: 1.3 $
 */
 /*
-** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/nurbtess/sampleMonoPoly.cc,v 1.1 2001/03/17 00:25:41 brianp Exp $
+** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libnurbs/nurbtess/sampleMonoPoly.cc,v 1.3 2002/11/08 17:38:13 brianp Exp $
 */
 
 #include "gluos.h"
@@ -483,7 +483,7 @@ rightChain->print();
 
 
       Real tempMin = rightChain->getVertex(index2)[0];
-      Real tempI = index2;
+      Int tempI = index2;
       for(i=index2+1; i<= rightChainEndIndex; i++)
 	if(rightChain->getVertex(i)[0] < tempMin)
 	  {
@@ -505,7 +505,7 @@ rightChain->print();
      else
        {
 	 ret_leftCornerWhere = 2; //right
-	 ret_leftCornerIndex = (int)tempI;
+	 ret_leftCornerIndex = tempI;
        }
     }
   else if(index2> rightChainEndIndex) /*index1<=leftChainEndIndex*/
@@ -517,7 +517,7 @@ rightChain->print();
        *either this vertex or the botvertex can be used as the right corner
        */
 
-      Real tempI;
+      Int tempI;
       //skip those points which are equal to v. (avoid degeneratcy)
       for(tempI = index1; tempI <= leftChainEndIndex; tempI++)
 	if(leftChain->getVertex(tempI)[1] < v) 
@@ -527,7 +527,7 @@ rightChain->print();
       else
 	{
 	  Real tempMax = leftChain->getVertex(tempI)[0];
-	  for(i=(int)tempI; i<= leftChainEndIndex; i++)
+	  for(i=tempI; i<= leftChainEndIndex; i++)
 	    if(leftChain->getVertex(i)[0] > tempMax)
 	      {
 		tempI = i;
@@ -552,7 +552,7 @@ rightChain->print();
 	  else
 	    {
 	      ret_rightCornerWhere = 0;
-	      ret_rightCornerIndex = (int)tempI;
+	      ret_rightCornerIndex = tempI;
 	    }
 	}
       

src/glu/sgi/libtess/normal.c

@@ -35,8 +35,8 @@
 /*
 ** Author: Eric Veach, July 1994.
 **
-** $Date: 2001/03/17 00:25:41 $ $Revision: 1.1 $
-** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libtess/normal.c,v 1.1 2001/03/17 00:25:41 brianp Exp $
+** $Date: 2002/11/01 23:45:31 $ $Revision: 1.2 $
+** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libtess/normal.c,v 1.2 2002/11/01 23:45:31 brianp Exp $
 */
 
 #include "gluos.h"
@@ -51,6 +51,7 @@
 
 #define Dot(u,v)	(u[0]*v[0] + u[1]*v[1] + u[2]*v[2])
 
+#if 0
 static void Normalize( GLdouble v[3] )
 {
   GLdouble len = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
@@ -61,6 +62,7 @@ static void Normalize( GLdouble v[3] )
   v[1] /= len;
   v[2] /= len;
 }
+#endif
 
 #define ABS(x)	((x) < 0 ? -(x) : (x))
 
@@ -198,7 +200,7 @@ extern int RandomSweep;
 void __gl_projectPolygon( GLUtesselator *tess )
 {
   GLUvertex *v, *vHead = &tess->mesh->vHead;
-  GLdouble w, norm[3];
+  GLdouble norm[3];
   GLdouble *sUnit, *tUnit;
   int i, computedNormal = FALSE;
 

src/glu/sgi/libtess/sweep.c

@@ -35,8 +35,8 @@
 /*
 ** Author: Eric Veach, July 1994.
 **
-** $Date: 2001/09/20 21:47:52 $ $Revision: 1.2 $
-** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libtess/sweep.c,v 1.2 2001/09/20 21:47:52 kschultz Exp $
+** $Date: 2002/11/07 14:17:05 $ $Revision: 1.5 $
+** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libtess/sweep.c,v 1.5 2002/11/07 14:17:05 brianp Exp $
 */
 
 #include "gluos.h"
@@ -1174,7 +1174,9 @@ static void InitEdgeDict( GLUtesselator *tess )
 static void DoneEdgeDict( GLUtesselator *tess )
 {
   ActiveRegion *reg;
+#ifndef NDEBUG
   int fixedEdges = 0;
+#endif
 
   /* __GL_DICTLISTKEY */ /* __GL_DICTLISTMIN */
   while( (reg = (ActiveRegion *)dictKey( dictMin( tess->dict ))) != NULL ) {

src/glu/sgi/libtess/tess.c

@@ -35,8 +35,8 @@
 /*
 ** Author: Eric Veach, July 1994.
 **
-** $Date: 2001/09/20 21:47:52 $ $Revision: 1.2 $
-** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libtess/tess.c,v 1.2 2001/09/20 21:47:52 kschultz Exp $
+** $Date: 2002/11/01 23:45:31 $ $Revision: 1.3 $
+** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libtess/tess.c,v 1.3 2002/11/01 23:45:31 brianp Exp $
 */
 
 #include "gluos.h"
@@ -169,6 +169,8 @@ static void GotoState( GLUtesselator *tess, enum TessState newState )
 	CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_BEGIN_CONTOUR );
 	gluTessBeginContour( tess );
 	break;
+      default:
+         ;
       }
     } else {
       switch( tess->state ) {
@@ -181,6 +183,8 @@ static void GotoState( GLUtesselator *tess, enum TessState newState )
 	/* gluTessEndPolygon( tess ) is too much work! */
 	MakeDormant( tess );
 	break;
+      default:
+         ;
       }
     }
   }

src/glu/sgi/libutil/mipmap.c

@@ -31,8 +31,8 @@
 ** published by SGI, but has not been independently verified as being
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date: 2001/08/07 17:34:11 $ $Revision: 1.2 $
-** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libutil/mipmap.c,v 1.2 2001/08/07 17:34:11 brianp Exp $
+** $Date: 2002/11/01 23:45:31 $ $Revision: 1.3 $
+** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libutil/mipmap.c,v 1.3 2002/11/01 23:45:31 brianp Exp $
 */
 
 #include "gluos.h"
@@ -573,7 +573,7 @@ static void halveImage_ushort(GLint components, GLuint width, GLuint height,
 			GLint element_size, GLint ysize, GLint group_size,
 			GLint myswap_bytes)
 {
-    int i, j, k, l;
+    int i, j, k;
     int newwidth, newheight;
     GLushort *s;
     const char *t;
@@ -708,7 +708,7 @@ static void halveImage_short(GLint components, GLuint width, GLuint height,
 			GLint element_size, GLint ysize, GLint group_size,
 			GLint myswap_bytes)
 {
-    int i, j, k, l;
+    int i, j, k;
     int newwidth, newheight;
     GLshort *s;
     const char *t;
@@ -850,7 +850,7 @@ static void halveImage_uint(GLint components, GLuint width, GLuint height,
 			GLint element_size, GLint ysize, GLint group_size,
 			GLint myswap_bytes)
 {
-    int i, j, k, l;
+    int i, j, k;
     int newwidth, newheight;
     GLuint *s;
     const char *t;
@@ -990,7 +990,7 @@ static void halveImage_int(GLint components, GLuint width, GLuint height,
 		        const GLint *datain, GLint *dataout, GLint element_size,
 			GLint ysize, GLint group_size, GLint myswap_bytes)
 {
-    int i, j, k, l;
+    int i, j, k;
     int newwidth, newheight;
     GLint *s;
     const char *t;
@@ -1134,7 +1134,7 @@ static void halveImage_float(GLint components, GLuint width, GLuint height,
 			GLint element_size, GLint ysize, GLint group_size,
 			GLint myswap_bytes)
 {
-    int i, j, k, l;
+    int i, j, k;
     int newwidth, newheight;
     GLfloat *s;
     const char *t;
@@ -1370,8 +1370,8 @@ static void scale_internal_ubyte(GLint components, GLint widthin,
 			   GLubyte *dataout, GLint element_size,
 			   GLint ysize, GLint group_size)
 {
-    float x, convx;
-    float y, convy;
+    float convx;
+    float convy;
     float percent;
     /* Max components in a format is 4, so... */
     float totals[4];
@@ -1584,8 +1584,8 @@ static void scale_internal_byte(GLint components, GLint widthin,
 			   GLbyte *dataout, GLint element_size,
 			   GLint ysize, GLint group_size)
 {
-    float x, convx;
-    float y, convy;
+    float convx;
+    float convy;
     float percent;
     /* Max components in a format is 4, so... */
     float totals[4];
@@ -1799,8 +1799,8 @@ static void scale_internal_ushort(GLint components, GLint widthin,
 			   GLint ysize, GLint group_size,
 			   GLint myswap_bytes)
 {
-    float x, convx;
-    float y, convy;
+    float convx;
+    float convy;
     float percent;
     /* Max components in a format is 4, so... */
     float totals[4];
@@ -2076,8 +2076,8 @@ static void scale_internal_short(GLint components, GLint widthin,
                            GLint ysize, GLint group_size,
                            GLint myswap_bytes)
 {
-    float x, convx;
-    float y, convy;
+    float convx;
+    float convy;
     float percent;
     /* Max components in a format is 4, so... */
     float totals[4];
@@ -2367,8 +2367,8 @@ static void scale_internal_uint(GLint components, GLint widthin,
                            GLint ysize, GLint group_size,
                            GLint myswap_bytes)
 {
-    float x, convx;
-    float y, convy;
+    float convx;
+    float convy;
     float percent;
     /* Max components in a format is 4, so... */
     float totals[4];
@@ -2651,8 +2651,8 @@ static void scale_internal_int(GLint components, GLint widthin,
                            GLint ysize, GLint group_size,
                            GLint myswap_bytes)
 {
-    float x, convx;
-    float y, convy;
+    float convx;
+    float convy;
     float percent;
     /* Max components in a format is 4, so... */
     float totals[4];
@@ -2944,8 +2944,8 @@ static void scale_internal_float(GLint components, GLint widthin,
                            GLint ysize, GLint group_size,
                            GLint myswap_bytes)
 {
-    float x, convx;
-    float y, convy;
+    float convx;
+    float convy;
     float percent;
     /* Max components in a format is 4, so... */
     float totals[4];
@@ -3517,7 +3517,6 @@ int gluBuild1DMipmapLevelsCore(GLenum target, GLint internalFormat,
     GLushort *otherImage;
     GLushort *imageTemp;
     GLint memreq;
-    GLint maxsize;
     GLint cmpts;
     PixelStorageModes psm;
 
@@ -3664,7 +3663,6 @@ static int bitmapBuild2DMipmaps(GLenum target, GLint internalFormat,
     GLushort *otherImage;
     GLushort *imageTemp;
     GLint memreq;
-    GLint maxsize;
     GLint cmpts;
     PixelStorageModes psm;
 
@@ -3771,11 +3769,8 @@ static int gluBuild2DMipmapLevelsCore(GLenum target, GLint internalFormat,
     GLint level, levels;
     const void *usersImage; /* passed from user. Don't touch! */
     void *srcImage, *dstImage; /* scratch area to build mipmapped images */
-    GLint newImage_width;
-    GLint newImage_height;
     __GLU_INIT_SWAP_IMAGE;
     GLint memreq;
-    GLint maxsize;
     GLint cmpts;
 
     GLint myswap_bytes, groups_per_line, element_size, group_size;
@@ -4588,7 +4583,6 @@ static int fastBuild2DMipmaps(const PixelStorageModes *psm,
     GLubyte *otherImage;
     GLubyte *imageTemp;
     GLint memreq;
-    GLint maxsize;
     GLint cmpts;
 
 
@@ -5979,8 +5973,8 @@ static void scaleInternalPackedPixel(int components,
 				     GLint pixelSizeInBytes,
 				     GLint rowSizeInBytes,GLint isSwap)
 {
-    float x, convx;
-    float y, convy;
+    float convx;
+    float convy;
     float percent;
 
     /* Max components in a format is 4, so... */
@@ -5991,7 +5985,6 @@ static void scaleInternalPackedPixel(int components,
     int i,j,k,xindex;
 
     const char *temp, *temp0;
-    const char *temp_index;
     int outindex;
 
     int lowx_int, highx_int, lowy_int, highy_int;
@@ -7308,6 +7301,7 @@ static void emptyImage3D(const PixelStorageModes *psm,
 					psm->unpack_skip_images * imageSize] );
 } /* emptyImage3D() */
 
+static 
 int gluScaleImage3D(GLenum format, 
 		    GLint widthIn, GLint heightIn, GLint depthIn,
 		    GLenum typeIn, const void *dataIn, 
@@ -7361,6 +7355,7 @@ int gluScaleImage3D(GLenum format,
    return 0;
 } /* gluScaleImage3D() */
 
+
 static void closestFit3D(GLenum target, GLint width, GLint height, GLint depth,
 			 GLint internalFormat, GLenum format, GLenum type, 
 			 GLint *newWidth, GLint *newHeight, GLint *newDepth)
@@ -7434,7 +7429,6 @@ static void halveImagePackedPixelSlice(int components,
    int halfHeight= height / 2;
    int halfDepth= depth / 2;
    const char *src= (const char *)dataIn;
-   int padBytes= rowSizeInBytes - (width * pixelSizeInBytes);
    int outIndex= 0;
 
    assert((width == 1 || height == 1) && depth >= 2);
@@ -7690,10 +7684,8 @@ static int gluBuild3DMipmapLevelsCore(GLenum target, GLint internalFormat,
    GLint level, levels;
    const void *usersImage;
    void *srcImage, *dstImage;
-   GLint newImageWidth, newImageHeight, newImageDepth;
    __GLU_INIT_SWAP_IMAGE;
    GLint memReq;
-   GLint maxSize;
    GLint cmpts;
 
    GLint myswapBytes, groupsPerLine, elementSize, groupSize;

src/glu/sgi/libutil/project.c

@@ -31,8 +31,8 @@
 ** published by SGI, but has not been independently verified as being
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date: 2001/09/18 16:39:38 $ $Revision: 1.4 $
-** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libutil/project.c,v 1.4 2001/09/18 16:39:38 kschultz Exp $
+** $Date: 2002/11/01 23:45:31 $ $Revision: 1.5 $
+** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libutil/project.c,v 1.5 2002/11/01 23:45:31 brianp Exp $
 */
 
 #include "gluos.h"
@@ -116,7 +116,6 @@ gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx,
 	  GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy,
 	  GLdouble upz)
 {
-    int i;
     float forward[3], side[3], up[3];
     GLfloat m[4][4];
 

src/glu/sgi/libutil/quad.c

@@ -31,8 +31,8 @@
 ** published by SGI, but has not been independently verified as being
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date: 2001/09/20 21:47:52 $ $Revision: 1.2 $
-** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libutil/quad.c,v 1.2 2001/09/20 21:47:52 kschultz Exp $
+** $Date: 2002/11/01 23:45:31 $ $Revision: 1.3 $
+** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libutil/quad.c,v 1.3 2002/11/01 23:45:31 brianp Exp $
 */
 
 #include "gluos.h"
@@ -156,7 +156,7 @@ void GLAPIENTRY
 gluCylinder(GLUquadric *qobj, GLdouble baseRadius, GLdouble topRadius, 
 		GLdouble height, GLint slices, GLint stacks)
 {
-    GLint i,j,max;
+    GLint i,j;
     GLfloat sinCache[CACHE_SIZE];
     GLfloat cosCache[CACHE_SIZE];
     GLfloat sinCache2[CACHE_SIZE];
@@ -164,7 +164,7 @@ gluCylinder(GLUquadric *qobj, GLdouble baseRadius, GLdouble topRadius,
     GLfloat sinCache3[CACHE_SIZE];
     GLfloat cosCache3[CACHE_SIZE];
     GLfloat angle;
-    GLfloat x, y, zLow, zHigh;
+    GLfloat zLow, zHigh;
     GLfloat sintemp, costemp;
     GLfloat length;
     GLfloat deltaRadius;
@@ -438,11 +438,10 @@ gluPartialDisk(GLUquadric *qobj, GLdouble innerRadius,
 		   GLdouble outerRadius, GLint slices, GLint loops,
 		   GLdouble startAngle, GLdouble sweepAngle)
 {
-    GLint i,j,max;
+    GLint i,j;
     GLfloat sinCache[CACHE_SIZE];
     GLfloat cosCache[CACHE_SIZE];
     GLfloat angle;
-    GLfloat x, y;
     GLfloat sintemp, costemp;
     GLfloat deltaRadius;
     GLfloat radiusLow, radiusHigh;
@@ -700,7 +699,7 @@ gluPartialDisk(GLUquadric *qobj, GLdouble innerRadius,
 void GLAPIENTRY
 gluSphere(GLUquadric *qobj, GLdouble radius, GLint slices, GLint stacks)
 {
-    GLint i,j,max;
+    GLint i,j;
     GLfloat sinCache1a[CACHE_SIZE];
     GLfloat cosCache1a[CACHE_SIZE];
     GLfloat sinCache2a[CACHE_SIZE];
@@ -714,11 +713,9 @@ gluSphere(GLUquadric *qobj, GLdouble radius, GLint slices, GLint stacks)
     GLfloat sinCache3b[CACHE_SIZE];
     GLfloat cosCache3b[CACHE_SIZE];
     GLfloat angle;
-    GLfloat x, y, zLow, zHigh;
+    GLfloat zLow, zHigh;
     GLfloat sintemp1, sintemp2, sintemp3, sintemp4;
     GLfloat costemp1, costemp2, costemp3, costemp4;
-    GLfloat zNormal;
-    GLfloat xyNormalRatio;
     GLboolean needCache2, needCache3;
     GLint start, finish;
 

src/glu/sgi/mesaglu.opt

@@ -5,7 +5,6 @@ case_sensitive=YES
 symbol_vector = (gluErrorString	= PROCEDURE)                                    
 symbol_vector = (__gluNURBSErrorString	= PROCEDURE)                             
 symbol_vector = (__gluTessErrorString	= PROCEDURE)                              
-symbol_vector = (gluScaleImage3D	= PROCEDURE)                                   
 symbol_vector = (gluBuild3DMipmaps	= PROCEDURE)                                 
 symbol_vector = (gluBuild3DMipmapLevels	= PROCEDURE)                            
 symbol_vector = (gluBuild2DMipmaps	= PROCEDURE)                                 

src/glut/dos/PC_HW/pc_hw.c

@@ -1,5 +1,5 @@
 /*
- * PC/HW routine collection v1.0 for DOS/DJGPP
+ * PC/HW routine collection v1.2 for DOS/DJGPP
  *
  *  Copyright (C) 2002 - Borca Daniel
  *  Email : dborca@yahoo.com
@@ -12,7 +12,6 @@
 #include <sys/stat.h> /* for mode definitions */
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <unistd.h>
 
 #include "pc_hw.h"
@@ -74,68 +73,76 @@ void *pc_malloc (size_t size)
 /*
  * standard redirection
  */
-static char errname[L_tmpnam];
-static char outname[L_tmpnam];
+static int h_out, h_outbak, h_err, h_errbak;
 
-static int h_out, h_outbak;
-static int h_err, h_errbak;
-
-void pc_open_stderr (void)
+int pc_open_stdout (void)
 {
- if (tmpnam(errname)) {
-    h_err = open(errname, O_WRONLY |/* O_BINARY |*/ O_CREAT | O_TRUNC,
-                          S_IREAD | S_IWRITE);
-    h_errbak = dup(2);
-    fflush(stderr);
-    dup2(h_err, 2);
- }
-}
-
-void pc_close_stderr (void)
-{
- FILE *f;
- char *line = alloca(512);
- 
- dup2(h_errbak, 2);
- close(h_err);
- close(h_errbak);
- 
- if ((f=fopen(errname, "r"))!=NULL) {
-    while (fgets(line, 512, f)) {
-          fputs(line, stderr);
+ if ((h_out=open(tmpnam(NULL), O_WRONLY | O_CREAT | O_TRUNC | O_TEXT | O_TEMPORARY, S_IRUSR | S_IWUSR)) >= 0) {
+    if ((h_outbak=dup(1)) != -1) {
+       fflush(stdout);
+       if (dup2(h_out, 1) != -1) {
+          return 0;
+       }
+       close(h_outbak);
     }
-    fclose(f);
- }
-
- remove(errname);
-}
-
-void pc_open_stdout (void)
-{
- if (tmpnam(outname)) {
-    h_out = open(outname, O_WRONLY |/* O_BINARY |*/ O_CREAT | O_TRUNC,
-                          S_IREAD | S_IWRITE);
-    h_outbak = dup(1);
-    fflush(stdout);
-    dup2(h_out, 1);
+    close(h_out);
  }
+ return (h_out = -1);
 }
 
 void pc_close_stdout (void)
 {
  FILE *f;
  char *line = alloca(512);
- 
- dup2(h_outbak, 1);
- close(h_out);
- close(h_outbak);
- 
- if ((f=fopen(outname, "r"))!=NULL) {
-    while (fgets(line, 512, f)) {
-          fputs(line, stdout);
-    }
-    fclose(f);
- }
 
- remove(outname);
+ if (h_out >= 0) {
+    dup2(h_outbak, 1);
+    close(h_outbak);
+
+    if ((f=fdopen(h_out, "r")) != NULL) {
+       fseek(f, 0, SEEK_SET);
+       while (fgets(line, 512, f)) {
+             fputs(line, stdout);
+       }
+       fclose(f);
+    } else {
+       close(h_out);
+    }
+ }
+}
+
+int pc_open_stderr (void)
+{
+ if ((h_err=open(tmpnam(NULL), O_WRONLY | O_CREAT | O_TRUNC | O_TEXT | O_TEMPORARY, S_IRUSR | S_IWUSR)) >= 0) {
+    if ((h_errbak=dup(2)) != -1) {
+       fflush(stderr);
+       if (dup2(h_err, 2) != -1) {
+          return 0;
+       }
+       close(h_errbak);
+    }
+    close(h_err);
+ }
+ return (h_err = -1);
+}
+
+void pc_close_stderr (void)
+{
+ FILE *f;
+ char *line = alloca(512);
+
+ if (h_err >= 0) {
+    dup2(h_errbak, 2);
+    close(h_errbak);
+
+    if ((f=fdopen(h_err, "r")) != NULL) {
+       fseek(f, 0, SEEK_SET);
+       while (fgets(line, 512, f)) {
+             fputs(line, stderr);
+       }
+       fclose(f);
+    } else {
+       close(h_err);
+    }
+ }
 }

src/glut/dos/PC_HW/pc_hw.h

@@ -1,5 +1,5 @@
 /*
- * PC/HW routine collection v1.1 for DOS/DJGPP
+ * PC/HW routine collection v1.2 for DOS/DJGPP
  *
  *  Copyright (C) 2002 - Borca Daniel
  *  Email : dborca@yahoo.com
@@ -217,8 +217,8 @@ void pc_unscare_mouse (void);
 /*
  * standard redirection
  */
-void pc_open_stdout (void);
-void pc_open_stderr (void);
+int pc_open_stdout (void);
+int pc_open_stderr (void);
 void pc_close_stdout (void);
 void pc_close_stderr (void);
 

src/glut/dos/PC_HW/pc_mouse.c

@@ -1,5 +1,5 @@
 /*
- * PC/HW routine collection v1.1 for DOS/DJGPP
+ * PC/HW routine collection v1.2 for DOS/DJGPP
  *
  *  Copyright (C) 2002 - Borca Daniel
  *  Email : dborca@yahoo.com
@@ -226,6 +226,7 @@ void pc_unscare_mouse (void)
 }
 
 __asm("\n\
+		.text					\n\
 		.balign	4				\n\
 		.global	_mouse_wrapper			\n\
 _mouse_wrapper:						\n\
@@ -252,7 +253,6 @@ _mouse_wrapper:						\n\
 		movl	%esi, %esp			\n\
 		popl	%es				\n\
 		iret					\n\
-							\n\
 		.balign	4				\n\
 		.global	_mouse_wrapper_end		\n\
 _mouse_wrapper_end:");

src/glut/dos/window.c

@@ -1,6 +1,6 @@
 /*
  * Mesa 3-D graphics library
- * Version:  4.0
+ * Version:  4.1
  * Copyright (C) 1995-1998  Brian Paul
  *
  * This library is free software; you can redistribute it and/or
@@ -19,7 +19,7 @@
  */
 
 /*
- * DOS/DJGPP glut driver v1.1 for Mesa 4.0
+ * DOS/DJGPP glut driver v1.2 for Mesa 4.1
  *
  *  Copyright (C) 2002 - Borca Daniel
  *  Email : dborca@yahoo.com
@@ -113,6 +113,7 @@ int APIENTRY glutCreateWindow (const char *title)
     if ((context=fxMesaCreateBestContext(-1, screen_w, screen_h, fx_attrib))==NULL) {
        return 0;
     }
+    visual = context;
 #endif
     
     pc_open_stdout();

src/glut/glx/glut_win.c

@@ -328,11 +328,16 @@ getVisualInfoRGB(unsigned int mode)
       list[n++] = 1;
     }
   }
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+#if defined(GLX_VERSION_1_1) && (defined(GLX_SGIS_multisample) || defined(GLX_ARB_multisample))
   if (GLUT_WIND_IS_MULTISAMPLE(mode)) {
-    if (!__glutIsSupportedByGLX("GLX_SGIS_multisample"))
+    if (!__glutIsSupportedByGLX("GLX_SGIS_multisample") &&
+        !__glutIsSupportedByGLX("GLX_ARB_multisample"))
       return NULL;
+#if defined(GLX_ARB_multisample)
+    list[n++] = GLX_SAMPLES_ARB;
+#elif defined(GLX_SGIS_multisample)
     list[n++] = GLX_SAMPLES_SGIS;
+#endif
     /* XXX Is 4 a reasonable minimum acceptable number of
        samples? */
     list[n++] = 4;

src/glut/mini/.cvsignore

@@ -0,0 +1,2 @@
+*.d
+libglut.so*

src/glut/mini/Makefile

@@ -0,0 +1,98 @@
+# Mesa 3-D graphics library
+# Version:  4.0
+# 
+# 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.
+
+# DOS/DJGPP glut makefile v1.1 for Mesa 4.0
+#
+#  Copyright (C) 2002 - Borca Daniel
+#  Email : dborca@yahoo.com
+#  Web   : http://www.geocities.com/dborca
+
+
+
+.PHONY: all clean
+
+TOP = ../..
+MARK = $(TOP)/src-glut
+LIBDIR = $(TOP)/lib
+GLUT_LIB = libglut.so
+
+CC = gcc
+INCLUDES = -I$(TOP)/include -I$(MARK)
+CFLAGS = -c -g $(INCLUDES) -MD 
+
+CORE_SOURCES = \
+	bitmap.c \
+	callback.c \
+	color.c \
+	globals.c \
+	init.c \
+	menu.c \
+	models.c \
+	overlay.c \
+	state.c \
+	teapot.c \
+	window.c
+
+
+MARK_SOURCES = \
+	$(MARK)/glut_8x13.c \
+	$(MARK)/glut_9x15.c \
+	$(MARK)/glut_hel10.c \
+	$(MARK)/glut_hel12.c \
+	$(MARK)/glut_hel18.c \
+	$(MARK)/glut_tr10.c \
+	$(MARK)/glut_tr24.c
+
+SOURCES = $(CORE_SOURCES)  $(MARK_SOURCES)
+
+OBJS = $(addsuffix .o,$(basename $(SOURCES)))
+
+LIBS=-L$(TOP)/lib -lGL -lGLU -lm
+
+.c.o:
+	$(CC) -o $@ -c $(CFLAGS) $<
+.S.o:
+	$(CC) -o $@ -c $(CFLAGS) $<
+
+default: libglut.so.3.7 install 
+
+
+libglut.so.3.7: $(OBJS) Makefile
+	gcc -shared -Wl,-soname,libglut.so -Wl,-Bsymbolic $(OBJS) $(LIBS) -o $@ 
+
+install:
+	rm -f $(TOP)/lib/libglut.so*
+	install -D libglut.so.3.7 $(TOP)/lib/libglut.so.3.7
+	ln -s libglut.so.3.7 $(TOP)/lib/libglut.so.3
+	ln -s libglut.so.3 $(TOP)/lib/libglut.so
+
+
+clean:
+	rm -f *~ .*~ *.o libglut.so*  *.d
+
+
+-include $(SOURCES:.c=.d)
+
+.SUFFIXES: .c .d
+
+.c.d:
+	$(CC) -M $(INCLUDES) $< > $@

src/glut/mini/bitmap.c

@@ -0,0 +1,56 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* This program is freely distributable without licensing fees
+   and is provided without guarantee or warrantee expressed or
+   implied. This program is -not- in the public domain. */
+
+#include "glutbitmap.h"
+
+void APIENTRY 
+glutBitmapCharacter(GLUTbitmapFont font, int c)
+{
+  const BitmapCharRec *ch;
+  BitmapFontPtr fontinfo;
+  GLint swapbytes, lsbfirst, rowlength;
+  GLint skiprows, skippixels, alignment;
+
+#if defined(_WIN32)
+  fontinfo = (BitmapFontPtr) __glutFont(font);
+#else
+  fontinfo = (BitmapFontPtr) font;
+#endif
+
+  if (c < fontinfo->first ||
+    c >= fontinfo->first + fontinfo->num_chars)
+    return;
+  ch = fontinfo->ch[c - fontinfo->first];
+  if (ch) {
+    /* Save current modes. */
+    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);
+    /* Little endian machines (DEC Alpha for example) could
+       benefit from setting GL_UNPACK_LSB_FIRST to GL_TRUE
+       instead of GL_FALSE, but this would require changing the
+       generated bitmaps too. */
+    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);
+    glBitmap(ch->width, ch->height, ch->xorig, ch->yorig,
+      ch->advance, 0, ch->bitmap);
+    /* Restore saved 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);
+  }
+}

src/glut/mini/callback.c

@@ -0,0 +1,152 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.4
+ * Copyright (C) 1995-1998  Brian Paul
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * DOS/DJGPP glut driver v1.0 for Mesa 4.0
+ *
+ *  Copyright (C) 2002 - Borca Daniel
+ *  Email : dborca@yahoo.com
+ *  Web   : http://www.geocities.com/dborca
+ */
+
+
+#include "GL/glut.h"
+#include "internal.h"
+
+
+void APIENTRY glutDisplayFunc (void (GLUTCALLBACK *func) (void))
+{
+ display_func = func;
+}
+
+
+void APIENTRY glutReshapeFunc (void (GLUTCALLBACK *func) (int width, int height))
+{
+ reshape_func = func;
+}
+
+
+void APIENTRY glutKeyboardFunc (void (GLUTCALLBACK *func) (unsigned char key, int x, int y))
+{
+ keyboard_func = func;
+}
+
+
+void APIENTRY glutMouseFunc (void (GLUTCALLBACK *func) (int button, int state, int x, int y))
+{
+ mouse_func = func;
+}
+
+
+void APIENTRY glutMotionFunc (void (GLUTCALLBACK *func) (int x, int y))
+{
+ motion_func = func;
+}
+
+
+void APIENTRY glutPassiveMotionFunc (void (GLUTCALLBACK *func) (int x, int y))
+{
+ passive_motion_func = func;
+}
+
+
+void APIENTRY glutEntryFunc (void (GLUTCALLBACK *func) (int state))
+{
+ entry_func = func;
+}
+
+
+void APIENTRY glutVisibilityFunc (void (GLUTCALLBACK *func) (int state))
+{
+ visibility_func = func;
+}
+
+
+void APIENTRY glutIdleFunc (void (GLUTCALLBACK *func) (void))
+{
+ idle_func = func;
+}
+
+
+void APIENTRY glutTimerFunc (unsigned int millis, void (GLUTCALLBACK *func) (int value), int value)
+{
+}
+
+
+void APIENTRY glutMenuStateFunc (void (GLUTCALLBACK *func) (int state))
+{
+ menu_state_func = func;
+}
+
+
+void APIENTRY glutSpecialFunc (void (GLUTCALLBACK *func) (int key, int x, int y))
+{
+ special_func = func;
+}
+
+
+void APIENTRY glutSpaceballMotionFunc (void (GLUTCALLBACK *func) (int x, int y, int z))
+{
+}
+
+
+void APIENTRY glutSpaceballRotateFunc (void (GLUTCALLBACK *func) (int x, int y, int z))
+{
+}
+
+
+void APIENTRY glutSpaceballButtonFunc (void (GLUTCALLBACK *func) (int button, int state))
+{
+}
+
+
+void APIENTRY glutButtonBoxFunc (void (GLUTCALLBACK *func) (int button, int state))
+{
+}
+
+
+void APIENTRY glutDialsFunc (void (GLUTCALLBACK *func) (int dial, int value))
+{
+}
+
+
+void APIENTRY glutTabletMotionFunc (void (GLUTCALLBACK *func) (int x, int y))
+{
+}
+
+
+void APIENTRY glutTabletButtonFunc (void (GLUTCALLBACK *func) (int button, int state, int x, int y))
+{
+}
+
+
+void APIENTRY glutMenuStatusFunc (void (GLUTCALLBACK *func) (int status, int x, int y))
+{
+}
+
+
+void APIENTRY glutOverlayDisplayFunc (void (GLUTCALLBACK *func) (void))
+{
+}
+
+
+void APIENTRY glutWindowStatusFunc (void (GLUTCALLBACK *func) (int state))
+{
+}

src/glut/mini/color.c

@@ -0,0 +1,46 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.4
+ * Copyright (C) 1995-1998  Brian Paul
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * DOS/DJGPP glut driver v1.0 for Mesa 4.0
+ *
+ *  Copyright (C) 2002 - Borca Daniel
+ *  Email : dborca@yahoo.com
+ *  Web   : http://www.geocities.com/dborca
+ */
+
+
+#include "GL/glut.h"
+
+
+void APIENTRY glutSetColor (int ndx, GLfloat red, GLfloat green, GLfloat blue)
+{
+}
+
+
+GLfloat APIENTRY glutGetColor (int ndx, int component)
+{
+ return 0.0;
+}
+
+
+void APIENTRY glutCopyColormap (int win)
+{
+}

src/glut/mini/globals.c

@@ -0,0 +1,61 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.4
+ * Copyright (C) 1995-1998  Brian Paul
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * DOS/DJGPP glut driver v1.0 for Mesa 4.0
+ *
+ *  Copyright (C) 2002 - Borca Daniel
+ *  Email : dborca@yahoo.com
+ *  Web   : http://www.geocities.com/dborca
+ */
+
+
+#include "GL/glut.h"
+#include "internal.h"
+
+GLenum    g_display_mode = 0;
+GLuint    g_width        = DEFAULT_WIDTH;
+GLuint    g_height       = DEFAULT_HEIGHT;
+GLint     g_mouse        = GL_FALSE;
+GLboolean g_redisplay    = GL_FALSE;
+GLint     g_xpos         = 0;
+GLint     g_ypos         = 0;
+
+void (GLUTCALLBACK *display_func) (void)                              = 0;
+void (GLUTCALLBACK *reshape_func) (int width, int height)             = 0;
+void (GLUTCALLBACK *keyboard_func) (unsigned char key, int x, int y)  = 0;
+void (GLUTCALLBACK *mouse_func) (int button, int state, int x, int y) = 0;
+void (GLUTCALLBACK *motion_func) (int x, int y)                       = 0;
+void (GLUTCALLBACK *passive_motion_func) (int x, int y)               = 0;
+void (GLUTCALLBACK *entry_func) (int state)                           = 0;
+void (GLUTCALLBACK *visibility_func) (int state)                      = 0;
+void (GLUTCALLBACK *idle_func) (void)                                 = 0;
+void (GLUTCALLBACK *menu_state_func) (int state)                      = 0;
+void (GLUTCALLBACK *special_func) (int key, int x, int y)             = 0;
+void (GLUTCALLBACK *spaceball_motion_func) (int x, int y, int z)      = 0;
+void (GLUTCALLBACK *spaceball_rotate_func) (int x, int y, int z)      = 0;
+void (GLUTCALLBACK *spaceball_button_func) (int button, int state)    = 0;
+void (GLUTCALLBACK *button_box_func) (int button, int state)          = 0;
+void (GLUTCALLBACK *dials_func) (int dial, int value)                 = 0;
+void (GLUTCALLBACK *tablet_motion_func) (int x, int y)                = 0;
+void (GLUTCALLBACK *tabled_button_func) (int button, int state, int x, int y) = 0;
+void (GLUTCALLBACK *menu_status_func) (int status, int x, int y)      = 0;
+void (GLUTCALLBACK *overlay_display_func) (void)                      = 0;
+void (GLUTCALLBACK *window_status_func) (int state)                   = 0;

src/glut/mini/init.c

@@ -0,0 +1,162 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0
+ * Copyright (C) 1995-1998  Brian Paul
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * DOS/DJGPP glut driver v1.0 for Mesa 4.0
+ *
+ *  Copyright (C) 2002 - Borca Daniel
+ *  Email : dborca@yahoo.com
+ *  Web   : http://www.geocities.com/dborca
+ */
+
+
+#include "GL/glut.h"
+#include "internal.h"
+
+
+void APIENTRY glutInit (int *argcp, char **argv)
+{
+ glutGet(GLUT_ELAPSED_TIME);
+}
+
+
+void APIENTRY glutInitDisplayMode (unsigned int mode)
+{
+ g_display_mode = mode;
+
+/*  pc_install_keyb(); */
+/*  g_mouse = pc_install_mouse(); */
+}
+
+
+void APIENTRY glutInitWindowPosition (int x, int y)
+{
+ g_xpos = x;
+ g_ypos = y;
+}
+
+
+void APIENTRY glutInitWindowSize (int width, int height)
+{
+ g_width  = width;
+ g_height = height;
+}
+
+
+void APIENTRY glutMainLoop (void)
+{
+ GLboolean idle;
+ static int old_mouse_x = 0;
+ static int old_mouse_y = 0;
+ static int old_mouse_b = 0;
+
+ glutPostRedisplay();
+ if (reshape_func) reshape_func(g_width, g_height);
+ if (visibility_func) visibility_func(GLUT_VISIBLE);
+/*  if (g_mouse) pc_show_mouse(); */
+
+ while (GL_TRUE) {
+       idle = GL_TRUE;
+
+       if (g_redisplay && display_func) {
+          idle        = GL_FALSE;
+          g_redisplay = GL_FALSE;
+
+/*           if (g_mouse && !(g_display_mode & GLUT_DOUBLE)) pc_scare_mouse(); */
+          display_func();
+/*           if (g_mouse && !(g_display_mode & GLUT_DOUBLE)) pc_unscare_mouse(); */
+       }
+
+#if 0
+       if (pc_keypressed()) {
+          int key;
+
+          idle = GL_FALSE;
+          key  = pc_readkey();
+
+          switch (key>>16) {
+                 case KEY_F1:     if (special_func) special_func(GLUT_KEY_F1,        0, 0); break;
+                 case KEY_F2:     if (special_func) special_func(GLUT_KEY_F2,        0, 0); break;
+                 case KEY_F3:     if (special_func) special_func(GLUT_KEY_F3,        0, 0); break;
+                 case KEY_F4:     if (special_func) special_func(GLUT_KEY_F4,        0, 0); break;
+                 case KEY_F5:     if (special_func) special_func(GLUT_KEY_F5,        0, 0); break;
+                 case KEY_F6:     if (special_func) special_func(GLUT_KEY_F6,        0, 0); break;
+                 case KEY_F7:     if (special_func) special_func(GLUT_KEY_F7,        0, 0); break;
+                 case KEY_F8:     if (special_func) special_func(GLUT_KEY_F8,        0, 0); break;
+                 case KEY_F9:     if (special_func) special_func(GLUT_KEY_F9,        0, 0); break;
+                 case KEY_F10:    if (special_func) special_func(GLUT_KEY_F10,       0, 0); break;
+                 case KEY_F11:    if (special_func) special_func(GLUT_KEY_F11,       0, 0); break;
+                 case KEY_F12:    if (special_func) special_func(GLUT_KEY_F12,       0, 0); break;
+                 case KEY_LEFT:   if (special_func) special_func(GLUT_KEY_LEFT,      0, 0); break;
+                 case KEY_UP:     if (special_func) special_func(GLUT_KEY_UP,        0, 0); break;
+                 case KEY_RIGHT:  if (special_func) special_func(GLUT_KEY_RIGHT,     0, 0); break;
+                 case KEY_DOWN:   if (special_func) special_func(GLUT_KEY_DOWN,      0, 0); break;
+                 case KEY_PGUP:   if (special_func) special_func(GLUT_KEY_PAGE_UP,   0, 0); break;
+                 case KEY_PGDN:   if (special_func) special_func(GLUT_KEY_PAGE_DOWN, 0, 0); break;
+                 case KEY_HOME:   if (special_func) special_func(GLUT_KEY_HOME,      0, 0); break;
+                 case KEY_END:    if (special_func) special_func(GLUT_KEY_END,       0, 0); break;
+                 case KEY_INSERT: if (special_func) special_func(GLUT_KEY_INSERT,    0, 0); break;
+                 default:         if (keyboard_func) keyboard_func(key & 0xFF, 0, 0);
+          }
+       }
+
+       if (g_mouse) {
+          int mouse_x;
+          int mouse_y;
+          int mouse_b;
+       
+          mouse_b = pc_query_mouse(&mouse_x, &mouse_y);
+          
+          if (motion_func && ((mouse_x != old_mouse_x) || (mouse_y != old_mouse_y))) {
+             idle        = GL_FALSE;
+             old_mouse_x = mouse_x;
+             old_mouse_y = mouse_y;
+   
+             motion_func(old_mouse_x, old_mouse_y);
+          }
+   
+          if (mouse_func && (mouse_b != old_mouse_b)) {
+             int new_mouse_b = mouse_b;
+   
+             if ((old_mouse_b & 1) && !(new_mouse_b & 1))
+                mouse_func(GLUT_LEFT_BUTTON, GLUT_UP,   mouse_x, mouse_y);
+             else if (!(old_mouse_b & 1) && (new_mouse_b & 1))
+                mouse_func(GLUT_LEFT_BUTTON, GLUT_DOWN, mouse_x, mouse_y);
+   
+             if ((old_mouse_b & 2) && !(new_mouse_b & 2))
+                mouse_func(GLUT_RIGHT_BUTTON, GLUT_UP,   mouse_x, mouse_y);
+             else if (!(old_mouse_b & 2) && (new_mouse_b & 2))
+                mouse_func(GLUT_RIGHT_BUTTON, GLUT_DOWN, mouse_x, mouse_y);
+   
+             if ((old_mouse_b & 4) && !(new_mouse_b & 4))
+                mouse_func(GLUT_MIDDLE_BUTTON, GLUT_UP,   mouse_x, mouse_y);
+             else if (!(old_mouse_b & 3) && (new_mouse_b & 4))
+                mouse_func(GLUT_MIDDLE_BUTTON, GLUT_DOWN, mouse_x, mouse_y);
+   
+             idle        = GL_FALSE;
+             old_mouse_b = new_mouse_b;
+          }
+       }
+#endif
+
+       if (idle && idle_func)
+          idle_func();
+ }
+}

src/glut/mini/internal.h

@@ -0,0 +1,78 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0
+ * Copyright (C) 1995-1998  Brian Paul
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * DOS/DJGPP glut driver v1.0 for Mesa 4.0
+ *
+ *  Copyright (C) 2002 - Borca Daniel
+ *  Email : dborca@yahoo.com
+ *  Web   : http://www.geocities.com/dborca
+ */
+
+ 
+#ifndef INTERNAL_H_included
+#define INTERNAL_H_included
+
+
+#include "GL/glut.h"
+/* #include "pc_hw/pc_hw.h" */
+
+
+#define MAX_WINDOWS    4
+
+#define DEFAULT_WIDTH  640
+#define DEFAULT_HEIGHT 480
+#define DEFAULT_BPP    16
+
+#define DEPTH_SIZE   16
+#define STENCIL_SIZE 8
+#define ACCUM_SIZE   16
+
+extern GLenum    g_display_mode;
+extern GLuint    g_width;
+extern GLuint    g_height;
+extern GLint     g_mouse;
+extern GLboolean g_redisplay;
+extern GLint     g_xpos;
+extern GLint     g_ypos;
+
+extern void (GLUTCALLBACK *display_func) (void);
+extern void (GLUTCALLBACK *reshape_func) (int width, int height);
+extern void (GLUTCALLBACK *keyboard_func) (unsigned char key, int x, int y);
+extern void (GLUTCALLBACK *mouse_func) (int button, int state, int x, int y);
+extern void (GLUTCALLBACK *motion_func) (int x, int y);
+extern void (GLUTCALLBACK *passive_motion_func) (int x, int y);
+extern void (GLUTCALLBACK *entry_func) (int state);
+extern void (GLUTCALLBACK *visibility_func) (int state);
+extern void (GLUTCALLBACK *idle_func) (void);
+extern void (GLUTCALLBACK *menu_state_func) (int state);
+extern void (GLUTCALLBACK *special_func) (int key, int x, int y);
+extern void (GLUTCALLBACK *spaceball_motion_func) (int x, int y, int z);
+extern void (GLUTCALLBACK *spaceball_rotate_func) (int x, int y, int z);
+extern void (GLUTCALLBACK *spaceball_button_func) (int button, int state);
+extern void (GLUTCALLBACK *button_box_func) (int button, int state);
+extern void (GLUTCALLBACK *dials_func) (int dial, int value);
+extern void (GLUTCALLBACK *tablet_motion_func) (int x, int y);
+extern void (GLUTCALLBACK *tabled_button_func) (int button, int state, int x, int y);
+extern void (GLUTCALLBACK *menu_status_func) (int status, int x, int y);
+extern void (GLUTCALLBACK *overlay_display_func) (void);
+extern void (GLUTCALLBACK *window_status_func) (int state);
+
+#endif