remove carriage return chars

10 files changed, 5292 insertions, 5292 deletions

diff --git a/src/glu/sgi/Makefile.win b/src/glu/sgi/Makefile.win
index 1d239e7dfdf..3d0067ef017 100644
--- a/src/glu/sgi/Makefile.win
+++ b/src/glu/sgi/Makefile.win
@@ -1,156 +1,156 @@
-# Makefile for Win32

-

-#

-# Sept 12, 2001

-# Note: The nurbs code is not being built at this time.

-# If you want to work on it, uncomment the definitions

-# noted below to try to compile the sources.

-# There are numerous problems, some of which may be solved

-# by setting some #defines.

-#

-

-!include <win32.mak>

-

-.SUFFIXES : .cc

-

-TOP = ..

-

-GLU_SRCS_CC = \

-	libnurbs\interface\bezierEval.cc \

-	libnurbs\interface\bezierPatch.cc \

-	libnurbs\interface\bezierPatchMesh.cc \

-	libnurbs\interface\glcurveval.cc \

-	libnurbs\interface\glinterface.cc \

-	libnurbs\interface\glrenderer.cc \

-	libnurbs\interface\glsurfeval.cc \

-	libnurbs\interface\incurveeval.cc \

-	libnurbs\interface\insurfeval.cc \

-	libnurbs\internals\arc.cc \

-	libnurbs\internals\arcsorter.cc \

-	libnurbs\internals\arctess.cc \

-	libnurbs\internals\backend.cc \

-	libnurbs\internals\basiccrveval.cc \

-	libnurbs\internals\basicsurfeval.cc \

-	libnurbs\internals\bin.cc \

-	libnurbs\internals\bufpool.cc \

-	libnurbs\internals\cachingeval.cc \

-	libnurbs\internals\ccw.cc \

-	libnurbs\internals\coveandtiler.cc \

-	libnurbs\internals\curve.cc \

-	libnurbs\internals\curvelist.cc \

-	libnurbs\internals\curvesub.cc \

-	libnurbs\internals\dataTransform.cc \

-	libnurbs\internals\displaylist.cc \

-	libnurbs\internals\flist.cc \

-	libnurbs\internals\flistsorter.cc \

-	libnurbs\internals\hull.cc \

-	libnurbs\internals\intersect.cc \

-	libnurbs\internals\knotvector.cc \

-	libnurbs\internals\mapdesc.cc \

-	libnurbs\internals\mapdescv.cc \

-	libnurbs\internals\maplist.cc \

-	libnurbs\internals\mesher.cc \

-	libnurbs\internals\monoTriangulationBackend.cc \

-	libnurbs\internals\monotonizer.cc \

-	libnurbs\internals\mycode.cc \

-	libnurbs\internals\nurbsinterfac.cc \

-	libnurbs\internals\nurbstess.cc \

-	libnurbs\internals\patch.cc \

-	libnurbs\internals\patchlist.cc \

-	libnurbs\internals\quilt.cc \

-	libnurbs\internals\reader.cc \

-	libnurbs\internals\renderhints.cc \

-	libnurbs\internals\slicer.cc \

-	libnurbs\internals\sorter.cc \

-	libnurbs\internals\splitarcs.cc \

-	libnurbs\internals\subdivider.cc \

-	libnurbs\internals\tobezier.cc \

-	libnurbs\internals\trimline.cc \

-	libnurbs\internals\trimregion.cc \

-	libnurbs\internals\trimvertpool.cc \

-	libnurbs\internals\uarray.cc \

-	libnurbs\internals\varray.cc \

-	libnurbs\nurbtess\directedLine.cc \

-	libnurbs\nurbtess\gridWrap.cc \

-	libnurbs\nurbtess\monoChain.cc \

-	libnurbs\nurbtess\monoPolyPart.cc \

-	libnurbs\nurbtess\monoTriangulation.cc \

-	libnurbs\nurbtess\partitionX.cc \

-	libnurbs\nurbtess\partitionY.cc \

-	libnurbs\nurbtess\polyDBG.cc \

-	libnurbs\nurbtess\polyUtil.cc \

-	libnurbs\nurbtess\primitiveStream.cc \

-	libnurbs\nurbtess\quicksort.cc \

-	libnurbs\nurbtess\rectBlock.cc \

-	libnurbs\nurbtess\sampleComp.cc \

-	libnurbs\nurbtess\sampleCompBot.cc \

-	libnurbs\nurbtess\sampleCompRight.cc \

-	libnurbs\nurbtess\sampleCompTop.cc \

-	libnurbs\nurbtess\sampleMonoPoly.cc \

-	libnurbs\nurbtess\sampledLine.cc \

-	libnurbs\nurbtess\searchTree.cc

-

-GLU_SRCS = \

-	libtess\dict.c \

-	libtess\geom.c \

-	libtess\memalloc.c \

-	libtess\mesh.c \

-	libtess\normal.c \

-	libtess\priorityq.c \

-	libtess\render.c \

-	libtess\sweep.c \

-	libtess\tess.c \

-	libtess\tessmono.c \

-	libutil\error.c \

-	libutil\glue.c \

-	libutil\mipmap.c \

-	libutil\project.c \

-	libutil\quad.c \

-	libutil\registry.c

-

-SRCS	= $(GLU_SRCS)

-

-GLUDLL	= glu32.dll

-

-all	: gludll install

-

-!include "$(TOP)/mesawin32.mak"

-

-gludll	: $(GLUDLL)

-

-CFLAGS	= $(cvarsdll) $(CFLAGS) -D_OPENGL32_ -Iinclude -DBUILD_GL32

-LFLAGS	= $(dlllflags) $(LFLAGS)

-

-OBJS	= $(GLU_SRCS:.c=.obj)

-LIBS	= ../lib/opengl32.lib winmm.lib $(guilibsdll)

-

-# Uncomment these definitions to try to compile the NURBS code.

-#OBJS	= $(GLU_SRCS_CC:.cc=.obj) $(GLU_SRCS:.c=.obj)

-#NURBSINC = -Ilibnurbs\interface -Ilibnurbs\internals -Ilibnurbs\nurbtess 

-#CFLAGS  = $(CFLAGS) $(NURBSINC)

-

-$(GLUDLL)	: $(OBJS) glu.def

-	$(link) $(LFLAGS) -out:$(GLUDLL) -def:glu.def $(OBJS) $(LIBS)

-

-install	: $(GLUDLL)

-	@echo "copying Mesa GLU dynamic link library to system directory..."

-	-copy $(GLUDLL) $(TOP)\lib

-	@echo "copying Mesa GLU import library to library directory..."

-	-copy $(GLU) $(TOP)\lib

-

-clean	::

-	@del /f libtess\*.obj libutil\*.obj 

-	@del /f libnurbs\interface\*.obj libnurbs\internals\*.obj 

-	@del /f libnurbs\nurbtess\*.obj

-

-# override default inference rule with one that writes the object to

-# the correct subdir. 

-

-.c.obj	:

-	$(cc) $(CFLAGS) -I. $< /Fo$*.obj

-

-# /TP is needed for C++ files because MS compiler

-# does not recognize .cc as a C++ file.

-

-.cc.obj	:

-	$(cc) $(CFLAGS) -I. $< /TP /Fo$*.obj

+# Makefile for Win32
+
+#
+# Sept 12, 2001
+# Note: The nurbs code is not being built at this time.
+# If you want to work on it, uncomment the definitions
+# noted below to try to compile the sources.
+# There are numerous problems, some of which may be solved
+# by setting some #defines.
+#
+
+!include <win32.mak>
+
+.SUFFIXES : .cc
+
+TOP = ..
+
+GLU_SRCS_CC = \
+	libnurbs\interface\bezierEval.cc \
+	libnurbs\interface\bezierPatch.cc \
+	libnurbs\interface\bezierPatchMesh.cc \
+	libnurbs\interface\glcurveval.cc \
+	libnurbs\interface\glinterface.cc \
+	libnurbs\interface\glrenderer.cc \
+	libnurbs\interface\glsurfeval.cc \
+	libnurbs\interface\incurveeval.cc \
+	libnurbs\interface\insurfeval.cc \
+	libnurbs\internals\arc.cc \
+	libnurbs\internals\arcsorter.cc \
+	libnurbs\internals\arctess.cc \
+	libnurbs\internals\backend.cc \
+	libnurbs\internals\basiccrveval.cc \
+	libnurbs\internals\basicsurfeval.cc \
+	libnurbs\internals\bin.cc \
+	libnurbs\internals\bufpool.cc \
+	libnurbs\internals\cachingeval.cc \
+	libnurbs\internals\ccw.cc \
+	libnurbs\internals\coveandtiler.cc \
+	libnurbs\internals\curve.cc \
+	libnurbs\internals\curvelist.cc \
+	libnurbs\internals\curvesub.cc \
+	libnurbs\internals\dataTransform.cc \
+	libnurbs\internals\displaylist.cc \
+	libnurbs\internals\flist.cc \
+	libnurbs\internals\flistsorter.cc \
+	libnurbs\internals\hull.cc \
+	libnurbs\internals\intersect.cc \
+	libnurbs\internals\knotvector.cc \
+	libnurbs\internals\mapdesc.cc \
+	libnurbs\internals\mapdescv.cc \
+	libnurbs\internals\maplist.cc \
+	libnurbs\internals\mesher.cc \
+	libnurbs\internals\monoTriangulationBackend.cc \
+	libnurbs\internals\monotonizer.cc \
+	libnurbs\internals\mycode.cc \
+	libnurbs\internals\nurbsinterfac.cc \
+	libnurbs\internals\nurbstess.cc \
+	libnurbs\internals\patch.cc \
+	libnurbs\internals\patchlist.cc \
+	libnurbs\internals\quilt.cc \
+	libnurbs\internals\reader.cc \
+	libnurbs\internals\renderhints.cc \
+	libnurbs\internals\slicer.cc \
+	libnurbs\internals\sorter.cc \
+	libnurbs\internals\splitarcs.cc \
+	libnurbs\internals\subdivider.cc \
+	libnurbs\internals\tobezier.cc \
+	libnurbs\internals\trimline.cc \
+	libnurbs\internals\trimregion.cc \
+	libnurbs\internals\trimvertpool.cc \
+	libnurbs\internals\uarray.cc \
+	libnurbs\internals\varray.cc \
+	libnurbs\nurbtess\directedLine.cc \
+	libnurbs\nurbtess\gridWrap.cc \
+	libnurbs\nurbtess\monoChain.cc \
+	libnurbs\nurbtess\monoPolyPart.cc \
+	libnurbs\nurbtess\monoTriangulation.cc \
+	libnurbs\nurbtess\partitionX.cc \
+	libnurbs\nurbtess\partitionY.cc \
+	libnurbs\nurbtess\polyDBG.cc \
+	libnurbs\nurbtess\polyUtil.cc \
+	libnurbs\nurbtess\primitiveStream.cc \
+	libnurbs\nurbtess\quicksort.cc \
+	libnurbs\nurbtess\rectBlock.cc \
+	libnurbs\nurbtess\sampleComp.cc \
+	libnurbs\nurbtess\sampleCompBot.cc \
+	libnurbs\nurbtess\sampleCompRight.cc \
+	libnurbs\nurbtess\sampleCompTop.cc \
+	libnurbs\nurbtess\sampleMonoPoly.cc \
+	libnurbs\nurbtess\sampledLine.cc \
+	libnurbs\nurbtess\searchTree.cc
+
+GLU_SRCS = \
+	libtess\dict.c \
+	libtess\geom.c \
+	libtess\memalloc.c \
+	libtess\mesh.c \
+	libtess\normal.c \
+	libtess\priorityq.c \
+	libtess\render.c \
+	libtess\sweep.c \
+	libtess\tess.c \
+	libtess\tessmono.c \
+	libutil\error.c \
+	libutil\glue.c \
+	libutil\mipmap.c \
+	libutil\project.c \
+	libutil\quad.c \
+	libutil\registry.c
+
+SRCS	= $(GLU_SRCS)
+
+GLUDLL	= glu32.dll
+
+all	: gludll install
+
+!include "$(TOP)/mesawin32.mak"
+
+gludll	: $(GLUDLL)
+
+CFLAGS	= $(cvarsdll) $(CFLAGS) -D_OPENGL32_ -Iinclude -DBUILD_GL32
+LFLAGS	= $(dlllflags) $(LFLAGS)
+
+OBJS	= $(GLU_SRCS:.c=.obj)
+LIBS	= ../lib/opengl32.lib winmm.lib $(guilibsdll)
+
+# Uncomment these definitions to try to compile the NURBS code.
+#OBJS	= $(GLU_SRCS_CC:.cc=.obj) $(GLU_SRCS:.c=.obj)
+#NURBSINC = -Ilibnurbs\interface -Ilibnurbs\internals -Ilibnurbs\nurbtess 
+#CFLAGS  = $(CFLAGS) $(NURBSINC)
+
+$(GLUDLL)	: $(OBJS) glu.def
+	$(link) $(LFLAGS) -out:$(GLUDLL) -def:glu.def $(OBJS) $(LIBS)
+
+install	: $(GLUDLL)
+	@echo "copying Mesa GLU dynamic link library to system directory..."
+	-copy $(GLUDLL) $(TOP)\lib
+	@echo "copying Mesa GLU import library to library directory..."
+	-copy $(GLU) $(TOP)\lib
+
+clean	::
+	@del /f libtess\*.obj libutil\*.obj 
+	@del /f libnurbs\interface\*.obj libnurbs\internals\*.obj 
+	@del /f libnurbs\nurbtess\*.obj
+
+# override default inference rule with one that writes the object to
+# the correct subdir. 
+
+.c.obj	:
+	$(cc) $(CFLAGS) -I. $< /Fo$*.obj
+
+# /TP is needed for C++ files because MS compiler
+# does not recognize .cc as a C++ file.
+
+.cc.obj	:
+	$(cc) $(CFLAGS) -I. $< /TP /Fo$*.obj
diff --git a/src/glu/sgi/libutil/project.c b/src/glu/sgi/libutil/project.c
index 4d9819471b6..348bd7e40cc 100644
--- a/src/glu/sgi/libutil/project.c
+++ b/src/glu/sgi/libutil/project.c
@@ -1,381 +1,381 @@
-/*

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

-**

-** $Date: 2001/09/14 22:19:19 $ $Revision: 1.3 $

-** $Header: /home/krh/git/sync/mesa-cvs-repo/Mesa/src/glu/sgi/libutil/project.c,v 1.3 2001/09/14 22:19:19 brianp Exp $

-*/

-

-#include "gluos.h"

-#include <math.h>

-#include <GL/gl.h>

-#include <GL/glu.h>

-#include "gluint.h"

-

-/*

-** Make m an identity matrix

-*/

-static void __gluMakeIdentityd(GLdouble m[16])

-{

-    m[0+4*0] = 1; m[0+4*1] = 0; m[0+4*2] = 0; m[0+4*3] = 0;

-    m[1+4*0] = 0; m[1+4*1] = 1; m[1+4*2] = 0; m[1+4*3] = 0;

-    m[2+4*0] = 0; m[2+4*1] = 0; m[2+4*2] = 1; m[2+4*3] = 0;

-    m[3+4*0] = 0; m[3+4*1] = 0; m[3+4*2] = 0; m[3+4*3] = 1;

-}

-

-static void __gluMakeIdentityf(GLfloat m[16])

-{

-    m[0+4*0] = 1; m[0+4*1] = 0; m[0+4*2] = 0; m[0+4*3] = 0;

-    m[1+4*0] = 0; m[1+4*1] = 1; m[1+4*2] = 0; m[1+4*3] = 0;

-    m[2+4*0] = 0; m[2+4*1] = 0; m[2+4*2] = 1; m[2+4*3] = 0;

-    m[3+4*0] = 0; m[3+4*1] = 0; m[3+4*2] = 0; m[3+4*3] = 1;

-}

-

-void GLAPIENTRY

-gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)

-{

-    glOrtho(left, right, bottom, top, -1, 1);

-}

-

-#define __glPi 3.14159265358979323846

-

-void GLAPIENTRY

-gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)

-{

-    GLdouble m[4][4];

-    double sine, cotangent, deltaZ;

-    double radians = fovy / 2 * __glPi / 180;

-

-    deltaZ = zFar - zNear;

-    sine = sin(radians);

-    if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {

-	return;

-    }

-    cotangent = COS(radians) / sine;

-

-    __gluMakeIdentityd(&m[0][0]);

-    m[0][0] = cotangent / aspect;

-    m[1][1] = cotangent;

-    m[2][2] = -(zFar + zNear) / deltaZ;

-    m[2][3] = -1;

-    m[3][2] = -2 * zNear * zFar / deltaZ;

-    m[3][3] = 0;

-    glMultMatrixd(&m[0][0]);

-}

-

-static void normalize(float v[3])

-{

-    float r;

-

-    r = sqrt( v[0]*v[0] + v[1]*v[1] + v[2]*v[2] );

-    if (r == 0.0) return;

-

-    v[0] /= r;

-    v[1] /= r;

-    v[2] /= r;

-}

-

-static void cross(float v1[3], float v2[3], float result[3])

-{

-    result[0] = v1[1]*v2[2] - v1[2]*v2[1];

-    result[1] = v1[2]*v2[0] - v1[0]*v2[2];

-    result[2] = v1[0]*v2[1] - v1[1]*v2[0];

-}

-

-void GLAPIENTRY

-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];

-

-    forward[0] = centerx - eyex;

-    forward[1] = centery - eyey;

-    forward[2] = centerz - eyez;

-

-    up[0] = upx;

-    up[1] = upy;

-    up[2] = upz;

-

-    normalize(forward);

-

-    /* Side = forward x up */

-    cross(forward, up, side);

-    normalize(side);

-

-    /* Recompute up as: up = side x forward */

-    cross(side, forward, up);

-

-    __gluMakeIdentityf(&m[0][0]);

-    m[0][0] = side[0];

-    m[1][0] = side[1];

-    m[2][0] = side[2];

-

-    m[0][1] = up[0];

-    m[1][1] = up[1];

-    m[2][1] = up[2];

-

-    m[0][2] = -forward[0];

-    m[1][2] = -forward[1];

-    m[2][2] = -forward[2];

-

-    glMultMatrixf(&m[0][0]);

-    glTranslated(-eyex, -eyey, -eyez);

-}

-

-static void __gluMultMatrixVecd(const GLdouble matrix[16], const GLdouble in[4],

-		      GLdouble out[4])

-{

-    int i;

-

-    for (i=0; i<4; i++) {

-	out[i] = 

-	    in[0] * matrix[0*4+i] +

-	    in[1] * matrix[1*4+i] +

-	    in[2] * matrix[2*4+i] +

-	    in[3] * matrix[3*4+i];

-    }

-}

-

-/*

-** inverse = invert(src)

-*/

-static int __gluInvertMatrixd(const GLdouble src[16], GLdouble inverse[16])

-{

-    int i, j, k, swap;

-    double t;

-    GLdouble temp[4][4];

-

-    for (i=0; i<4; i++) {

-	for (j=0; j<4; j++) {

-	    temp[i][j] = src[i*4+j];

-	}

-    }

-    __gluMakeIdentityd(inverse);

-

-    for (i = 0; i < 4; i++) {

-	/*

-	** Look for largest element in column

-	*/

-	swap = i;

-	for (j = i + 1; j < 4; j++) {

-	    if (fabs(temp[j][i]) > fabs(temp[i][i])) {

-		swap = j;

-	    }

-	}

-

-	if (swap != i) {

-	    /*

-	    ** Swap rows.

-	    */

-	    for (k = 0; k < 4; k++) {

-		t = temp[i][k];

-		temp[i][k] = temp[swap][k];

-		temp[swap][k] = t;

-

-		t = inverse[i*4+k];

-		inverse[i*4+k] = inverse[swap*4+k];

-		inverse[swap*4+k] = t;

-	    }

-	}

-

-	if (temp[i][i] == 0) {

-	    /*

-	    ** No non-zero pivot.  The matrix is singular, which shouldn't

-	    ** happen.  This means the user gave us a bad matrix.

-	    */

-	    return GL_FALSE;

-	}

-

-	t = temp[i][i];

-	for (k = 0; k < 4; k++) {

-	    temp[i][k] /= t;

-	    inverse[i*4+k] /= t;

-	}

-	for (j = 0; j < 4; j++) {

-	    if (j != i) {

-		t = temp[j][i];

-		for (k = 0; k < 4; k++) {

-		    temp[j][k] -= temp[i][k]*t;

-		    inverse[j*4+k] -= inverse[i*4+k]*t;

-		}

-	    }

-	}

-    }

-    return GL_TRUE;

-}

-

-static void __gluMultMatricesd(const GLdouble a[16], const GLdouble b[16],

-				GLdouble r[16])

-{

-    int i, j;

-

-    for (i = 0; i < 4; i++) {

-	for (j = 0; j < 4; j++) {

-	    r[i*4+j] = 

-		a[i*4+0]*b[0*4+j] +

-		a[i*4+1]*b[1*4+j] +

-		a[i*4+2]*b[2*4+j] +

-		a[i*4+3]*b[3*4+j];

-	}

-    }

-}

-

-GLint GLAPIENTRY

-gluProject(GLdouble objx, GLdouble objy, GLdouble objz, 

-	      const GLdouble modelMatrix[16], 

-	      const GLdouble projMatrix[16],

-              const GLint viewport[4],

-	      GLdouble *winx, GLdouble *winy, GLdouble *winz)

-{

-    double in[4];

-    double out[4];

-

-    in[0]=objx;

-    in[1]=objy;

-    in[2]=objz;

-    in[3]=1.0;

-    __gluMultMatrixVecd(modelMatrix, in, out);

-    __gluMultMatrixVecd(projMatrix, out, in);

-    if (in[3] == 0.0) return(GL_FALSE);

-    in[0] /= in[3];

-    in[1] /= in[3];

-    in[2] /= in[3];

-    /* Map x, y and z to range 0-1 */

-    in[0] = in[0] * 0.5 + 0.5;

-    in[1] = in[1] * 0.5 + 0.5;

-    in[2] = in[2] * 0.5 + 0.5;

-

-    /* Map x,y to viewport */

-    in[0] = in[0] * viewport[2] + viewport[0];

-    in[1] = in[1] * viewport[3] + viewport[1];

-

-    *winx=in[0];

-    *winy=in[1];

-    *winz=in[2];

-    return(GL_TRUE);

-}

-

-GLint GLAPIENTRY

-gluUnProject(GLdouble winx, GLdouble winy, GLdouble winz,

-		const GLdouble modelMatrix[16], 

-		const GLdouble projMatrix[16],

-                const GLint viewport[4],

-	        GLdouble *objx, GLdouble *objy, GLdouble *objz)

-{

-    double finalMatrix[16];

-    double in[4];

-    double out[4];

-

-    __gluMultMatricesd(modelMatrix, projMatrix, finalMatrix);

-    if (!__gluInvertMatrixd(finalMatrix, finalMatrix)) return(GL_FALSE);

-

-    in[0]=winx;

-    in[1]=winy;

-    in[2]=winz;

-    in[3]=1.0;

-

-    /* Map x and y from window coordinates */

-    in[0] = (in[0] - viewport[0]) / viewport[2];

-    in[1] = (in[1] - viewport[1]) / viewport[3];

-

-    /* Map to range -1 to 1 */

-    in[0] = in[0] * 2 - 1;

-    in[1] = in[1] * 2 - 1;

-    in[2] = in[2] * 2 - 1;

-

-    __gluMultMatrixVecd(finalMatrix, in, out);

-    if (out[3] == 0.0) return(GL_FALSE);

-    out[0] /= out[3];

-    out[1] /= out[3];

-    out[2] /= out[3];

-    *objx = out[0];

-    *objy = out[1];

-    *objz = out[2];

-    return(GL_TRUE);

-}

-

-GLint GLAPIENTRY

-gluUnProject4(GLdouble winx, GLdouble winy, GLdouble winz, GLdouble clipw,

-	      const GLdouble modelMatrix[16], 

-	      const GLdouble projMatrix[16],

-	      const GLint viewport[4],

-	      GLclampd nearVal, GLclampd farVal,		    

-	      GLdouble *objx, GLdouble *objy, GLdouble *objz,

-	      GLdouble *objw)

-{

-    double finalMatrix[16];

-    double in[4];

-    double out[4];

-

-    __gluMultMatricesd(modelMatrix, projMatrix, finalMatrix);

-    if (!__gluInvertMatrixd(finalMatrix, finalMatrix)) return(GL_FALSE);

-

-    in[0]=winx;

-    in[1]=winy;

-    in[2]=winz;

-    in[3]=clipw;

-

-    /* Map x and y from window coordinates */

-    in[0] = (in[0] - viewport[0]) / viewport[2];

-    in[1] = (in[1] - viewport[1]) / viewport[3];

-    in[2] = (in[2] - nearVal) / (farVal - nearVal);

-

-    /* Map to range -1 to 1 */

-    in[0] = in[0] * 2 - 1;

-    in[1] = in[1] * 2 - 1;

-    in[2] = in[2] * 2 - 1;

-

-    __gluMultMatrixVecd(finalMatrix, in, out);

-    if (out[3] == 0.0) return(GL_FALSE);

-    *objx = out[0];

-    *objy = out[1];

-    *objz = out[2];

-    *objw = out[3];

-    return(GL_TRUE);

-}

-

-void GLAPIENTRY

-gluPickMatrix(GLdouble x, GLdouble y, GLdouble deltax, GLdouble deltay,

-		  GLint viewport[4])

-{

-    if (deltax <= 0 || deltay <= 0) { 

-	return;

-    }

-

-    /* Translate and scale the picked region to the entire window */

-    glTranslatef((viewport[2] - 2 * (x - viewport[0])) / deltax,

-	    (viewport[3] - 2 * (y - viewport[1])) / deltay, 0);

-    glScalef(viewport[2] / deltax, viewport[3] / deltay, 1.0);

-}

+/*
+** 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.
+**
+** $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 $
+*/
+
+#include "gluos.h"
+#include <math.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include "gluint.h"
+
+/*
+** Make m an identity matrix
+*/
+static void __gluMakeIdentityd(GLdouble m[16])
+{
+    m[0+4*0] = 1; m[0+4*1] = 0; m[0+4*2] = 0; m[0+4*3] = 0;
+    m[1+4*0] = 0; m[1+4*1] = 1; m[1+4*2] = 0; m[1+4*3] = 0;
+    m[2+4*0] = 0; m[2+4*1] = 0; m[2+4*2] = 1; m[2+4*3] = 0;
+    m[3+4*0] = 0; m[3+4*1] = 0; m[3+4*2] = 0; m[3+4*3] = 1;
+}
+
+static void __gluMakeIdentityf(GLfloat m[16])
+{
+    m[0+4*0] = 1; m[0+4*1] = 0; m[0+4*2] = 0; m[0+4*3] = 0;
+    m[1+4*0] = 0; m[1+4*1] = 1; m[1+4*2] = 0; m[1+4*3] = 0;
+    m[2+4*0] = 0; m[2+4*1] = 0; m[2+4*2] = 1; m[2+4*3] = 0;
+    m[3+4*0] = 0; m[3+4*1] = 0; m[3+4*2] = 0; m[3+4*3] = 1;
+}
+
+void GLAPIENTRY
+gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)
+{
+    glOrtho(left, right, bottom, top, -1, 1);
+}
+
+#define __glPi 3.14159265358979323846
+
+void GLAPIENTRY
+gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)
+{
+    GLdouble m[4][4];
+    double sine, cotangent, deltaZ;
+    double radians = fovy / 2 * __glPi / 180;
+
+    deltaZ = zFar - zNear;
+    sine = sin(radians);
+    if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {
+	return;
+    }
+    cotangent = COS(radians) / sine;
+
+    __gluMakeIdentityd(&m[0][0]);
+    m[0][0] = cotangent / aspect;
+    m[1][1] = cotangent;
+    m[2][2] = -(zFar + zNear) / deltaZ;
+    m[2][3] = -1;
+    m[3][2] = -2 * zNear * zFar / deltaZ;
+    m[3][3] = 0;
+    glMultMatrixd(&m[0][0]);
+}
+
+static void normalize(float v[3])
+{
+    float r;
+
+    r = sqrt( v[0]*v[0] + v[1]*v[1] + v[2]*v[2] );
+    if (r == 0.0) return;
+
+    v[0] /= r;
+    v[1] /= r;
+    v[2] /= r;
+}
+
+static void cross(float v1[3], float v2[3], float result[3])
+{
+    result[0] = v1[1]*v2[2] - v1[2]*v2[1];
+    result[1] = v1[2]*v2[0] - v1[0]*v2[2];
+    result[2] = v1[0]*v2[1] - v1[1]*v2[0];
+}
+
+void GLAPIENTRY
+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];
+
+    forward[0] = centerx - eyex;
+    forward[1] = centery - eyey;
+    forward[2] = centerz - eyez;
+
+    up[0] = upx;
+    up[1] = upy;
+    up[2] = upz;
+
+    normalize(forward);
+
+    /* Side = forward x up */
+    cross(forward, up, side);
+    normalize(side);
+
+    /* Recompute up as: up = side x forward */
+    cross(side, forward, up);
+
+    __gluMakeIdentityf(&m[0][0]);
+    m[0][0] = side[0];
+    m[1][0] = side[1];
+    m[2][0] = side[2];
+
+    m[0][1] = up[0];
+    m[1][1] = up[1];
+    m[2][1] = up[2];
+
+    m[0][2] = -forward[0];
+    m[1][2] = -forward[1];
+    m[2][2] = -forward[2];
+
+    glMultMatrixf(&m[0][0]);
+    glTranslated(-eyex, -eyey, -eyez);
+}
+
+static void __gluMultMatrixVecd(const GLdouble matrix[16], const GLdouble in[4],
+		      GLdouble out[4])
+{
+    int i;
+
+    for (i=0; i<4; i++) {
+	out[i] = 
+	    in[0] * matrix[0*4+i] +
+	    in[1] * matrix[1*4+i] +
+	    in[2] * matrix[2*4+i] +
+	    in[3] * matrix[3*4+i];
+    }
+}
+
+/*
+** inverse = invert(src)
+*/
+static int __gluInvertMatrixd(const GLdouble src[16], GLdouble inverse[16])
+{
+    int i, j, k, swap;
+    double t;
+    GLdouble temp[4][4];
+
+    for (i=0; i<4; i++) {
+	for (j=0; j<4; j++) {
+	    temp[i][j] = src[i*4+j];
+	}
+    }
+    __gluMakeIdentityd(inverse);
+
+    for (i = 0; i < 4; i++) {
+	/*
+	** Look for largest element in column
+	*/
+	swap = i;
+	for (j = i + 1; j < 4; j++) {
+	    if (fabs(temp[j][i]) > fabs(temp[i][i])) {
+		swap = j;
+	    }
+	}
+
+	if (swap != i) {
+	    /*
+	    ** Swap rows.
+	    */
+	    for (k = 0; k < 4; k++) {
+		t = temp[i][k];
+		temp[i][k] = temp[swap][k];
+		temp[swap][k] = t;
+
+		t = inverse[i*4+k];
+		inverse[i*4+k] = inverse[swap*4+k];
+		inverse[swap*4+k] = t;
+	    }
+	}
+
+	if (temp[i][i] == 0) {
+	    /*
+	    ** No non-zero pivot.  The matrix is singular, which shouldn't
+	    ** happen.  This means the user gave us a bad matrix.
+	    */
+	    return GL_FALSE;
+	}
+
+	t = temp[i][i];
+	for (k = 0; k < 4; k++) {
+	    temp[i][k] /= t;
+	    inverse[i*4+k] /= t;
+	}
+	for (j = 0; j < 4; j++) {
+	    if (j != i) {
+		t = temp[j][i];
+		for (k = 0; k < 4; k++) {
+		    temp[j][k] -= temp[i][k]*t;
+		    inverse[j*4+k] -= inverse[i*4+k]*t;
+		}
+	    }
+	}
+    }
+    return GL_TRUE;
+}
+
+static void __gluMultMatricesd(const GLdouble a[16], const GLdouble b[16],
+				GLdouble r[16])
+{
+    int i, j;
+
+    for (i = 0; i < 4; i++) {
+	for (j = 0; j < 4; j++) {
+	    r[i*4+j] = 
+		a[i*4+0]*b[0*4+j] +
+		a[i*4+1]*b[1*4+j] +
+		a[i*4+2]*b[2*4+j] +
+		a[i*4+3]*b[3*4+j];
+	}
+    }
+}
+
+GLint GLAPIENTRY
+gluProject(GLdouble objx, GLdouble objy, GLdouble objz, 
+	      const GLdouble modelMatrix[16], 
+	      const GLdouble projMatrix[16],
+              const GLint viewport[4],
+	      GLdouble *winx, GLdouble *winy, GLdouble *winz)
+{
+    double in[4];
+    double out[4];
+
+    in[0]=objx;
+    in[1]=objy;
+    in[2]=objz;
+    in[3]=1.0;
+    __gluMultMatrixVecd(modelMatrix, in, out);
+    __gluMultMatrixVecd(projMatrix, out, in);
+    if (in[3] == 0.0) return(GL_FALSE);
+    in[0] /= in[3];
+    in[1] /= in[3];
+    in[2] /= in[3];
+    /* Map x, y and z to range 0-1 */
+    in[0] = in[0] * 0.5 + 0.5;
+    in[1] = in[1] * 0.5 + 0.5;
+    in[2] = in[2] * 0.5 + 0.5;
+
+    /* Map x,y to viewport */
+    in[0] = in[0] * viewport[2] + viewport[0];
+    in[1] = in[1] * viewport[3] + viewport[1];
+
+    *winx=in[0];
+    *winy=in[1];
+    *winz=in[2];
+    return(GL_TRUE);
+}
+
+GLint GLAPIENTRY
+gluUnProject(GLdouble winx, GLdouble winy, GLdouble winz,
+		const GLdouble modelMatrix[16], 
+		const GLdouble projMatrix[16],
+                const GLint viewport[4],
+	        GLdouble *objx, GLdouble *objy, GLdouble *objz)
+{
+    double finalMatrix[16];
+    double in[4];
+    double out[4];
+
+    __gluMultMatricesd(modelMatrix, projMatrix, finalMatrix);
+    if (!__gluInvertMatrixd(finalMatrix, finalMatrix)) return(GL_FALSE);
+
+    in[0]=winx;
+    in[1]=winy;
+    in[2]=winz;
+    in[3]=1.0;
+
+    /* Map x and y from window coordinates */
+    in[0] = (in[0] - viewport[0]) / viewport[2];
+    in[1] = (in[1] - viewport[1]) / viewport[3];
+
+    /* Map to range -1 to 1 */
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    __gluMultMatrixVecd(finalMatrix, in, out);
+    if (out[3] == 0.0) return(GL_FALSE);
+    out[0] /= out[3];
+    out[1] /= out[3];
+    out[2] /= out[3];
+    *objx = out[0];
+    *objy = out[1];
+    *objz = out[2];
+    return(GL_TRUE);
+}
+
+GLint GLAPIENTRY
+gluUnProject4(GLdouble winx, GLdouble winy, GLdouble winz, GLdouble clipw,
+	      const GLdouble modelMatrix[16], 
+	      const GLdouble projMatrix[16],
+	      const GLint viewport[4],
+	      GLclampd nearVal, GLclampd farVal,		    
+	      GLdouble *objx, GLdouble *objy, GLdouble *objz,
+	      GLdouble *objw)
+{
+    double finalMatrix[16];
+    double in[4];
+    double out[4];
+
+    __gluMultMatricesd(modelMatrix, projMatrix, finalMatrix);
+    if (!__gluInvertMatrixd(finalMatrix, finalMatrix)) return(GL_FALSE);
+
+    in[0]=winx;
+    in[1]=winy;
+    in[2]=winz;
+    in[3]=clipw;
+
+    /* Map x and y from window coordinates */
+    in[0] = (in[0] - viewport[0]) / viewport[2];
+    in[1] = (in[1] - viewport[1]) / viewport[3];
+    in[2] = (in[2] - nearVal) / (farVal - nearVal);
+
+    /* Map to range -1 to 1 */
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    __gluMultMatrixVecd(finalMatrix, in, out);
+    if (out[3] == 0.0) return(GL_FALSE);
+    *objx = out[0];
+    *objy = out[1];
+    *objz = out[2];
+    *objw = out[3];
+    return(GL_TRUE);
+}
+
+void GLAPIENTRY
+gluPickMatrix(GLdouble x, GLdouble y, GLdouble deltax, GLdouble deltay,
+		  GLint viewport[4])
+{
+    if (deltax <= 0 || deltay <= 0) { 
+	return;
+    }
+
+    /* Translate and scale the picked region to the entire window */
+    glTranslatef((viewport[2] - 2 * (x - viewport[0])) / deltax,
+	    (viewport[3] - 2 * (y - viewport[1])) / deltay, 0);
+    glScalef(viewport[2] / deltax, viewport[3] / deltay, 1.0);
+}
diff --git a/src/glut/glx/Makefile.win b/src/glut/glx/Makefile.win
index c3f9614099a..2823a009006 100644
--- a/src/glut/glx/Makefile.win
+++ b/src/glut/glx/Makefile.win
@@ -1,100 +1,100 @@
-# Makefile for Win32

-

-!include <win32.mak>

-

-TOP = ..

-

-# NOTE: glut_menu.c and glut_glxext.c are NOT compiled into Win32 GLUT

-

-SRCS = glut_8x13.c glut_9x15.c glut_bitmap.c glut_bwidth.c glut_cindex.c glut_cmap.c glut_cursor.c glut_dials.c glut_dstr.c glut_event.c glut_ext.c glut_fbc.c glut_fullscrn.c glut_gamemode.c glut_get.c glut_hel10.c glut_hel12.c glut_hel18.c glut_init.c glut_input.c glut_joy.c glut_key.c glut_keyctrl.c glut_keyup.c glut_mesa.c glut_modifier.c glut_mroman.c glut_overlay.c glut_roman.c glut_shapes.c glut_space.c glut_stroke.c glut_swap.c glut_swidth.c glut_tablet.c glut_teapot.c glut_tr10.c glut_tr24.c glut_util.c glut_vidresize.c glut_warp.c glut_win.c glut_winmisc.c win32_glx.c win32_menu.c win32_util.c win32_winproc.c win32_x11.c

-

-all	: glutdll 

-

-!include "$(TOP)/mesawin32.mak"

-

-glutdll	: $(GLUTDLL)

-

-!IFDEF NODEBUG

-OPTIMIZE_CFLAGS = -DNDEBUG

-!ENDIF

-

-CFLAGS = $(cvarsdll) $(CFLAGS) $(OPTIMIZE_CFLAGS) -DMESA -DBUILD_GL32

-LFLAGS = $(dlllflags) $(LFLAGS)

-

-OBJS   = $(SRCS:.c=.obj)

-MS_LIBS   = $(MS_OPENGL) $(MS_GLU) winmm.lib $(guilibsdll)

-MS_LIBS   = ../lib/opengl32.lib ../lib/glu32.lib winmm.lib $(guilibsdll)

-SGI_LIBS   = $(SGI_OPENGL) $(SGI_GLU) winmm.lib $(guilibsdll)

-

-glut32.dll : $(OBJS) glut.def

-	$(link) $(LFLAGS) -out:glut32.dll -def:glut.def $(OBJS) $(MS_LIBS)

-	@echo "copying GLUT dynamic link library to lib directory..."

-	-copy $(GLUTDLL) ..\lib

-	@echo "copying GLUT import library to lib directory..."

-	-copy $(GLUTLIB) ..\lib

-

-glut.dll : $(OBJS) glut.def

-	$(link) $(LFLAGS) -out:glut.dll -def:glut.def $(OBJS) $(SGI_LIBS)

-

-install	: $(GLUTDLL)

-	@echo "copying GLUT dynamic link library to system directory..."

-	-copy $(GLUTDLL) $(DLLINSTALL)

-	@echo "copying GLUT header file to include directory..."

-	-copy ..\include\GL\glut.h $(INCLUDEINSTALL)

-	@echo "copying GLUT import library to library directory..."

-	-copy $(GLUTLIB) $(LIBINSTALL)

-

-.c.obj	:

-	$(cc)   $(CFLAGS) -I . $*.c

-

-# explicit object dependencies for all source files

-

-win32_glx.obj: win32_glx.c win32_glx.h

-win32_x11.obj: win32_x11.c win32_x11.h

-win32_menu.obj: win32_menu.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h

-win32_util.obj: win32_util.c glutint.h ..\include\GL\glutf90.h

-win32_winproc.obj: win32_winproc.c glutint.h ..\include\GL\glutf90.h

-

-glut_mroman.obj: glut_mroman.c glutstroke.h glutint.h ..\include\GL\glutf90.h

-glut_roman.obj: glut_roman.c glutstroke.h glutint.h ..\include\GL\glutf90.h

-glut_hel12.obj: glut_hel12.c glutbitmap.h glutint.h ..\include\GL\glutf90.h

-glut_8x13.obj: glut_8x13.c glutbitmap.h glutint.h ..\include\GL\glutf90.h

-glut_hel18.obj: glut_hel18.c glutbitmap.h glutint.h ..\include\GL\glutf90.h

-glut_9x15.obj: glut_9x15.c glutbitmap.h glutint.h ..\include\GL\glutf90.h

-glut_tr10.obj: glut_tr10.c glutbitmap.h glutint.h ..\include\GL\glutf90.h

-glut_hel10.obj: glut_hel10.c glutbitmap.h glutint.h ..\include\GL\glutf90.h

-glut_tr24.obj: glut_tr24.c glutbitmap.h glutint.h ..\include\GL\glutf90.h

-

-glut_bitmap.obj: glut_bitmap.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_bwidth.obj: glut_bwidth.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_cindex.obj: glut_cindex.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_cmap.obj: glut_cmap.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_cursor.obj: glut_cursor.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_dials.obj: glut_dials.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_dstr.obj: glut_dstr.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_event.obj: glut_event.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_ext.obj: glut_ext.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_fullscrn.obj: glut_fullscrn.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_gamemode.obj: glut_gamemode.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_get.obj: glut_get.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_init.obj: glut_init.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_input.obj: glut_input.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_joy.obj: glut_joy.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_key.obj: glut_key.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_keyctrl.obj: glut_keyctrl.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_keyup.obj: glut_keyup.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_mesa.obj: glut_mesa.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_modifier.obj: glut_modifier.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_overlay.obj: glut_overlay.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_shapes.obj: glut_shapes.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_space.obj: glut_space.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_swap.obj: glut_swap.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_swidth.obj: glut_swidth.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_tablet.obj: glut_tablet.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_teapot.obj: glut_teapot.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_util.obj: glut_util.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_vidresize.obj: glut_vidresize.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_warp.obj: glut_warp.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-glut_win.obj: glut_win.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h

-glut_winmisc.obj: glut_winmisc.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

-

+# Makefile for Win32
+
+!include <win32.mak>
+
+TOP = ..
+
+# NOTE: glut_menu.c and glut_glxext.c are NOT compiled into Win32 GLUT
+
+SRCS = glut_8x13.c glut_9x15.c glut_bitmap.c glut_bwidth.c glut_cindex.c glut_cmap.c glut_cursor.c glut_dials.c glut_dstr.c glut_event.c glut_ext.c glut_fbc.c glut_fullscrn.c glut_gamemode.c glut_get.c glut_hel10.c glut_hel12.c glut_hel18.c glut_init.c glut_input.c glut_joy.c glut_key.c glut_keyctrl.c glut_keyup.c glut_mesa.c glut_modifier.c glut_mroman.c glut_overlay.c glut_roman.c glut_shapes.c glut_space.c glut_stroke.c glut_swap.c glut_swidth.c glut_tablet.c glut_teapot.c glut_tr10.c glut_tr24.c glut_util.c glut_vidresize.c glut_warp.c glut_win.c glut_winmisc.c win32_glx.c win32_menu.c win32_util.c win32_winproc.c win32_x11.c
+
+all	: glutdll 
+
+!include "$(TOP)/mesawin32.mak"
+
+glutdll	: $(GLUTDLL)
+
+!IFDEF NODEBUG
+OPTIMIZE_CFLAGS = -DNDEBUG
+!ENDIF
+
+CFLAGS = $(cvarsdll) $(CFLAGS) $(OPTIMIZE_CFLAGS) -DMESA -DBUILD_GL32
+LFLAGS = $(dlllflags) $(LFLAGS)
+
+OBJS   = $(SRCS:.c=.obj)
+MS_LIBS   = $(MS_OPENGL) $(MS_GLU) winmm.lib $(guilibsdll)
+MS_LIBS   = ../lib/opengl32.lib ../lib/glu32.lib winmm.lib $(guilibsdll)
+SGI_LIBS   = $(SGI_OPENGL) $(SGI_GLU) winmm.lib $(guilibsdll)
+
+glut32.dll : $(OBJS) glut.def
+	$(link) $(LFLAGS) -out:glut32.dll -def:glut.def $(OBJS) $(MS_LIBS)
+	@echo "copying GLUT dynamic link library to lib directory..."
+	-copy $(GLUTDLL) ..\lib
+	@echo "copying GLUT import library to lib directory..."
+	-copy $(GLUTLIB) ..\lib
+
+glut.dll : $(OBJS) glut.def
+	$(link) $(LFLAGS) -out:glut.dll -def:glut.def $(OBJS) $(SGI_LIBS)
+
+install	: $(GLUTDLL)
+	@echo "copying GLUT dynamic link library to system directory..."
+	-copy $(GLUTDLL) $(DLLINSTALL)
+	@echo "copying GLUT header file to include directory..."
+	-copy ..\include\GL\glut.h $(INCLUDEINSTALL)
+	@echo "copying GLUT import library to library directory..."
+	-copy $(GLUTLIB) $(LIBINSTALL)
+
+.c.obj	:
+	$(cc)   $(CFLAGS) -I . $*.c
+
+# explicit object dependencies for all source files
+
+win32_glx.obj: win32_glx.c win32_glx.h
+win32_x11.obj: win32_x11.c win32_x11.h
+win32_menu.obj: win32_menu.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h
+win32_util.obj: win32_util.c glutint.h ..\include\GL\glutf90.h
+win32_winproc.obj: win32_winproc.c glutint.h ..\include\GL\glutf90.h
+
+glut_mroman.obj: glut_mroman.c glutstroke.h glutint.h ..\include\GL\glutf90.h
+glut_roman.obj: glut_roman.c glutstroke.h glutint.h ..\include\GL\glutf90.h
+glut_hel12.obj: glut_hel12.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
+glut_8x13.obj: glut_8x13.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
+glut_hel18.obj: glut_hel18.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
+glut_9x15.obj: glut_9x15.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
+glut_tr10.obj: glut_tr10.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
+glut_hel10.obj: glut_hel10.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
+glut_tr24.obj: glut_tr24.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
+
+glut_bitmap.obj: glut_bitmap.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_bwidth.obj: glut_bwidth.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_cindex.obj: glut_cindex.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_cmap.obj: glut_cmap.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_cursor.obj: glut_cursor.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_dials.obj: glut_dials.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_dstr.obj: glut_dstr.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_event.obj: glut_event.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_ext.obj: glut_ext.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_fullscrn.obj: glut_fullscrn.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_gamemode.obj: glut_gamemode.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_get.obj: glut_get.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_init.obj: glut_init.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_input.obj: glut_input.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_joy.obj: glut_joy.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_key.obj: glut_key.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_keyctrl.obj: glut_keyctrl.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_keyup.obj: glut_keyup.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_mesa.obj: glut_mesa.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_modifier.obj: glut_modifier.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_overlay.obj: glut_overlay.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_shapes.obj: glut_shapes.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_space.obj: glut_space.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_swap.obj: glut_swap.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_swidth.obj: glut_swidth.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_tablet.obj: glut_tablet.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_teapot.obj: glut_teapot.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_util.obj: glut_util.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_vidresize.obj: glut_vidresize.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_warp.obj: glut_warp.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_win.obj: glut_win.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h
+glut_winmisc.obj: glut_winmisc.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+
diff --git a/src/glut/glx/glut.def b/src/glut/glx/glut.def
index 94da6ab852e..d7d0240fca0 100644
--- a/src/glut/glx/glut.def
+++ b/src/glut/glx/glut.def
@@ -1,9 +1,9 @@
 DESCRIPTION 'OpenGL Utility Toolkit for Win32'
-

-VERSION 3.7

-

+
+VERSION 3.7
+
 EXPORTS
-

+
 	glutAddMenuEntry
 	glutAddSubMenu
 	glutAttachMenu
@@ -123,4 +123,4 @@ EXPORTS
 	glutWireTorus
 ;    __glutSetFCB
 ;    __glutGetFCB
-

+
diff --git a/src/glut/glx/win32_x11.h b/src/glut/glx/win32_x11.h
index 70de9060919..1d8d048b2e0 100644
--- a/src/glut/glx/win32_x11.h
+++ b/src/glut/glx/win32_x11.h
@@ -1,326 +1,326 @@
-#ifndef __win32_x11_h__

-#define __win32_x11_h__

-

-/* Copyright (c) Nate Robins, 1997. */

-

-/* 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 <stdlib.h>

-#include <windows.h>

-

-/* These definitions are missing from windows.h */

-WINGDIAPI int WINAPI wglChoosePixelFormat(HDC, PIXELFORMATDESCRIPTOR *);

-WINGDIAPI int WINAPI wglDescribePixelFormat(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);

-WINGDIAPI int WINAPI wglGetPixelFormat(HDC);

-WINGDIAPI BOOL WINAPI wglSetPixelFormat(HDC, int, PIXELFORMATDESCRIPTOR *);

-WINGDIAPI BOOL WINAPI wglSwapBuffers(HDC);

-

-/* Type definitions (conversions) */

-typedef int Visual;			/* Win32 equivalent of X11 type */

-typedef HWND Window;

-typedef HPALETTE Colormap;

-typedef PIXELFORMATDESCRIPTOR XVisualInfo;

-typedef BOOL Bool;

-typedef MSG XEvent;

-typedef HDC Display;

-typedef HCURSOR Cursor;

-

-typedef int Atom;			/* dummies */

-typedef int XDevice;

-typedef int Status;

-

-#define True  TRUE			/* Win32 equivalents of X11 booleans */

-#define False FALSE

-

-#define None                 0L	/* universal null resource or null atom */

-

-/* Input Event Masks. Used as event-mask window attribute and as arguments

-   to Grab requests.  Not to be confused with event names.  */

-

-#define NoEventMask			0L

-#define KeyPressMask			(1L<<0)  

-#define KeyReleaseMask			(1L<<1)  

-#define ButtonPressMask			(1L<<2)  

-#define ButtonReleaseMask		(1L<<3)  

-#define EnterWindowMask			(1L<<4)  

-#define LeaveWindowMask			(1L<<5)  

-#define PointerMotionMask		(1L<<6)  

-#define PointerMotionHintMask		(1L<<7)  

-#define Button1MotionMask		(1L<<8)  

-#define Button2MotionMask		(1L<<9)  

-#define Button3MotionMask		(1L<<10) 

-#define Button4MotionMask		(1L<<11) 

-#define Button5MotionMask		(1L<<12) 

-#define ButtonMotionMask		(1L<<13) 

-#define KeymapStateMask			(1L<<14)

-#define ExposureMask			(1L<<15) 

-#define VisibilityChangeMask		(1L<<16) 

-#define StructureNotifyMask		(1L<<17) 

-#define ResizeRedirectMask		(1L<<18) 

-#define SubstructureNotifyMask		(1L<<19) 

-#define SubstructureRedirectMask	(1L<<20) 

-#define FocusChangeMask			(1L<<21) 

-#define PropertyChangeMask		(1L<<22) 

-#define ColormapChangeMask		(1L<<23) 

-#define OwnerGrabButtonMask		(1L<<24) 

-

-/* Key masks. Used as modifiers to GrabButton and GrabKey, results of

-   QueryPointer, state in various key-, mouse-, and button-related

-   events. */

-

-#define ShiftMask		(1<<0)

-#define LockMask		(1<<1)

-#define ControlMask		(1<<2)

-#define Mod1Mask		(1<<3)

-#define Mod2Mask		(1<<4)

-#define Mod3Mask		(1<<5)

-#define Mod4Mask		(1<<6)

-#define Mod5Mask		(1<<7)

-

-/* Window classes used by CreateWindow */

-/* Note that CopyFromParent is already defined as 0 above */

-

-#define InputOutput		1

-#define InputOnly		2

-

-/* Window attributes for CreateWindow and ChangeWindowAttributes */

-

-#define CWBackPixmap		(1L<<0)

-#define CWBackPixel		(1L<<1)

-#define CWBorderPixmap		(1L<<2)

-#define CWBorderPixel           (1L<<3)

-#define CWBitGravity		(1L<<4)

-#define CWWinGravity		(1L<<5)

-#define CWBackingStore          (1L<<6)

-#define CWBackingPlanes	        (1L<<7)

-#define CWBackingPixel	        (1L<<8)

-#define CWOverrideRedirect	(1L<<9)

-#define CWSaveUnder		(1L<<10)

-#define CWEventMask		(1L<<11)

-#define CWDontPropagate	        (1L<<12)

-#define CWColormap		(1L<<13)

-#define CWCursor	        (1L<<14)

-

-/* ConfigureWindow structure */

-

-#define CWX			(1<<0)

-#define CWY			(1<<1)

-#define CWWidth			(1<<2)

-#define CWHeight		(1<<3)

-#define CWBorderWidth		(1<<4)

-#define CWSibling		(1<<5)

-#define CWStackMode		(1<<6)

-

-

-/* Used in GetWindowAttributes reply */

-

-#define IsUnmapped		0

-#define IsUnviewable		1

-#define IsViewable		2

-

-/* Window stacking method (in configureWindow) */

-

-#define Above                   0

-#define Below                   1

-#define TopIf                   2

-#define BottomIf                3

-#define Opposite                4

-

-/* For CreateColormap */

-

-#define AllocNone		0	/* create map with no entries */

-#define AllocAll		1	/* allocate entire map writeable */

-

-

-/* Flags used in StoreNamedColor, StoreColors */

-

-#define DoRed			(1<<0)

-#define DoGreen			(1<<1)

-#define DoBlue			(1<<2)

-

-/* 

- * Bitmask returned by XParseGeometry().  Each bit tells if the corresponding

- * value (x, y, width, height) was found in the parsed string.

- */

-#define NoValue		0x0000

-#define XValue  	0x0001

-#define YValue		0x0002

-#define WidthValue  	0x0004

-#define HeightValue  	0x0008

-#define AllValues 	0x000F

-#define XNegative 	0x0010

-#define YNegative 	0x0020

-

-/* flags argument in size hints */

-#define USPosition	(1L << 0) /* user specified x, y */

-#define USSize		(1L << 1) /* user specified width, height */

-

-/* definitions for initial window state */

-#define WithdrawnState 0	/* for windows that are not mapped */

-#define NormalState 1	/* most applications want to start this way */

-#define IconicState 3	/* application wants to start as an icon */

-#define GameModeState 4  /* Win32 GLUT only (not in Xlib!). */

-

-/* Type definitions */

-

-typedef struct {

-    unsigned int background_pixmap;	/* background pixmap */

-    unsigned long background_pixel;	/* background pixel */

-    unsigned long border_pixel;	/* border pixel value */

-    long event_mask;		/* set of events that should be saved */

-    long do_not_propagate_mask;	/* set of events that should not propagate */

-    Bool override_redirect;	   /* boolean value for override-redirect */

-    Colormap colormap;		   /* color map to be associated with window */

-} XSetWindowAttributes;

-

-typedef struct {

-  unsigned long pixel;

-  unsigned short red, green, blue;

-  char flags;  /* do_red, do_green, do_blue */

-} XColor;

-

-typedef struct {

-  unsigned char *value;	   /* same as Property routines */

-  Atom encoding;	   /* prop type */

-  int format;		   /* prop data format: 8, 16, or 32 */

-  unsigned long nitems;	   /* number of data items in value */

-} XTextProperty;

-

-typedef struct {

-  long flags;	        /* marks which fields in this structure are defined */

-  int x, y;		/* obsolete for new window mgrs, but clients */

-  int width, height;	/* should set so old wm's don't mess up */

-} XSizeHints;

-

-/* Functions emulated by macros. */

-

-#define XFreeColormap(display, colormap) \

-  DeleteObject(colormap)

-

-#define XCreateFontCursor(display, shape) \

-  LoadCursor(NULL, shape)

-

-#define XDefineCursor(display, window, cursor) \

-  SetCursor(cursor)

-

-#define XFlush(display) \

-  /* Nothing. */

-

-#define DisplayWidth(display, screen) \

-  GetSystemMetrics(SM_CXSCREEN)

-

-#define DisplayHeight(display, screen) \

-  GetSystemMetrics(SM_CYSCREEN)

-

-#define XMapWindow(display, window) \

-  ShowWindow(window, SW_SHOWNORMAL)

-

-#define XUnmapWindow(display, window) \

-  ShowWindow(window, SW_HIDE)

-

-#define XIconifyWindow(display, window, screen) \

-  ShowWindow(window, SW_MINIMIZE)

-

-#define XWithdrawWindow(display, window, screen) \

-  ShowWindow(window, SW_HIDE)

-

-#define XLowerWindow(display, window) \

-  SetWindowPos(window, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE)

-

-#define XSetWMName(display, window, tp) \

-  SetWindowText(window, (tp)->value)

-

-/* There really isn't a way to set the icon name separate from the

-   windows name in Win32, so, just set the windows name. */

-#define XSetWMIconName(display, window, tp) \

-  XSetWMName(display, window, tp)

-

-#define XDestroyWindow(display, window) \

-  DestroyWindow(window)

-

-/* Anything that needs to be freed was allocated with malloc in our

-   fake X windows library for Win32, so free it with plain old

-   free(). */

-#define XFree(data) \

-  free(data)

-

-/* Nothing to be done for this...the pointer is always 'ungrabbed'

-   in Win32. */

-#define XUngrabPointer(display, time) \

-  /* Nothing. */

-

-/* Function prototypes. */

-

-extern XVisualInfo* XGetVisualInfo(

-  Display* display,

-  long mask,

-  XVisualInfo* ttemplate,  /* Avoid class with C++ keyword. */

-  int*nitems);

-

-extern Colormap XCreateColormap(

-  Display* display,

-  Window root,

-  Visual* visual,

-  int alloc);

-

-extern void XAllocColorCells(

-  Display* display,

-  Colormap colormap,

-  Bool contig, 

-  unsigned long plane_masks_return[],

-  unsigned int nplanes,

-  unsigned long pixels_return[],

-  unsigned int npixels);

-

-extern void XStoreColor(

-  Display* display,

-  Colormap colormap,

-  XColor* color);

-

-extern void XSetWindowColormap(

-  Display* display,

-  Window window,

-  Colormap colormap);

-

-extern Bool XTranslateCoordinates(

-  Display *display,

-  Window src, Window dst, 

-  int src_x, int src_y, 

-  int* dest_x_return, int* dest_y_return,

-  Window* child_return);

-

-extern Status XGetGeometry(

-  Display* display,

-  Window window,

-  Window* root_return, 

-  int* x_return, int* y_return, 

-  unsigned int* width_return, unsigned int* height_return,

-  unsigned int *border_width_return,

-  unsigned int* depth_return);

-

-extern int DisplayWidthMM(

-  Display* display,

-  int screen);

-

-extern int DisplayHeightMM(

-  Display* display,

-  int screen);

-

-extern void XWarpPointer(

-  Display* display,

-  Window src, Window dst, 

-  int src_x, int src_y,

-  int src_width, int src_height, 

-  int dst_x, int dst_y);

-

-extern int XParseGeometry(

-  char* string,

-  int* x, int* y, 

-  unsigned int* width, unsigned int* height);

-

-extern int XPending(

-  Display* display);

-

-#endif /* __win32_x11_h__ */

+#ifndef __win32_x11_h__
+#define __win32_x11_h__
+
+/* Copyright (c) Nate Robins, 1997. */
+
+/* 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 <stdlib.h>
+#include <windows.h>
+
+/* These definitions are missing from windows.h */
+WINGDIAPI int WINAPI wglChoosePixelFormat(HDC, PIXELFORMATDESCRIPTOR *);
+WINGDIAPI int WINAPI wglDescribePixelFormat(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
+WINGDIAPI int WINAPI wglGetPixelFormat(HDC);
+WINGDIAPI BOOL WINAPI wglSetPixelFormat(HDC, int, PIXELFORMATDESCRIPTOR *);
+WINGDIAPI BOOL WINAPI wglSwapBuffers(HDC);
+
+/* Type definitions (conversions) */
+typedef int Visual;			/* Win32 equivalent of X11 type */
+typedef HWND Window;
+typedef HPALETTE Colormap;
+typedef PIXELFORMATDESCRIPTOR XVisualInfo;
+typedef BOOL Bool;
+typedef MSG XEvent;
+typedef HDC Display;
+typedef HCURSOR Cursor;
+
+typedef int Atom;			/* dummies */
+typedef int XDevice;
+typedef int Status;
+
+#define True  TRUE			/* Win32 equivalents of X11 booleans */
+#define False FALSE
+
+#define None                 0L	/* universal null resource or null atom */
+
+/* Input Event Masks. Used as event-mask window attribute and as arguments
+   to Grab requests.  Not to be confused with event names.  */
+
+#define NoEventMask			0L
+#define KeyPressMask			(1L<<0)  
+#define KeyReleaseMask			(1L<<1)  
+#define ButtonPressMask			(1L<<2)  
+#define ButtonReleaseMask		(1L<<3)  
+#define EnterWindowMask			(1L<<4)  
+#define LeaveWindowMask			(1L<<5)  
+#define PointerMotionMask		(1L<<6)  
+#define PointerMotionHintMask		(1L<<7)  
+#define Button1MotionMask		(1L<<8)  
+#define Button2MotionMask		(1L<<9)  
+#define Button3MotionMask		(1L<<10) 
+#define Button4MotionMask		(1L<<11) 
+#define Button5MotionMask		(1L<<12) 
+#define ButtonMotionMask		(1L<<13) 
+#define KeymapStateMask			(1L<<14)
+#define ExposureMask			(1L<<15) 
+#define VisibilityChangeMask		(1L<<16) 
+#define StructureNotifyMask		(1L<<17) 
+#define ResizeRedirectMask		(1L<<18) 
+#define SubstructureNotifyMask		(1L<<19) 
+#define SubstructureRedirectMask	(1L<<20) 
+#define FocusChangeMask			(1L<<21) 
+#define PropertyChangeMask		(1L<<22) 
+#define ColormapChangeMask		(1L<<23) 
+#define OwnerGrabButtonMask		(1L<<24) 
+
+/* Key masks. Used as modifiers to GrabButton and GrabKey, results of
+   QueryPointer, state in various key-, mouse-, and button-related
+   events. */
+
+#define ShiftMask		(1<<0)
+#define LockMask		(1<<1)
+#define ControlMask		(1<<2)
+#define Mod1Mask		(1<<3)
+#define Mod2Mask		(1<<4)
+#define Mod3Mask		(1<<5)
+#define Mod4Mask		(1<<6)
+#define Mod5Mask		(1<<7)
+
+/* Window classes used by CreateWindow */
+/* Note that CopyFromParent is already defined as 0 above */
+
+#define InputOutput		1
+#define InputOnly		2
+
+/* Window attributes for CreateWindow and ChangeWindowAttributes */
+
+#define CWBackPixmap		(1L<<0)
+#define CWBackPixel		(1L<<1)
+#define CWBorderPixmap		(1L<<2)
+#define CWBorderPixel           (1L<<3)
+#define CWBitGravity		(1L<<4)
+#define CWWinGravity		(1L<<5)
+#define CWBackingStore          (1L<<6)
+#define CWBackingPlanes	        (1L<<7)
+#define CWBackingPixel	        (1L<<8)
+#define CWOverrideRedirect	(1L<<9)
+#define CWSaveUnder		(1L<<10)
+#define CWEventMask		(1L<<11)
+#define CWDontPropagate	        (1L<<12)
+#define CWColormap		(1L<<13)
+#define CWCursor	        (1L<<14)
+
+/* ConfigureWindow structure */
+
+#define CWX			(1<<0)
+#define CWY			(1<<1)
+#define CWWidth			(1<<2)
+#define CWHeight		(1<<3)
+#define CWBorderWidth		(1<<4)
+#define CWSibling		(1<<5)
+#define CWStackMode		(1<<6)
+
+
+/* Used in GetWindowAttributes reply */
+
+#define IsUnmapped		0
+#define IsUnviewable		1
+#define IsViewable		2
+
+/* Window stacking method (in configureWindow) */
+
+#define Above                   0
+#define Below                   1
+#define TopIf                   2
+#define BottomIf                3
+#define Opposite                4
+
+/* For CreateColormap */
+
+#define AllocNone		0	/* create map with no entries */
+#define AllocAll		1	/* allocate entire map writeable */
+
+
+/* Flags used in StoreNamedColor, StoreColors */
+
+#define DoRed			(1<<0)
+#define DoGreen			(1<<1)
+#define DoBlue			(1<<2)
+
+/* 
+ * Bitmask returned by XParseGeometry().  Each bit tells if the corresponding
+ * value (x, y, width, height) was found in the parsed string.
+ */
+#define NoValue		0x0000
+#define XValue  	0x0001
+#define YValue		0x0002
+#define WidthValue  	0x0004
+#define HeightValue  	0x0008
+#define AllValues 	0x000F
+#define XNegative 	0x0010
+#define YNegative 	0x0020
+
+/* flags argument in size hints */
+#define USPosition	(1L << 0) /* user specified x, y */
+#define USSize		(1L << 1) /* user specified width, height */
+
+/* definitions for initial window state */
+#define WithdrawnState 0	/* for windows that are not mapped */
+#define NormalState 1	/* most applications want to start this way */
+#define IconicState 3	/* application wants to start as an icon */
+#define GameModeState 4  /* Win32 GLUT only (not in Xlib!). */
+
+/* Type definitions */
+
+typedef struct {
+    unsigned int background_pixmap;	/* background pixmap */
+    unsigned long background_pixel;	/* background pixel */
+    unsigned long border_pixel;	/* border pixel value */
+    long event_mask;		/* set of events that should be saved */
+    long do_not_propagate_mask;	/* set of events that should not propagate */
+    Bool override_redirect;	   /* boolean value for override-redirect */
+    Colormap colormap;		   /* color map to be associated with window */
+} XSetWindowAttributes;
+
+typedef struct {
+  unsigned long pixel;
+  unsigned short red, green, blue;
+  char flags;  /* do_red, do_green, do_blue */
+} XColor;
+
+typedef struct {
+  unsigned char *value;	   /* same as Property routines */
+  Atom encoding;	   /* prop type */
+  int format;		   /* prop data format: 8, 16, or 32 */
+  unsigned long nitems;	   /* number of data items in value */
+} XTextProperty;
+
+typedef struct {
+  long flags;	        /* marks which fields in this structure are defined */
+  int x, y;		/* obsolete for new window mgrs, but clients */
+  int width, height;	/* should set so old wm's don't mess up */
+} XSizeHints;
+
+/* Functions emulated by macros. */
+
+#define XFreeColormap(display, colormap) \
+  DeleteObject(colormap)
+
+#define XCreateFontCursor(display, shape) \
+  LoadCursor(NULL, shape)
+
+#define XDefineCursor(display, window, cursor) \
+  SetCursor(cursor)
+
+#define XFlush(display) \
+  /* Nothing. */
+
+#define DisplayWidth(display, screen) \
+  GetSystemMetrics(SM_CXSCREEN)
+
+#define DisplayHeight(display, screen) \
+  GetSystemMetrics(SM_CYSCREEN)
+
+#define XMapWindow(display, window) \
+  ShowWindow(window, SW_SHOWNORMAL)
+
+#define XUnmapWindow(display, window) \
+  ShowWindow(window, SW_HIDE)
+
+#define XIconifyWindow(display, window, screen) \
+  ShowWindow(window, SW_MINIMIZE)
+
+#define XWithdrawWindow(display, window, screen) \
+  ShowWindow(window, SW_HIDE)
+
+#define XLowerWindow(display, window) \
+  SetWindowPos(window, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE)
+
+#define XSetWMName(display, window, tp) \
+  SetWindowText(window, (tp)->value)
+
+/* There really isn't a way to set the icon name separate from the
+   windows name in Win32, so, just set the windows name. */
+#define XSetWMIconName(display, window, tp) \
+  XSetWMName(display, window, tp)
+
+#define XDestroyWindow(display, window) \
+  DestroyWindow(window)
+
+/* Anything that needs to be freed was allocated with malloc in our
+   fake X windows library for Win32, so free it with plain old
+   free(). */
+#define XFree(data) \
+  free(data)
+
+/* Nothing to be done for this...the pointer is always 'ungrabbed'
+   in Win32. */
+#define XUngrabPointer(display, time) \
+  /* Nothing. */
+
+/* Function prototypes. */
+
+extern XVisualInfo* XGetVisualInfo(
+  Display* display,
+  long mask,
+  XVisualInfo* ttemplate,  /* Avoid class with C++ keyword. */
+  int*nitems);
+
+extern Colormap XCreateColormap(
+  Display* display,
+  Window root,
+  Visual* visual,
+  int alloc);
+
+extern void XAllocColorCells(
+  Display* display,
+  Colormap colormap,
+  Bool contig, 
+  unsigned long plane_masks_return[],
+  unsigned int nplanes,
+  unsigned long pixels_return[],
+  unsigned int npixels);
+
+extern void XStoreColor(
+  Display* display,
+  Colormap colormap,
+  XColor* color);
+
+extern void XSetWindowColormap(
+  Display* display,
+  Window window,
+  Colormap colormap);
+
+extern Bool XTranslateCoordinates(
+  Display *display,
+  Window src, Window dst, 
+  int src_x, int src_y, 
+  int* dest_x_return, int* dest_y_return,
+  Window* child_return);
+
+extern Status XGetGeometry(
+  Display* display,
+  Window window,
+  Window* root_return, 
+  int* x_return, int* y_return, 
+  unsigned int* width_return, unsigned int* height_return,
+  unsigned int *border_width_return,
+  unsigned int* depth_return);
+
+extern int DisplayWidthMM(
+  Display* display,
+  int screen);
+
+extern int DisplayHeightMM(
+  Display* display,
+  int screen);
+
+extern void XWarpPointer(
+  Display* display,
+  Window src, Window dst, 
+  int src_x, int src_y,
+  int src_width, int src_height, 
+  int dst_x, int dst_y);
+
+extern int XParseGeometry(
+  char* string,
+  int* x, int* y, 
+  unsigned int* width, unsigned int* height);
+
+extern int XPending(
+  Display* display);
+
+#endif /* __win32_x11_h__ */
diff --git a/src/mesa/drivers/osmesa/Makefile.win b/src/mesa/drivers/osmesa/Makefile.win
index 1d2f0aac4d4..a9597c2714a 100644
--- a/src/mesa/drivers/osmesa/Makefile.win
+++ b/src/mesa/drivers/osmesa/Makefile.win
@@ -1,37 +1,37 @@
-# Makefile for Win32

-

-!include <win32.mak>

-

-TOP = ..\..

-

-OSMESA_SRCS = osmesa.c

-OSMESA_OBJS = osmesa.obj

-OSMESALIB = OSmesa.lib

-

-ASM_SRCS =

-CORE_SRCS = $(OSMESA_SRCS)

-DRIVER_SRCS =

-

-SRCS	= $(OSMESA_SRCS)

-

-all	: osmesalib install

-

-!include "$(TOP)/mesawin32.mak"

-

-osmesalib	: $(OSMESALIB)

-

-CFLAGS	= $(cvarsdll) $(CFLAGS) -D_OPENGL32_ -I$(TOP)/src

-LFLAGS	= /LIB

-

-OBJS	= $(ASM_SRCS:.S=.obj) $(CORE_SRCS:.c=.obj) $(DRIVER_SRCS:.c=.obj)

-LIBS	= $(TOP)/lib/OpenGL32.lib $(TOP)/src/opengl32.exp

-

-$(OSMESALIB)	: $(OBJS)

-	$(link) $(LFLAGS) -out:$(OSMESALIB) $(OBJS) $(LIBS)

-

-install	: $(OSMESALIB)

-	@echo "copying OSMesa library to library directory..."

-	-copy $(OSMESALIB) $(TOP)\lib

-

-clean	::

-	@del /f osmesa.obj

+# Makefile for Win32
+
+!include <win32.mak>
+
+TOP = ..\..
+
+OSMESA_SRCS = osmesa.c
+OSMESA_OBJS = osmesa.obj
+OSMESALIB = OSmesa.lib
+
+ASM_SRCS =
+CORE_SRCS = $(OSMESA_SRCS)
+DRIVER_SRCS =
+
+SRCS	= $(OSMESA_SRCS)
+
+all	: osmesalib install
+
+!include "$(TOP)/mesawin32.mak"
+
+osmesalib	: $(OSMESALIB)
+
+CFLAGS	= $(cvarsdll) $(CFLAGS) -D_OPENGL32_ -I$(TOP)/src
+LFLAGS	= /LIB
+
+OBJS	= $(ASM_SRCS:.S=.obj) $(CORE_SRCS:.c=.obj) $(DRIVER_SRCS:.c=.obj)
+LIBS	= $(TOP)/lib/OpenGL32.lib $(TOP)/src/opengl32.exp
+
+$(OSMESALIB)	: $(OBJS)
+	$(link) $(LFLAGS) -out:$(OSMESALIB) $(OBJS) $(LIBS)
+
+install	: $(OSMESALIB)
+	@echo "copying OSMesa library to library directory..."
+	-copy $(OSMESALIB) $(TOP)\lib
+
+clean	::
+	@del /f osmesa.obj
diff --git a/src/mesa/drivers/windows/wgl.c b/src/mesa/drivers/windows/wgl.c
index f7bf6820169..0db57641fe1 100644
--- a/src/mesa/drivers/windows/wgl.c
+++ b/src/mesa/drivers/windows/wgl.c
@@ -1,645 +1,645 @@
-/* $Id: wgl.c,v 1.8 2001/09/14 22:19:19 brianp Exp $ */

-

-/*

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

-*

-*/

-

-/*

-* File name 	: wgl.c

-* WGL stuff. Added by Oleg Letsinsky, [email protected]

-* Some things originated from the 3Dfx WGL functions

-*/

-

-#ifdef WIN32

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-#include <windows.h>

-#define GL_GLEXT_PROTOTYPES

-#include <GL/gl.h>

-#include <GL/glext.h>

-//#include <GL/glu.h>

-

-#ifdef __cplusplus

-}

-#endif

-

-#include <stdio.h>

-#include <tchar.h>

-#include "wmesadef.h"

-#include "GL/wmesa.h"

-#include "mtypes.h"

-

-#define MAX_MESA_ATTRS	20

-

-struct __extensions__

-{

-    PROC	proc;

-    char	*name;

-};

-

-struct __pixelformat__

-{

-    PIXELFORMATDESCRIPTOR	pfd;

-    GLboolean doubleBuffered;

-};

-

-struct __extensions__	ext[] = {

-

-#ifdef GL_EXT_polygon_offset

-   { (PROC)glPolygonOffsetEXT,			"glPolygonOffsetEXT"		},

-#endif

-   { (PROC)glBlendEquationEXT,			"glBlendEquationEXT"		},

-   { (PROC)glBlendColorEXT,			"glBlendColorExt"		},

-   { (PROC)glVertexPointerEXT,			"glVertexPointerEXT"		},

-   { (PROC)glNormalPointerEXT,			"glNormalPointerEXT"		},

-   { (PROC)glColorPointerEXT,			"glColorPointerEXT"		},

-   { (PROC)glIndexPointerEXT,			"glIndexPointerEXT"		},

-   { (PROC)glTexCoordPointerEXT,		"glTexCoordPointer"		},

-   { (PROC)glEdgeFlagPointerEXT,		"glEdgeFlagPointerEXT"		},

-   { (PROC)glGetPointervEXT,			"glGetPointervEXT"		},

-   { (PROC)glArrayElementEXT,			"glArrayElementEXT"		},

-   { (PROC)glDrawArraysEXT,			"glDrawArrayEXT"		},

-   { (PROC)glAreTexturesResidentEXT,		"glAreTexturesResidentEXT"	},

-   { (PROC)glBindTextureEXT,			"glBindTextureEXT"		},

-   { (PROC)glDeleteTexturesEXT,			"glDeleteTexturesEXT"		},

-   { (PROC)glGenTexturesEXT,			"glGenTexturesEXT"		},

-   { (PROC)glIsTextureEXT,			"glIsTextureEXT"		},

-   { (PROC)glPrioritizeTexturesEXT,		"glPrioritizeTexturesEXT"	},

-   { (PROC)glCopyTexSubImage3DEXT,		"glCopyTexSubImage3DEXT"	},

-   { (PROC)glTexImage3DEXT,			"glTexImage3DEXT"		},

-   { (PROC)glTexSubImage3DEXT,			"glTexSubImage3DEXT"		},

-   { (PROC)glColorTableEXT,			"glColorTableEXT"		},

-   { (PROC)glColorSubTableEXT,			"glColorSubTableEXT"		},

-   { (PROC)glGetColorTableEXT,			"glGetColorTableEXT"		},

-   { (PROC)glGetColorTableParameterfvEXT,	"glGetColorTableParameterfvEXT"	},

-   { (PROC)glGetColorTableParameterivEXT,	"glGetColorTableParameterivEXT"	},

-   { (PROC)glPointParameterfEXT,		"glPointParameterfEXT"		},

-   { (PROC)glPointParameterfvEXT,		"glPointParameterfvEXT"		},

-   { (PROC)glBlendFuncSeparateEXT,		"glBlendFuncSeparateEXT"	},

-   { (PROC)glLockArraysEXT,			"glLockArraysEXT"		},

-   { (PROC)glUnlockArraysEXT,			"glUnlockArraysEXT"		}

-};

-

-int qt_ext = sizeof(ext) / sizeof(ext[0]);

-

-struct __pixelformat__	pix[] =

-{

-    {	{	sizeof(PIXELFORMATDESCRIPTOR),	1,

-        PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,

-        PFD_TYPE_RGBA,

-        24,	8,	0,	8,	8,	8,	16,	8,	24,

-        0,	0,	0,	0,	0,	16,	8,	0,	0,	0,	0,	0,	0 },

-        GL_TRUE

-    },

-    {	{	sizeof(PIXELFORMATDESCRIPTOR),	1,

-        PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_FORMAT,

-        PFD_TYPE_RGBA,

-        24,	8,	0,	8,	8,	8,	16,	8,	24,

-        0,	0,	0,	0,	0,	16,	8,	0,	0,	0,	0,	0,	0 },

-        GL_FALSE

-    },

-};

-

-int				qt_pix = sizeof(pix) / sizeof(pix[0]);

-

-typedef struct {

-    WMesaContext ctx;

-    HDC hdc;

-} MesaWglCtx;

-

-#define MESAWGL_CTX_MAX_COUNT 20

-

-static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];

-

-static unsigned ctx_count = 0;

-static unsigned ctx_current = -1;

-static unsigned curPFD = 0;

-

-WGLAPI BOOL GLAPIENTRY wglCopyContext(HGLRC hglrcSrc,HGLRC hglrcDst,UINT mask)

-{

-    return(FALSE);

-}

-

-WGLAPI HGLRC GLAPIENTRY wglCreateContext(HDC hdc)

-{

-    HWND		hWnd;

-    int i = 0;

-    if(!(hWnd = WindowFromDC(hdc)))

-    {

-        SetLastError(0);

-        return(NULL);

-    }

-    if (!ctx_count)

-    {

-    	for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++)

-    	{

-    		wgl_ctx[i].ctx = NULL;

-    		wgl_ctx[i].hdc = NULL;

-    	}

-    }

-    for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )

-    {

-        if ( wgl_ctx[i].ctx == NULL )

-        {

-            wgl_ctx[i].ctx = WMesaCreateContext( hWnd, NULL, GL_TRUE,

-                pix[curPFD-1].doubleBuffered );

-            if (wgl_ctx[i].ctx == NULL)

-                break;

-            wgl_ctx[i].hdc = hdc;

-            ctx_count++;

-            return ((HGLRC)wgl_ctx[i].ctx);

-        }

-    }

-    SetLastError(0);

-    return(NULL);

-}

-

-WGLAPI BOOL GLAPIENTRY wglDeleteContext(HGLRC hglrc)

-{

-    int i;

-    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )

-    {

-    	if ( wgl_ctx[i].ctx == (PWMC) hglrc )

-    	{

-            WMesaMakeCurrent((PWMC) hglrc);

-            WMesaDestroyContext();

-            wgl_ctx[i].ctx = NULL;

-            wgl_ctx[i].hdc = NULL;

-            ctx_count--;

-            return(TRUE);

-    	}

-    }

-    SetLastError(0);

-    return(FALSE);

-}

-

-WGLAPI HGLRC GLAPIENTRY wglCreateLayerContext(HDC hdc,int iLayerPlane)

-{

-    SetLastError(0);

-    return(NULL);

-}

-

-WGLAPI HGLRC GLAPIENTRY wglGetCurrentContext(VOID)

-{

-   if (ctx_current < 0)

-      return 0;

-   else

-      return (HGLRC) wgl_ctx[ctx_current].ctx;

-}

-

-WGLAPI HDC GLAPIENTRY wglGetCurrentDC(VOID)

-{

-   if (ctx_current < 0)

-      return 0;

-   else

-      return wgl_ctx[ctx_current].hdc;

-}

-

-WGLAPI BOOL GLAPIENTRY wglMakeCurrent(HDC hdc,HGLRC hglrc)

-{

-    int i;

-

-    /* new code suggested by Andy Sy */

-    if (!hdc || !hglrc) {

-       WMesaMakeCurrent(NULL);

-       ctx_current = -1;

-       return TRUE;

-    }

-

-    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )

-    {

-        if ( wgl_ctx[i].ctx == (PWMC) hglrc )

-        {

-            wgl_ctx[i].hdc = hdc;

-            WMesaMakeCurrent( (WMesaContext) hglrc );

-            ctx_current = i;

-            return TRUE;

-        }

-    }

-    return FALSE;

-}

-

-WGLAPI BOOL GLAPIENTRY wglShareLists(HGLRC hglrc1,HGLRC hglrc2)

-{

-    return(TRUE);

-}

-

-

-static FIXED FixedFromDouble(double d)

-{

-   long l = (long) (d * 65536L);

-   return *(FIXED *)&l;

-}

-

-

-/*

-** This is cribbed from FX/fxwgl.c, and seems to implement support

-** for bitmap fonts where the wglUseFontBitmapsA() code implements

-** support for outline fonts.  In combination they hopefully give

-** fairly generic support for fonts.

-*/

-static BOOL wglUseFontBitmaps_FX(HDC fontDevice, DWORD firstChar,

-                                 DWORD numChars, DWORD listBase)

-{

-#define VERIFY(a) a

-

-  TEXTMETRIC metric;

-  BITMAPINFO *dibInfo;

-  HDC bitDevice;

-  COLORREF tempColor;

-  int i;

-

-  VERIFY(GetTextMetrics(fontDevice, &metric));

-

-  dibInfo = (BITMAPINFO *) calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);

-  dibInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

-  dibInfo->bmiHeader.biPlanes = 1;

-  dibInfo->bmiHeader.biBitCount = 1;

-  dibInfo->bmiHeader.biCompression = BI_RGB;

-

-  bitDevice = CreateCompatibleDC(fontDevice);

-  // HDC bitDevice = CreateDC("DISPLAY", NULL, NULL, NULL);

-  // VERIFY(bitDevice);

-

-  // Swap fore and back colors so the bitmap has the right polarity

-  tempColor = GetBkColor(bitDevice);

-  SetBkColor(bitDevice, GetTextColor(bitDevice));

-  SetTextColor(bitDevice, tempColor);

-

-  // Place chars based on base line

-  VERIFY(SetTextAlign(bitDevice, TA_BASELINE) >= 0 ? 1 : 0);

-

-  for(i = 0; i < numChars; i++) {

-    SIZE size;

-    char curChar;

-    int charWidth,charHeight,bmapWidth,bmapHeight,numBytes,res;

-    HBITMAP bitObject;

-    HGDIOBJ origBmap;

-    unsigned char *bmap;

-

-    curChar = i + firstChar;

-

-    // Find how high/wide this character is

-    VERIFY(GetTextExtentPoint32(bitDevice, &curChar, 1, &size));

-

-    // Create the output bitmap

-    charWidth = size.cx;

-    charHeight = size.cy;

-    bmapWidth = ((charWidth + 31) / 32) * 32;   // Round up to the next multiple of 32 bits

-    bmapHeight = charHeight;

-    bitObject = CreateCompatibleBitmap(bitDevice,

-                                       bmapWidth,

-                                       bmapHeight);

-    //VERIFY(bitObject);

-

-    // Assign the output bitmap to the device

-    origBmap = SelectObject(bitDevice, bitObject);

-    VERIFY(origBmap);

-

-    VERIFY( PatBlt( bitDevice, 0, 0, bmapWidth, bmapHeight,BLACKNESS ) );

-

-    // Use our source font on the device

-    VERIFY(SelectObject(bitDevice, GetCurrentObject(fontDevice,OBJ_FONT)));

-

-    // Draw the character

-    VERIFY(TextOut(bitDevice, 0, metric.tmAscent, &curChar, 1));

-

-    // Unselect our bmap object

-    VERIFY(SelectObject(bitDevice, origBmap));

-

-    // Convert the display dependant representation to a 1 bit deep DIB

-    numBytes = (bmapWidth * bmapHeight) / 8;

-    bmap = malloc(numBytes);

-    dibInfo->bmiHeader.biWidth = bmapWidth;

-    dibInfo->bmiHeader.biHeight = bmapHeight;

-    res = GetDIBits(bitDevice, bitObject, 0, bmapHeight, bmap,

-                    dibInfo,

-                    DIB_RGB_COLORS);

-    //VERIFY(res);

-

-    // Create the GL object

-    glNewList(i + listBase, GL_COMPILE);

-    glBitmap(bmapWidth, bmapHeight, 0.0, metric.tmDescent,

-             charWidth, 0.0,

-             bmap);

-    glEndList();

-    // CheckGL();

-

-    // Destroy the bmap object

-    DeleteObject(bitObject);

-

-    // Deallocate the bitmap data

-    free(bmap);

-  }

-

-  // Destroy the DC

-  VERIFY(DeleteDC(bitDevice));

-

-  free(dibInfo);

-

-  return TRUE;

-#undef VERIFY

-}

-

-WGLAPI BOOL GLAPIENTRY wglUseFontBitmapsA(HDC hdc, DWORD first,

-                                       DWORD count, DWORD listBase)

-{

-   int i;

-   GLuint font_list;

-   DWORD size;

-   GLYPHMETRICS gm;

-   HANDLE hBits;

-   LPSTR lpBits;

-   MAT2 mat;

-   int  success = TRUE;

-

-   if (first<0)

-      return FALSE;

-   if (count<0)

-      return FALSE;

-   if (listBase<0)

-      return FALSE;

-

-   font_list = listBase;

-

-   mat.eM11 = FixedFromDouble(1);

-   mat.eM12 = FixedFromDouble(0);

-   mat.eM21 = FixedFromDouble(0);

-   mat.eM22 = FixedFromDouble(-1);

-

-   memset(&gm,0,sizeof(gm));

-

-   /*

-   ** If we can't get the glyph outline, it may be because this is a fixed

-   ** font.  Try processing it that way.

-   */

-   if( GetGlyphOutline(hdc, first, GGO_BITMAP, &gm, 0, NULL, &mat)

-       == GDI_ERROR )

-   {

-       return wglUseFontBitmaps_FX( hdc, first, count, listBase );

-   }

-

-   /*

-   ** Otherwise process all desired characters.

-   */

-   for (i = 0; i < count; i++)

-   {

-       DWORD err;

-       

-      glNewList( font_list+i, GL_COMPILE );

-

-      /* allocate space for the bitmap/outline */

-      size = GetGlyphOutline(hdc, first + i, GGO_BITMAP, &gm, 0, NULL, &mat);

-      if (size == GDI_ERROR)

-      {

-         glEndList( );

-         err = GetLastError();

-         success = FALSE;

-         continue;

-      }

-

-      hBits  = GlobalAlloc(GHND, size+1);

-      lpBits = GlobalLock(hBits);

-

-      err = 

-      GetGlyphOutline(hdc,    /* handle to device context */

-                      first + i,          /* character to query */

-                      GGO_BITMAP,         /* format of data to return */

-                      &gm,                /* pointer to structure for metrics*/

-                      size,               /* size of buffer for data */

-                      lpBits,             /* pointer to buffer for data */

-                      &mat                /* pointer to transformation */

-                                          /* matrix structure */

-                  );

-

-      if (err == GDI_ERROR)

-      {

-         GlobalUnlock(hBits);

-         GlobalFree(hBits);

-         

-         glEndList( );

-         err = GetLastError();

-         success = FALSE;

-         continue;

-      }

-

-      glBitmap(gm.gmBlackBoxX,gm.gmBlackBoxY,

-               -gm.gmptGlyphOrigin.x,

-               gm.gmptGlyphOrigin.y,

-               gm.gmCellIncX,gm.gmCellIncY,

-               (const GLubyte * )lpBits);

-

-      GlobalUnlock(hBits);

-      GlobalFree(hBits);

-

-      glEndList( );

-   }

-

-   return success;

-}

-

-

-WGLAPI BOOL GLAPIENTRY wglUseFontBitmapsW(HDC hdc,DWORD first,DWORD count,DWORD listBase)

-{

-    return FALSE;

-}

-

-WGLAPI BOOL GLAPIENTRY wglUseFontOutlinesA(HDC hdc,DWORD first,DWORD count,

-                                  DWORD listBase,FLOAT deviation,

-                                  FLOAT extrusion,int format,

-                                  LPGLYPHMETRICSFLOAT lpgmf)

-{

-    SetLastError(0);

-    return(FALSE);

-}

-

-WGLAPI BOOL GLAPIENTRY wglUseFontOutlinesW(HDC hdc,DWORD first,DWORD count,

-                                  DWORD listBase,FLOAT deviation,

-                                  FLOAT extrusion,int format,

-                                  LPGLYPHMETRICSFLOAT lpgmf)

-{

-    SetLastError(0);

-    return(FALSE);

-}

-

-WGLAPI BOOL GLAPIENTRY wglDescribeLayerPlane(HDC hdc,int iPixelFormat,

-                                    int iLayerPlane,UINT nBytes,

-                                    LPLAYERPLANEDESCRIPTOR plpd)

-{

-    SetLastError(0);

-    return(FALSE);

-}

-

-WGLAPI int GLAPIENTRY wglSetLayerPaletteEntries(HDC hdc,int iLayerPlane,

-                                       int iStart,int cEntries,

-                                       CONST COLORREF *pcr)

-{

-    SetLastError(0);

-    return(0);

-}

-

-WGLAPI int GLAPIENTRY wglGetLayerPaletteEntries(HDC hdc,int iLayerPlane,

-                                       int iStart,int cEntries,

-                                       COLORREF *pcr)

-{

-    SetLastError(0);

-    return(0);

-}

-

-WGLAPI BOOL GLAPIENTRY wglRealizeLayerPalette(HDC hdc,int iLayerPlane,BOOL bRealize)

-{

-    SetLastError(0);

-    return(FALSE);

-}

-

-WGLAPI BOOL GLAPIENTRY wglSwapLayerBuffers(HDC hdc,UINT fuPlanes)

-{

-    if( !hdc )

-    {

-        WMesaSwapBuffers();

-        return(TRUE);

-    }

-    SetLastError(0);

-    return(FALSE);

-}

-

-WGLAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc,

-                                  CONST PIXELFORMATDESCRIPTOR *ppfd)

-{

-    int		i,best = -1,bestdelta = 0x7FFFFFFF,delta,qt_valid_pix;

-

-    qt_valid_pix = qt_pix;

-    if(ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR) || ppfd->nVersion != 1)

-    {

-        SetLastError(0);

-        return(0);

-    }

-    for(i = 0;i < qt_valid_pix;i++)

-    {

-        delta = 0;

-        if(

-            (ppfd->dwFlags & PFD_DRAW_TO_WINDOW) &&

-            !(pix[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW))

-            continue;

-        if(

-            (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) &&

-            !(pix[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP))

-            continue;

-        if(

-            (ppfd->dwFlags & PFD_SUPPORT_GDI) &&

-            !(pix[i].pfd.dwFlags & PFD_SUPPORT_GDI))

-            continue;

-        if(

-            (ppfd->dwFlags & PFD_SUPPORT_OPENGL) &&

-            !(pix[i].pfd.dwFlags & PFD_SUPPORT_OPENGL))

-            continue;

-        if(

-            !(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&

-            ((ppfd->dwFlags & PFD_DOUBLEBUFFER) != (pix[i].pfd.dwFlags & PFD_DOUBLEBUFFER)))

-            continue;

-        if(

-            !(ppfd->dwFlags & PFD_STEREO_DONTCARE) &&

-            ((ppfd->dwFlags & PFD_STEREO) != (pix[i].pfd.dwFlags & PFD_STEREO)))

-            continue;

-        if(ppfd->iPixelType != pix[i].pfd.iPixelType)

-            delta++;

-        if(delta < bestdelta)

-        {

-            best = i + 1;

-            bestdelta = delta;

-            if(bestdelta == 0)

-                break;

-        }

-    }

-    if(best == -1)

-    {

-        SetLastError(0);

-        return(0);

-    }

-    return(best);

-}

-

-WGLAPI int GLAPIENTRY wglDescribePixelFormat(HDC hdc,int iPixelFormat,UINT nBytes,

-                                    LPPIXELFORMATDESCRIPTOR ppfd)

-{

-    int		qt_valid_pix;

-

-    qt_valid_pix = qt_pix;

-    if(iPixelFormat < 1 || iPixelFormat > qt_valid_pix || nBytes != sizeof(PIXELFORMATDESCRIPTOR))

-    {

-        SetLastError(0);

-        return(0);

-    }

-    *ppfd = pix[iPixelFormat - 1].pfd;

-    return(qt_valid_pix);

-}

-

-/*

-* GetProcAddress - return the address of an appropriate extension

-*/

-WGLAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc)

-{

-    int		i;

-    for(i = 0;i < qt_ext;i++)

-        if(!strcmp(lpszProc,ext[i].name))

-            return(ext[i].proc);

-

-        SetLastError(0);

-        return(NULL);

-}

-

-WGLAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc)

-{

-    if(curPFD == 0)

-    {

-        SetLastError(0);

-        return(0);

-    }

-    return(curPFD);

-}

-

-WGLAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc,int iPixelFormat,

-                                PIXELFORMATDESCRIPTOR *ppfd)

-{

-    int		qt_valid_pix;

-

-    qt_valid_pix = qt_pix;

-    if(iPixelFormat < 1 || iPixelFormat > qt_valid_pix || ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR))

-    {

-        SetLastError(0);

-        return(FALSE);

-    }

-    curPFD = iPixelFormat;

-    return(TRUE);

-}

-

-WGLAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc)

-{

-   if (ctx_current < 0)

-      return FALSE;

-

-   if(wgl_ctx[ctx_current].ctx == NULL) {

-      SetLastError(0);

-      return(FALSE);

-   }

-   WMesaSwapBuffers();

-   return(TRUE);

-}

-

-#endif /* WIN32 */

+/* $Id: wgl.c,v 1.9 2001/09/18 16:39:38 kschultz Exp $ */
+
+/*
+* 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.
+*
+*/
+
+/*
+* File name 	: wgl.c
+* WGL stuff. Added by Oleg Letsinsky, [email protected]
+* Some things originated from the 3Dfx WGL functions
+*/
+
+#ifdef WIN32
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <windows.h>
+#define GL_GLEXT_PROTOTYPES
+#include <GL/gl.h>
+#include <GL/glext.h>
+//#include <GL/glu.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <stdio.h>
+#include <tchar.h>
+#include "wmesadef.h"
+#include "GL/wmesa.h"
+#include "mtypes.h"
+
+#define MAX_MESA_ATTRS	20
+
+struct __extensions__
+{
+    PROC	proc;
+    char	*name;
+};
+
+struct __pixelformat__
+{
+    PIXELFORMATDESCRIPTOR	pfd;
+    GLboolean doubleBuffered;
+};
+
+struct __extensions__	ext[] = {
+
+#ifdef GL_EXT_polygon_offset
+   { (PROC)glPolygonOffsetEXT,			"glPolygonOffsetEXT"		},
+#endif
+   { (PROC)glBlendEquationEXT,			"glBlendEquationEXT"		},
+   { (PROC)glBlendColorEXT,			"glBlendColorExt"		},
+   { (PROC)glVertexPointerEXT,			"glVertexPointerEXT"		},
+   { (PROC)glNormalPointerEXT,			"glNormalPointerEXT"		},
+   { (PROC)glColorPointerEXT,			"glColorPointerEXT"		},
+   { (PROC)glIndexPointerEXT,			"glIndexPointerEXT"		},
+   { (PROC)glTexCoordPointerEXT,		"glTexCoordPointer"		},
+   { (PROC)glEdgeFlagPointerEXT,		"glEdgeFlagPointerEXT"		},
+   { (PROC)glGetPointervEXT,			"glGetPointervEXT"		},
+   { (PROC)glArrayElementEXT,			"glArrayElementEXT"		},
+   { (PROC)glDrawArraysEXT,			"glDrawArrayEXT"		},
+   { (PROC)glAreTexturesResidentEXT,		"glAreTexturesResidentEXT"	},
+   { (PROC)glBindTextureEXT,			"glBindTextureEXT"		},
+   { (PROC)glDeleteTexturesEXT,			"glDeleteTexturesEXT"		},
+   { (PROC)glGenTexturesEXT,			"glGenTexturesEXT"		},
+   { (PROC)glIsTextureEXT,			"glIsTextureEXT"		},
+   { (PROC)glPrioritizeTexturesEXT,		"glPrioritizeTexturesEXT"	},
+   { (PROC)glCopyTexSubImage3DEXT,		"glCopyTexSubImage3DEXT"	},
+   { (PROC)glTexImage3DEXT,			"glTexImage3DEXT"		},
+   { (PROC)glTexSubImage3DEXT,			"glTexSubImage3DEXT"		},
+   { (PROC)glColorTableEXT,			"glColorTableEXT"		},
+   { (PROC)glColorSubTableEXT,			"glColorSubTableEXT"		},
+   { (PROC)glGetColorTableEXT,			"glGetColorTableEXT"		},
+   { (PROC)glGetColorTableParameterfvEXT,	"glGetColorTableParameterfvEXT"	},
+   { (PROC)glGetColorTableParameterivEXT,	"glGetColorTableParameterivEXT"	},
+   { (PROC)glPointParameterfEXT,		"glPointParameterfEXT"		},
+   { (PROC)glPointParameterfvEXT,		"glPointParameterfvEXT"		},
+   { (PROC)glBlendFuncSeparateEXT,		"glBlendFuncSeparateEXT"	},
+   { (PROC)glLockArraysEXT,			"glLockArraysEXT"		},
+   { (PROC)glUnlockArraysEXT,			"glUnlockArraysEXT"		}
+};
+
+int qt_ext = sizeof(ext) / sizeof(ext[0]);
+
+struct __pixelformat__	pix[] =
+{
+    {	{	sizeof(PIXELFORMATDESCRIPTOR),	1,
+        PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
+        PFD_TYPE_RGBA,
+        24,	8,	0,	8,	8,	8,	16,	8,	24,
+        0,	0,	0,	0,	0,	16,	8,	0,	0,	0,	0,	0,	0 },
+        GL_TRUE
+    },
+    {	{	sizeof(PIXELFORMATDESCRIPTOR),	1,
+        PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_FORMAT,
+        PFD_TYPE_RGBA,
+        24,	8,	0,	8,	8,	8,	16,	8,	24,
+        0,	0,	0,	0,	0,	16,	8,	0,	0,	0,	0,	0,	0 },
+        GL_FALSE
+    },
+};
+
+int				qt_pix = sizeof(pix) / sizeof(pix[0]);
+
+typedef struct {
+    WMesaContext ctx;
+    HDC hdc;
+} MesaWglCtx;
+
+#define MESAWGL_CTX_MAX_COUNT 20
+
+static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];
+
+static unsigned ctx_count = 0;
+static unsigned ctx_current = -1;
+static unsigned curPFD = 0;
+
+WGLAPI BOOL GLAPIENTRY wglCopyContext(HGLRC hglrcSrc,HGLRC hglrcDst,UINT mask)
+{
+    return(FALSE);
+}
+
+WGLAPI HGLRC GLAPIENTRY wglCreateContext(HDC hdc)
+{
+    HWND		hWnd;
+    int i = 0;
+    if(!(hWnd = WindowFromDC(hdc)))
+    {
+        SetLastError(0);
+        return(NULL);
+    }
+    if (!ctx_count)
+    {
+    	for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++)
+    	{
+    		wgl_ctx[i].ctx = NULL;
+    		wgl_ctx[i].hdc = NULL;
+    	}
+    }
+    for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
+    {
+        if ( wgl_ctx[i].ctx == NULL )
+        {
+            wgl_ctx[i].ctx = WMesaCreateContext( hWnd, NULL, GL_TRUE,
+                pix[curPFD-1].doubleBuffered );
+            if (wgl_ctx[i].ctx == NULL)
+                break;
+            wgl_ctx[i].hdc = hdc;
+            ctx_count++;
+            return ((HGLRC)wgl_ctx[i].ctx);
+        }
+    }
+    SetLastError(0);
+    return(NULL);
+}
+
+WGLAPI BOOL GLAPIENTRY wglDeleteContext(HGLRC hglrc)
+{
+    int i;
+    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
+    {
+    	if ( wgl_ctx[i].ctx == (PWMC) hglrc )
+    	{
+            WMesaMakeCurrent((PWMC) hglrc);
+            WMesaDestroyContext();
+            wgl_ctx[i].ctx = NULL;
+            wgl_ctx[i].hdc = NULL;
+            ctx_count--;
+            return(TRUE);
+    	}
+    }
+    SetLastError(0);
+    return(FALSE);
+}
+
+WGLAPI HGLRC GLAPIENTRY wglCreateLayerContext(HDC hdc,int iLayerPlane)
+{
+    SetLastError(0);
+    return(NULL);
+}
+
+WGLAPI HGLRC GLAPIENTRY wglGetCurrentContext(VOID)
+{
+   if (ctx_current < 0)
+      return 0;
+   else
+      return (HGLRC) wgl_ctx[ctx_current].ctx;
+}
+
+WGLAPI HDC GLAPIENTRY wglGetCurrentDC(VOID)
+{
+   if (ctx_current < 0)
+      return 0;
+   else
+      return wgl_ctx[ctx_current].hdc;
+}
+
+WGLAPI BOOL GLAPIENTRY wglMakeCurrent(HDC hdc,HGLRC hglrc)
+{
+    int i;
+
+    /* new code suggested by Andy Sy */
+    if (!hdc || !hglrc) {
+       WMesaMakeCurrent(NULL);
+       ctx_current = -1;
+       return TRUE;
+    }
+
+    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ )
+    {
+        if ( wgl_ctx[i].ctx == (PWMC) hglrc )
+        {
+            wgl_ctx[i].hdc = hdc;
+            WMesaMakeCurrent( (WMesaContext) hglrc );
+            ctx_current = i;
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+WGLAPI BOOL GLAPIENTRY wglShareLists(HGLRC hglrc1,HGLRC hglrc2)
+{
+    return(TRUE);
+}
+
+
+static FIXED FixedFromDouble(double d)
+{
+   long l = (long) (d * 65536L);
+   return *(FIXED *)&l;
+}
+
+
+/*
+** This is cribbed from FX/fxwgl.c, and seems to implement support
+** for bitmap fonts where the wglUseFontBitmapsA() code implements
+** support for outline fonts.  In combination they hopefully give
+** fairly generic support for fonts.
+*/
+static BOOL wglUseFontBitmaps_FX(HDC fontDevice, DWORD firstChar,
+                                 DWORD numChars, DWORD listBase)
+{
+#define VERIFY(a) a
+
+  TEXTMETRIC metric;
+  BITMAPINFO *dibInfo;
+  HDC bitDevice;
+  COLORREF tempColor;
+  int i;
+
+  VERIFY(GetTextMetrics(fontDevice, &metric));
+
+  dibInfo = (BITMAPINFO *) calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);
+  dibInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+  dibInfo->bmiHeader.biPlanes = 1;
+  dibInfo->bmiHeader.biBitCount = 1;
+  dibInfo->bmiHeader.biCompression = BI_RGB;
+
+  bitDevice = CreateCompatibleDC(fontDevice);
+  // HDC bitDevice = CreateDC("DISPLAY", NULL, NULL, NULL);
+  // VERIFY(bitDevice);
+
+  // Swap fore and back colors so the bitmap has the right polarity
+  tempColor = GetBkColor(bitDevice);
+  SetBkColor(bitDevice, GetTextColor(bitDevice));
+  SetTextColor(bitDevice, tempColor);
+
+  // Place chars based on base line
+  VERIFY(SetTextAlign(bitDevice, TA_BASELINE) >= 0 ? 1 : 0);
+
+  for(i = 0; i < numChars; i++) {
+    SIZE size;
+    char curChar;
+    int charWidth,charHeight,bmapWidth,bmapHeight,numBytes,res;
+    HBITMAP bitObject;
+    HGDIOBJ origBmap;
+    unsigned char *bmap;
+
+    curChar = i + firstChar;
+
+    // Find how high/wide this character is
+    VERIFY(GetTextExtentPoint32(bitDevice, &curChar, 1, &size));
+
+    // Create the output bitmap
+    charWidth = size.cx;
+    charHeight = size.cy;
+    bmapWidth = ((charWidth + 31) / 32) * 32;   // Round up to the next multiple of 32 bits
+    bmapHeight = charHeight;
+    bitObject = CreateCompatibleBitmap(bitDevice,
+                                       bmapWidth,
+                                       bmapHeight);
+    //VERIFY(bitObject);
+
+    // Assign the output bitmap to the device
+    origBmap = SelectObject(bitDevice, bitObject);
+    VERIFY(origBmap);
+
+    VERIFY( PatBlt( bitDevice, 0, 0, bmapWidth, bmapHeight,BLACKNESS ) );
+
+    // Use our source font on the device
+    VERIFY(SelectObject(bitDevice, GetCurrentObject(fontDevice,OBJ_FONT)));
+
+    // Draw the character
+    VERIFY(TextOut(bitDevice, 0, metric.tmAscent, &curChar, 1));
+
+    // Unselect our bmap object
+    VERIFY(SelectObject(bitDevice, origBmap));
+
+    // Convert the display dependant representation to a 1 bit deep DIB
+    numBytes = (bmapWidth * bmapHeight) / 8;
+    bmap = malloc(numBytes);
+    dibInfo->bmiHeader.biWidth = bmapWidth;
+    dibInfo->bmiHeader.biHeight = bmapHeight;
+    res = GetDIBits(bitDevice, bitObject, 0, bmapHeight, bmap,
+                    dibInfo,
+                    DIB_RGB_COLORS);
+    //VERIFY(res);
+
+    // Create the GL object
+    glNewList(i + listBase, GL_COMPILE);
+    glBitmap(bmapWidth, bmapHeight, 0.0, metric.tmDescent,
+             charWidth, 0.0,
+             bmap);
+    glEndList();
+    // CheckGL();
+
+    // Destroy the bmap object
+    DeleteObject(bitObject);
+
+    // Deallocate the bitmap data
+    free(bmap);
+  }
+
+  // Destroy the DC
+  VERIFY(DeleteDC(bitDevice));
+
+  free(dibInfo);
+
+  return TRUE;
+#undef VERIFY
+}
+
+WGLAPI BOOL GLAPIENTRY wglUseFontBitmapsA(HDC hdc, DWORD first,
+                                       DWORD count, DWORD listBase)
+{
+   int i;
+   GLuint font_list;
+   DWORD size;
+   GLYPHMETRICS gm;
+   HANDLE hBits;
+   LPSTR lpBits;
+   MAT2 mat;
+   int  success = TRUE;
+
+   if (first<0)
+      return FALSE;
+   if (count<0)
+      return FALSE;
+   if (listBase<0)
+      return FALSE;
+
+   font_list = listBase;
+
+   mat.eM11 = FixedFromDouble(1);
+   mat.eM12 = FixedFromDouble(0);
+   mat.eM21 = FixedFromDouble(0);
+   mat.eM22 = FixedFromDouble(-1);
+
+   memset(&gm,0,sizeof(gm));
+
+   /*
+   ** If we can't get the glyph outline, it may be because this is a fixed
+   ** font.  Try processing it that way.
+   */
+   if( GetGlyphOutline(hdc, first, GGO_BITMAP, &gm, 0, NULL, &mat)
+       == GDI_ERROR )
+   {
+       return wglUseFontBitmaps_FX( hdc, first, count, listBase );
+   }
+
+   /*
+   ** Otherwise process all desired characters.
+   */
+   for (i = 0; i < count; i++)
+   {
+       DWORD err;
+       
+      glNewList( font_list+i, GL_COMPILE );
+
+      /* allocate space for the bitmap/outline */
+      size = GetGlyphOutline(hdc, first + i, GGO_BITMAP, &gm, 0, NULL, &mat);
+      if (size == GDI_ERROR)
+      {
+         glEndList( );
+         err = GetLastError();
+         success = FALSE;
+         continue;
+      }
+
+      hBits  = GlobalAlloc(GHND, size+1);
+      lpBits = GlobalLock(hBits);
+
+      err = 
+      GetGlyphOutline(hdc,    /* handle to device context */
+                      first + i,          /* character to query */
+                      GGO_BITMAP,         /* format of data to return */
+                      &gm,                /* pointer to structure for metrics*/
+                      size,               /* size of buffer for data */
+                      lpBits,             /* pointer to buffer for data */
+                      &mat                /* pointer to transformation */
+                                          /* matrix structure */
+                  );
+
+      if (err == GDI_ERROR)
+      {
+         GlobalUnlock(hBits);
+         GlobalFree(hBits);
+         
+         glEndList( );
+         err = GetLastError();
+         success = FALSE;
+         continue;
+      }
+
+      glBitmap(gm.gmBlackBoxX,gm.gmBlackBoxY,
+               -gm.gmptGlyphOrigin.x,
+               gm.gmptGlyphOrigin.y,
+               gm.gmCellIncX,gm.gmCellIncY,
+               (const GLubyte * )lpBits);
+
+      GlobalUnlock(hBits);
+      GlobalFree(hBits);
+
+      glEndList( );
+   }
+
+   return success;
+}
+
+
+WGLAPI BOOL GLAPIENTRY wglUseFontBitmapsW(HDC hdc,DWORD first,DWORD count,DWORD listBase)
+{
+    return FALSE;
+}
+
+WGLAPI BOOL GLAPIENTRY wglUseFontOutlinesA(HDC hdc,DWORD first,DWORD count,
+                                  DWORD listBase,FLOAT deviation,
+                                  FLOAT extrusion,int format,
+                                  LPGLYPHMETRICSFLOAT lpgmf)
+{
+    SetLastError(0);
+    return(FALSE);
+}
+
+WGLAPI BOOL GLAPIENTRY wglUseFontOutlinesW(HDC hdc,DWORD first,DWORD count,
+                                  DWORD listBase,FLOAT deviation,
+                                  FLOAT extrusion,int format,
+                                  LPGLYPHMETRICSFLOAT lpgmf)
+{
+    SetLastError(0);
+    return(FALSE);
+}
+
+WGLAPI BOOL GLAPIENTRY wglDescribeLayerPlane(HDC hdc,int iPixelFormat,
+                                    int iLayerPlane,UINT nBytes,
+                                    LPLAYERPLANEDESCRIPTOR plpd)
+{
+    SetLastError(0);
+    return(FALSE);
+}
+
+WGLAPI int GLAPIENTRY wglSetLayerPaletteEntries(HDC hdc,int iLayerPlane,
+                                       int iStart,int cEntries,
+                                       CONST COLORREF *pcr)
+{
+    SetLastError(0);
+    return(0);
+}
+
+WGLAPI int GLAPIENTRY wglGetLayerPaletteEntries(HDC hdc,int iLayerPlane,
+                                       int iStart,int cEntries,
+                                       COLORREF *pcr)
+{
+    SetLastError(0);
+    return(0);
+}
+
+WGLAPI BOOL GLAPIENTRY wglRealizeLayerPalette(HDC hdc,int iLayerPlane,BOOL bRealize)
+{
+    SetLastError(0);
+    return(FALSE);
+}
+
+WGLAPI BOOL GLAPIENTRY wglSwapLayerBuffers(HDC hdc,UINT fuPlanes)
+{
+    if( !hdc )
+    {
+        WMesaSwapBuffers();
+        return(TRUE);
+    }
+    SetLastError(0);
+    return(FALSE);
+}
+
+WGLAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc,
+                                  CONST PIXELFORMATDESCRIPTOR *ppfd)
+{
+    int		i,best = -1,bestdelta = 0x7FFFFFFF,delta,qt_valid_pix;
+
+    qt_valid_pix = qt_pix;
+    if(ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR) || ppfd->nVersion != 1)
+    {
+        SetLastError(0);
+        return(0);
+    }
+    for(i = 0;i < qt_valid_pix;i++)
+    {
+        delta = 0;
+        if(
+            (ppfd->dwFlags & PFD_DRAW_TO_WINDOW) &&
+            !(pix[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW))
+            continue;
+        if(
+            (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) &&
+            !(pix[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP))
+            continue;
+        if(
+            (ppfd->dwFlags & PFD_SUPPORT_GDI) &&
+            !(pix[i].pfd.dwFlags & PFD_SUPPORT_GDI))
+            continue;
+        if(
+            (ppfd->dwFlags & PFD_SUPPORT_OPENGL) &&
+            !(pix[i].pfd.dwFlags & PFD_SUPPORT_OPENGL))
+            continue;
+        if(
+            !(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&
+            ((ppfd->dwFlags & PFD_DOUBLEBUFFER) != (pix[i].pfd.dwFlags & PFD_DOUBLEBUFFER)))
+            continue;
+        if(
+            !(ppfd->dwFlags & PFD_STEREO_DONTCARE) &&
+            ((ppfd->dwFlags & PFD_STEREO) != (pix[i].pfd.dwFlags & PFD_STEREO)))
+            continue;
+        if(ppfd->iPixelType != pix[i].pfd.iPixelType)
+            delta++;
+        if(delta < bestdelta)
+        {
+            best = i + 1;
+            bestdelta = delta;
+            if(bestdelta == 0)
+                break;
+        }
+    }
+    if(best == -1)
+    {
+        SetLastError(0);
+        return(0);
+    }
+    return(best);
+}
+
+WGLAPI int GLAPIENTRY wglDescribePixelFormat(HDC hdc,int iPixelFormat,UINT nBytes,
+                                    LPPIXELFORMATDESCRIPTOR ppfd)
+{
+    int		qt_valid_pix;
+
+    qt_valid_pix = qt_pix;
+    if(iPixelFormat < 1 || iPixelFormat > qt_valid_pix || nBytes != sizeof(PIXELFORMATDESCRIPTOR))
+    {
+        SetLastError(0);
+        return(0);
+    }
+    *ppfd = pix[iPixelFormat - 1].pfd;
+    return(qt_valid_pix);
+}
+
+/*
+* GetProcAddress - return the address of an appropriate extension
+*/
+WGLAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc)
+{
+    int		i;
+    for(i = 0;i < qt_ext;i++)
+        if(!strcmp(lpszProc,ext[i].name))
+            return(ext[i].proc);
+
+        SetLastError(0);
+        return(NULL);
+}
+
+WGLAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc)
+{
+    if(curPFD == 0)
+    {
+        SetLastError(0);
+        return(0);
+    }
+    return(curPFD);
+}
+
+WGLAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc,int iPixelFormat,
+                                PIXELFORMATDESCRIPTOR *ppfd)
+{
+    int		qt_valid_pix;
+
+    qt_valid_pix = qt_pix;
+    if(iPixelFormat < 1 || iPixelFormat > qt_valid_pix || ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR))
+    {
+        SetLastError(0);
+        return(FALSE);
+    }
+    curPFD = iPixelFormat;
+    return(TRUE);
+}
+
+WGLAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc)
+{
+   if (ctx_current < 0)
+      return FALSE;
+
+   if(wgl_ctx[ctx_current].ctx == NULL) {
+      SetLastError(0);
+      return(FALSE);
+   }
+   WMesaSwapBuffers();
+   return(TRUE);
+}
+
+#endif /* WIN32 */
diff --git a/src/mesa/drivers/windows/wmesa.c b/src/mesa/drivers/windows/wmesa.c
index 7eb13cab098..38174a2e9ff 100644
--- a/src/mesa/drivers/windows/wmesa.c
+++ b/src/mesa/drivers/windows/wmesa.c
@@ -1,2971 +1,2971 @@
-/* $Id: wmesa.c,v 1.18 2001/09/14 22:19:19 brianp Exp $ */

-

-/*

- * Windows (Win32) device driver for Mesa 3.4

- *

- * Original author:

- *

- *  Copyright (C) 1996-  Li Wei

- *  Address      :       Institute of Artificial Intelligence

- *               :           & Robotics

- *               :       Xi'an Jiaotong University

- *  Email        :       [email protected]

- *  Web page :       http://sun.aiar.xjtu.edu.cn

- *

- *  This file and its associations are partially borrowed from the

- *  Windows NT driver for Mesa 1.8 , written by Mark Leaming

- *  ([email protected]).

- */

-

-

-#define WMESA_STEREO_C

-

-#include <windows.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <GL/wmesa.h>

-#include "mesa_extend.h"

-#include "colors.h"

-#include "macros.h"

-#include "context.h"

-#include "dd.h"

-//#include "xform.h"

-//#include "vb.h"

-#include "matrix.h"

-#include "depth.h"

-#include "wmesadef.h"

-

-#pragma warning ( disable : 4100 4133 4761 )

-

-#ifdef PROFILE

-//  #include "profile.h"

-#endif

-

-#ifdef DITHER

-#include <wing.h>

-#endif

-

-#ifdef __CYGWIN32__

-#include "macros.h"

-#include <string.h>

-#define CopyMemory memcpy

-#endif

-

-#if !defined(NO_STEREO)

-

-#include "gl\glu.h"

-#include "stereo.h"

-

-#endif

-#if !defined(NO_PARALLEL)

-  #include "parallel.h"

-#endif

-

-struct DISPLAY_OPTIONS displayOptions;

-

-GLenum stereoCompile = GL_FALSE ;

-GLenum stereoShowing  = GL_FALSE ;

-GLenum stereoBuffer = GL_FALSE;

-#if !defined(NO_STEREO)

-GLint displayList = MAXIMUM_DISPLAY_LIST ;

-#endif

-GLint stereo_flag = 0 ;

-

-/* end of added code*/

-

-static PWMC Current = NULL;

-WMesaContext WC = NULL;

-

-#ifdef NDEBUG

-#define assert(ignore)  ((void) 0)

-#else

-void Mesa_Assert(void *Cond,void *File,unsigned Line)

-{

-    char Msg[512];

-    sprintf(Msg,"%s %s %d",Cond,File,Line);

-    MessageBox(NULL,Msg,"Assertion failed.",MB_OK);

-    exit(1);

-}

-#define assert(e)   if (!e) Mesa_Assert(#e,__FILE__,__LINE__);

-#endif

-

-//#define DD_GETDC (Current->hDC )

-#define DD_GETDC ((Current->db_flag) ? Current->dib.hDC : Current->hDC )

-//#define DD_GETDC ((Current->db_flag) ? Current->hDCPrimary : Current->hDCBack )

-#define DD_RELEASEDC

-

-//#define BEGINGDICALL  if(Current->rgb_flag)wmFlushBits(Current);

-#define BEGINGDICALL

-//#define ENDGDICALL        if(Current->rgb_flag)wmGetBits(Current);

-#define ENDGDICALL

-

-//#define FLIP(Y)  (Current->dither_flag? Y : Current->height-(Y)-1)

-//#define FLIP(Y)  (Current->height-(Y)-1)

-//#define FLIP(Y) Y

-/*

- * XXX Why only flip Y coord if single buffered???

- */

-#define FLIP(Y)  (Current->db_flag? Y: Current->height-(Y)-1)

-#define STARTPROFILE

-#define ENDPROFILE(PARA)

-

-#define DITHER_RGB_TO_8BIT_SETUP            \

-GLubyte pixelDithered;

-

-#define DITHER_RGB_TO_8BIT(red, green, blue, pixel, scanline)               \

-{                                                                           \

-    char unsigned redtemp, greentemp, bluetemp, paletteindex;               \

-    redtemp = aDividedBy51[red]                                             \

-    + (aModulo51[red] > aHalftone8x8[(pixel%8)*8                        \

-    + scanline%8]);                                                 \

-    greentemp = aDividedBy51[(char unsigned)green]                          \

-    + (aModulo51[green] > aHalftone8x8[                             \

-    (pixel%8)*8 + scanline%8]);                                     \

-    bluetemp = aDividedBy51[(char unsigned)blue]                            \

-    + (aModulo51[blue] > aHalftone8x8[                              \

-    (pixel%8)*8 +scanline%8]);                                      \

-    paletteindex = redtemp + aTimes6[greentemp] + aTimes36[bluetemp];       \

-    pixelDithered = aWinGHalftoneTranslation[paletteindex];                 \

-}

-

-

-#ifdef DDRAW

-static BOOL DDInit( WMesaContext wc, HWND hwnd);

-static void DDFree( WMesaContext wc);

-static HRESULT DDRestoreAll( WMesaContext wc );

-static void DDDeleteOffScreen(WMesaContext wc);

-static BOOL DDCreateOffScreen(WMesaContext wc);

-#endif

-

-static void FlushToFile(PWMC pwc, PSTR  szFile);

-

-BOOL wmCreateBackingStore(PWMC pwc, long lxSize, long lySize);

-BOOL wmDeleteBackingStore(PWMC pwc);

-void wmCreatePalette( PWMC pwdc );

-BOOL wmSetDibColors(PWMC pwc);

-void wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);

-

-void wmCreateDIBSection(

-                        HDC  hDC,

-                        PWMC pwc,   // handle of device context

-                        CONST BITMAPINFO *pbmi, // address of structure containing bitmap size, format, and color data

-                        UINT iUsage // color data type indicator: RGB values or palette indices

-                        );

-

-

-void WMesaViewport( GLcontext *ctx,

-                    GLint x, GLint y, GLsizei width, GLsizei height );

-

-

-//static triangle_func choose_triangle_function( GLcontext *ctx );

-

-

-static void wmSetPixelFormat( PWMC wc, HDC hDC)

-{

-    if(wc->rgb_flag)

-        wc->cColorBits = GetDeviceCaps(hDC, BITSPIXEL);

-    else

-        wc->cColorBits = 8;

-    switch(wc->cColorBits){

-    case 8:

-        if(wc->dither_flag != GL_TRUE)

-            wc->pixelformat = PF_INDEX8;

-        else

-            wc->pixelformat = PF_DITHER8;

-        break;

-    case 16:

-        wc->pixelformat = PF_5R6G5B;

-        break;

-    case 32:

-        wc->pixelformat = PF_8R8G8B;

-        break;

-    default:

-        wc->pixelformat = PF_BADFORMAT;

-    }

-}

-

-//

-// This function sets the color table of a DIB section

-// to match that of the destination DC

-//

-BOOL /*WINAPI*/ wmSetDibColors(PWMC pwc)

-{

-    RGBQUAD         *pColTab, *pRGB;

-    PALETTEENTRY    *pPal, *pPE;

-    int             i, nColors;

-    BOOL            bRet=TRUE;

-    DWORD           dwErr=0;

-

-    /* Build a color table in the DIB that maps to the

-    selected palette in the DC.

-    */

-    nColors = 1 << pwc->cColorBits;

-    pPal = (PALETTEENTRY *)malloc( nColors * sizeof(PALETTEENTRY));

-    memset( pPal, 0, nColors * sizeof(PALETTEENTRY) );

-    GetPaletteEntries( pwc->hGLPalette, 0, nColors, pPal );

-    pColTab = (RGBQUAD *)malloc( nColors * sizeof(RGBQUAD));

-    for (i = 0, pRGB = pColTab, pPE = pPal; i < nColors; i++, pRGB++, pPE++) {

-        pRGB->rgbRed = pPE->peRed;

-        pRGB->rgbGreen = pPE->peGreen;

-        pRGB->rgbBlue = pPE->peBlue;

-    }

-    if(pwc->db_flag)

-        bRet = SetDIBColorTable(pwc->dib.hDC, 0, nColors, pColTab );

-

-    if(!bRet)

-        dwErr = GetLastError();

-

-    free( pColTab );

-    free( pPal );

-

-    return(bRet);

-}

-

-

-//

-// Free up the dib section that was created

-//

-BOOL wmDeleteBackingStore(PWMC pwc)

-{

-    SelectObject(pwc->dib.hDC, pwc->hOldBitmap);

-    DeleteDC(pwc->dib.hDC);

-    DeleteObject(pwc->hbmDIB);

-    UnmapViewOfFile(pwc->dib.base);

-    CloseHandle(pwc->dib.hFileMap);

-    return TRUE;

-}

-

-

-//

-// This function creates the DIB section that is used for combined

-// GL and GDI calls

-//

-BOOL /*WINAPI*/ wmCreateBackingStore(PWMC pwc, long lxSize, long lySize)

-{

-    HDC hdc = pwc->hDC;

-    LPBITMAPINFO pbmi = &(pwc->bmi);

-    int     iUsage;

-

-    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

-    pbmi->bmiHeader.biWidth = lxSize;

-    pbmi->bmiHeader.biHeight= -lySize;

-    pbmi->bmiHeader.biPlanes = 1;

-    if(pwc->rgb_flag)

-        pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwc->hDC, BITSPIXEL);

-    else

-        pbmi->bmiHeader.biBitCount = 8;

-    pbmi->bmiHeader.biCompression = BI_RGB;

-    pbmi->bmiHeader.biSizeImage = 0;

-    pbmi->bmiHeader.biXPelsPerMeter = 0;

-    pbmi->bmiHeader.biYPelsPerMeter = 0;

-    pbmi->bmiHeader.biClrUsed = 0;

-    pbmi->bmiHeader.biClrImportant = 0;

-

-    iUsage = (pbmi->bmiHeader.biBitCount <= 8) ? DIB_PAL_COLORS : DIB_RGB_COLORS;

-

-    pwc->cColorBits = pbmi->bmiHeader.biBitCount;

-    pwc->ScanWidth = pwc->pitch = lxSize;

-

-    wmCreateDIBSection(hdc, pwc, pbmi, iUsage);

-

-    if ((iUsage == DIB_PAL_COLORS) && !(pwc->hGLPalette)) {

-        wmCreatePalette( pwc );

-        wmSetDibColors( pwc );

-    }

-    wmSetPixelFormat(pwc, pwc->hDC);

-    return(TRUE);

-

-}

-

-

-//

-// This function copies one scan line in a DIB section to another

-//

-BOOL WINAPI wmSetDIBits(PWMC pwc, UINT uiScanWidth, UINT uiNumScans, UINT nBypp, UINT uiNewWidth, LPBYTE pBits)

-{

-    UINT uiScans = 0;

-    LPBYTE  pDest = pwc->pbPixels;

-    DWORD   dwNextScan = uiScanWidth;

-    DWORD   dwNewScan = uiNewWidth;

-    DWORD   dwScanWidth = (uiScanWidth * nBypp);

-

-    //

-    // We need to round up to the nearest DWORD

-    // and multiply by the number of bytes per

-    // pixel

-    //

-    dwNextScan = (((dwNextScan * nBypp)+ 3) & ~3);

-    dwNewScan = (((dwNewScan * nBypp)+ 3) & ~3);

-

-    for(uiScans = 0; uiScans < uiNumScans; uiScans++){

-        CopyMemory(pDest, pBits, dwScanWidth);

-        pBits += dwNextScan;

-        pDest += dwNewScan;

-    }

-

-    return(TRUE);

-

-}

-

-

-BOOL wmFlush(PWMC pwc);

-

-/*

-* Useful macros:

-Modified from file osmesa.c

-*/

-

-

-#define PIXELADDR(X,Y)  ((GLubyte *)Current->pbPixels + (Current->height-Y-1)* Current->ScanWidth + (X)*nBypp)

-#define PIXELADDR1( X, Y )  \

-((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X))

-#define PIXELADDR2( X, Y )  \

-((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X)*2)

-#define PIXELADDR4( X, Y )  \

-((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X)*4)

-

-

-BYTE DITHER_RGB_2_8BIT( int r, int g, int b, int x, int y);

-

-/* Finish all pending operations and synchronize. */

-static void finish(GLcontext* ctx)

-{

-    /* No op */

-}

-

-

-//

-// We cache all gl draw routines until a flush is made

-//

-static void flush(GLcontext* ctx)

-{

-    STARTPROFILE

-        if((Current->rgb_flag /*&& !(Current->dib.fFlushed)*/&&!(Current->db_flag))

-            ||(!Current->rgb_flag))

-        {

-            wmFlush(Current);

-        }

-        ENDPROFILE(flush)

-

-}

-

-

-

-/*

-* Set the color index used to clear the color buffer.

-*/

-static void clear_index(GLcontext* ctx, GLuint index)

-{

-    STARTPROFILE

-        Current->clearpixel = index;

-    ENDPROFILE(clear_index)

-}

-

-

-

-/*

-* Set the color used to clear the color buffer.

-*/

-static void clear_color( GLcontext* ctx, const GLchan color[4] )

-{

-    STARTPROFILE

-        Current->clearpixel = RGB(color[0], color[1], color[2]);

-    ENDPROFILE(clear_color)

-}

-

-

-

-/*

-* Clear the specified region of the color buffer using the clear color

-* or index as specified by one of the two functions above.

-*/

-//static void clear(GLcontext* ctx,

-//                  GLboolean all,GLint x, GLint y, GLint width, GLint height )

-// TODO: I modified this function to match the prototype in

-//       dd.h. ([email protected])

-

-static GLbitfield clear(GLcontext* ctx, GLbitfield mask,

-                  GLboolean all, GLint x, GLint y, GLint width, GLint height)

-{

-    DWORD   dwColor;

-    WORD    wColor;

-    BYTE    bColor;

-    LPDWORD lpdw = (LPDWORD)Current->pbPixels;

-    LPWORD  lpw = (LPWORD)Current->pbPixels;

-    LPBYTE  lpb = Current->pbPixels;

-    int     lines;

-

-    STARTPROFILE

-

-        if (all){

-            x=y=0;

-            width=Current->width;

-            height=Current->height;

-        }

-        if(Current->db_flag==GL_TRUE){

-            UINT    nBypp = Current->cColorBits / 8;

-            int     i = 0;

-            int     iSize = 0;

-

-            if(nBypp ==1 ){

-                /* Need rectification */

-                iSize = Current->width/4;

-                bColor  = BGR8(GetRValue(Current->clearpixel),

-                    GetGValue(Current->clearpixel),

-                    GetBValue(Current->clearpixel));

-                wColor  = MAKEWORD(bColor,bColor);

-                dwColor = MAKELONG(wColor, wColor);

-            }

-            if(nBypp == 2){

-                iSize = Current->width / 2;

-                wColor = BGR16(GetRValue(Current->clearpixel),

-                    GetGValue(Current->clearpixel),

-                    GetBValue(Current->clearpixel));

-                dwColor = MAKELONG(wColor, wColor);

-            }

-            else if(nBypp == 4){

-                iSize = Current->width;

-                dwColor = BGR32(GetRValue(Current->clearpixel),

-                    GetGValue(Current->clearpixel),

-                    GetBValue(Current->clearpixel));

-            }

-

-            while(i < iSize){

-                *lpdw = dwColor;

-                lpdw++;

-                i++;

-            }

-

-            //

-            // This is the 24bit case

-            //

-            if (nBypp == 3) {

-                iSize = Current->width *3/4;

-                dwColor = BGR24(GetRValue(Current->clearpixel),

-                    GetGValue(Current->clearpixel),

-                    GetBValue(Current->clearpixel));

-                while(i < iSize){

-                    *lpdw = dwColor;

-                    lpb += nBypp;

-                    lpdw = (LPDWORD)lpb;

-                    i++;

-                }

-            }

-

-            i = 0;

-            if (stereo_flag)

-               lines = height /2;

-            else

-               lines = height;

-            do {

-                memcpy(lpb, Current->pbPixels, iSize*4);

-                lpb += Current->ScanWidth;

-                i++;

-            }

-            while (i<lines-1);

-        }

-        else { // For single buffer

-            HDC DC=DD_GETDC;

-            HPEN Pen=CreatePen(PS_SOLID,1,Current->clearpixel);

-            HBRUSH Brush=CreateSolidBrush(Current->clearpixel);

-            HPEN Old_Pen=SelectObject(DC,Pen);

-            HBRUSH Old_Brush=SelectObject(DC,Brush);

-            Rectangle(DC,x,y,x+width,y+height);

-            SelectObject(DC,Old_Pen);

-            SelectObject(DC,Old_Brush);

-            DeleteObject(Pen);

-            DeleteObject(Brush);

-            DD_RELEASEDC;

-        }

-

-

-

-        ENDPROFILE(clear)

-

-		return mask;	// TODO: I doubt this is correct. dd.h doesn't explain what this should

-		                //       be...

-}

-

-

-

-static void enable( GLcontext* ctx, GLenum pname, GLboolean enable )

-{

-   if (!Current)

-      return;

-

-   if (pname == GL_DITHER) {

-      if(enable == GL_FALSE){

-         Current->dither_flag = GL_FALSE;

-         if(Current->cColorBits == 8)

-            Current->pixelformat = PF_INDEX8;

-      }

-      else{

-         if (Current->rgb_flag && Current->cColorBits == 8){

-            Current->pixelformat = PF_DITHER8;

-            Current->dither_flag = GL_TRUE;

-         }

-         else

-            Current->dither_flag = GL_FALSE;

-      }

-   }

-}

-

-

-

-static GLboolean set_draw_buffer( GLcontext* ctx, GLenum mode )

-{

-   STARTPROFILE

-   /* TODO: this could be better */

-   if (mode==GL_FRONT_LEFT || mode==GL_BACK_LEFT) {

-      return GL_TRUE;

-   }

-   else {

-      return GL_FALSE;

-   }

-   ENDPROFILE(set_draw_buffer)

-}

-

-

-static void set_read_buffer(GLcontext *ctx, GLframebuffer *colorBuffer,

-                            GLenum buffer )

-{

-   /* XXX todo */

-   return;

-}

-

-

-

-/* Return characteristics of the output buffer. */

-static void buffer_size( GLcontext* ctx, GLuint *width, GLuint *height )

-{

-   int New_Size;

-   RECT CR;

-

-   STARTPROFILE

-   GetClientRect(Current->Window,&CR);

-

-   *width=CR.right;

-   *height=CR.bottom;

-

-   New_Size=((*width)!=Current->width) || ((*height)!=Current->height);

-

-   if (New_Size){

-      Current->width=*width;

-      Current->height=*height;

-      Current->ScanWidth=Current->width;

-      if ((Current->ScanWidth%sizeof(long))!=0)

-         Current->ScanWidth+=(sizeof(long)-(Current->ScanWidth%sizeof(long)));

-

-      if (Current->db_flag){

-#ifdef DDRAW

-         DDDeleteOffScreen(Current);

-         DDCreateOffScreen(Current);

-#else

-         if (Current->rgb_flag==GL_TRUE && Current->dither_flag!=GL_TRUE){

-            wmDeleteBackingStore(Current);

-            wmCreateBackingStore(Current, Current->width, Current->height);

-         }

-#endif

-      }

-

-      //  Resize OsmesaBuffer if in Parallel mode

-#if !defined(NO_PARALLEL)

-      if(parallelFlag)

-         PRSizeRenderBuffer(Current->width, Current->height,Current->ScanWidth,

-                            Current->rgb_flag == GL_TRUE ? Current->pbPixels: Current->ScreenMem);

-#endif

-   }

-   ENDPROFILE(buffer_size)

-}

-

-

-

-/**********************************************************************/

-/*****           Accelerated point, line, polygon rendering       *****/

-/**********************************************************************/

-

-

-static void fast_rgb_points( GLcontext* ctx, GLuint first, GLuint last )

-{

-#if 0

-    GLuint i;

-    //  HDC DC=DD_GETDC;

-    PWMC    pwc = Current;

-

-    STARTPROFILE

-

-        if (0 /*Current->gl_ctx->VB->MonoColor*/) {

-            /* all drawn with current color */

-            for (i=first;i<=last;i++) {

-                if (!Current->gl_ctx->VB->ClipMask[i]) {

-                    int x, y;

-                    x =       (GLint) Current->gl_ctx->VB->Win.data[i][0];

-                    y = FLIP( (GLint) Current->gl_ctx->VB->Win.data[i][1] );

-                    wmSetPixel(pwc, y,x,GetRValue(Current->pixel),

-                        GetGValue(Current->pixel), GetBValue(Current->pixel));

-                }

-            }

-        }

-        else {

-            /* draw points of different colors */

-            for (i=first;i<=last;i++) {

-                if (!Current->gl_ctx->VB->ClipMask[i]) {

-                    int x, y;

-                    unsigned long pixel=RGB(Current->gl_ctx->VB->ColorPtr->data[i][0]*255.0,

-                        Current->gl_ctx->VB->ColorPtr->data[i][1]*255.0,

-                        Current->gl_ctx->VB->ColorPtr->data[i][2]*255.0);

-                    x =       (GLint) Current->gl_ctx->VB->Win.data[i][0];

-                    y = FLIP( (GLint) Current->gl_ctx->VB->Win.data[i][1] );

-                    wmSetPixel(pwc, y,x,Current->gl_ctx->VB->ColorPtr->data[i][0]*255.0,

-                        Current->gl_ctx->VB->ColorPtr->data[i][1]*255.0,

-                        Current->gl_ctx->VB->ColorPtr->data[i][2]*255.0);

-                }

-            }

-        }

-        //   DD_RELEASEDC;

-        ENDPROFILE(fast_rgb_points)

-#endif

-}

-

-

-

-/* Return pointer to accerated points function */

-extern /*points_func*/ choose_points_function( GLcontext* ctx )

-{

-#if 0

-    STARTPROFILE

-        if (ctx->Point.Size==1.0 && !ctx->Point.SmoothFlag && ctx->_RasterMask==0

-            && !ctx->Texture._ReallyEnabled  && ctx->Visual->RGBAflag) {

-            ENDPROFILE(choose_points_function)

-                return fast_rgb_points;

-        }

-        else {

-            ENDPROFILE(choose_points_function)

-                return NULL;

-        }

-#endif

-}

-

-

-

-/* Draw a line using the color specified by Current->gl_ctx->VB->ColorPtr->data[pv] */

-static void fast_flat_rgb_line( GLcontext* ctx, GLuint v0, GLuint v1, GLuint pv )

-{

-#if 0

-    STARTPROFILE

-        int x0, y0, x1, y1;

-    unsigned long pixel;

-    HDC DC=DD_GETDC;

-    HPEN Pen;

-    HPEN Old_Pen;

-

-    if (0 /*Current->gl_ctx->VB->MonoColor*/) {

-        pixel = Current->pixel;  /* use current color */

-    }

-    else {

-        pixel = RGB(Current->gl_ctx->VB->ColorPtr->data[pv][0]*255.0, Current->gl_ctx->VB->ColorPtr->data[pv][1]*255.0, Current->gl_ctx->VB->ColorPtr->data[pv][2]*255.0);

-    }

-

-    x0 =       (int) Current->gl_ctx->VB->Win.data[v0][0];

-    y0 = FLIP( (int) Current->gl_ctx->VB->Win.data[v0][1] );

-    x1 =       (int) Current->gl_ctx->VB->Win.data[v1][0];

-    y1 = FLIP( (int) Current->gl_ctx->VB->Win.data[v1][1] );

-

-

-    BEGINGDICALL

-

-    Pen=CreatePen(PS_SOLID,1,pixel);

-    Old_Pen=SelectObject(DC,Pen);

-    MoveToEx(DC,x0,y0,NULL);

-    LineTo(DC,x1,y1);

-    SelectObject(DC,Old_Pen);

-    DeleteObject(Pen);

-    DD_RELEASEDC;

-

-    ENDGDICALL

-

-    ENDPROFILE(fast_flat_rgb_line)

-#endif

-}

-

-

-

-/* Return pointer to accerated line function */

-static /*line_func*/ choose_line_function( GLcontext* ctx )

-{

-#if 0

-    STARTPROFILE

-    if (ctx->Line.Width==1.0 && !ctx->Line.SmoothFlag && !ctx->Line.StippleFlag

-        && ctx->Light.ShadeModel==GL_FLAT && ctx->_RasterMask==0

-        && !ctx->Texture._ReallyEnabled && Current->rgb_flag) {

-       ENDPROFILE(choose_line_function)

-       return fast_flat_rgb_line;

-    }

-    else {

-       ENDPROFILE(choose_line_function)

-       return NULL;

-    }

-#endif

-}

-

-

-/**********************************************************************/

-/*****                 Span-based pixel drawing                   *****/

-/**********************************************************************/

-

-

-/* Write a horizontal span of 32-bit color-index pixels with a boolean mask. */

-static void write_ci32_span( const GLcontext* ctx,

-                             GLuint n, GLint x, GLint y,

-                             const GLuint index[],

-                             const GLubyte mask[] )

-{

-    STARTPROFILE

-    GLuint i;

-    PBYTE Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;

-    assert(Current->rgb_flag==GL_FALSE);

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

-        if (mask[i])

-            Mem[i]=index[i];

-    ENDPROFILE(write_ci32_span)

-}

-

-

-/* Write a horizontal span of 8-bit color-index pixels with a boolean mask. */

-static void write_ci8_span( const GLcontext* ctx,

-                            GLuint n, GLint x, GLint y,

-                            const GLubyte index[],

-                            const GLubyte mask[] )

-{

-    STARTPROFILE

-    GLuint i;

-    PBYTE Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;

-    assert(Current->rgb_flag==GL_FALSE);

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

-        if (mask[i])

-            Mem[i]=index[i];

-    ENDPROFILE(write_ci8_span)

-}

-

-

-

-/*

-* Write a horizontal span of pixels with a boolean mask.  The current

-* color index is used for all pixels.

-*/

-static void write_mono_ci_span(const GLcontext* ctx,

-                               GLuint n,GLint x,GLint y,

-                               GLuint colorIndex, const GLubyte mask[])

-{

-   STARTPROFILE

-   GLuint i;

-   BYTE *Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;

-   assert(Current->rgb_flag==GL_FALSE);

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

-      if (mask[i])

-         Mem[i]=colorIndex;

-   ENDPROFILE(write_mono_ci_span)

-}

-

-/*

- * To improve the performance of this routine, frob the data into an actual

- * scanline and call bitblt on the complete scan line instead of SetPixel.

- */

-

-/* Write a horizontal span of RGBA color pixels with a boolean mask. */

-static void write_rgba_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,

-                             const GLubyte rgba[][4], const GLubyte mask[] )

-{

-    STARTPROFILE

-    PWMC    pwc = Current;

-

-    if (pwc->rgb_flag==GL_TRUE)

-    {

-        GLuint i;

-        HDC DC=DD_GETDC;

-        y=FLIP(y);

-        if (mask) {

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

-                if (mask[i])

-                    wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);

-        }

-        else {

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

-                wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );

-        }

-        DD_RELEASEDC;

-    }

-    else

-    {

-        GLuint i;

-        BYTE *Mem=Current->ScreenMem+y*Current->ScanWidth+x;

-        y = FLIP(y);

-        if (mask) {

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

-                if (mask[i])

-                    Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));

-        }

-        else {

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

-                Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));

-        }

-    }

-    ENDPROFILE(write_rgba_span)

-

-}

-

-/* Write a horizontal span of RGB color pixels with a boolean mask. */

-static void write_rgb_span( const GLcontext* ctx,

-                            GLuint n, GLint x, GLint y,

-                            const GLubyte rgb[][3], const GLubyte mask[] )

-{

-    STARTPROFILE

-    PWMC    pwc = Current;

-

-    if (pwc->rgb_flag==GL_TRUE)

-    {

-        GLuint i;

-        HDC DC=DD_GETDC;

-        y=FLIP(y);

-        if (mask) {

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

-                if (mask[i])

-                    wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);

-        }

-        else {

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

-                wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );

-        }

-        DD_RELEASEDC;

-    }

-    else

-    {

-        GLuint i;

-        BYTE *Mem=Current->ScreenMem+y*Current->ScanWidth+x;

-        y = FLIP(y);

-        if (mask) {

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

-                if (mask[i])

-                    Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));

-        }

-        else {

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

-                Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));

-        }

-    }

-    ENDPROFILE(write_rgb_span)

-

-}

-

-/*

-* Write a horizontal span of pixels with a boolean mask.  The current color

-* is used for all pixels.

-*/

-static void write_mono_rgba_span( const GLcontext* ctx,

-                                  GLuint n, GLint x, GLint y,

-                                  const GLchan color[4], const GLubyte mask[])

-{

-    ULONG pixel =  RGB( color[RCOMP], color[GCOMP], color[BCOMP] );

-    STARTPROFILE

-    GLuint i;

-    HDC DC=DD_GETDC;

-    PWMC pwc = Current;

-    assert(Current->rgb_flag==GL_TRUE);

-    y=FLIP(y);

-    if(Current->rgb_flag==GL_TRUE){

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

-            if (mask[i])

-                // Trying

-                wmSetPixel(pwc,y,x+i,color[RCOMP], color[GCOMP], color[BCOMP]);

-    }

-    else {

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

-            if (mask[i])

-                SetPixel(DC, y, x+i, pixel);

-    }

-    DD_RELEASEDC;

-    ENDPROFILE(write_mono_rgba_span)

-}

-

-

-

-/**********************************************************************/

-/*****                   Array-based pixel drawing                *****/

-/**********************************************************************/

-

-

-/* Write an array of 32-bit index pixels with a boolean mask. */

-static void write_ci32_pixels( const GLcontext* ctx,

-                               GLuint n, const GLint x[], const GLint y[],

-                               const GLuint index[], const GLubyte mask[] )

-{

-   STARTPROFILE

-   GLuint i;

-   assert(Current->rgb_flag==GL_FALSE);

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

-      if (mask[i]) {

-         BYTE *Mem=Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i];

-         *Mem = index[i];

-      }

-   }

-   ENDPROFILE(write_ci32_pixels)

-}

-

-

-

-/*

-* Write an array of pixels with a boolean mask.  The current color

-* index is used for all pixels.

-*/

-static void write_mono_ci_pixels( const GLcontext* ctx,

-                                  GLuint n,

-                                  const GLint x[], const GLint y[],

-                                  GLuint colorIndex, const GLubyte mask[] )

-{

-   STARTPROFILE

-   GLuint i;

-   assert(Current->rgb_flag==GL_FALSE);

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

-      if (mask[i]) {

-         BYTE *Mem=Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i];

-         *Mem = colorIndex;

-      }

-   }

-   ENDPROFILE(write_mono_ci_pixels)

-}

-

-

-

-/* Write an array of RGBA pixels with a boolean mask. */

-static void write_rgba_pixels( const GLcontext* ctx,

-                               GLuint n, const GLint x[], const GLint y[],

-                               const GLubyte rgba[][4], const GLubyte mask[] )

-{

-    STARTPROFILE

-        GLuint i;

-    PWMC    pwc = Current;

-    HDC DC=DD_GETDC;

-    assert(Current->rgb_flag==GL_TRUE);

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

-       if (mask[i])

-          wmSetPixel(pwc, FLIP(y[i]), x[i],

-                     rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);

-    DD_RELEASEDC;

-    ENDPROFILE(write_rgba_pixels)

-}

-

-

-

-/*

-* Write an array of pixels with a boolean mask.  The current color

-* is used for all pixels.

-*/

-static void write_mono_rgba_pixels( const GLcontext* ctx,

-                                    GLuint n,

-                                    const GLint x[], const GLint y[],

-                                    const GLchan color[4],

-                                    const GLubyte mask[] )

-{

-    STARTPROFILE

-    GLuint i;

-    PWMC    pwc = Current;

-    HDC DC=DD_GETDC;

-    assert(Current->rgb_flag==GL_TRUE);

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

-        if (mask[i])

-            wmSetPixel(pwc, FLIP(y[i]),x[i],color[RCOMP],

-                       color[GCOMP], color[BCOMP]);

-    DD_RELEASEDC;

-    ENDPROFILE(write_mono_rgba_pixels)

-}

-

-

-

-/**********************************************************************/

-/*****            Read spans/arrays of pixels                     *****/

-/**********************************************************************/

-

-

-/* Read a horizontal span of color-index pixels. */

-static void read_ci32_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,

-                            GLuint index[])

-{

-   STARTPROFILE

-   GLuint i;

-   BYTE *Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;

-   assert(Current->rgb_flag==GL_FALSE);

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

-      index[i]=Mem[i];

-   ENDPROFILE(read_ci32_span)

-}

-

-

-

-

-/* Read an array of color index pixels. */

-static void read_ci32_pixels( const GLcontext* ctx,

-                              GLuint n, const GLint x[], const GLint y[],

-                              GLuint indx[], const GLubyte mask[] )

-{

-   STARTPROFILE

-   GLuint i;

-   assert(Current->rgb_flag==GL_FALSE);

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

-      if (mask[i]) {

-         indx[i]=*(Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i]);

-      }

-   }

-   ENDPROFILE(read_ci32_pixels)

-}

-

-

-

-/* Read a horizontal span of color pixels. */

-static void read_rgba_span( const GLcontext* ctx,

-                            GLuint n, GLint x, GLint y,

-                            GLubyte rgba[][4] )

-{

-   STARTPROFILE

-   UINT i;

-   COLORREF Color;

-   HDC DC=DD_GETDC;

-   assert(Current->rgb_flag==GL_TRUE);

-   /*   y=FLIP(y);*/

-   y = Current->height - y - 1;

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

-      Color=GetPixel(DC,x+i,y);

-      rgba[i][RCOMP] = GetRValue(Color);

-      rgba[i][GCOMP] = GetGValue(Color);

-      rgba[i][BCOMP] = GetBValue(Color);

-      rgba[i][ACOMP] = 255;

-   }

-   DD_RELEASEDC;

-// Brian P. Has mentioned to comment this out.

-//   memset(alpha,0,n*sizeof(GLubyte));

-   ENDPROFILE(read_rgba_span)

-}

-

-

-/* Read an array of color pixels. */

-static void read_rgba_pixels( const GLcontext* ctx,

-                              GLuint n, const GLint x[], const GLint y[],

-                              GLubyte rgba[][4], const GLubyte mask[] )

-{

-   STARTPROFILE

-   GLuint i;

-   COLORREF Color;

-   HDC DC=DD_GETDC;

-   assert(Current->rgb_flag==GL_TRUE);

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

-      if (mask[i]) {

-         GLint y2 = Current->height - y[i] - 1;

-         Color=GetPixel(DC,x[i],y2);

-         rgba[i][RCOMP] = GetRValue(Color);

-         rgba[i][GCOMP] = GetGValue(Color);

-         rgba[i][BCOMP] = GetBValue(Color);

-         rgba[i][ACOMP] = 255;

-      }

-   }

-   DD_RELEASEDC;

-// Brian P. has mentioned to comment this out.

-//   memset(alpha,0,n*sizeof(GLint));

-   ENDPROFILE(read_rgba_pixels)

-}

-

-

-

-/**********************************************************************/

-/**********************************************************************/

-

-

-static const GLubyte *get_string(GLcontext *ctx, GLenum name)

-{

-   if (name == GL_RENDERER) {

-      return (GLubyte *) "Mesa Windows";

-   }

-   else {

-      return NULL;

-   }

-}

-

-

-

-void setup_DD_pointers( GLcontext* ctx )

-{

-#if 0

-    ctx->Driver.GetString = get_string;

-    ctx->Driver.UpdateState = setup_DD_pointers;

-    ctx->Driver.GetBufferSize = buffer_size;

-    ctx->Driver.Finish = finish;

-    ctx->Driver.Flush = flush;

-

-    ctx->Driver.ClearIndex = clear_index;

-    ctx->Driver.ClearColor = clear_color;

-    ctx->Driver.Clear = clear;

-

-    ctx->Driver.Enable = enable;

-

-    ctx->Driver.SetDrawBuffer = set_draw_buffer;

-    ctx->Driver.SetReadBuffer = set_read_buffer;

-    ctx->Driver.GetBufferSize = buffer_size;

-

-    ctx->Driver.PointsFunc = choose_points_function(ctx);

-    ctx->Driver.LineFunc = choose_line_function(ctx);

-    ctx->Driver.TriangleFunc = choose_triangle_function( ctx );

-

-    /* Pixel/span writing functions: */

-	ctx->Driver.WriteRGBASpan        = write_rgba_span;

-    ctx->Driver.WriteRGBSpan         = write_rgb_span;

-    ctx->Driver.WriteMonoRGBASpan    = write_mono_rgba_span;

-    ctx->Driver.WriteRGBAPixels      = write_rgba_pixels;

-    ctx->Driver.WriteMonoRGBAPixels  = write_mono_rgba_pixels;

-    ctx->Driver.WriteCI32Span        = write_ci32_span;

-    ctx->Driver.WriteCI8Span         = write_ci8_span;

-    ctx->Driver.WriteMonoCISpan      = write_mono_ci_span;

-    ctx->Driver.WriteCI32Pixels      = write_ci32_pixels;

-    ctx->Driver.WriteMonoCIPixels    = write_mono_ci_pixels;

-

-    ctx->Driver.ReadCI32Span        = read_ci32_span;

-    ctx->Driver.ReadRGBASpan        = read_rgba_span;

-    ctx->Driver.ReadCI32Pixels      = read_ci32_pixels;

-    ctx->Driver.ReadRGBAPixels      = read_rgba_pixels;

-#endif

-}

-

-

-/**********************************************************************/

-/*****                  WMesa API Functions                       *****/

-/**********************************************************************/

-

-

-

-#define PAL_SIZE 256

-static void GetPalette(HPALETTE Pal,RGBQUAD *aRGB)

-{

-    STARTPROFILE

-        int i;

-    HDC hdc;

-    struct

-    {

-        WORD Version;

-        WORD NumberOfEntries;

-        PALETTEENTRY aEntries[PAL_SIZE];

-    } Palette =

-    {

-        0x300,

-            PAL_SIZE

-    };

-    hdc=GetDC(NULL);

-    if (Pal!=NULL)

-        GetPaletteEntries(Pal,0,PAL_SIZE,Palette.aEntries);

-    else

-        GetSystemPaletteEntries(hdc,0,PAL_SIZE,Palette.aEntries);

-    if (GetSystemPaletteUse(hdc) == SYSPAL_NOSTATIC)

-    {

-        for(i = 0; i <PAL_SIZE; i++)

-            Palette.aEntries[i].peFlags = PC_RESERVED;

-        Palette.aEntries[255].peRed = 255;

-        Palette.aEntries[255].peGreen = 255;

-        Palette.aEntries[255].peBlue = 255;

-        Palette.aEntries[255].peFlags = 0;

-        Palette.aEntries[0].peRed = 0;

-        Palette.aEntries[0].peGreen = 0;

-        Palette.aEntries[0].peBlue = 0;

-        Palette.aEntries[0].peFlags = 0;

-    }

-    else

-    {

-        int nStaticColors;

-        int nUsableColors;

-        nStaticColors = GetDeviceCaps(hdc, NUMCOLORS)/2;

-        for (i=0; i<nStaticColors; i++)

-            Palette.aEntries[i].peFlags = 0;

-        nUsableColors = PAL_SIZE-nStaticColors;

-        for (; i<nUsableColors; i++)

-            Palette.aEntries[i].peFlags = PC_RESERVED;

-        for (; i<PAL_SIZE-nStaticColors; i++)

-            Palette.aEntries[i].peFlags = PC_RESERVED;

-        for (i=PAL_SIZE-nStaticColors; i<PAL_SIZE; i++)

-            Palette.aEntries[i].peFlags = 0;

-    }

-    ReleaseDC(NULL,hdc);

-    for (i=0; i<PAL_SIZE; i++)

-    {

-        aRGB[i].rgbRed=Palette.aEntries[i].peRed;

-        aRGB[i].rgbGreen=Palette.aEntries[i].peGreen;

-        aRGB[i].rgbBlue=Palette.aEntries[i].peBlue;

-        aRGB[i].rgbReserved=Palette.aEntries[i].peFlags;

-    }

-    ENDPROFILE(GetPalette)

-}

-

-

-WMesaContext WMesaCreateContext( HWND hWnd, HPALETTE* Pal,

-                                GLboolean rgb_flag,

-                                GLboolean db_flag )

-{

-    RECT CR;

-    WMesaContext c;

-    GLboolean true_color_flag;

-    c = (struct wmesa_context * ) calloc(1,sizeof(struct wmesa_context));

-    if (!c)

-        return NULL;

-

-    c->Window=hWnd;

-    c->hDC = GetDC(hWnd);

-    true_color_flag = GetDeviceCaps(c->hDC, BITSPIXEL) > 8;

-#ifdef DDRAW

-    if(true_color_flag) c->rgb_flag = rgb_flag = GL_TRUE;

-#endif

-

-

-#ifdef DITHER

-    if ((true_color_flag==GL_FALSE) && (rgb_flag == GL_TRUE)){

-        c->dither_flag = GL_TRUE;

-        c->hPalHalfTone = WinGCreateHalftonePalette();

-    }

-    else

-        c->dither_flag = GL_FALSE;

-#else

-    c->dither_flag = GL_FALSE;

-#endif

-

-

-    if (rgb_flag==GL_FALSE)

-    {

-        c->rgb_flag = GL_FALSE;

-        //    c->pixel = 1;

-        c->db_flag = db_flag =GL_TRUE; // WinG requires double buffering

-        printf("Single buffer is not supported in color index mode, setting to double buffer.\n");

-    }

-    else

-    {

-        c->rgb_flag = GL_TRUE;

-        //    c->pixel = 0;

-    }

-    GetClientRect(c->Window,&CR);

-    c->width=CR.right;

-    c->height=CR.bottom;

-    if (db_flag)

-    {

-        c->db_flag = 1;

-        /* Double buffered */

-#ifndef DDRAW

-        //  if (c->rgb_flag==GL_TRUE && c->dither_flag != GL_TRUE )

-        {

-            wmCreateBackingStore(c, c->width, c->height);

-

-        }

-#endif

-    }

-    else

-    {

-        /* Single Buffered */

-        if (c->rgb_flag)

-            c->db_flag = 0;

-    }

-#ifdef DDRAW

-    if (DDInit(c,hWnd) == GL_FALSE) {

-        free( (void *) c );

-        exit(1);

-    }

-#endif

-

-

-    c->gl_visual = _mesa_create_visual(rgb_flag,

-                                       db_flag,    /* db_flag */

-                                       GL_FALSE,   /* stereo */

-                                       8,8,8,8,    /* r, g, b, a bits */

-                                       0,          /* index bits */

-                                       16,         /* depth_bits */

-                                       8,          /* stencil_bits */

-                                       16,16,16,16,/* accum_bits */

-                                       1);

-

-    if (!c->gl_visual) {

-        return NULL;

-    }

-

-    /* allocate a new Mesa context */

-    c->gl_ctx = _mesa_create_context( c->gl_visual, NULL, c, GL_TRUE);

-

-    if (!c->gl_ctx) {

-        _mesa_destroy_visual( c->gl_visual );

-        free(c);

-        return NULL;

-    }

-

-    _mesa_enable_sw_extensions(c->gl_ctx);

-#if 0

-    c->gl_buffer = _mesa_create_framebuffer( c->gl_visual,

-                                          c->gl_visual->DepthBits > 0,

-                                          c->gl_visual->StencilBits > 0,

-                                          c->gl_visual->AccumRedBits > 0,

-					  c->gl_visual->AlphaBits > 0 );

-#endif

-    c->gl_buffer = NULL; /* TEMP */

-    if (!c->gl_buffer) {

-        _mesa_destroy_visual( c->gl_visual );

-        _mesa_destroy_context( c->gl_ctx );

-        free(c);

-        return NULL;

-    }

-

-	c->gl_ctx->Driver.UpdateState = setup_DD_pointers;

-

-    //  setup_DD_pointers(c->gl_ctx);

-

-    return c;

-}

-

-void WMesaDestroyContext( void )

-{

-    WMesaContext c = Current;

-    ReleaseDC(c->Window,c->hDC);

-    WC = c;

-    if(c->hPalHalfTone != NULL)

-        DeleteObject(c->hPalHalfTone);

-    _mesa_destroy_visual( c->gl_visual );

-    _mesa_destroy_framebuffer( c->gl_buffer );

-    _mesa_destroy_context( c->gl_ctx );

-

-    if (c->db_flag)

-#ifdef DDRAW

-        DDFree(c);

-#else

-    wmDeleteBackingStore(c);

-#endif

-    free( (void *) c );

-    //Following code is added to enable parallel render

-    // Parallel render only work in double buffer mode

-#if !defined(NO_PARALLEL)

-    if(parallelMachine)

-        PRDestroyRenderBuffer();

-#endif

-    // End modification

-}

-

-

-

-void /*APIENTRY*/ WMesaMakeCurrent( WMesaContext c )

-{

-    if(!c){

-        Current = c;

-        return;

-    }

-

-    //

-    // A little optimization

-    // If it already is current,

-    // don't set it again

-    //

-    if(Current == c)

-        return;

-

-    //gl_set_context( c->gl_ctx );

-    _mesa_make_current(c->gl_ctx, c->gl_buffer);

-    setup_DD_pointers(c->gl_ctx);

-    Current = c;

-    if (Current->gl_ctx->Viewport.Width==0) {

-        /* initialize viewport to window size */

-        _mesa_set_viewport( Current->gl_ctx,

-            0, 0, Current->width, Current->height );

-    }

-    if ((c->cColorBits <= 8 ) && (c->rgb_flag == GL_TRUE)){

-        WMesaPaletteChange(c->hPalHalfTone);

-    }

-}

-

-

-

-void /*APIENTRY*/ WMesaSwapBuffers( void )

-{

-    HDC DC = Current->hDC;

-    GET_CURRENT_CONTEXT(ctx);

-

-    /* If we're swapping the buffer associated with the current context

-     * we have to flush any pending rendering commands first.

-    */

-    if (Current && Current->gl_ctx == ctx)

-       _mesa_swapbuffers(ctx);

-

-    if (Current->db_flag)

-        wmFlush(Current);

-}

-

-

-

-void /*APIENTRY*/ WMesaPaletteChange(HPALETTE Pal)

-{

-    int vRet;

-    LPPALETTEENTRY pPal;

-    if (Current && (Current->rgb_flag==GL_FALSE || Current->dither_flag == GL_TRUE))

-    {

-        pPal = (PALETTEENTRY *)malloc( 256 * sizeof(PALETTEENTRY));

-        Current->hPal=Pal;

-        //  GetPaletteEntries( Pal, 0, 256, pPal );

-        GetPalette( Pal, pPal );

-#ifdef DDRAW

-        Current->lpDD->lpVtbl->CreatePalette(Current->lpDD,DDPCAPS_8BIT,

-            pPal, &(Current->lpDDPal), NULL);

-        if (Current->lpDDPal)

-            Current->lpDDSPrimary->lpVtbl->SetPalette(Current->lpDDSPrimary,Current->lpDDPal);

-#else

-        vRet = SetDIBColorTable(Current->dib.hDC,0,256,pPal);

-#endif

-        free( pPal );

-    }

-

-}

-

-

-

-

-static unsigned char threeto8[8] = {

-    0, 0111>>1, 0222>>1, 0333>>1, 0444>>1, 0555>>1, 0666>>1, 0377

-};

-

-static unsigned char twoto8[4] = {

-    0, 0x55, 0xaa, 0xff

-};

-

-static unsigned char oneto8[2] = {

-    0, 255

-};

-

-static unsigned char componentFromIndex(UCHAR i, UINT nbits, UINT shift)

-{

-    unsigned char val;

-

-    val = i >> shift;

-    switch (nbits) {

-

-    case 1:

-        val &= 0x1;

-        return oneto8[val];

-

-    case 2:

-        val &= 0x3;

-        return twoto8[val];

-

-    case 3:

-        val &= 0x7;

-        return threeto8[val];

-

-    default:

-        return 0;

-    }

-}

-

-void /*WINAPI*/ wmCreatePalette( PWMC pwdc )

-{

-    /* Create a compressed and re-expanded 3:3:2 palette */

-    int            i;

-    LOGPALETTE     *pPal;

-    BYTE           rb, rs, gb, gs, bb, bs;

-

-    pwdc->nColors = 0x100;

-

-    pPal = (PLOGPALETTE)malloc(sizeof(LOGPALETTE) + pwdc->nColors * sizeof(PALETTEENTRY));

-    memset( pPal, 0, sizeof(LOGPALETTE) + pwdc->nColors * sizeof(PALETTEENTRY) );

-

-    pPal->palVersion = 0x300;

-

-    rb = REDBITS;

-    rs = REDSHIFT;

-    gb = GREENBITS;

-    gs = GREENSHIFT;

-    bb = BLUEBITS;

-    bs = BLUESHIFT;

-

-    if (pwdc->db_flag) {

-

-        /* Need to make two palettes: one for the screen DC and one for the DIB. */

-        pPal->palNumEntries = pwdc->nColors;

-        for (i = 0; i < pwdc->nColors; i++) {

-            pPal->palPalEntry[i].peRed = componentFromIndex( i, rb, rs );

-            pPal->palPalEntry[i].peGreen = componentFromIndex( i, gb, gs );

-            pPal->palPalEntry[i].peBlue = componentFromIndex( i, bb, bs );

-            pPal->palPalEntry[i].peFlags = 0;

-        }

-        pwdc->hGLPalette = CreatePalette( pPal );

-        pwdc->hPalette = CreatePalette( pPal );

-    }

-

-    else {

-        pPal->palNumEntries = pwdc->nColors;

-        for (i = 0; i < pwdc->nColors; i++) {

-            pPal->palPalEntry[i].peRed = componentFromIndex( i, rb, rs );

-            pPal->palPalEntry[i].peGreen = componentFromIndex( i, gb, gs );

-            pPal->palPalEntry[i].peBlue = componentFromIndex( i, bb, bs );

-            pPal->palPalEntry[i].peFlags = 0;

-        }

-        pwdc->hGLPalette = CreatePalette( pPal );

-    }

-

-    free(pPal);

-

-}

-

-void /*WINAPI*/ wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b)

-{

-    if (Current->db_flag) {

-        LPBYTE  lpb = pwc->pbPixels;

-        LPDWORD lpdw;

-        LPWORD  lpw;

-        UINT    nBypp = pwc->cColorBits >> 3;

-        UINT    nOffset = iPixel % nBypp;

-

-        // Move the pixel buffer pointer to the scanline that we

-        // want to access

-

-        //      pwc->dib.fFlushed = FALSE;

-

-        lpb += pwc->ScanWidth * iScanLine;

-        // Now move to the desired pixel

-        lpb += iPixel * nBypp;

-        lpb = PIXELADDR(iPixel, iScanLine);

-        lpdw = (LPDWORD)lpb;

-        lpw = (LPWORD)lpb;

-

-        if(nBypp == 1){

-            if(pwc->dither_flag)

-                *lpb = DITHER_RGB_2_8BIT(r,g,b,iScanLine,iPixel);

-            else

-                *lpb = BGR8(r,g,b);

-        }

-        else if(nBypp == 2)

-            *lpw = BGR16(r,g,b);

-        else if (nBypp == 3){

-            *lpdw = BGR24(r,g,b);

-        }

-        else if (nBypp == 4)

-            *lpdw = BGR32(r,g,b);

-    }

-    else{

-        SetPixel(Current->hDC, iPixel, iScanLine, RGB(r,g,b));

-        DD_RELEASEDC;

-    }

-}

-

-void /*WINAPI*/ wmCreateDIBSection(

-                                   HDC   hDC,

-                                   PWMC pwc,    // handle of device context

-                                   CONST BITMAPINFO *pbmi,  // address of structure containing bitmap size, format, and color data

-                                   UINT iUsage  // color data type indicator: RGB values or palette indices

-                                   )

-{

-    DWORD   dwSize = 0;

-    DWORD   dwScanWidth;

-    UINT    nBypp = pwc->cColorBits / 8;

-    HDC     hic;

-

-    dwScanWidth = (((pwc->ScanWidth * nBypp)+ 3) & ~3);

-

-    pwc->ScanWidth =pwc->pitch = dwScanWidth;

-

-    if (stereo_flag)

-        pwc->ScanWidth = 2* pwc->pitch;

-

-    dwSize = sizeof(BITMAPINFO) + (dwScanWidth * pwc->height);

-

-    pwc->dib.hFileMap = CreateFileMapping((HANDLE)PAGE_FILE,

-        NULL,

-        PAGE_READWRITE | SEC_COMMIT,

-        0,

-        dwSize,

-        NULL);

-

-    if (!pwc->dib.hFileMap)

-        return;

-

-    pwc->dib.base = MapViewOfFile(pwc->dib.hFileMap,

-        FILE_MAP_ALL_ACCESS,

-        0,

-        0,

-        0);

-

-    if(!pwc->dib.base){

-        CloseHandle(pwc->dib.hFileMap);

-        return;

-    }

-

-    //  pwc->pbPixels = pwc->addrOffScreen = ((LPBYTE)pwc->dib.base) + sizeof(BITMAPINFO);

-

-    //  pwc->dib.hDC = CreateCompatibleDC(hDC);

-

-    CopyMemory(pwc->dib.base, pbmi, sizeof(BITMAPINFO));

-

-    hic = CreateIC("display", NULL, NULL, NULL);

-    pwc->dib.hDC = CreateCompatibleDC(hic);

-

-

-    /*  pwc->hbmDIB = CreateDIBitmap(hic,

-    &(pwc->bmi.bmiHeader),

-    CBM_INIT,

-    pwc->pbPixels,

-    &(pwc->bmi),

-    DIB_RGB_COLORS);

-    */

-    pwc->hbmDIB = CreateDIBSection(hic,

-        &(pwc->bmi),

-        (iUsage ? DIB_PAL_COLORS : DIB_RGB_COLORS),

-        &(pwc->pbPixels),

-        pwc->dib.hFileMap,

-        0);

-        /*

-        pwc->hbmDIB = CreateDIBSection(hic,

-        &(pwc->bmi),

-        DIB_RGB_COLORS,

-        &(pwc->pbPixels),

-        pwc->dib.hFileMap,

-        0);

-    */

-    pwc->ScreenMem = pwc->addrOffScreen = pwc->pbPixels;

-    pwc->hOldBitmap = SelectObject(pwc->dib.hDC, pwc->hbmDIB);

-

-    DeleteDC(hic);

-

-    return;

-

-}

-

-//

-// Blit memory DC to screen DC

-//

-BOOL /*WINAPI*/ wmFlush(PWMC pwc)

-{

-    BOOL    bRet = 0;

-    DWORD   dwErr = 0;

-#ifdef DDRAW

-    HRESULT             ddrval;

-#endif

-

-    // Now search through the torus frames and mark used colors

-    if(pwc->db_flag){

-#ifdef DDRAW

-        if (pwc->lpDDSOffScreen == NULL)

-            if(DDCreateOffScreen(pwc) == GL_FALSE)

-                return;

-

-            pwc->lpDDSOffScreen->lpVtbl->Unlock(pwc->lpDDSOffScreen, NULL);

-

-            while( 1 )

-            {

-                ddrval = pwc->lpDDSPrimary->lpVtbl->Blt( pwc->lpDDSPrimary,

-                    &(pwc->rectSurface), pwc->lpDDSOffScreen, &(pwc->rectOffScreen), 0, NULL );

-

-                if( ddrval == DD_OK )

-                {

-                    break;

-                }

-                if( ddrval == DDERR_SURFACELOST )

-                {

-                    if(!DDRestoreAll(pwc))

-                    {

-                        break;

-                    }

-                }

-                if( ddrval != DDERR_WASSTILLDRAWING )

-                {

-                    break;

-                }

-            }

-

-            while (pwc->lpDDSOffScreen->lpVtbl->Lock(pwc->lpDDSOffScreen,

-                NULL, &(pwc->ddsd), 0, NULL) == DDERR_WASSTILLDRAWING)

-                ;

-

-            if(ddrval != DD_OK)

-                dwErr = GetLastError();

-#else

-            bRet = BitBlt(pwc->hDC, 0, 0, pwc->width, pwc->height,

-                pwc->dib.hDC, 0, 0, SRCCOPY);

-#endif

-    }

-

-    return(TRUE);

-

-}

-

-

-// The following code is added by Li Wei to enable stereo display

-

-#if !defined(NO_STEREO)

-

-void WMesaShowStereo(GLuint list)

-{

-

-    GLbitfield mask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;

-    GLfloat cm[16];

-    GLint matrix_mode;

-    // Must use double Buffer

-    if( ! Current-> db_flag )

-        return;

-

-

-    glGetIntegerv(GL_MATRIX_MODE,&matrix_mode);

-

-    //  glPushMatrix();  //****

-    WMesaViewport(Current->gl_ctx,0,Current->height/2,Current->width,Current->height/2);

-    //  Current->gl_ctx->NewState = 0;

-

-    //  glViewport(0,0,Current->width,Current->height/2);

-    if(matrix_mode!=GL_MODELVIEW)

-        glMatrixMode(GL_MODELVIEW);

-

-    glGetFloatv(GL_MODELVIEW_MATRIX,cm);

-    glLoadIdentity();

-    gluLookAt(viewDistance/2,0.0,0.0 ,

-        viewDistance/2,0.0,-1.0,

-        0.0,1.0,0.0 );

-    //  glTranslatef(viewDistance/2.0,0.,0.);

-    glMultMatrixf( cm );

-

-    Current->ScreenMem = Current->pbPixels = Current->addrOffScreen;

-    //glPushMatrix();

-    glCallList( list );

-    //glPopMatrix();

-

-    glGetFloatv(GL_MODELVIEW_MATRIX,cm);

-    glLoadIdentity();

-    gluLookAt(-viewDistance/2,0.0,0.0 ,

-        -viewDistance/2,0.0,-1.0,

-        0.0,1.0,0.0 );

-    //  glTranslatef(-viewDistance/2.0,0.,0.);

-    glMultMatrixf(cm);

-

-    Current->ScreenMem = Current->pbPixels = Current->addrOffScreen + Current->pitch;

-    glCallList(list);

-    if(matrix_mode!=GL_MODELVIEW)

-        glMatrixMode(matrix_mode);

-

-    //  glPopMatrix();

-    glFlush();

-

-    WMesaViewport(Current->gl_ctx,0,0,Current->width,Current->height);

-    //  Current->gl_ctx->NewState = 0;

-    WMesaSwapBuffers();

-

-}

-

-void toggleStereoMode()

-{

-    if(!Current->db_flag)

-        return;

-    if(!stereo_flag){

-        stereo_flag = 1;

-        if(stereoBuffer==GL_FALSE)

-#if !defined(NO_PARALLEL)

-            if(!parallelFlag)

-#endif

-            {

-                Current->ScanWidth = Current->pitch*2;

-            }

-    }

-    else {

-        stereo_flag = 0;

-#if !defined(NO_PARALLEL)

-        if(!parallelFlag)

-#endif

-            Current->ScanWidth = Current->pitch;

-        Current->pbPixels = Current->addrOffScreen;

-    }

-}

-

-/* if in stereo mode, the following function is called */

-void glShowStereo(GLuint list)

-{

-    WMesaShowStereo(list);

-}

-

-#endif // End if NO_STEREO not defined

-

-#if !defined(NO_PARALLEL)

-

-void toggleParallelMode(void)

-{

-    if(!parallelFlag){

-        parallelFlag = GL_TRUE;

-        if(parallelMachine==GL_FALSE){

-            PRCreateRenderBuffer( Current->rgb_flag? GL_RGBA :GL_COLOR_INDEX,

-                Current->cColorBits/8,

-                Current->width ,Current->height,

-                Current->ScanWidth,

-                Current->rgb_flag? Current->pbPixels: Current->ScreenMem);

-            parallelMachine = GL_TRUE;

-        }

-    }

-    else {

-        parallelFlag = GL_FALSE;

-        if(parallelMachine==GL_TRUE){

-            PRDestroyRenderBuffer();

-            parallelMachine=GL_FALSE;

-            ReadyForNextFrame = GL_TRUE;

-        }

-

-        /***********************************************

-        // Seems something wrong!!!!

-        ************************************************/

-

-        WMesaMakeCurrent(Current);

-#if !defined(NO_STEREO)

-        stereo_flag = GL_FALSE ;

-#endif

-    }

-}

-

-void PRShowRenderResult(void)

-{

-    int flag = 0;

-    if(!glImageRendered())

-        return;

-

-    if (parallelFlag)

-    {

-        WMesaSwapBuffers();

-    }

-

-}

-#endif //End if NO_PARALLEL not defined

-

-//end modification

-

-BYTE DITHER_RGB_2_8BIT( int red, int green, int blue, int pixel, int scanline)

-{

-    char unsigned redtemp, greentemp, bluetemp, paletteindex;

-

-    //*** now, look up each value in the halftone matrix

-    //*** using an 8x8 ordered dither.

-    redtemp = aDividedBy51[red]

-        + (aModulo51[red] > aHalftone8x8[(pixel%8)*8

-        + scanline%8]);

-    greentemp = aDividedBy51[(char unsigned)green]

-        + (aModulo51[green] > aHalftone8x8[

-        (pixel%8)*8 + scanline%8]);

-    bluetemp = aDividedBy51[(char unsigned)blue]

-        + (aModulo51[blue] > aHalftone8x8[

-        (pixel%8)*8 +scanline%8]);

-

-    //*** recombine the halftoned rgb values into a palette index

-    paletteindex =

-        redtemp + aTimes6[greentemp] + aTimes36[bluetemp];

-

-    //*** and translate through the wing halftone palette

-    //*** translation vector to give the correct value.

-    return aWinGHalftoneTranslation[paletteindex];

-}

-

-#ifdef DDRAW

-/*

-* restoreAll

-*

-* restore all lost objects

-*/

-HRESULT DDRestoreAll( WMesaContext wc )

-{

-    HRESULT     ddrval;

-

-    ddrval = wc->lpDDSPrimary->lpVtbl->Restore(wc->lpDDSPrimary);

-    if( ddrval == DD_OK )

-    {

-        ddrval = wc->lpDDSOffScreen->lpVtbl->Restore(wc->lpDDSOffScreen);

-    }

-    return ddrval;

-

-} /* restoreAll */

-

-

-  /*

-  * This function is called if the initialization function fails

-*/

-BOOL initFail( HWND hwnd, WMesaContext wc )

-{

-    DDFree(wc);

-    MessageBox( hwnd, "DirectDraw Init FAILED", "", MB_OK );

-    return FALSE;

-

-} /* initFail */

-

-

-static void DDDeleteOffScreen(WMesaContext wc)

-{

-    if( wc->lpDDSOffScreen != NULL )

-    {

-        wc->lpDDSOffScreen->lpVtbl->Unlock(wc->lpDDSOffScreen,NULL);

-        wc->lpDDSOffScreen->lpVtbl->Release(wc->lpDDSOffScreen);

-        wc->lpDDSOffScreen = NULL;

-    }

-

-}

-

-static void DDFreePrimarySurface(WMesaContext wc)

-{

-    if( wc->lpDDSPrimary != NULL )

-    {

-        if(wc->db_flag == GL_FALSE)

-            wc->lpDDSPrimary->lpVtbl->ReleaseDC(wc->lpDDSPrimary, wc->hDC);

-        wc->lpDDSPrimary->lpVtbl->Release(wc->lpDDSPrimary);

-        wc->lpDDSPrimary = NULL;

-    }

-}

-

-static BOOL DDCreatePrimarySurface(WMesaContext wc)

-{

-    HRESULT ddrval;

-    DDSCAPS             ddscaps;

-    wc->ddsd.dwSize = sizeof( wc->ddsd );

-    wc->ddsd.dwFlags = DDSD_CAPS;

-    wc->ddsd.ddsCaps.dwCaps =   DDSCAPS_PRIMARYSURFACE;

-

-    ddrval = wc->lpDD->lpVtbl->CreateSurface( wc->lpDD,&(wc->ddsd), &(wc->lpDDSPrimary), NULL );

-    if( ddrval != DD_OK )

-    {

-        return initFail(wc->hwnd , wc);

-    }

-    if(wc->db_flag == GL_FALSE)

-        wc->lpDDSPrimary->lpVtbl->GetDC(wc->lpDDSPrimary, wc->hDC);

-    return TRUE;

-}

-

-static BOOL DDCreateOffScreen(WMesaContext wc)

-{

-    POINT   pt;

-    HRESULT     ddrval;

-    if(wc->lpDD == NULL)

-        return FALSE;

-    GetClientRect( wc->hwnd, &(wc->rectOffScreen) );

-    wc->ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;

-    wc->ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;

-    wc->ddsd.dwHeight = wc->rectOffScreen.bottom - wc->rectOffScreen.top;

-    wc->ddsd.dwWidth = wc->rectOffScreen.right - wc->rectOffScreen.left;

-

-    ddrval = wc->lpDD->lpVtbl->CreateSurface( wc->lpDD, &(wc->ddsd), &(wc->lpDDSOffScreen), NULL );

-    if( ddrval != DD_OK )

-    {

-        return FALSE;

-    }

-

-    while (wc->lpDDSOffScreen->lpVtbl->Lock(wc->lpDDSOffScreen,NULL, &(wc->ddsd), 0, NULL) == DDERR_WASSTILLDRAWING)

-        ;

-    //  while ((ddrval = wc->lpDDSOffScreen->lpVtbl->Lock(wc->lpDDSOffScreen,NULL, &(wc->ddsd), DDLOCK_SURFACEMEMORYPTR , NULL)) != DD_OK)

-    ;

-    if(wc->ddsd.lpSurface==NULL)

-        return initFail(wc->hwnd, wc);

-

-    wc->ScreenMem = wc->pbPixels = wc->addrOffScreen = (PBYTE)(wc->ddsd.lpSurface);

-    wc->ScanWidth = wc->pitch = wc->ddsd.lPitch;

-    if (stereo_flag)

-        wc->ScanWidth = wc->ddsd.lPitch*2;

-

-    GetClientRect( wc->hwnd, &(wc->rectSurface) );

-    pt.x = pt.y = 0;

-    ClientToScreen( wc->hwnd, &pt );

-    OffsetRect(&(wc->rectSurface), pt.x, pt.y);

-    wmSetPixelFormat(wc, wc->hDC);

-    return TRUE;

-}

-

-/*

-* doInit - do work required for every instance of the application:

-*                create the window, initialize data

-*/

-static BOOL DDInit( WMesaContext wc, HWND hwnd)

-{

-    HRESULT             ddrval;

-    DWORD dwFrequency;

-

-    LPDIRECTDRAW            lpDD;           // DirectDraw object

-    LPDIRECTDRAW2            lpDD2;

-

-

-    wc->fullScreen = displayOptions.fullScreen;

-    wc->gMode = displayOptions.mode;

-    wc->hwnd = hwnd;

-    stereo_flag = displayOptions.stereo;

-    if(wc->db_flag!= GL_TRUE)

-        stereo_flag = GL_FALSE;

-        /*

-        * create the main DirectDraw object

-    */

-    ddrval = DirectDrawCreate( NULL, &(wc->lpDD), NULL );

-    if( ddrval != DD_OK )

-    {

-        return initFail(hwnd,wc);

-    }

-

-    // Get exclusive mode if requested

-    if(wc->fullScreen)

-    {

-        ddrval = wc->lpDD->lpVtbl->SetCooperativeLevel( wc->lpDD, hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );

-    }

-    else

-    {

-        ddrval = wc->lpDD->lpVtbl->SetCooperativeLevel( wc->lpDD, hwnd, DDSCL_NORMAL );

-    }

-    if( ddrval != DD_OK )

-    {

-        return initFail(hwnd , wc);

-    }

-

-

-    /*  ddrval = wc->lpDD->lpVtbl->QueryInterface(wc->lpDD, IID_IDirectDraw2,

-    (LPVOID *)((wc->lpDD2)));

-

-    */

-    if(ddrval != DD_OK)

-        return initFail(hwnd , wc);

-

-

-    //ddrval = wc->lpDD->lpVtbl->GetDisplayMode( wc->lpDD, &(wc->ddsd));

-    //  wc->lpDD2->lpVtbl->GetMonitorFrequency(wc->lpDD, &dwFrequency);

-    switch( wc->gMode )

-    {

-    case 1:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 640, 480, displayOptions.bpp); break;

-    case 2:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 800, 600, displayOptions.bpp); break;

-    case 3:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1024, 768, displayOptions.bpp); break;

-    case 4:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1152, 864, displayOptions.bpp); break;

-    case 5:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1280, 1024, displayOptions.bpp); break;

-    }

-

-    if( ddrval != DD_OK )

-    {

-        printf("Can't modify display mode, current mode used\n");

-        //        return initFail(hwnd , wc);

-    }

-    //ddrval = wc->lpDD->lpVtbl->GetDisplayMode( wc->lpDD, &(wc->ddsd));

-    switch(ddrval){

-    case DDERR_INVALIDOBJECT:

-        break;

-    case DDERR_INVALIDPARAMS:

-        break;

-    case DDERR_UNSUPPORTEDMODE:

-        ;

-    }

-

-    if(DDCreatePrimarySurface(wc) == GL_FALSE)

-        return initFail(hwnd, wc);

-

-    if(wc->db_flag)

-        return DDCreateOffScreen(wc);

-} /* DDInit */

-

-static void DDFree( WMesaContext wc)

-{

-    if( wc->lpDD != NULL )

-    {

-        DDFreePrimarySurface(wc);

-        DDDeleteOffScreen(wc);

-        wc->lpDD->lpVtbl->Release(wc->lpDD);

-        wc->lpDD = NULL;

-    }

-    // Clean up the screen on exit

-    RedrawWindow( NULL, NULL, NULL, RDW_INVALIDATE | RDW_ERASE |

-        RDW_ALLCHILDREN );

-

-}

-#endif

-

-void WMesaMove(void)

-{

-    WMesaContext wc = Current;

-    POINT   pt;

-    if (Current != NULL){

-        GetClientRect( wc->hwnd, &(wc->rectSurface) );

-        pt.x = pt.y = 0;

-        ClientToScreen( wc->hwnd, &pt );

-        OffsetRect(&(wc->rectSurface), pt.x, pt.y);

-    }

-}

-

-

-

-/*

-* Like PACK_8A8B8G8R() but don't use alpha.  This is usually an acceptable

-* shortcut.

-*/

-#define PACK_8B8G8R( R, G, B )   ( ((B) << 16) | ((G) << 8) | (R) )

-

-

-/**********************************************************************/

-/***                   Triangle rendering                            ***/

-/**********************************************************************/

-

-/*

- * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.

- */

-static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,

-                                       GLuint v0, GLuint v1, GLuint v2,

-                                       GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE

-#define INTERP_RGB 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)

-#define PIXEL_TYPE GLuint

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                    \

-    {                                   \

-    GLint i, len = RIGHT-LEFT;                      \

-    for (i=0;i<len;i++) {                       \

-    GLdepth z = FixedToDepth(ffz);                  \

-    if (z < zRow[i]) {                      \

-    pRow[i] = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),    \

-    FixedToInt(ffb) );          \

-    zRow[i] = z;                            \

-    }                                   \

-    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \

-    ffz += fdzdx;                           \

-    }                                   \

-    }

-

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, smooth, depth-buffered, PF_8R8G8B triangle.

-*/

-static void smooth_8R8G8B_z_triangle( GLcontext *ctx,

-                                     GLuint v0, GLuint v1, GLuint v2,

-                                     GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define INTERP_RGB 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)

-#define PIXEL_TYPE GLuint

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                    \

-    {                                   \

-    GLint i, len = RIGHT-LEFT;                      \

-    for (i=0;i<len;i++) {                       \

-    GLdepth z = FixedToDepth(ffz);                  \

-    if (z < zRow[i]) {                      \

-    pRow[i] = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),    \

-    FixedToInt(ffb) );          \

-    zRow[i] = z;                            \

-    }                                   \

-    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \

-    ffz += fdzdx;                           \

-    }                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-

-/*

-* XImage, smooth, depth-buffered, PF_5R6G5B triangle.

-*/

-static void smooth_5R6G5B_z_triangle( GLcontext *ctx,

-                                     GLuint v0, GLuint v1, GLuint v2,

-                                     GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define INTERP_RGB 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)

-#define PIXEL_TYPE GLushort

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                    \

-    {                                   \

-    GLint i, len = RIGHT-LEFT;                      \

-    for (i=0;i<len;i++) {                       \

-    GLdepth z = FixedToDepth(ffz);                  \

-    if (z < zRow[i]) {                      \

-    pRow[i] = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg),    \

-    FixedToInt(ffb) );          \

-    zRow[i] = z;                            \

-    }                                   \

-    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \

-    ffz += fdzdx;                           \

-    }                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-/*

-* XImage, flat, depth-buffered, PF_8A8B8G8R triangle.

-*/

-static void flat_8A8B8G8R_z_triangle( GLcontext *ctx, GLuint v0,

-                                     GLuint v1, GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)

-#define PIXEL_TYPE GLuint

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define SETUP_CODE                  \

-    unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0],    \

-    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );

-#define INNER_LOOP( LEFT, RIGHT, Y )                    \

-    {                                   \

-    GLint i, len = RIGHT-LEFT;                      \

-    for (i=0;i<len;i++) {                       \

-    GLdepth z = FixedToDepth(ffz);                  \

-    if (z < zRow[i]) {                      \

-    pRow[i] = p;                            \

-    zRow[i] = z;                            \

-    }                                   \

-    ffz += fdzdx;                           \

-    }                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, flat, depth-buffered, PF_8R8G8B triangle.

-*/

-static void flat_8R8G8B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                   GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)

-#define PIXEL_TYPE GLuint

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define SETUP_CODE                  \

-    unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0],    \

-    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );

-#define INNER_LOOP( LEFT, RIGHT, Y )            \

-    {                           \

-    GLint i, len = RIGHT-LEFT;              \

-    for (i=0;i<len;i++) {               \

-    GLdepth z = FixedToDepth(ffz);          \

-    if (z < zRow[i]) {              \

-    pRow[i] = p;                    \

-    zRow[i] = z;                    \

-    }                           \

-    ffz += fdzdx;                   \

-    }                           \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, flat, depth-buffered, PF_5R6G5B triangle.

-*/

-static void flat_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                   GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)

-#define PIXEL_TYPE GLushort

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define SETUP_CODE                  \

-    unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0],    \

-    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );

-#define INNER_LOOP( LEFT, RIGHT, Y )            \

-    {                           \

-    GLint i, len = RIGHT-LEFT;              \

-    for (i=0;i<len;i++) {               \

-    GLdepth z = FixedToDepth(ffz);          \

-    if (z < zRow[i]) {              \

-    pRow[i] = p;                    \

-    zRow[i] = z;                    \

-    }                           \

-    ffz += fdzdx;                   \

-    }                           \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.

-*/

-static void smooth_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                     GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_RGB 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)

-#define PIXEL_TYPE GLuint

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                    \

-    {                                   \

-    GLint xx;                               \

-    PIXEL_TYPE *pixel = pRow;                       \

-    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {               \

-    *pixel = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),     \

-                FixedToInt(ffb) );          \

-                ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \

-    }                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.

-*/

-static void smooth_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                   GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_RGB 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)

-#define PIXEL_TYPE GLuint

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                    \

-    {                                   \

-    GLint xx;                               \

-    PIXEL_TYPE *pixel = pRow;                       \

-    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {               \

-    *pixel = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),     \

-                FixedToInt(ffb) );          \

-                ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \

-    }                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.

-*/

-static void smooth_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                   GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_RGB 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)

-#define PIXEL_TYPE GLushort

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                    \

-    {                                   \

-    GLint xx;                               \

-    PIXEL_TYPE *pixel = pRow;                       \

-    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {               \

-    *pixel = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg),     \

-                FixedToInt(ffb) );          \

-                ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \

-    }                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-

-/*

-* XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.

-*/

-static void flat_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0,

-                                   GLuint v1, GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)

-#define PIXEL_TYPE GLuint

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define SETUP_CODE                  \

-    unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0],    \

-    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );

-#define INNER_LOOP( LEFT, RIGHT, Y )            \

-    {                           \

-    GLint xx;                       \

-    PIXEL_TYPE *pixel = pRow;               \

-    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {       \

-    *pixel = p;                 \

-    }                           \

-    }

-

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.

-*/

-static void flat_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                 GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)

-#define PIXEL_TYPE GLuint

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define SETUP_CODE                  \

-    unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0],    \

-    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );

-#define INNER_LOOP( LEFT, RIGHT, Y )            \

-    {                           \

-    GLint xx;                       \

-    PIXEL_TYPE *pixel = pRow;               \

-    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {       \

-    *pixel = p;                 \

-    }                           \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.

-*/

-static void flat_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                 GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)

-#define PIXEL_TYPE GLushort

-    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define SETUP_CODE                  \

-    unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0],    \

-    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );

-#define INNER_LOOP( LEFT, RIGHT, Y )            \

-    {                           \

-    GLint xx;                       \

-    PIXEL_TYPE *pixel = pRow;               \

-    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {       \

-    *pixel = p;                 \

-    }                           \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.

-*/

-

-static void smooth_ci_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                 GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define INTERP_INDEX 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)

-#define PIXEL_TYPE GLubyte

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                                \

-    {                                                                   \

-    GLint i, len = RIGHT-LEFT;                                      \

-    for (i=0;i<len;i++) {                                           \

-    GLdepth z = FixedToDepth(ffz);                              \

-    if (z < zRow[i]) {                                          \

-    pRow[i] = FixedToInt(ffi);                                  \

-    zRow[i] = z;                                                \

-    }                                                               \

-    ffi += fdidx;                                                   \

-    ffz += fdzdx;                                                   \

-    }                                                               \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.

-*/

-

-static void flat_ci_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                               GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)

-#define PIXEL_TYPE GLubyte

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define SETUP_CODE			\

-   GLuint index = VB->IndexPtr->data[pv];	\

-   (*ctx->Driver.Index)( ctx, index );

-#define INNER_LOOP( LEFT, RIGHT, Y )	\

-   {					\

-      GLint i, len = RIGHT-LEFT;	\

-      for (i=0;i<len;i++) {		\

-         GLdepth z = FixedToDepth(ffz);	\

-         if (z < zRow[i]) {		\

-            pRow[i] = index;		\

-            zRow[i] = z;		\

-         }				\

-         ffz += fdzdx;			\

-      }					\

-   }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-

-/*

-* XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.

-*/

-

-static void smooth_ci_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                               GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define INTERP_INDEX 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)

-#define PIXEL_TYPE GLubyte

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                    \

-    {                                   \

-    GLint xx;                               \

-    PIXEL_TYPE *pixel = pRow;                       \

-    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {               \

-    *pixel = FixedToInt(ffi);           \

-    ffi += fdidx;           \

-    }                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-/*

-* XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.

-*/

-static void flat_ci_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                             GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-#define INTERP_Z 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)

-#define PIXEL_TYPE GLubyte

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define SETUP_CODE			\

-   GLuint index = VB->IndexPtr->data[pv];	\

-   (*ctx->Driver.Index)( ctx, index );

-#define INNER_LOOP( LEFT, RIGHT, Y )		\

-   {						\

-      GLint xx;					\

-      PIXEL_TYPE *pixel = pRow;			\

-      for (xx=LEFT;xx<RIGHT;xx++,pixel++) {	\

-         *pixel = index;			\

-      }						\

-   }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-/*

-* XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.

-*/

-static void smooth_DITHER8_z_triangle( GLcontext *ctx,

-                                      GLuint v0, GLuint v1, GLuint v2,

-                                      GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-    DITHER_RGB_TO_8BIT_SETUP

-#define INTERP_Z 1

-#define INTERP_RGB 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)

-#define PIXEL_TYPE GLubyte

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                                    \

-    {                                                                       \

-    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;                 \

-    for (i=0;i<len;i++,xx++) {                                          \

-    GLdepth z = FixedToDepth(ffz);                                  \

-    if (z < zRow[i]) {                                              \

-    DITHER_RGB_TO_8BIT( FixedToInt(ffr), FixedToInt(ffg),           \

-    FixedToInt(ffb), xx, yy);               \

-    pRow[i] = pixelDithered;                                        \

-    zRow[i] = z;                                                    \

-    }                                                                   \

-    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;                     \

-    ffz += fdzdx;                                                       \

-    }                                                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-/*

-* XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.

-*/

-static void flat_DITHER8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                    GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-    DITHER_RGB_TO_8BIT_SETUP

-#define INTERP_Z 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)

-#define PIXEL_TYPE GLubyte

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-

-#define INNER_LOOP( LEFT, RIGHT, Y )                                    \

-    {                                                                       \

-    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;                 \

-    for (i=0;i<len;i++,xx++) {                                          \

-    GLdepth z = FixedToDepth(ffz);                                  \

-    if (z < zRow[i]) {                                              \

-    DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0],                           \

-             VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy);               \

-             pRow[i] = pixelDithered;                                       \

-             zRow[i] = z;                                                   \

-    }                                                                   \

-    ffz += fdzdx;                                                       \

-    }                                                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-/*

-* XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.

-*/

-static void smooth_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                    GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-    DITHER_RGB_TO_8BIT_SETUP

-#define INTERP_RGB 1

-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)

-#define PIXEL_TYPE GLubyte

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-#define INNER_LOOP( LEFT, RIGHT, Y )                                    \

-    {                                                                       \

-    GLint xx, yy = FLIP(Y);                                             \

-    PIXEL_TYPE *pixel = pRow;                                           \

-    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                               \

-    DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0],   VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy);\

-    *pixel = pixelDithered;                                         \

-    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;                     \

-    }                                                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-/*

-* XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.

-*/

-

-static void flat_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,

-                                  GLuint v2, GLuint pv )

-{

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-    DITHER_RGB_TO_8BIT_SETUP

-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)

-#define PIXEL_TYPE GLubyte

-#define BYTES_PER_ROW (wmesa->ScanWidth)

-

-#define INNER_LOOP( LEFT, RIGHT, Y )                                    \

-    {                                                                       \

-    GLint xx, yy = FLIP(Y);                                             \

-    PIXEL_TYPE *pixel = pRow;                                           \

-    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                               \

-    DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0],                               \

-             VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy);               \

-             *pixel = pixelDithered;                                            \

-    }                                                                   \

-    }

-#ifdef __MINGW32__

-	#include "tritemp.h"

-#else

-

-	#ifdef WIN32

-//		#include "..\tritemp.h"

-	#else

-		#include "tritemp.h"

-	#endif

-#endif

-}

-

-

-

-

-static /*triangle_func*/ choose_triangle_function( GLcontext *ctx )

-{

-#if 0

-    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;

-    int depth = wmesa->cColorBits;

-

-    if (ctx->Polygon.SmoothFlag)     return NULL;

-    if (ctx->Texture._ReallyEnabled)  return NULL;

-    if (!wmesa->db_flag) return NULL;

-    /*if (wmesa->xm_buffer->buffer==XIMAGE)*/ {

-    if (   ctx->Light.ShadeModel==GL_SMOOTH

-        && ctx->_RasterMask==DEPTH_BIT

-        && ctx->Depth.Func==GL_LESS

-        && ctx->Depth.Mask==GL_TRUE

-        && ctx->Polygon.StippleFlag==GL_FALSE) {

-        switch (wmesa->pixelformat) {

-        case PF_8A8B8G8R:

-            return smooth_8A8B8G8R_z_triangle;

-        case PF_8R8G8B:

-            return smooth_8R8G8B_z_triangle;

-        case PF_5R6G5B:

-            return smooth_5R6G5B_z_triangle;

-        case PF_DITHER8:

-            return  smooth_DITHER8_z_triangle;

-        case PF_INDEX8:

-            return smooth_ci_z_triangle;

-        default:

-            return NULL;

-        }

-    }

-    if (   ctx->Light.ShadeModel==GL_FLAT

-        && ctx->_RasterMask==DEPTH_BIT

-        && ctx->Depth.Func==GL_LESS

-        && ctx->Depth.Mask==GL_TRUE

-        && ctx->Polygon.StippleFlag==GL_FALSE) {

-        switch (wmesa->pixelformat) {

-        case PF_8A8B8G8R:

-            return flat_8A8B8G8R_z_triangle;

-        case PF_8R8G8B:

-            return flat_8R8G8B_z_triangle;

-        case PF_5R6G5B:

-            return flat_5R6G5B_z_triangle;

-        case PF_DITHER8:

-            return flat_DITHER8_z_triangle;

-        case PF_INDEX8:

-            return flat_ci_z_triangle;

-        default:

-            return NULL;

-        }

-    }

-    if (   ctx->_RasterMask==0   /* no depth test */

-        && ctx->Light.ShadeModel==GL_SMOOTH

-        && ctx->Polygon.StippleFlag==GL_FALSE) {

-        switch (wmesa->pixelformat) {

-        case PF_8A8B8G8R:

-            return smooth_8A8B8G8R_triangle;

-        case PF_8R8G8B:

-            return smooth_8R8G8B_triangle;

-        case PF_5R6G5B:

-            return smooth_5R6G5B_triangle;

-        case PF_DITHER8:

-            return smooth_DITHER8_triangle;

-        case PF_INDEX8:

-            return smooth_ci_triangle;

-        default:

-            return NULL;

-        }

-    }

-

-    if (   ctx->_RasterMask==0   /* no depth test */

-        && ctx->Light.ShadeModel==GL_FLAT

-        && ctx->Polygon.StippleFlag==GL_FALSE) {

-        switch (wmesa->pixelformat) {

-        case PF_8A8B8G8R:

-            return flat_8A8B8G8R_triangle;

-        case PF_8R8G8B:

-            return flat_8R8G8B_triangle;

-        case PF_5R6G5B:

-            return flat_5R6G5B_triangle;

-        case PF_DITHER8:

-            return flat_DITHER8_triangle;

-        case PF_INDEX8:

-            return flat_ci_triangle;

-        default:

-            return NULL;

-        }

-    }

-

-    return NULL;

-    }

-#endif

-}

-

-/*

-* Define a new viewport and reallocate auxillary buffers if the size of

-* the window (color buffer) has changed.

-*/

-void WMesaViewport( GLcontext *ctx,

-                   GLint x, GLint y, GLsizei width, GLsizei height )

-{

-#if 0

-    /* Save viewport */

-    ctx->Viewport.X = x;

-    ctx->Viewport.Width = width;

-    ctx->Viewport.Y = y;

-    ctx->Viewport.Height = height;

-

-    /* compute scale and bias values */

-/* Pre-Keith 3.1 changes

-    ctx->Viewport.Map.m[Sx] = (GLfloat) width / 2.0F;

-    ctx->Viewport.Map.m[Tx] = ctx->Viewport.Sx + x;

-    ctx->Viewport.Map.m[Sy] = (GLfloat) height / 2.0F;

-    ctx->Viewport.Map.m[Ty] = ctx->Viewport.Sy + y;

-*/

-	ctx->Viewport.WindowMap.m[MAT_SX] = (GLfloat) width / 2.0F;

-	ctx->Viewport.WindowMap.m[MAT_TX] = ctx->Viewport.WindowMap.m[MAT_SX] + x;

-	ctx->Viewport.WindowMap.m[MAT_SY] = (GLfloat) height / 2.0F;

-	ctx->Viewport.WindowMap.m[MAT_TY] = ctx->Viewport.WindowMap.m[MAT_SY] + y;

-#endif

-}

+/* $Id: wmesa.c,v 1.19 2001/09/18 16:39:38 kschultz Exp $ */
+
+/*
+ * Windows (Win32) device driver for Mesa 3.4
+ *
+ * Original author:
+ *
+ *  Copyright (C) 1996-  Li Wei
+ *  Address      :       Institute of Artificial Intelligence
+ *               :           & Robotics
+ *               :       Xi'an Jiaotong University
+ *  Email        :       [email protected]
+ *  Web page :       http://sun.aiar.xjtu.edu.cn
+ *
+ *  This file and its associations are partially borrowed from the
+ *  Windows NT driver for Mesa 1.8 , written by Mark Leaming
+ *  ([email protected]).
+ */
+
+
+#define WMESA_STEREO_C
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <GL/wmesa.h>
+#include "mesa_extend.h"
+#include "colors.h"
+#include "macros.h"
+#include "context.h"
+#include "dd.h"
+//#include "xform.h"
+//#include "vb.h"
+#include "matrix.h"
+#include "depth.h"
+#include "wmesadef.h"
+
+#pragma warning ( disable : 4100 4133 4761 )
+
+#ifdef PROFILE
+//  #include "profile.h"
+#endif
+
+#ifdef DITHER
+#include <wing.h>
+#endif
+
+#ifdef __CYGWIN32__
+#include "macros.h"
+#include <string.h>
+#define CopyMemory memcpy
+#endif
+
+#if !defined(NO_STEREO)
+
+#include "gl\glu.h"
+#include "stereo.h"
+
+#endif
+#if !defined(NO_PARALLEL)
+  #include "parallel.h"
+#endif
+
+struct DISPLAY_OPTIONS displayOptions;
+
+GLenum stereoCompile = GL_FALSE ;
+GLenum stereoShowing  = GL_FALSE ;
+GLenum stereoBuffer = GL_FALSE;
+#if !defined(NO_STEREO)
+GLint displayList = MAXIMUM_DISPLAY_LIST ;
+#endif
+GLint stereo_flag = 0 ;
+
+/* end of added code*/
+
+static PWMC Current = NULL;
+WMesaContext WC = NULL;
+
+#ifdef NDEBUG
+#define assert(ignore)  ((void) 0)
+#else
+void Mesa_Assert(void *Cond,void *File,unsigned Line)
+{
+    char Msg[512];
+    sprintf(Msg,"%s %s %d",Cond,File,Line);
+    MessageBox(NULL,Msg,"Assertion failed.",MB_OK);
+    exit(1);
+}
+#define assert(e)   if (!e) Mesa_Assert(#e,__FILE__,__LINE__);
+#endif
+
+//#define DD_GETDC (Current->hDC )
+#define DD_GETDC ((Current->db_flag) ? Current->dib.hDC : Current->hDC )
+//#define DD_GETDC ((Current->db_flag) ? Current->hDCPrimary : Current->hDCBack )
+#define DD_RELEASEDC
+
+//#define BEGINGDICALL  if(Current->rgb_flag)wmFlushBits(Current);
+#define BEGINGDICALL
+//#define ENDGDICALL        if(Current->rgb_flag)wmGetBits(Current);
+#define ENDGDICALL
+
+//#define FLIP(Y)  (Current->dither_flag? Y : Current->height-(Y)-1)
+//#define FLIP(Y)  (Current->height-(Y)-1)
+//#define FLIP(Y) Y
+/*
+ * XXX Why only flip Y coord if single buffered???
+ */
+#define FLIP(Y)  (Current->db_flag? Y: Current->height-(Y)-1)
+#define STARTPROFILE
+#define ENDPROFILE(PARA)
+
+#define DITHER_RGB_TO_8BIT_SETUP            \
+GLubyte pixelDithered;
+
+#define DITHER_RGB_TO_8BIT(red, green, blue, pixel, scanline)               \
+{                                                                           \
+    char unsigned redtemp, greentemp, bluetemp, paletteindex;               \
+    redtemp = aDividedBy51[red]                                             \
+    + (aModulo51[red] > aHalftone8x8[(pixel%8)*8                        \
+    + scanline%8]);                                                 \
+    greentemp = aDividedBy51[(char unsigned)green]                          \
+    + (aModulo51[green] > aHalftone8x8[                             \
+    (pixel%8)*8 + scanline%8]);                                     \
+    bluetemp = aDividedBy51[(char unsigned)blue]                            \
+    + (aModulo51[blue] > aHalftone8x8[                              \
+    (pixel%8)*8 +scanline%8]);                                      \
+    paletteindex = redtemp + aTimes6[greentemp] + aTimes36[bluetemp];       \
+    pixelDithered = aWinGHalftoneTranslation[paletteindex];                 \
+}
+
+
+#ifdef DDRAW
+static BOOL DDInit( WMesaContext wc, HWND hwnd);
+static void DDFree( WMesaContext wc);
+static HRESULT DDRestoreAll( WMesaContext wc );
+static void DDDeleteOffScreen(WMesaContext wc);
+static BOOL DDCreateOffScreen(WMesaContext wc);
+#endif
+
+static void FlushToFile(PWMC pwc, PSTR  szFile);
+
+BOOL wmCreateBackingStore(PWMC pwc, long lxSize, long lySize);
+BOOL wmDeleteBackingStore(PWMC pwc);
+void wmCreatePalette( PWMC pwdc );
+BOOL wmSetDibColors(PWMC pwc);
+void wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b);
+
+void wmCreateDIBSection(
+                        HDC  hDC,
+                        PWMC pwc,   // handle of device context
+                        CONST BITMAPINFO *pbmi, // address of structure containing bitmap size, format, and color data
+                        UINT iUsage // color data type indicator: RGB values or palette indices
+                        );
+
+
+void WMesaViewport( GLcontext *ctx,
+                    GLint x, GLint y, GLsizei width, GLsizei height );
+
+
+//static triangle_func choose_triangle_function( GLcontext *ctx );
+
+
+static void wmSetPixelFormat( PWMC wc, HDC hDC)
+{
+    if(wc->rgb_flag)
+        wc->cColorBits = GetDeviceCaps(hDC, BITSPIXEL);
+    else
+        wc->cColorBits = 8;
+    switch(wc->cColorBits){
+    case 8:
+        if(wc->dither_flag != GL_TRUE)
+            wc->pixelformat = PF_INDEX8;
+        else
+            wc->pixelformat = PF_DITHER8;
+        break;
+    case 16:
+        wc->pixelformat = PF_5R6G5B;
+        break;
+    case 32:
+        wc->pixelformat = PF_8R8G8B;
+        break;
+    default:
+        wc->pixelformat = PF_BADFORMAT;
+    }
+}
+
+//
+// This function sets the color table of a DIB section
+// to match that of the destination DC
+//
+BOOL /*WINAPI*/ wmSetDibColors(PWMC pwc)
+{
+    RGBQUAD         *pColTab, *pRGB;
+    PALETTEENTRY    *pPal, *pPE;
+    int             i, nColors;
+    BOOL            bRet=TRUE;
+    DWORD           dwErr=0;
+
+    /* Build a color table in the DIB that maps to the
+    selected palette in the DC.
+    */
+    nColors = 1 << pwc->cColorBits;
+    pPal = (PALETTEENTRY *)malloc( nColors * sizeof(PALETTEENTRY));
+    memset( pPal, 0, nColors * sizeof(PALETTEENTRY) );
+    GetPaletteEntries( pwc->hGLPalette, 0, nColors, pPal );
+    pColTab = (RGBQUAD *)malloc( nColors * sizeof(RGBQUAD));
+    for (i = 0, pRGB = pColTab, pPE = pPal; i < nColors; i++, pRGB++, pPE++) {
+        pRGB->rgbRed = pPE->peRed;
+        pRGB->rgbGreen = pPE->peGreen;
+        pRGB->rgbBlue = pPE->peBlue;
+    }
+    if(pwc->db_flag)
+        bRet = SetDIBColorTable(pwc->dib.hDC, 0, nColors, pColTab );
+
+    if(!bRet)
+        dwErr = GetLastError();
+
+    free( pColTab );
+    free( pPal );
+
+    return(bRet);
+}
+
+
+//
+// Free up the dib section that was created
+//
+BOOL wmDeleteBackingStore(PWMC pwc)
+{
+    SelectObject(pwc->dib.hDC, pwc->hOldBitmap);
+    DeleteDC(pwc->dib.hDC);
+    DeleteObject(pwc->hbmDIB);
+    UnmapViewOfFile(pwc->dib.base);
+    CloseHandle(pwc->dib.hFileMap);
+    return TRUE;
+}
+
+
+//
+// This function creates the DIB section that is used for combined
+// GL and GDI calls
+//
+BOOL /*WINAPI*/ wmCreateBackingStore(PWMC pwc, long lxSize, long lySize)
+{
+    HDC hdc = pwc->hDC;
+    LPBITMAPINFO pbmi = &(pwc->bmi);
+    int     iUsage;
+
+    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    pbmi->bmiHeader.biWidth = lxSize;
+    pbmi->bmiHeader.biHeight= -lySize;
+    pbmi->bmiHeader.biPlanes = 1;
+    if(pwc->rgb_flag)
+        pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwc->hDC, BITSPIXEL);
+    else
+        pbmi->bmiHeader.biBitCount = 8;
+    pbmi->bmiHeader.biCompression = BI_RGB;
+    pbmi->bmiHeader.biSizeImage = 0;
+    pbmi->bmiHeader.biXPelsPerMeter = 0;
+    pbmi->bmiHeader.biYPelsPerMeter = 0;
+    pbmi->bmiHeader.biClrUsed = 0;
+    pbmi->bmiHeader.biClrImportant = 0;
+
+    iUsage = (pbmi->bmiHeader.biBitCount <= 8) ? DIB_PAL_COLORS : DIB_RGB_COLORS;
+
+    pwc->cColorBits = pbmi->bmiHeader.biBitCount;
+    pwc->ScanWidth = pwc->pitch = lxSize;
+
+    wmCreateDIBSection(hdc, pwc, pbmi, iUsage);
+
+    if ((iUsage == DIB_PAL_COLORS) && !(pwc->hGLPalette)) {
+        wmCreatePalette( pwc );
+        wmSetDibColors( pwc );
+    }
+    wmSetPixelFormat(pwc, pwc->hDC);
+    return(TRUE);
+
+}
+
+
+//
+// This function copies one scan line in a DIB section to another
+//
+BOOL WINAPI wmSetDIBits(PWMC pwc, UINT uiScanWidth, UINT uiNumScans, UINT nBypp, UINT uiNewWidth, LPBYTE pBits)
+{
+    UINT uiScans = 0;
+    LPBYTE  pDest = pwc->pbPixels;
+    DWORD   dwNextScan = uiScanWidth;
+    DWORD   dwNewScan = uiNewWidth;
+    DWORD   dwScanWidth = (uiScanWidth * nBypp);
+
+    //
+    // We need to round up to the nearest DWORD
+    // and multiply by the number of bytes per
+    // pixel
+    //
+    dwNextScan = (((dwNextScan * nBypp)+ 3) & ~3);
+    dwNewScan = (((dwNewScan * nBypp)+ 3) & ~3);
+
+    for(uiScans = 0; uiScans < uiNumScans; uiScans++){
+        CopyMemory(pDest, pBits, dwScanWidth);
+        pBits += dwNextScan;
+        pDest += dwNewScan;
+    }
+
+    return(TRUE);
+
+}
+
+
+BOOL wmFlush(PWMC pwc);
+
+/*
+* Useful macros:
+Modified from file osmesa.c
+*/
+
+
+#define PIXELADDR(X,Y)  ((GLubyte *)Current->pbPixels + (Current->height-Y-1)* Current->ScanWidth + (X)*nBypp)
+#define PIXELADDR1( X, Y )  \
+((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X))
+#define PIXELADDR2( X, Y )  \
+((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X)*2)
+#define PIXELADDR4( X, Y )  \
+((GLubyte *)wmesa->pbPixels + (wmesa->height-Y-1)* wmesa->ScanWidth + (X)*4)
+
+
+BYTE DITHER_RGB_2_8BIT( int r, int g, int b, int x, int y);
+
+/* Finish all pending operations and synchronize. */
+static void finish(GLcontext* ctx)
+{
+    /* No op */
+}
+
+
+//
+// We cache all gl draw routines until a flush is made
+//
+static void flush(GLcontext* ctx)
+{
+    STARTPROFILE
+        if((Current->rgb_flag /*&& !(Current->dib.fFlushed)*/&&!(Current->db_flag))
+            ||(!Current->rgb_flag))
+        {
+            wmFlush(Current);
+        }
+        ENDPROFILE(flush)
+
+}
+
+
+
+/*
+* Set the color index used to clear the color buffer.
+*/
+static void clear_index(GLcontext* ctx, GLuint index)
+{
+    STARTPROFILE
+        Current->clearpixel = index;
+    ENDPROFILE(clear_index)
+}
+
+
+
+/*
+* Set the color used to clear the color buffer.
+*/
+static void clear_color( GLcontext* ctx, const GLchan color[4] )
+{
+    STARTPROFILE
+        Current->clearpixel = RGB(color[0], color[1], color[2]);
+    ENDPROFILE(clear_color)
+}
+
+
+
+/*
+* Clear the specified region of the color buffer using the clear color
+* or index as specified by one of the two functions above.
+*/
+//static void clear(GLcontext* ctx,
+//                  GLboolean all,GLint x, GLint y, GLint width, GLint height )
+// TODO: I modified this function to match the prototype in
+//       dd.h. ([email protected])
+
+static GLbitfield clear(GLcontext* ctx, GLbitfield mask,
+                  GLboolean all, GLint x, GLint y, GLint width, GLint height)
+{
+    DWORD   dwColor;
+    WORD    wColor;
+    BYTE    bColor;
+    LPDWORD lpdw = (LPDWORD)Current->pbPixels;
+    LPWORD  lpw = (LPWORD)Current->pbPixels;
+    LPBYTE  lpb = Current->pbPixels;
+    int     lines;
+
+    STARTPROFILE
+
+        if (all){
+            x=y=0;
+            width=Current->width;
+            height=Current->height;
+        }
+        if(Current->db_flag==GL_TRUE){
+            UINT    nBypp = Current->cColorBits / 8;
+            int     i = 0;
+            int     iSize = 0;
+
+            if(nBypp ==1 ){
+                /* Need rectification */
+                iSize = Current->width/4;
+                bColor  = BGR8(GetRValue(Current->clearpixel),
+                    GetGValue(Current->clearpixel),
+                    GetBValue(Current->clearpixel));
+                wColor  = MAKEWORD(bColor,bColor);
+                dwColor = MAKELONG(wColor, wColor);
+            }
+            if(nBypp == 2){
+                iSize = Current->width / 2;
+                wColor = BGR16(GetRValue(Current->clearpixel),
+                    GetGValue(Current->clearpixel),
+                    GetBValue(Current->clearpixel));
+                dwColor = MAKELONG(wColor, wColor);
+            }
+            else if(nBypp == 4){
+                iSize = Current->width;
+                dwColor = BGR32(GetRValue(Current->clearpixel),
+                    GetGValue(Current->clearpixel),
+                    GetBValue(Current->clearpixel));
+            }
+
+            while(i < iSize){
+                *lpdw = dwColor;
+                lpdw++;
+                i++;
+            }
+
+            //
+            // This is the 24bit case
+            //
+            if (nBypp == 3) {
+                iSize = Current->width *3/4;
+                dwColor = BGR24(GetRValue(Current->clearpixel),
+                    GetGValue(Current->clearpixel),
+                    GetBValue(Current->clearpixel));
+                while(i < iSize){
+                    *lpdw = dwColor;
+                    lpb += nBypp;
+                    lpdw = (LPDWORD)lpb;
+                    i++;
+                }
+            }
+
+            i = 0;
+            if (stereo_flag)
+               lines = height /2;
+            else
+               lines = height;
+            do {
+                memcpy(lpb, Current->pbPixels, iSize*4);
+                lpb += Current->ScanWidth;
+                i++;
+            }
+            while (i<lines-1);
+        }
+        else { // For single buffer
+            HDC DC=DD_GETDC;
+            HPEN Pen=CreatePen(PS_SOLID,1,Current->clearpixel);
+            HBRUSH Brush=CreateSolidBrush(Current->clearpixel);
+            HPEN Old_Pen=SelectObject(DC,Pen);
+            HBRUSH Old_Brush=SelectObject(DC,Brush);
+            Rectangle(DC,x,y,x+width,y+height);
+            SelectObject(DC,Old_Pen);
+            SelectObject(DC,Old_Brush);
+            DeleteObject(Pen);
+            DeleteObject(Brush);
+            DD_RELEASEDC;
+        }
+
+
+
+        ENDPROFILE(clear)
+
+		return mask;	// TODO: I doubt this is correct. dd.h doesn't explain what this should
+		                //       be...
+}
+
+
+
+static void enable( GLcontext* ctx, GLenum pname, GLboolean enable )
+{
+   if (!Current)
+      return;
+
+   if (pname == GL_DITHER) {
+      if(enable == GL_FALSE){
+         Current->dither_flag = GL_FALSE;
+         if(Current->cColorBits == 8)
+            Current->pixelformat = PF_INDEX8;
+      }
+      else{
+         if (Current->rgb_flag && Current->cColorBits == 8){
+            Current->pixelformat = PF_DITHER8;
+            Current->dither_flag = GL_TRUE;
+         }
+         else
+            Current->dither_flag = GL_FALSE;
+      }
+   }
+}
+
+
+
+static GLboolean set_draw_buffer( GLcontext* ctx, GLenum mode )
+{
+   STARTPROFILE
+   /* TODO: this could be better */
+   if (mode==GL_FRONT_LEFT || mode==GL_BACK_LEFT) {
+      return GL_TRUE;
+   }
+   else {
+      return GL_FALSE;
+   }
+   ENDPROFILE(set_draw_buffer)
+}
+
+
+static void set_read_buffer(GLcontext *ctx, GLframebuffer *colorBuffer,
+                            GLenum buffer )
+{
+   /* XXX todo */
+   return;
+}
+
+
+
+/* Return characteristics of the output buffer. */
+static void buffer_size( GLcontext* ctx, GLuint *width, GLuint *height )
+{
+   int New_Size;
+   RECT CR;
+
+   STARTPROFILE
+   GetClientRect(Current->Window,&CR);
+
+   *width=CR.right;
+   *height=CR.bottom;
+
+   New_Size=((*width)!=Current->width) || ((*height)!=Current->height);
+
+   if (New_Size){
+      Current->width=*width;
+      Current->height=*height;
+      Current->ScanWidth=Current->width;
+      if ((Current->ScanWidth%sizeof(long))!=0)
+         Current->ScanWidth+=(sizeof(long)-(Current->ScanWidth%sizeof(long)));
+
+      if (Current->db_flag){
+#ifdef DDRAW
+         DDDeleteOffScreen(Current);
+         DDCreateOffScreen(Current);
+#else
+         if (Current->rgb_flag==GL_TRUE && Current->dither_flag!=GL_TRUE){
+            wmDeleteBackingStore(Current);
+            wmCreateBackingStore(Current, Current->width, Current->height);
+         }
+#endif
+      }
+
+      //  Resize OsmesaBuffer if in Parallel mode
+#if !defined(NO_PARALLEL)
+      if(parallelFlag)
+         PRSizeRenderBuffer(Current->width, Current->height,Current->ScanWidth,
+                            Current->rgb_flag == GL_TRUE ? Current->pbPixels: Current->ScreenMem);
+#endif
+   }
+   ENDPROFILE(buffer_size)
+}
+
+
+
+/**********************************************************************/
+/*****           Accelerated point, line, polygon rendering       *****/
+/**********************************************************************/
+
+
+static void fast_rgb_points( GLcontext* ctx, GLuint first, GLuint last )
+{
+#if 0
+    GLuint i;
+    //  HDC DC=DD_GETDC;
+    PWMC    pwc = Current;
+
+    STARTPROFILE
+
+        if (0 /*Current->gl_ctx->VB->MonoColor*/) {
+            /* all drawn with current color */
+            for (i=first;i<=last;i++) {
+                if (!Current->gl_ctx->VB->ClipMask[i]) {
+                    int x, y;
+                    x =       (GLint) Current->gl_ctx->VB->Win.data[i][0];
+                    y = FLIP( (GLint) Current->gl_ctx->VB->Win.data[i][1] );
+                    wmSetPixel(pwc, y,x,GetRValue(Current->pixel),
+                        GetGValue(Current->pixel), GetBValue(Current->pixel));
+                }
+            }
+        }
+        else {
+            /* draw points of different colors */
+            for (i=first;i<=last;i++) {
+                if (!Current->gl_ctx->VB->ClipMask[i]) {
+                    int x, y;
+                    unsigned long pixel=RGB(Current->gl_ctx->VB->ColorPtr->data[i][0]*255.0,
+                        Current->gl_ctx->VB->ColorPtr->data[i][1]*255.0,
+                        Current->gl_ctx->VB->ColorPtr->data[i][2]*255.0);
+                    x =       (GLint) Current->gl_ctx->VB->Win.data[i][0];
+                    y = FLIP( (GLint) Current->gl_ctx->VB->Win.data[i][1] );
+                    wmSetPixel(pwc, y,x,Current->gl_ctx->VB->ColorPtr->data[i][0]*255.0,
+                        Current->gl_ctx->VB->ColorPtr->data[i][1]*255.0,
+                        Current->gl_ctx->VB->ColorPtr->data[i][2]*255.0);
+                }
+            }
+        }
+        //   DD_RELEASEDC;
+        ENDPROFILE(fast_rgb_points)
+#endif
+}
+
+
+
+/* Return pointer to accerated points function */
+extern /*points_func*/ choose_points_function( GLcontext* ctx )
+{
+#if 0
+    STARTPROFILE
+        if (ctx->Point.Size==1.0 && !ctx->Point.SmoothFlag && ctx->_RasterMask==0
+            && !ctx->Texture._ReallyEnabled  && ctx->Visual->RGBAflag) {
+            ENDPROFILE(choose_points_function)
+                return fast_rgb_points;
+        }
+        else {
+            ENDPROFILE(choose_points_function)
+                return NULL;
+        }
+#endif
+}
+
+
+
+/* Draw a line using the color specified by Current->gl_ctx->VB->ColorPtr->data[pv] */
+static void fast_flat_rgb_line( GLcontext* ctx, GLuint v0, GLuint v1, GLuint pv )
+{
+#if 0
+    STARTPROFILE
+        int x0, y0, x1, y1;
+    unsigned long pixel;
+    HDC DC=DD_GETDC;
+    HPEN Pen;
+    HPEN Old_Pen;
+
+    if (0 /*Current->gl_ctx->VB->MonoColor*/) {
+        pixel = Current->pixel;  /* use current color */
+    }
+    else {
+        pixel = RGB(Current->gl_ctx->VB->ColorPtr->data[pv][0]*255.0, Current->gl_ctx->VB->ColorPtr->data[pv][1]*255.0, Current->gl_ctx->VB->ColorPtr->data[pv][2]*255.0);
+    }
+
+    x0 =       (int) Current->gl_ctx->VB->Win.data[v0][0];
+    y0 = FLIP( (int) Current->gl_ctx->VB->Win.data[v0][1] );
+    x1 =       (int) Current->gl_ctx->VB->Win.data[v1][0];
+    y1 = FLIP( (int) Current->gl_ctx->VB->Win.data[v1][1] );
+
+
+    BEGINGDICALL
+
+    Pen=CreatePen(PS_SOLID,1,pixel);
+    Old_Pen=SelectObject(DC,Pen);
+    MoveToEx(DC,x0,y0,NULL);
+    LineTo(DC,x1,y1);
+    SelectObject(DC,Old_Pen);
+    DeleteObject(Pen);
+    DD_RELEASEDC;
+
+    ENDGDICALL
+
+    ENDPROFILE(fast_flat_rgb_line)
+#endif
+}
+
+
+
+/* Return pointer to accerated line function */
+static /*line_func*/ choose_line_function( GLcontext* ctx )
+{
+#if 0
+    STARTPROFILE
+    if (ctx->Line.Width==1.0 && !ctx->Line.SmoothFlag && !ctx->Line.StippleFlag
+        && ctx->Light.ShadeModel==GL_FLAT && ctx->_RasterMask==0
+        && !ctx->Texture._ReallyEnabled && Current->rgb_flag) {
+       ENDPROFILE(choose_line_function)
+       return fast_flat_rgb_line;
+    }
+    else {
+       ENDPROFILE(choose_line_function)
+       return NULL;
+    }
+#endif
+}
+
+
+/**********************************************************************/
+/*****                 Span-based pixel drawing                   *****/
+/**********************************************************************/
+
+
+/* Write a horizontal span of 32-bit color-index pixels with a boolean mask. */
+static void write_ci32_span( const GLcontext* ctx,
+                             GLuint n, GLint x, GLint y,
+                             const GLuint index[],
+                             const GLubyte mask[] )
+{
+    STARTPROFILE
+    GLuint i;
+    PBYTE Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;
+    assert(Current->rgb_flag==GL_FALSE);
+    for (i=0; i<n; i++)
+        if (mask[i])
+            Mem[i]=index[i];
+    ENDPROFILE(write_ci32_span)
+}
+
+
+/* Write a horizontal span of 8-bit color-index pixels with a boolean mask. */
+static void write_ci8_span( const GLcontext* ctx,
+                            GLuint n, GLint x, GLint y,
+                            const GLubyte index[],
+                            const GLubyte mask[] )
+{
+    STARTPROFILE
+    GLuint i;
+    PBYTE Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;
+    assert(Current->rgb_flag==GL_FALSE);
+    for (i=0; i<n; i++)
+        if (mask[i])
+            Mem[i]=index[i];
+    ENDPROFILE(write_ci8_span)
+}
+
+
+
+/*
+* Write a horizontal span of pixels with a boolean mask.  The current
+* color index is used for all pixels.
+*/
+static void write_mono_ci_span(const GLcontext* ctx,
+                               GLuint n,GLint x,GLint y,
+                               GLuint colorIndex, const GLubyte mask[])
+{
+   STARTPROFILE
+   GLuint i;
+   BYTE *Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;
+   assert(Current->rgb_flag==GL_FALSE);
+   for (i=0; i<n; i++)
+      if (mask[i])
+         Mem[i]=colorIndex;
+   ENDPROFILE(write_mono_ci_span)
+}
+
+/*
+ * To improve the performance of this routine, frob the data into an actual
+ * scanline and call bitblt on the complete scan line instead of SetPixel.
+ */
+
+/* Write a horizontal span of RGBA color pixels with a boolean mask. */
+static void write_rgba_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,
+                             const GLubyte rgba[][4], const GLubyte mask[] )
+{
+    STARTPROFILE
+    PWMC    pwc = Current;
+
+    if (pwc->rgb_flag==GL_TRUE)
+    {
+        GLuint i;
+        HDC DC=DD_GETDC;
+        y=FLIP(y);
+        if (mask) {
+            for (i=0; i<n; i++)
+                if (mask[i])
+                    wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+        }
+        else {
+            for (i=0; i<n; i++)
+                wmSetPixel(pwc, y, x + i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+        }
+        DD_RELEASEDC;
+    }
+    else
+    {
+        GLuint i;
+        BYTE *Mem=Current->ScreenMem+y*Current->ScanWidth+x;
+        y = FLIP(y);
+        if (mask) {
+            for (i=0; i<n; i++)
+                if (mask[i])
+                    Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
+        }
+        else {
+            for (i=0; i<n; i++)
+                Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
+        }
+    }
+    ENDPROFILE(write_rgba_span)
+
+}
+
+/* Write a horizontal span of RGB color pixels with a boolean mask. */
+static void write_rgb_span( const GLcontext* ctx,
+                            GLuint n, GLint x, GLint y,
+                            const GLubyte rgb[][3], const GLubyte mask[] )
+{
+    STARTPROFILE
+    PWMC    pwc = Current;
+
+    if (pwc->rgb_flag==GL_TRUE)
+    {
+        GLuint i;
+        HDC DC=DD_GETDC;
+        y=FLIP(y);
+        if (mask) {
+            for (i=0; i<n; i++)
+                if (mask[i])
+                    wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+        }
+        else {
+            for (i=0; i<n; i++)
+                wmSetPixel(pwc, y, x + i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+        }
+        DD_RELEASEDC;
+    }
+    else
+    {
+        GLuint i;
+        BYTE *Mem=Current->ScreenMem+y*Current->ScanWidth+x;
+        y = FLIP(y);
+        if (mask) {
+            for (i=0; i<n; i++)
+                if (mask[i])
+                    Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));
+        }
+        else {
+            for (i=0; i<n; i++)
+                Mem[i] = GetNearestPaletteIndex(Current->hPal,RGB(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));
+        }
+    }
+    ENDPROFILE(write_rgb_span)
+
+}
+
+/*
+* Write a horizontal span of pixels with a boolean mask.  The current color
+* is used for all pixels.
+*/
+static void write_mono_rgba_span( const GLcontext* ctx,
+                                  GLuint n, GLint x, GLint y,
+                                  const GLchan color[4], const GLubyte mask[])
+{
+    ULONG pixel =  RGB( color[RCOMP], color[GCOMP], color[BCOMP] );
+    STARTPROFILE
+    GLuint i;
+    HDC DC=DD_GETDC;
+    PWMC pwc = Current;
+    assert(Current->rgb_flag==GL_TRUE);
+    y=FLIP(y);
+    if(Current->rgb_flag==GL_TRUE){
+        for (i=0; i<n; i++)
+            if (mask[i])
+                // Trying
+                wmSetPixel(pwc,y,x+i,color[RCOMP], color[GCOMP], color[BCOMP]);
+    }
+    else {
+        for (i=0; i<n; i++)
+            if (mask[i])
+                SetPixel(DC, y, x+i, pixel);
+    }
+    DD_RELEASEDC;
+    ENDPROFILE(write_mono_rgba_span)
+}
+
+
+
+/**********************************************************************/
+/*****                   Array-based pixel drawing                *****/
+/**********************************************************************/
+
+
+/* Write an array of 32-bit index pixels with a boolean mask. */
+static void write_ci32_pixels( const GLcontext* ctx,
+                               GLuint n, const GLint x[], const GLint y[],
+                               const GLuint index[], const GLubyte mask[] )
+{
+   STARTPROFILE
+   GLuint i;
+   assert(Current->rgb_flag==GL_FALSE);
+   for (i=0; i<n; i++) {
+      if (mask[i]) {
+         BYTE *Mem=Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i];
+         *Mem = index[i];
+      }
+   }
+   ENDPROFILE(write_ci32_pixels)
+}
+
+
+
+/*
+* Write an array of pixels with a boolean mask.  The current color
+* index is used for all pixels.
+*/
+static void write_mono_ci_pixels( const GLcontext* ctx,
+                                  GLuint n,
+                                  const GLint x[], const GLint y[],
+                                  GLuint colorIndex, const GLubyte mask[] )
+{
+   STARTPROFILE
+   GLuint i;
+   assert(Current->rgb_flag==GL_FALSE);
+   for (i=0; i<n; i++) {
+      if (mask[i]) {
+         BYTE *Mem=Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i];
+         *Mem = colorIndex;
+      }
+   }
+   ENDPROFILE(write_mono_ci_pixels)
+}
+
+
+
+/* Write an array of RGBA pixels with a boolean mask. */
+static void write_rgba_pixels( const GLcontext* ctx,
+                               GLuint n, const GLint x[], const GLint y[],
+                               const GLubyte rgba[][4], const GLubyte mask[] )
+{
+    STARTPROFILE
+        GLuint i;
+    PWMC    pwc = Current;
+    HDC DC=DD_GETDC;
+    assert(Current->rgb_flag==GL_TRUE);
+    for (i=0; i<n; i++)
+       if (mask[i])
+          wmSetPixel(pwc, FLIP(y[i]), x[i],
+                     rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+    DD_RELEASEDC;
+    ENDPROFILE(write_rgba_pixels)
+}
+
+
+
+/*
+* Write an array of pixels with a boolean mask.  The current color
+* is used for all pixels.
+*/
+static void write_mono_rgba_pixels( const GLcontext* ctx,
+                                    GLuint n,
+                                    const GLint x[], const GLint y[],
+                                    const GLchan color[4],
+                                    const GLubyte mask[] )
+{
+    STARTPROFILE
+    GLuint i;
+    PWMC    pwc = Current;
+    HDC DC=DD_GETDC;
+    assert(Current->rgb_flag==GL_TRUE);
+    for (i=0; i<n; i++)
+        if (mask[i])
+            wmSetPixel(pwc, FLIP(y[i]),x[i],color[RCOMP],
+                       color[GCOMP], color[BCOMP]);
+    DD_RELEASEDC;
+    ENDPROFILE(write_mono_rgba_pixels)
+}
+
+
+
+/**********************************************************************/
+/*****            Read spans/arrays of pixels                     *****/
+/**********************************************************************/
+
+
+/* Read a horizontal span of color-index pixels. */
+static void read_ci32_span( const GLcontext* ctx, GLuint n, GLint x, GLint y,
+                            GLuint index[])
+{
+   STARTPROFILE
+   GLuint i;
+   BYTE *Mem=Current->ScreenMem+FLIP(y)*Current->ScanWidth+x;
+   assert(Current->rgb_flag==GL_FALSE);
+   for (i=0; i<n; i++)
+      index[i]=Mem[i];
+   ENDPROFILE(read_ci32_span)
+}
+
+
+
+
+/* Read an array of color index pixels. */
+static void read_ci32_pixels( const GLcontext* ctx,
+                              GLuint n, const GLint x[], const GLint y[],
+                              GLuint indx[], const GLubyte mask[] )
+{
+   STARTPROFILE
+   GLuint i;
+   assert(Current->rgb_flag==GL_FALSE);
+   for (i=0; i<n; i++) {
+      if (mask[i]) {
+         indx[i]=*(Current->ScreenMem+FLIP(y[i])*Current->ScanWidth+x[i]);
+      }
+   }
+   ENDPROFILE(read_ci32_pixels)
+}
+
+
+
+/* Read a horizontal span of color pixels. */
+static void read_rgba_span( const GLcontext* ctx,
+                            GLuint n, GLint x, GLint y,
+                            GLubyte rgba[][4] )
+{
+   STARTPROFILE
+   UINT i;
+   COLORREF Color;
+   HDC DC=DD_GETDC;
+   assert(Current->rgb_flag==GL_TRUE);
+   /*   y=FLIP(y);*/
+   y = Current->height - y - 1;
+   for (i=0; i<n; i++) {
+      Color=GetPixel(DC,x+i,y);
+      rgba[i][RCOMP] = GetRValue(Color);
+      rgba[i][GCOMP] = GetGValue(Color);
+      rgba[i][BCOMP] = GetBValue(Color);
+      rgba[i][ACOMP] = 255;
+   }
+   DD_RELEASEDC;
+// Brian P. Has mentioned to comment this out.
+//   memset(alpha,0,n*sizeof(GLubyte));
+   ENDPROFILE(read_rgba_span)
+}
+
+
+/* Read an array of color pixels. */
+static void read_rgba_pixels( const GLcontext* ctx,
+                              GLuint n, const GLint x[], const GLint y[],
+                              GLubyte rgba[][4], const GLubyte mask[] )
+{
+   STARTPROFILE
+   GLuint i;
+   COLORREF Color;
+   HDC DC=DD_GETDC;
+   assert(Current->rgb_flag==GL_TRUE);
+   for (i=0; i<n; i++) {
+      if (mask[i]) {
+         GLint y2 = Current->height - y[i] - 1;
+         Color=GetPixel(DC,x[i],y2);
+         rgba[i][RCOMP] = GetRValue(Color);
+         rgba[i][GCOMP] = GetGValue(Color);
+         rgba[i][BCOMP] = GetBValue(Color);
+         rgba[i][ACOMP] = 255;
+      }
+   }
+   DD_RELEASEDC;
+// Brian P. has mentioned to comment this out.
+//   memset(alpha,0,n*sizeof(GLint));
+   ENDPROFILE(read_rgba_pixels)
+}
+
+
+
+/**********************************************************************/
+/**********************************************************************/
+
+
+static const GLubyte *get_string(GLcontext *ctx, GLenum name)
+{
+   if (name == GL_RENDERER) {
+      return (GLubyte *) "Mesa Windows";
+   }
+   else {
+      return NULL;
+   }
+}
+
+
+
+void setup_DD_pointers( GLcontext* ctx )
+{
+#if 0
+    ctx->Driver.GetString = get_string;
+    ctx->Driver.UpdateState = setup_DD_pointers;
+    ctx->Driver.GetBufferSize = buffer_size;
+    ctx->Driver.Finish = finish;
+    ctx->Driver.Flush = flush;
+
+    ctx->Driver.ClearIndex = clear_index;
+    ctx->Driver.ClearColor = clear_color;
+    ctx->Driver.Clear = clear;
+
+    ctx->Driver.Enable = enable;
+
+    ctx->Driver.SetDrawBuffer = set_draw_buffer;
+    ctx->Driver.SetReadBuffer = set_read_buffer;
+    ctx->Driver.GetBufferSize = buffer_size;
+
+    ctx->Driver.PointsFunc = choose_points_function(ctx);
+    ctx->Driver.LineFunc = choose_line_function(ctx);
+    ctx->Driver.TriangleFunc = choose_triangle_function( ctx );
+
+    /* Pixel/span writing functions: */
+	ctx->Driver.WriteRGBASpan        = write_rgba_span;
+    ctx->Driver.WriteRGBSpan         = write_rgb_span;
+    ctx->Driver.WriteMonoRGBASpan    = write_mono_rgba_span;
+    ctx->Driver.WriteRGBAPixels      = write_rgba_pixels;
+    ctx->Driver.WriteMonoRGBAPixels  = write_mono_rgba_pixels;
+    ctx->Driver.WriteCI32Span        = write_ci32_span;
+    ctx->Driver.WriteCI8Span         = write_ci8_span;
+    ctx->Driver.WriteMonoCISpan      = write_mono_ci_span;
+    ctx->Driver.WriteCI32Pixels      = write_ci32_pixels;
+    ctx->Driver.WriteMonoCIPixels    = write_mono_ci_pixels;
+
+    ctx->Driver.ReadCI32Span        = read_ci32_span;
+    ctx->Driver.ReadRGBASpan        = read_rgba_span;
+    ctx->Driver.ReadCI32Pixels      = read_ci32_pixels;
+    ctx->Driver.ReadRGBAPixels      = read_rgba_pixels;
+#endif
+}
+
+
+/**********************************************************************/
+/*****                  WMesa API Functions                       *****/
+/**********************************************************************/
+
+
+
+#define PAL_SIZE 256
+static void GetPalette(HPALETTE Pal,RGBQUAD *aRGB)
+{
+    STARTPROFILE
+        int i;
+    HDC hdc;
+    struct
+    {
+        WORD Version;
+        WORD NumberOfEntries;
+        PALETTEENTRY aEntries[PAL_SIZE];
+    } Palette =
+    {
+        0x300,
+            PAL_SIZE
+    };
+    hdc=GetDC(NULL);
+    if (Pal!=NULL)
+        GetPaletteEntries(Pal,0,PAL_SIZE,Palette.aEntries);
+    else
+        GetSystemPaletteEntries(hdc,0,PAL_SIZE,Palette.aEntries);
+    if (GetSystemPaletteUse(hdc) == SYSPAL_NOSTATIC)
+    {
+        for(i = 0; i <PAL_SIZE; i++)
+            Palette.aEntries[i].peFlags = PC_RESERVED;
+        Palette.aEntries[255].peRed = 255;
+        Palette.aEntries[255].peGreen = 255;
+        Palette.aEntries[255].peBlue = 255;
+        Palette.aEntries[255].peFlags = 0;
+        Palette.aEntries[0].peRed = 0;
+        Palette.aEntries[0].peGreen = 0;
+        Palette.aEntries[0].peBlue = 0;
+        Palette.aEntries[0].peFlags = 0;
+    }
+    else
+    {
+        int nStaticColors;
+        int nUsableColors;
+        nStaticColors = GetDeviceCaps(hdc, NUMCOLORS)/2;
+        for (i=0; i<nStaticColors; i++)
+            Palette.aEntries[i].peFlags = 0;
+        nUsableColors = PAL_SIZE-nStaticColors;
+        for (; i<nUsableColors; i++)
+            Palette.aEntries[i].peFlags = PC_RESERVED;
+        for (; i<PAL_SIZE-nStaticColors; i++)
+            Palette.aEntries[i].peFlags = PC_RESERVED;
+        for (i=PAL_SIZE-nStaticColors; i<PAL_SIZE; i++)
+            Palette.aEntries[i].peFlags = 0;
+    }
+    ReleaseDC(NULL,hdc);
+    for (i=0; i<PAL_SIZE; i++)
+    {
+        aRGB[i].rgbRed=Palette.aEntries[i].peRed;
+        aRGB[i].rgbGreen=Palette.aEntries[i].peGreen;
+        aRGB[i].rgbBlue=Palette.aEntries[i].peBlue;
+        aRGB[i].rgbReserved=Palette.aEntries[i].peFlags;
+    }
+    ENDPROFILE(GetPalette)
+}
+
+
+WMesaContext WMesaCreateContext( HWND hWnd, HPALETTE* Pal,
+                                GLboolean rgb_flag,
+                                GLboolean db_flag )
+{
+    RECT CR;
+    WMesaContext c;
+    GLboolean true_color_flag;
+    c = (struct wmesa_context * ) calloc(1,sizeof(struct wmesa_context));
+    if (!c)
+        return NULL;
+
+    c->Window=hWnd;
+    c->hDC = GetDC(hWnd);
+    true_color_flag = GetDeviceCaps(c->hDC, BITSPIXEL) > 8;
+#ifdef DDRAW
+    if(true_color_flag) c->rgb_flag = rgb_flag = GL_TRUE;
+#endif
+
+
+#ifdef DITHER
+    if ((true_color_flag==GL_FALSE) && (rgb_flag == GL_TRUE)){
+        c->dither_flag = GL_TRUE;
+        c->hPalHalfTone = WinGCreateHalftonePalette();
+    }
+    else
+        c->dither_flag = GL_FALSE;
+#else
+    c->dither_flag = GL_FALSE;
+#endif
+
+
+    if (rgb_flag==GL_FALSE)
+    {
+        c->rgb_flag = GL_FALSE;
+        //    c->pixel = 1;
+        c->db_flag = db_flag =GL_TRUE; // WinG requires double buffering
+        printf("Single buffer is not supported in color index mode, setting to double buffer.\n");
+    }
+    else
+    {
+        c->rgb_flag = GL_TRUE;
+        //    c->pixel = 0;
+    }
+    GetClientRect(c->Window,&CR);
+    c->width=CR.right;
+    c->height=CR.bottom;
+    if (db_flag)
+    {
+        c->db_flag = 1;
+        /* Double buffered */
+#ifndef DDRAW
+        //  if (c->rgb_flag==GL_TRUE && c->dither_flag != GL_TRUE )
+        {
+            wmCreateBackingStore(c, c->width, c->height);
+
+        }
+#endif
+    }
+    else
+    {
+        /* Single Buffered */
+        if (c->rgb_flag)
+            c->db_flag = 0;
+    }
+#ifdef DDRAW
+    if (DDInit(c,hWnd) == GL_FALSE) {
+        free( (void *) c );
+        exit(1);
+    }
+#endif
+
+
+    c->gl_visual = _mesa_create_visual(rgb_flag,
+                                       db_flag,    /* db_flag */
+                                       GL_FALSE,   /* stereo */
+                                       8,8,8,8,    /* r, g, b, a bits */
+                                       0,          /* index bits */
+                                       16,         /* depth_bits */
+                                       8,          /* stencil_bits */
+                                       16,16,16,16,/* accum_bits */
+                                       1);
+
+    if (!c->gl_visual) {
+        return NULL;
+    }
+
+    /* allocate a new Mesa context */
+    c->gl_ctx = _mesa_create_context( c->gl_visual, NULL, c, GL_TRUE);
+
+    if (!c->gl_ctx) {
+        _mesa_destroy_visual( c->gl_visual );
+        free(c);
+        return NULL;
+    }
+
+    _mesa_enable_sw_extensions(c->gl_ctx);
+#if 0
+    c->gl_buffer = _mesa_create_framebuffer( c->gl_visual,
+                                          c->gl_visual->DepthBits > 0,
+                                          c->gl_visual->StencilBits > 0,
+                                          c->gl_visual->AccumRedBits > 0,
+					  c->gl_visual->AlphaBits > 0 );
+#endif
+    c->gl_buffer = NULL; /* TEMP */
+    if (!c->gl_buffer) {
+        _mesa_destroy_visual( c->gl_visual );
+        _mesa_destroy_context( c->gl_ctx );
+        free(c);
+        return NULL;
+    }
+
+	c->gl_ctx->Driver.UpdateState = setup_DD_pointers;
+
+    //  setup_DD_pointers(c->gl_ctx);
+
+    return c;
+}
+
+void WMesaDestroyContext( void )
+{
+    WMesaContext c = Current;
+    ReleaseDC(c->Window,c->hDC);
+    WC = c;
+    if(c->hPalHalfTone != NULL)
+        DeleteObject(c->hPalHalfTone);
+    _mesa_destroy_visual( c->gl_visual );
+    _mesa_destroy_framebuffer( c->gl_buffer );
+    _mesa_destroy_context( c->gl_ctx );
+
+    if (c->db_flag)
+#ifdef DDRAW
+        DDFree(c);
+#else
+    wmDeleteBackingStore(c);
+#endif
+    free( (void *) c );
+    //Following code is added to enable parallel render
+    // Parallel render only work in double buffer mode
+#if !defined(NO_PARALLEL)
+    if(parallelMachine)
+        PRDestroyRenderBuffer();
+#endif
+    // End modification
+}
+
+
+
+void /*APIENTRY*/ WMesaMakeCurrent( WMesaContext c )
+{
+    if(!c){
+        Current = c;
+        return;
+    }
+
+    //
+    // A little optimization
+    // If it already is current,
+    // don't set it again
+    //
+    if(Current == c)
+        return;
+
+    //gl_set_context( c->gl_ctx );
+    _mesa_make_current(c->gl_ctx, c->gl_buffer);
+    setup_DD_pointers(c->gl_ctx);
+    Current = c;
+    if (Current->gl_ctx->Viewport.Width==0) {
+        /* initialize viewport to window size */
+        _mesa_set_viewport( Current->gl_ctx,
+            0, 0, Current->width, Current->height );
+    }
+    if ((c->cColorBits <= 8 ) && (c->rgb_flag == GL_TRUE)){
+        WMesaPaletteChange(c->hPalHalfTone);
+    }
+}
+
+
+
+void /*APIENTRY*/ WMesaSwapBuffers( void )
+{
+    HDC DC = Current->hDC;
+    GET_CURRENT_CONTEXT(ctx);
+
+    /* If we're swapping the buffer associated with the current context
+     * we have to flush any pending rendering commands first.
+    */
+    if (Current && Current->gl_ctx == ctx)
+       _mesa_swapbuffers(ctx);
+
+    if (Current->db_flag)
+        wmFlush(Current);
+}
+
+
+
+void /*APIENTRY*/ WMesaPaletteChange(HPALETTE Pal)
+{
+    int vRet;
+    LPPALETTEENTRY pPal;
+    if (Current && (Current->rgb_flag==GL_FALSE || Current->dither_flag == GL_TRUE))
+    {
+        pPal = (PALETTEENTRY *)malloc( 256 * sizeof(PALETTEENTRY));
+        Current->hPal=Pal;
+        //  GetPaletteEntries( Pal, 0, 256, pPal );
+        GetPalette( Pal, pPal );
+#ifdef DDRAW
+        Current->lpDD->lpVtbl->CreatePalette(Current->lpDD,DDPCAPS_8BIT,
+            pPal, &(Current->lpDDPal), NULL);
+        if (Current->lpDDPal)
+            Current->lpDDSPrimary->lpVtbl->SetPalette(Current->lpDDSPrimary,Current->lpDDPal);
+#else
+        vRet = SetDIBColorTable(Current->dib.hDC,0,256,pPal);
+#endif
+        free( pPal );
+    }
+
+}
+
+
+
+
+static unsigned char threeto8[8] = {
+    0, 0111>>1, 0222>>1, 0333>>1, 0444>>1, 0555>>1, 0666>>1, 0377
+};
+
+static unsigned char twoto8[4] = {
+    0, 0x55, 0xaa, 0xff
+};
+
+static unsigned char oneto8[2] = {
+    0, 255
+};
+
+static unsigned char componentFromIndex(UCHAR i, UINT nbits, UINT shift)
+{
+    unsigned char val;
+
+    val = i >> shift;
+    switch (nbits) {
+
+    case 1:
+        val &= 0x1;
+        return oneto8[val];
+
+    case 2:
+        val &= 0x3;
+        return twoto8[val];
+
+    case 3:
+        val &= 0x7;
+        return threeto8[val];
+
+    default:
+        return 0;
+    }
+}
+
+void /*WINAPI*/ wmCreatePalette( PWMC pwdc )
+{
+    /* Create a compressed and re-expanded 3:3:2 palette */
+    int            i;
+    LOGPALETTE     *pPal;
+    BYTE           rb, rs, gb, gs, bb, bs;
+
+    pwdc->nColors = 0x100;
+
+    pPal = (PLOGPALETTE)malloc(sizeof(LOGPALETTE) + pwdc->nColors * sizeof(PALETTEENTRY));
+    memset( pPal, 0, sizeof(LOGPALETTE) + pwdc->nColors * sizeof(PALETTEENTRY) );
+
+    pPal->palVersion = 0x300;
+
+    rb = REDBITS;
+    rs = REDSHIFT;
+    gb = GREENBITS;
+    gs = GREENSHIFT;
+    bb = BLUEBITS;
+    bs = BLUESHIFT;
+
+    if (pwdc->db_flag) {
+
+        /* Need to make two palettes: one for the screen DC and one for the DIB. */
+        pPal->palNumEntries = pwdc->nColors;
+        for (i = 0; i < pwdc->nColors; i++) {
+            pPal->palPalEntry[i].peRed = componentFromIndex( i, rb, rs );
+            pPal->palPalEntry[i].peGreen = componentFromIndex( i, gb, gs );
+            pPal->palPalEntry[i].peBlue = componentFromIndex( i, bb, bs );
+            pPal->palPalEntry[i].peFlags = 0;
+        }
+        pwdc->hGLPalette = CreatePalette( pPal );
+        pwdc->hPalette = CreatePalette( pPal );
+    }
+
+    else {
+        pPal->palNumEntries = pwdc->nColors;
+        for (i = 0; i < pwdc->nColors; i++) {
+            pPal->palPalEntry[i].peRed = componentFromIndex( i, rb, rs );
+            pPal->palPalEntry[i].peGreen = componentFromIndex( i, gb, gs );
+            pPal->palPalEntry[i].peBlue = componentFromIndex( i, bb, bs );
+            pPal->palPalEntry[i].peFlags = 0;
+        }
+        pwdc->hGLPalette = CreatePalette( pPal );
+    }
+
+    free(pPal);
+
+}
+
+void /*WINAPI*/ wmSetPixel(PWMC pwc, int iScanLine, int iPixel, BYTE r, BYTE g, BYTE b)
+{
+    if (Current->db_flag) {
+        LPBYTE  lpb = pwc->pbPixels;
+        LPDWORD lpdw;
+        LPWORD  lpw;
+        UINT    nBypp = pwc->cColorBits >> 3;
+        UINT    nOffset = iPixel % nBypp;
+
+        // Move the pixel buffer pointer to the scanline that we
+        // want to access
+
+        //      pwc->dib.fFlushed = FALSE;
+
+        lpb += pwc->ScanWidth * iScanLine;
+        // Now move to the desired pixel
+        lpb += iPixel * nBypp;
+        lpb = PIXELADDR(iPixel, iScanLine);
+        lpdw = (LPDWORD)lpb;
+        lpw = (LPWORD)lpb;
+
+        if(nBypp == 1){
+            if(pwc->dither_flag)
+                *lpb = DITHER_RGB_2_8BIT(r,g,b,iScanLine,iPixel);
+            else
+                *lpb = BGR8(r,g,b);
+        }
+        else if(nBypp == 2)
+            *lpw = BGR16(r,g,b);
+        else if (nBypp == 3){
+            *lpdw = BGR24(r,g,b);
+        }
+        else if (nBypp == 4)
+            *lpdw = BGR32(r,g,b);
+    }
+    else{
+        SetPixel(Current->hDC, iPixel, iScanLine, RGB(r,g,b));
+        DD_RELEASEDC;
+    }
+}
+
+void /*WINAPI*/ wmCreateDIBSection(
+                                   HDC   hDC,
+                                   PWMC pwc,    // handle of device context
+                                   CONST BITMAPINFO *pbmi,  // address of structure containing bitmap size, format, and color data
+                                   UINT iUsage  // color data type indicator: RGB values or palette indices
+                                   )
+{
+    DWORD   dwSize = 0;
+    DWORD   dwScanWidth;
+    UINT    nBypp = pwc->cColorBits / 8;
+    HDC     hic;
+
+    dwScanWidth = (((pwc->ScanWidth * nBypp)+ 3) & ~3);
+
+    pwc->ScanWidth =pwc->pitch = dwScanWidth;
+
+    if (stereo_flag)
+        pwc->ScanWidth = 2* pwc->pitch;
+
+    dwSize = sizeof(BITMAPINFO) + (dwScanWidth * pwc->height);
+
+    pwc->dib.hFileMap = CreateFileMapping((HANDLE)PAGE_FILE,
+        NULL,
+        PAGE_READWRITE | SEC_COMMIT,
+        0,
+        dwSize,
+        NULL);
+
+    if (!pwc->dib.hFileMap)
+        return;
+
+    pwc->dib.base = MapViewOfFile(pwc->dib.hFileMap,
+        FILE_MAP_ALL_ACCESS,
+        0,
+        0,
+        0);
+
+    if(!pwc->dib.base){
+        CloseHandle(pwc->dib.hFileMap);
+        return;
+    }
+
+    //  pwc->pbPixels = pwc->addrOffScreen = ((LPBYTE)pwc->dib.base) + sizeof(BITMAPINFO);
+
+    //  pwc->dib.hDC = CreateCompatibleDC(hDC);
+
+    CopyMemory(pwc->dib.base, pbmi, sizeof(BITMAPINFO));
+
+    hic = CreateIC("display", NULL, NULL, NULL);
+    pwc->dib.hDC = CreateCompatibleDC(hic);
+
+
+    /*  pwc->hbmDIB = CreateDIBitmap(hic,
+    &(pwc->bmi.bmiHeader),
+    CBM_INIT,
+    pwc->pbPixels,
+    &(pwc->bmi),
+    DIB_RGB_COLORS);
+    */
+    pwc->hbmDIB = CreateDIBSection(hic,
+        &(pwc->bmi),
+        (iUsage ? DIB_PAL_COLORS : DIB_RGB_COLORS),
+        &(pwc->pbPixels),
+        pwc->dib.hFileMap,
+        0);
+        /*
+        pwc->hbmDIB = CreateDIBSection(hic,
+        &(pwc->bmi),
+        DIB_RGB_COLORS,
+        &(pwc->pbPixels),
+        pwc->dib.hFileMap,
+        0);
+    */
+    pwc->ScreenMem = pwc->addrOffScreen = pwc->pbPixels;
+    pwc->hOldBitmap = SelectObject(pwc->dib.hDC, pwc->hbmDIB);
+
+    DeleteDC(hic);
+
+    return;
+
+}
+
+//
+// Blit memory DC to screen DC
+//
+BOOL /*WINAPI*/ wmFlush(PWMC pwc)
+{
+    BOOL    bRet = 0;
+    DWORD   dwErr = 0;
+#ifdef DDRAW
+    HRESULT             ddrval;
+#endif
+
+    // Now search through the torus frames and mark used colors
+    if(pwc->db_flag){
+#ifdef DDRAW
+        if (pwc->lpDDSOffScreen == NULL)
+            if(DDCreateOffScreen(pwc) == GL_FALSE)
+                return;
+
+            pwc->lpDDSOffScreen->lpVtbl->Unlock(pwc->lpDDSOffScreen, NULL);
+
+            while( 1 )
+            {
+                ddrval = pwc->lpDDSPrimary->lpVtbl->Blt( pwc->lpDDSPrimary,
+                    &(pwc->rectSurface), pwc->lpDDSOffScreen, &(pwc->rectOffScreen), 0, NULL );
+
+                if( ddrval == DD_OK )
+                {
+                    break;
+                }
+                if( ddrval == DDERR_SURFACELOST )
+                {
+                    if(!DDRestoreAll(pwc))
+                    {
+                        break;
+                    }
+                }
+                if( ddrval != DDERR_WASSTILLDRAWING )
+                {
+                    break;
+                }
+            }
+
+            while (pwc->lpDDSOffScreen->lpVtbl->Lock(pwc->lpDDSOffScreen,
+                NULL, &(pwc->ddsd), 0, NULL) == DDERR_WASSTILLDRAWING)
+                ;
+
+            if(ddrval != DD_OK)
+                dwErr = GetLastError();
+#else
+            bRet = BitBlt(pwc->hDC, 0, 0, pwc->width, pwc->height,
+                pwc->dib.hDC, 0, 0, SRCCOPY);
+#endif
+    }
+
+    return(TRUE);
+
+}
+
+
+// The following code is added by Li Wei to enable stereo display
+
+#if !defined(NO_STEREO)
+
+void WMesaShowStereo(GLuint list)
+{
+
+    GLbitfield mask = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT;
+    GLfloat cm[16];
+    GLint matrix_mode;
+    // Must use double Buffer
+    if( ! Current-> db_flag )
+        return;
+
+
+    glGetIntegerv(GL_MATRIX_MODE,&matrix_mode);
+
+    //  glPushMatrix();  //****
+    WMesaViewport(Current->gl_ctx,0,Current->height/2,Current->width,Current->height/2);
+    //  Current->gl_ctx->NewState = 0;
+
+    //  glViewport(0,0,Current->width,Current->height/2);
+    if(matrix_mode!=GL_MODELVIEW)
+        glMatrixMode(GL_MODELVIEW);
+
+    glGetFloatv(GL_MODELVIEW_MATRIX,cm);
+    glLoadIdentity();
+    gluLookAt(viewDistance/2,0.0,0.0 ,
+        viewDistance/2,0.0,-1.0,
+        0.0,1.0,0.0 );
+    //  glTranslatef(viewDistance/2.0,0.,0.);
+    glMultMatrixf( cm );
+
+    Current->ScreenMem = Current->pbPixels = Current->addrOffScreen;
+    //glPushMatrix();
+    glCallList( list );
+    //glPopMatrix();
+
+    glGetFloatv(GL_MODELVIEW_MATRIX,cm);
+    glLoadIdentity();
+    gluLookAt(-viewDistance/2,0.0,0.0 ,
+        -viewDistance/2,0.0,-1.0,
+        0.0,1.0,0.0 );
+    //  glTranslatef(-viewDistance/2.0,0.,0.);
+    glMultMatrixf(cm);
+
+    Current->ScreenMem = Current->pbPixels = Current->addrOffScreen + Current->pitch;
+    glCallList(list);
+    if(matrix_mode!=GL_MODELVIEW)
+        glMatrixMode(matrix_mode);
+
+    //  glPopMatrix();
+    glFlush();
+
+    WMesaViewport(Current->gl_ctx,0,0,Current->width,Current->height);
+    //  Current->gl_ctx->NewState = 0;
+    WMesaSwapBuffers();
+
+}
+
+void toggleStereoMode()
+{
+    if(!Current->db_flag)
+        return;
+    if(!stereo_flag){
+        stereo_flag = 1;
+        if(stereoBuffer==GL_FALSE)
+#if !defined(NO_PARALLEL)
+            if(!parallelFlag)
+#endif
+            {
+                Current->ScanWidth = Current->pitch*2;
+            }
+    }
+    else {
+        stereo_flag = 0;
+#if !defined(NO_PARALLEL)
+        if(!parallelFlag)
+#endif
+            Current->ScanWidth = Current->pitch;
+        Current->pbPixels = Current->addrOffScreen;
+    }
+}
+
+/* if in stereo mode, the following function is called */
+void glShowStereo(GLuint list)
+{
+    WMesaShowStereo(list);
+}
+
+#endif // End if NO_STEREO not defined
+
+#if !defined(NO_PARALLEL)
+
+void toggleParallelMode(void)
+{
+    if(!parallelFlag){
+        parallelFlag = GL_TRUE;
+        if(parallelMachine==GL_FALSE){
+            PRCreateRenderBuffer( Current->rgb_flag? GL_RGBA :GL_COLOR_INDEX,
+                Current->cColorBits/8,
+                Current->width ,Current->height,
+                Current->ScanWidth,
+                Current->rgb_flag? Current->pbPixels: Current->ScreenMem);
+            parallelMachine = GL_TRUE;
+        }
+    }
+    else {
+        parallelFlag = GL_FALSE;
+        if(parallelMachine==GL_TRUE){
+            PRDestroyRenderBuffer();
+            parallelMachine=GL_FALSE;
+            ReadyForNextFrame = GL_TRUE;
+        }
+
+        /***********************************************
+        // Seems something wrong!!!!
+        ************************************************/
+
+        WMesaMakeCurrent(Current);
+#if !defined(NO_STEREO)
+        stereo_flag = GL_FALSE ;
+#endif
+    }
+}
+
+void PRShowRenderResult(void)
+{
+    int flag = 0;
+    if(!glImageRendered())
+        return;
+
+    if (parallelFlag)
+    {
+        WMesaSwapBuffers();
+    }
+
+}
+#endif //End if NO_PARALLEL not defined
+
+//end modification
+
+BYTE DITHER_RGB_2_8BIT( int red, int green, int blue, int pixel, int scanline)
+{
+    char unsigned redtemp, greentemp, bluetemp, paletteindex;
+
+    //*** now, look up each value in the halftone matrix
+    //*** using an 8x8 ordered dither.
+    redtemp = aDividedBy51[red]
+        + (aModulo51[red] > aHalftone8x8[(pixel%8)*8
+        + scanline%8]);
+    greentemp = aDividedBy51[(char unsigned)green]
+        + (aModulo51[green] > aHalftone8x8[
+        (pixel%8)*8 + scanline%8]);
+    bluetemp = aDividedBy51[(char unsigned)blue]
+        + (aModulo51[blue] > aHalftone8x8[
+        (pixel%8)*8 +scanline%8]);
+
+    //*** recombine the halftoned rgb values into a palette index
+    paletteindex =
+        redtemp + aTimes6[greentemp] + aTimes36[bluetemp];
+
+    //*** and translate through the wing halftone palette
+    //*** translation vector to give the correct value.
+    return aWinGHalftoneTranslation[paletteindex];
+}
+
+#ifdef DDRAW
+/*
+* restoreAll
+*
+* restore all lost objects
+*/
+HRESULT DDRestoreAll( WMesaContext wc )
+{
+    HRESULT     ddrval;
+
+    ddrval = wc->lpDDSPrimary->lpVtbl->Restore(wc->lpDDSPrimary);
+    if( ddrval == DD_OK )
+    {
+        ddrval = wc->lpDDSOffScreen->lpVtbl->Restore(wc->lpDDSOffScreen);
+    }
+    return ddrval;
+
+} /* restoreAll */
+
+
+  /*
+  * This function is called if the initialization function fails
+*/
+BOOL initFail( HWND hwnd, WMesaContext wc )
+{
+    DDFree(wc);
+    MessageBox( hwnd, "DirectDraw Init FAILED", "", MB_OK );
+    return FALSE;
+
+} /* initFail */
+
+
+static void DDDeleteOffScreen(WMesaContext wc)
+{
+    if( wc->lpDDSOffScreen != NULL )
+    {
+        wc->lpDDSOffScreen->lpVtbl->Unlock(wc->lpDDSOffScreen,NULL);
+        wc->lpDDSOffScreen->lpVtbl->Release(wc->lpDDSOffScreen);
+        wc->lpDDSOffScreen = NULL;
+    }
+
+}
+
+static void DDFreePrimarySurface(WMesaContext wc)
+{
+    if( wc->lpDDSPrimary != NULL )
+    {
+        if(wc->db_flag == GL_FALSE)
+            wc->lpDDSPrimary->lpVtbl->ReleaseDC(wc->lpDDSPrimary, wc->hDC);
+        wc->lpDDSPrimary->lpVtbl->Release(wc->lpDDSPrimary);
+        wc->lpDDSPrimary = NULL;
+    }
+}
+
+static BOOL DDCreatePrimarySurface(WMesaContext wc)
+{
+    HRESULT ddrval;
+    DDSCAPS             ddscaps;
+    wc->ddsd.dwSize = sizeof( wc->ddsd );
+    wc->ddsd.dwFlags = DDSD_CAPS;
+    wc->ddsd.ddsCaps.dwCaps =   DDSCAPS_PRIMARYSURFACE;
+
+    ddrval = wc->lpDD->lpVtbl->CreateSurface( wc->lpDD,&(wc->ddsd), &(wc->lpDDSPrimary), NULL );
+    if( ddrval != DD_OK )
+    {
+        return initFail(wc->hwnd , wc);
+    }
+    if(wc->db_flag == GL_FALSE)
+        wc->lpDDSPrimary->lpVtbl->GetDC(wc->lpDDSPrimary, wc->hDC);
+    return TRUE;
+}
+
+static BOOL DDCreateOffScreen(WMesaContext wc)
+{
+    POINT   pt;
+    HRESULT     ddrval;
+    if(wc->lpDD == NULL)
+        return FALSE;
+    GetClientRect( wc->hwnd, &(wc->rectOffScreen) );
+    wc->ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
+    wc->ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+    wc->ddsd.dwHeight = wc->rectOffScreen.bottom - wc->rectOffScreen.top;
+    wc->ddsd.dwWidth = wc->rectOffScreen.right - wc->rectOffScreen.left;
+
+    ddrval = wc->lpDD->lpVtbl->CreateSurface( wc->lpDD, &(wc->ddsd), &(wc->lpDDSOffScreen), NULL );
+    if( ddrval != DD_OK )
+    {
+        return FALSE;
+    }
+
+    while (wc->lpDDSOffScreen->lpVtbl->Lock(wc->lpDDSOffScreen,NULL, &(wc->ddsd), 0, NULL) == DDERR_WASSTILLDRAWING)
+        ;
+    //  while ((ddrval = wc->lpDDSOffScreen->lpVtbl->Lock(wc->lpDDSOffScreen,NULL, &(wc->ddsd), DDLOCK_SURFACEMEMORYPTR , NULL)) != DD_OK)
+    ;
+    if(wc->ddsd.lpSurface==NULL)
+        return initFail(wc->hwnd, wc);
+
+    wc->ScreenMem = wc->pbPixels = wc->addrOffScreen = (PBYTE)(wc->ddsd.lpSurface);
+    wc->ScanWidth = wc->pitch = wc->ddsd.lPitch;
+    if (stereo_flag)
+        wc->ScanWidth = wc->ddsd.lPitch*2;
+
+    GetClientRect( wc->hwnd, &(wc->rectSurface) );
+    pt.x = pt.y = 0;
+    ClientToScreen( wc->hwnd, &pt );
+    OffsetRect(&(wc->rectSurface), pt.x, pt.y);
+    wmSetPixelFormat(wc, wc->hDC);
+    return TRUE;
+}
+
+/*
+* doInit - do work required for every instance of the application:
+*                create the window, initialize data
+*/
+static BOOL DDInit( WMesaContext wc, HWND hwnd)
+{
+    HRESULT             ddrval;
+    DWORD dwFrequency;
+
+    LPDIRECTDRAW            lpDD;           // DirectDraw object
+    LPDIRECTDRAW2            lpDD2;
+
+
+    wc->fullScreen = displayOptions.fullScreen;
+    wc->gMode = displayOptions.mode;
+    wc->hwnd = hwnd;
+    stereo_flag = displayOptions.stereo;
+    if(wc->db_flag!= GL_TRUE)
+        stereo_flag = GL_FALSE;
+        /*
+        * create the main DirectDraw object
+    */
+    ddrval = DirectDrawCreate( NULL, &(wc->lpDD), NULL );
+    if( ddrval != DD_OK )
+    {
+        return initFail(hwnd,wc);
+    }
+
+    // Get exclusive mode if requested
+    if(wc->fullScreen)
+    {
+        ddrval = wc->lpDD->lpVtbl->SetCooperativeLevel( wc->lpDD, hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );
+    }
+    else
+    {
+        ddrval = wc->lpDD->lpVtbl->SetCooperativeLevel( wc->lpDD, hwnd, DDSCL_NORMAL );
+    }
+    if( ddrval != DD_OK )
+    {
+        return initFail(hwnd , wc);
+    }
+
+
+    /*  ddrval = wc->lpDD->lpVtbl->QueryInterface(wc->lpDD, IID_IDirectDraw2,
+    (LPVOID *)((wc->lpDD2)));
+
+    */
+    if(ddrval != DD_OK)
+        return initFail(hwnd , wc);
+
+
+    //ddrval = wc->lpDD->lpVtbl->GetDisplayMode( wc->lpDD, &(wc->ddsd));
+    //  wc->lpDD2->lpVtbl->GetMonitorFrequency(wc->lpDD, &dwFrequency);
+    switch( wc->gMode )
+    {
+    case 1:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 640, 480, displayOptions.bpp); break;
+    case 2:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 800, 600, displayOptions.bpp); break;
+    case 3:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1024, 768, displayOptions.bpp); break;
+    case 4:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1152, 864, displayOptions.bpp); break;
+    case 5:  ddrval = wc->lpDD->lpVtbl->SetDisplayMode( wc->lpDD, 1280, 1024, displayOptions.bpp); break;
+    }
+
+    if( ddrval != DD_OK )
+    {
+        printf("Can't modify display mode, current mode used\n");
+        //        return initFail(hwnd , wc);
+    }
+    //ddrval = wc->lpDD->lpVtbl->GetDisplayMode( wc->lpDD, &(wc->ddsd));
+    switch(ddrval){
+    case DDERR_INVALIDOBJECT:
+        break;
+    case DDERR_INVALIDPARAMS:
+        break;
+    case DDERR_UNSUPPORTEDMODE:
+        ;
+    }
+
+    if(DDCreatePrimarySurface(wc) == GL_FALSE)
+        return initFail(hwnd, wc);
+
+    if(wc->db_flag)
+        return DDCreateOffScreen(wc);
+} /* DDInit */
+
+static void DDFree( WMesaContext wc)
+{
+    if( wc->lpDD != NULL )
+    {
+        DDFreePrimarySurface(wc);
+        DDDeleteOffScreen(wc);
+        wc->lpDD->lpVtbl->Release(wc->lpDD);
+        wc->lpDD = NULL;
+    }
+    // Clean up the screen on exit
+    RedrawWindow( NULL, NULL, NULL, RDW_INVALIDATE | RDW_ERASE |
+        RDW_ALLCHILDREN );
+
+}
+#endif
+
+void WMesaMove(void)
+{
+    WMesaContext wc = Current;
+    POINT   pt;
+    if (Current != NULL){
+        GetClientRect( wc->hwnd, &(wc->rectSurface) );
+        pt.x = pt.y = 0;
+        ClientToScreen( wc->hwnd, &pt );
+        OffsetRect(&(wc->rectSurface), pt.x, pt.y);
+    }
+}
+
+
+
+/*
+* Like PACK_8A8B8G8R() but don't use alpha.  This is usually an acceptable
+* shortcut.
+*/
+#define PACK_8B8G8R( R, G, B )   ( ((B) << 16) | ((G) << 8) | (R) )
+
+
+/**********************************************************************/
+/***                   Triangle rendering                            ***/
+/**********************************************************************/
+
+/*
+ * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,
+                                       GLuint v0, GLuint v1, GLuint v2,
+                                       GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                    \
+    {                                   \
+    GLint i, len = RIGHT-LEFT;                      \
+    for (i=0;i<len;i++) {                       \
+    GLdepth z = FixedToDepth(ffz);                  \
+    if (z < zRow[i]) {                      \
+    pRow[i] = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),    \
+    FixedToInt(ffb) );          \
+    zRow[i] = z;                            \
+    }                                   \
+    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \
+    ffz += fdzdx;                           \
+    }                                   \
+    }
+
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, smooth, depth-buffered, PF_8R8G8B triangle.
+*/
+static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
+                                     GLuint v0, GLuint v1, GLuint v2,
+                                     GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                    \
+    {                                   \
+    GLint i, len = RIGHT-LEFT;                      \
+    for (i=0;i<len;i++) {                       \
+    GLdepth z = FixedToDepth(ffz);                  \
+    if (z < zRow[i]) {                      \
+    pRow[i] = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),    \
+    FixedToInt(ffb) );          \
+    zRow[i] = z;                            \
+    }                                   \
+    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \
+    ffz += fdzdx;                           \
+    }                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+
+/*
+* XImage, smooth, depth-buffered, PF_5R6G5B triangle.
+*/
+static void smooth_5R6G5B_z_triangle( GLcontext *ctx,
+                                     GLuint v0, GLuint v1, GLuint v2,
+                                     GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
+#define PIXEL_TYPE GLushort
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                    \
+    {                                   \
+    GLint i, len = RIGHT-LEFT;                      \
+    for (i=0;i<len;i++) {                       \
+    GLdepth z = FixedToDepth(ffz);                  \
+    if (z < zRow[i]) {                      \
+    pRow[i] = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg),    \
+    FixedToInt(ffb) );          \
+    zRow[i] = z;                            \
+    }                                   \
+    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \
+    ffz += fdzdx;                           \
+    }                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+/*
+* XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
+*/
+static void flat_8A8B8G8R_z_triangle( GLcontext *ctx, GLuint v0,
+                                     GLuint v1, GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE                  \
+    unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0],    \
+    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )                    \
+    {                                   \
+    GLint i, len = RIGHT-LEFT;                      \
+    for (i=0;i<len;i++) {                       \
+    GLdepth z = FixedToDepth(ffz);                  \
+    if (z < zRow[i]) {                      \
+    pRow[i] = p;                            \
+    zRow[i] = z;                            \
+    }                                   \
+    ffz += fdzdx;                           \
+    }                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, flat, depth-buffered, PF_8R8G8B triangle.
+*/
+static void flat_8R8G8B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                   GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE                  \
+    unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0],    \
+    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )            \
+    {                           \
+    GLint i, len = RIGHT-LEFT;              \
+    for (i=0;i<len;i++) {               \
+    GLdepth z = FixedToDepth(ffz);          \
+    if (z < zRow[i]) {              \
+    pRow[i] = p;                    \
+    zRow[i] = z;                    \
+    }                           \
+    ffz += fdzdx;                   \
+    }                           \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, flat, depth-buffered, PF_5R6G5B triangle.
+*/
+static void flat_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                   GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
+#define PIXEL_TYPE GLushort
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE                  \
+    unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0],    \
+    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )            \
+    {                           \
+    GLint i, len = RIGHT-LEFT;              \
+    for (i=0;i<len;i++) {               \
+    GLdepth z = FixedToDepth(ffz);          \
+    if (z < zRow[i]) {              \
+    pRow[i] = p;                    \
+    zRow[i] = z;                    \
+    }                           \
+    ffz += fdzdx;                   \
+    }                           \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
+*/
+static void smooth_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                     GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                    \
+    {                                   \
+    GLint xx;                               \
+    PIXEL_TYPE *pixel = pRow;                       \
+    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {               \
+    *pixel = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),     \
+                FixedToInt(ffb) );          \
+                ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \
+    }                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
+*/
+static void smooth_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                   GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                    \
+    {                                   \
+    GLint xx;                               \
+    PIXEL_TYPE *pixel = pRow;                       \
+    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {               \
+    *pixel = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),     \
+                FixedToInt(ffb) );          \
+                ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \
+    }                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
+*/
+static void smooth_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                   GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
+#define PIXEL_TYPE GLushort
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                    \
+    {                                   \
+    GLint xx;                               \
+    PIXEL_TYPE *pixel = pRow;                       \
+    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {               \
+    *pixel = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg),     \
+                FixedToInt(ffb) );          \
+                ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;         \
+    }                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+
+/*
+* XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
+*/
+static void flat_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0,
+                                   GLuint v1, GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE                  \
+    unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0],    \
+    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )            \
+    {                           \
+    GLint xx;                       \
+    PIXEL_TYPE *pixel = pRow;               \
+    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {       \
+    *pixel = p;                 \
+    }                           \
+    }
+
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
+*/
+static void flat_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                 GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(X,Y)
+#define PIXEL_TYPE GLuint
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE                  \
+    unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0],    \
+    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )            \
+    {                           \
+    GLint xx;                       \
+    PIXEL_TYPE *pixel = pRow;               \
+    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {       \
+    *pixel = p;                 \
+    }                           \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
+*/
+static void flat_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                 GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(X,Y)
+#define PIXEL_TYPE GLushort
+    //#define BYTES_PER_ROW (wmesa->xm_buffer->backimage->bytes_per_line)
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE                  \
+    unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0],    \
+    VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
+#define INNER_LOOP( LEFT, RIGHT, Y )            \
+    {                           \
+    GLint xx;                       \
+    PIXEL_TYPE *pixel = pRow;               \
+    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {       \
+    *pixel = p;                 \
+    }                           \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
+*/
+
+static void smooth_ci_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                 GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define INTERP_INDEX 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                                \
+    {                                                                   \
+    GLint i, len = RIGHT-LEFT;                                      \
+    for (i=0;i<len;i++) {                                           \
+    GLdepth z = FixedToDepth(ffz);                              \
+    if (z < zRow[i]) {                                          \
+    pRow[i] = FixedToInt(ffi);                                  \
+    zRow[i] = z;                                                \
+    }                                                               \
+    ffi += fdidx;                                                   \
+    ffz += fdzdx;                                                   \
+    }                                                               \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
+*/
+
+static void flat_ci_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                               GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE			\
+   GLuint index = VB->IndexPtr->data[pv];	\
+   (*ctx->Driver.Index)( ctx, index );
+#define INNER_LOOP( LEFT, RIGHT, Y )	\
+   {					\
+      GLint i, len = RIGHT-LEFT;	\
+      for (i=0;i<len;i++) {		\
+         GLdepth z = FixedToDepth(ffz);	\
+         if (z < zRow[i]) {		\
+            pRow[i] = index;		\
+            zRow[i] = z;		\
+         }				\
+         ffz += fdzdx;			\
+      }					\
+   }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+
+/*
+* XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+*/
+
+static void smooth_ci_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                               GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define INTERP_INDEX 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                    \
+    {                                   \
+    GLint xx;                               \
+    PIXEL_TYPE *pixel = pRow;                       \
+    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {               \
+    *pixel = FixedToInt(ffi);           \
+    ffi += fdidx;           \
+    }                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+/*
+* XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+*/
+static void flat_ci_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                             GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define SETUP_CODE			\
+   GLuint index = VB->IndexPtr->data[pv];	\
+   (*ctx->Driver.Index)( ctx, index );
+#define INNER_LOOP( LEFT, RIGHT, Y )		\
+   {						\
+      GLint xx;					\
+      PIXEL_TYPE *pixel = pRow;			\
+      for (xx=LEFT;xx<RIGHT;xx++,pixel++) {	\
+         *pixel = index;			\
+      }						\
+   }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+/*
+* XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
+*/
+static void smooth_DITHER8_z_triangle( GLcontext *ctx,
+                                      GLuint v0, GLuint v1, GLuint v2,
+                                      GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+    DITHER_RGB_TO_8BIT_SETUP
+#define INTERP_Z 1
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                                    \
+    {                                                                       \
+    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;                 \
+    for (i=0;i<len;i++,xx++) {                                          \
+    GLdepth z = FixedToDepth(ffz);                                  \
+    if (z < zRow[i]) {                                              \
+    DITHER_RGB_TO_8BIT( FixedToInt(ffr), FixedToInt(ffg),           \
+    FixedToInt(ffb), xx, yy);               \
+    pRow[i] = pixelDithered;                                        \
+    zRow[i] = z;                                                    \
+    }                                                                   \
+    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;                     \
+    ffz += fdzdx;                                                       \
+    }                                                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+/*
+* XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
+*/
+static void flat_DITHER8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+    DITHER_RGB_TO_8BIT_SETUP
+#define INTERP_Z 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+
+#define INNER_LOOP( LEFT, RIGHT, Y )                                    \
+    {                                                                       \
+    GLint i, xx = LEFT, yy = FLIP(Y), len = RIGHT-LEFT;                 \
+    for (i=0;i<len;i++,xx++) {                                          \
+    GLdepth z = FixedToDepth(ffz);                                  \
+    if (z < zRow[i]) {                                              \
+    DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0],                           \
+             VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy);               \
+             pRow[i] = pixelDithered;                                       \
+             zRow[i] = z;                                                   \
+    }                                                                   \
+    ffz += fdzdx;                                                       \
+    }                                                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+/*
+* XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
+*/
+static void smooth_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                    GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+    DITHER_RGB_TO_8BIT_SETUP
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+#define INNER_LOOP( LEFT, RIGHT, Y )                                    \
+    {                                                                       \
+    GLint xx, yy = FLIP(Y);                                             \
+    PIXEL_TYPE *pixel = pRow;                                           \
+    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                               \
+    DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0],   VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy);\
+    *pixel = pixelDithered;                                         \
+    ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;                     \
+    }                                                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+/*
+* XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
+*/
+
+static void flat_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
+                                  GLuint v2, GLuint pv )
+{
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+    DITHER_RGB_TO_8BIT_SETUP
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (wmesa->ScanWidth)
+
+#define INNER_LOOP( LEFT, RIGHT, Y )                                    \
+    {                                                                       \
+    GLint xx, yy = FLIP(Y);                                             \
+    PIXEL_TYPE *pixel = pRow;                                           \
+    for (xx=LEFT;xx<RIGHT;xx++,pixel++) {                               \
+    DITHER_RGB_TO_8BIT( VB->ColorPtr->data[pv][0],                               \
+             VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2], xx, yy);               \
+             *pixel = pixelDithered;                                            \
+    }                                                                   \
+    }
+#ifdef __MINGW32__
+	#include "tritemp.h"
+#else
+
+	#ifdef WIN32
+//		#include "..\tritemp.h"
+	#else
+		#include "tritemp.h"
+	#endif
+#endif
+}
+
+
+
+
+static /*triangle_func*/ choose_triangle_function( GLcontext *ctx )
+{
+#if 0
+    WMesaContext wmesa = (WMesaContext) ctx->DriverCtx;
+    int depth = wmesa->cColorBits;
+
+    if (ctx->Polygon.SmoothFlag)     return NULL;
+    if (ctx->Texture._ReallyEnabled)  return NULL;
+    if (!wmesa->db_flag) return NULL;
+    /*if (wmesa->xm_buffer->buffer==XIMAGE)*/ {
+    if (   ctx->Light.ShadeModel==GL_SMOOTH
+        && ctx->_RasterMask==DEPTH_BIT
+        && ctx->Depth.Func==GL_LESS
+        && ctx->Depth.Mask==GL_TRUE
+        && ctx->Polygon.StippleFlag==GL_FALSE) {
+        switch (wmesa->pixelformat) {
+        case PF_8A8B8G8R:
+            return smooth_8A8B8G8R_z_triangle;
+        case PF_8R8G8B:
+            return smooth_8R8G8B_z_triangle;
+        case PF_5R6G5B:
+            return smooth_5R6G5B_z_triangle;
+        case PF_DITHER8:
+            return  smooth_DITHER8_z_triangle;
+        case PF_INDEX8:
+            return smooth_ci_z_triangle;
+        default:
+            return NULL;
+        }
+    }
+    if (   ctx->Light.ShadeModel==GL_FLAT
+        && ctx->_RasterMask==DEPTH_BIT
+        && ctx->Depth.Func==GL_LESS
+        && ctx->Depth.Mask==GL_TRUE
+        && ctx->Polygon.StippleFlag==GL_FALSE) {
+        switch (wmesa->pixelformat) {
+        case PF_8A8B8G8R:
+            return flat_8A8B8G8R_z_triangle;
+        case PF_8R8G8B:
+            return flat_8R8G8B_z_triangle;
+        case PF_5R6G5B:
+            return flat_5R6G5B_z_triangle;
+        case PF_DITHER8:
+            return flat_DITHER8_z_triangle;
+        case PF_INDEX8:
+            return flat_ci_z_triangle;
+        default:
+            return NULL;
+        }
+    }
+    if (   ctx->_RasterMask==0   /* no depth test */
+        && ctx->Light.ShadeModel==GL_SMOOTH
+        && ctx->Polygon.StippleFlag==GL_FALSE) {
+        switch (wmesa->pixelformat) {
+        case PF_8A8B8G8R:
+            return smooth_8A8B8G8R_triangle;
+        case PF_8R8G8B:
+            return smooth_8R8G8B_triangle;
+        case PF_5R6G5B:
+            return smooth_5R6G5B_triangle;
+        case PF_DITHER8:
+            return smooth_DITHER8_triangle;
+        case PF_INDEX8:
+            return smooth_ci_triangle;
+        default:
+            return NULL;
+        }
+    }
+
+    if (   ctx->_RasterMask==0   /* no depth test */
+        && ctx->Light.ShadeModel==GL_FLAT
+        && ctx->Polygon.StippleFlag==GL_FALSE) {
+        switch (wmesa->pixelformat) {
+        case PF_8A8B8G8R:
+            return flat_8A8B8G8R_triangle;
+        case PF_8R8G8B:
+            return flat_8R8G8B_triangle;
+        case PF_5R6G5B:
+            return flat_5R6G5B_triangle;
+        case PF_DITHER8:
+            return flat_DITHER8_triangle;
+        case PF_INDEX8:
+            return flat_ci_triangle;
+        default:
+            return NULL;
+        }
+    }
+
+    return NULL;
+    }
+#endif
+}
+
+/*
+* Define a new viewport and reallocate auxillary buffers if the size of
+* the window (color buffer) has changed.
+*/
+void WMesaViewport( GLcontext *ctx,
+                   GLint x, GLint y, GLsizei width, GLsizei height )
+{
+#if 0
+    /* Save viewport */
+    ctx->Viewport.X = x;
+    ctx->Viewport.Width = width;
+    ctx->Viewport.Y = y;
+    ctx->Viewport.Height = height;
+
+    /* compute scale and bias values */
+/* Pre-Keith 3.1 changes
+    ctx->Viewport.Map.m[Sx] = (GLfloat) width / 2.0F;
+    ctx->Viewport.Map.m[Tx] = ctx->Viewport.Sx + x;
+    ctx->Viewport.Map.m[Sy] = (GLfloat) height / 2.0F;
+    ctx->Viewport.Map.m[Ty] = ctx->Viewport.Sy + y;
+*/
+	ctx->Viewport.WindowMap.m[MAT_SX] = (GLfloat) width / 2.0F;
+	ctx->Viewport.WindowMap.m[MAT_TX] = ctx->Viewport.WindowMap.m[MAT_SX] + x;
+	ctx->Viewport.WindowMap.m[MAT_SY] = (GLfloat) height / 2.0F;
+	ctx->Viewport.WindowMap.m[MAT_TY] = ctx->Viewport.WindowMap.m[MAT_SY] + y;
+#endif
+}
diff --git a/src/mesa/main/Makefile.win b/src/mesa/main/Makefile.win
index 284a9cb49ea..3b78249ea97 100644
--- a/src/mesa/main/Makefile.win
+++ b/src/mesa/main/Makefile.win
@@ -1,198 +1,198 @@
-# Makefile for Win32

-#

-#  NOTE: the install target may overwrite important files in the system dir

-# Sept 12, 2001

-# Windows driver not working.  OSMesa driver works.

-#

-

-!include <win32.mak>

-

-TOP = ..

-SUBDIRS = osmesa.dir

-

-CORE_SRCS = \

-	tnl\t_array_api.c \

-	tnl\t_array_import.c \

-	tnl\t_context.c \

-	tnl\t_eval_api.c \

-	tnl\t_imm_alloc.c \

-	tnl\t_imm_api.c \

-	tnl\t_imm_debug.c \

-	tnl\t_imm_dlist.c \

-	tnl\t_imm_elt.c \

-	tnl\t_imm_eval.c \

-	tnl\t_imm_exec.c \

-	tnl\t_imm_fixup.c \

-	tnl\t_pipeline.c \

-	tnl\t_vb_fog.c \

-	tnl\t_vb_light.c \

-	tnl\t_vb_normals.c \

-	tnl\t_vb_points.c \

-	tnl\t_vb_render.c \

-	tnl\t_vb_texgen.c \

-	tnl\t_vb_texmat.c \

-	tnl\t_vb_vertex.c \

-	swrast_setup\ss_context.c \

-	swrast_setup\ss_triangle.c \

-	swrast_setup\ss_vb.c \

-	api_loopback.c \

-	api_noop.c \

-	api_validate.c \

-	accum.c \

-	attrib.c \

-	blend.c \

-	buffers.c \

-	clip.c \

-	colortab.c \

-	config.c \

-	context.c \

-	convolve.c \

-	debug.c \

-	depth.c \

-	dispatch.c \

-	dlist.c \

-	drawpix.c \

-	enable.c \

-	enums.c \

-	eval.c \

-	extensions.c \

-	feedback.c \

-	fog.c \

-	get.c \

-	glapi.c \

-	glthread.c \

-	hash.c \

-	highpc.c \

-	hint.c \

-	histogram.c \

-	image.c \

-	imports.c \

-	light.c \

-	lines.c \

-	lowpc.c \

-	matrix.c \

-	mem.c \

-	mmath.c \

-	pixel.c \

-	points.c \

-	polygon.c \

-	rastpos.c \

-	state.c \

-	stencil.c \

-	teximage.c \

-	texformat.c \

-	texobj.c \

-	texstate.c \

-	texstore.c \

-	texutil.c \

-	varray.c \

-	vtxfmt.c \

-#	X86\x86.c \

-#	X86\common_x86.c \

-#	X86\3dnow.c \

-#	X86\sse.c \

-	math\m_debug_norm.c \

-	math\m_debug_vertex.c \

-	math\m_debug_xform.c \

-	math\m_eval.c \

-	math\m_matrix.c \

-	math\m_translate.c \

-	math\m_vector.c \

-	math\m_vertices.c \

-	math\m_xform.c \

-	array_cache\ac_context.c \

-	array_cache\ac_import.c \

-	swrast\s_aaline.c \

-	swrast\s_aatriangle.c \

-	swrast\s_accum.c \

-	swrast\s_alpha.c \

-	swrast\s_alphabuf.c \

-	swrast\s_bitmap.c \

-	swrast\s_blend.c \

-	swrast\s_buffers.c \

-	swrast\s_copypix.c \

-	swrast\s_context.c \

-	swrast\s_depth.c \

-	swrast\s_drawpix.c \

-	swrast\s_feedback.c \

-	swrast\s_fog.c \

-	swrast\s_histogram.c \

-	swrast\s_imaging.c \

-	swrast\s_lines.c \

-	swrast\s_logic.c \

-	swrast\s_masking.c \

-	swrast\s_pb.c \

-	swrast\s_pixeltex.c \

-	swrast\s_points.c \

-	swrast\s_readpix.c \

-	swrast\s_scissor.c \

-	swrast\s_span.c \

-	swrast\s_stencil.c \

-	swrast\s_texstore.c \

-	swrast\s_texture.c \

-	swrast\s_triangle.c \

-	swrast\s_zoom.c

-

-DRIVER_SRCS = \

-	Trace\tr_context.c \

-	Trace\tr_control.c \

-	Trace\tr_error.c \

-	Trace\tr_support.c \

-	Trace\tr_wrapper.c \

-	Trace\tr_write.c \

-	Windows\wgl.c \

-	Windows\wmesa.c

-

-ASM_SRCS =

-

-SRCS	= $(CORE_SRCS) $(DRIVER_SRCS)

-

-all	: mesadll $(SUBDIRS)

-

-!include "$(TOP)/mesawin32.mak"

-

-mesadll	: $(MESADLL)

-

-CFLAGS	= $(cvarsdll) $(CFLAGS) -D_OPENGL32_ -DBUILD_GL32 -DNO_PARALLEL -DNO_STEREO

-LFLAGS	= $(dlllflags) $(LFLAGS)

-

-OBJS	= $(ASM_SRCS:.S=.obj) $(CORE_SRCS:.c=.obj) $(DRIVER_SRCS:.c=.obj)

-LIBS	= $(GLU) winmm.lib $(guilibsdll)

-

-$(MESADLL)	: $(OBJS) mesa.def

-	$(link) $(LFLAGS) -out:$(MESADLL) -def:mesa.def $(OBJS) $(LIBS)

-	@echo "copying Mesa dynamic link library to lib directory..."

-	-copy $(MESADLL) ..\lib

-	@echo "copying Mesa import library to lib directory..."

-	-copy $(MESALIB) ..\lib

-

-$(SUBDIRS)	:

-	@echo.

-	@echo Making in $* directory

-	@cd $*

-	@nmake -f Makefile.win -nologo

-	@cd ..

-

-install	: $(MESADLL)

-	@echo "copying Mesa dynamic link library to system directory..."

-	-copy $(MESADLL) $(DLLINSTALL)

-	@echo "copying Mesa header files to include directory..."

-	-copy ..\..\include\GL\gl.h $(INCLUDEINSTALL)

-	-copy ..\..\include\GL\glext.h $(INCLUDEINSTALL)

-	@echo "copying Mesa import library to library directory..."

-	-copy $(MESALIB) $(LIBINSTALL)

-

-clean	::

-	@del /f tnl\*.obj

-	@del /f swrast_setup\*.obj

-	@del /f math\*.obj

-	@del /f array_cache\*.obj

-	@del /f swrast\*.obj

-	@del /f Trace\*.obj

-	@del /f osmesa\*.obj

-	@del /f Windows\*.obj

-

-# override default inference rule with one that writes the object to

-# the correct subdir

-.c.obj	:

-	$(cc) $(CFLAGS) -I. $< /Fo$*.obj

+# Makefile for Win32
+#
+#  NOTE: the install target may overwrite important files in the system dir
+# Sept 12, 2001
+# Windows driver not working.  OSMesa driver works.
+#
+
+!include <win32.mak>
+
+TOP = ..
+SUBDIRS = osmesa.dir
+
+CORE_SRCS = \
+	tnl\t_array_api.c \
+	tnl\t_array_import.c \
+	tnl\t_context.c \
+	tnl\t_eval_api.c \
+	tnl\t_imm_alloc.c \
+	tnl\t_imm_api.c \
+	tnl\t_imm_debug.c \
+	tnl\t_imm_dlist.c \
+	tnl\t_imm_elt.c \
+	tnl\t_imm_eval.c \
+	tnl\t_imm_exec.c \
+	tnl\t_imm_fixup.c \
+	tnl\t_pipeline.c \
+	tnl\t_vb_fog.c \
+	tnl\t_vb_light.c \
+	tnl\t_vb_normals.c \
+	tnl\t_vb_points.c \
+	tnl\t_vb_render.c \
+	tnl\t_vb_texgen.c \
+	tnl\t_vb_texmat.c \
+	tnl\t_vb_vertex.c \
+	swrast_setup\ss_context.c \
+	swrast_setup\ss_triangle.c \
+	swrast_setup\ss_vb.c \
+	api_loopback.c \
+	api_noop.c \
+	api_validate.c \
+	accum.c \
+	attrib.c \
+	blend.c \
+	buffers.c \
+	clip.c \
+	colortab.c \
+	config.c \
+	context.c \
+	convolve.c \
+	debug.c \
+	depth.c \
+	dispatch.c \
+	dlist.c \
+	drawpix.c \
+	enable.c \
+	enums.c \
+	eval.c \
+	extensions.c \
+	feedback.c \
+	fog.c \
+	get.c \
+	glapi.c \
+	glthread.c \
+	hash.c \
+	highpc.c \
+	hint.c \
+	histogram.c \
+	image.c \
+	imports.c \
+	light.c \
+	lines.c \
+	lowpc.c \
+	matrix.c \
+	mem.c \
+	mmath.c \
+	pixel.c \
+	points.c \
+	polygon.c \
+	rastpos.c \
+	state.c \
+	stencil.c \
+	teximage.c \
+	texformat.c \
+	texobj.c \
+	texstate.c \
+	texstore.c \
+	texutil.c \
+	varray.c \
+	vtxfmt.c \
+#	X86\x86.c \
+#	X86\common_x86.c \
+#	X86\3dnow.c \
+#	X86\sse.c \
+	math\m_debug_norm.c \
+	math\m_debug_vertex.c \
+	math\m_debug_xform.c \
+	math\m_eval.c \
+	math\m_matrix.c \
+	math\m_translate.c \
+	math\m_vector.c \
+	math\m_vertices.c \
+	math\m_xform.c \
+	array_cache\ac_context.c \
+	array_cache\ac_import.c \
+	swrast\s_aaline.c \
+	swrast\s_aatriangle.c \
+	swrast\s_accum.c \
+	swrast\s_alpha.c \
+	swrast\s_alphabuf.c \
+	swrast\s_bitmap.c \
+	swrast\s_blend.c \
+	swrast\s_buffers.c \
+	swrast\s_copypix.c \
+	swrast\s_context.c \
+	swrast\s_depth.c \
+	swrast\s_drawpix.c \
+	swrast\s_feedback.c \
+	swrast\s_fog.c \
+	swrast\s_histogram.c \
+	swrast\s_imaging.c \
+	swrast\s_lines.c \
+	swrast\s_logic.c \
+	swrast\s_masking.c \
+	swrast\s_pb.c \
+	swrast\s_pixeltex.c \
+	swrast\s_points.c \
+	swrast\s_readpix.c \
+	swrast\s_scissor.c \
+	swrast\s_span.c \
+	swrast\s_stencil.c \
+	swrast\s_texstore.c \
+	swrast\s_texture.c \
+	swrast\s_triangle.c \
+	swrast\s_zoom.c
+
+DRIVER_SRCS = \
+	Trace\tr_context.c \
+	Trace\tr_control.c \
+	Trace\tr_error.c \
+	Trace\tr_support.c \
+	Trace\tr_wrapper.c \
+	Trace\tr_write.c \
+	Windows\wgl.c \
+	Windows\wmesa.c
+
+ASM_SRCS =
+
+SRCS	= $(CORE_SRCS) $(DRIVER_SRCS)
+
+all	: mesadll $(SUBDIRS)
+
+!include "$(TOP)/mesawin32.mak"
+
+mesadll	: $(MESADLL)
+
+CFLAGS	= $(cvarsdll) $(CFLAGS) -D_OPENGL32_ -DBUILD_GL32 -DNO_PARALLEL -DNO_STEREO
+LFLAGS	= $(dlllflags) $(LFLAGS)
+
+OBJS	= $(ASM_SRCS:.S=.obj) $(CORE_SRCS:.c=.obj) $(DRIVER_SRCS:.c=.obj)
+LIBS	= $(GLU) winmm.lib $(guilibsdll)
+
+$(MESADLL)	: $(OBJS) mesa.def
+	$(link) $(LFLAGS) -out:$(MESADLL) -def:mesa.def $(OBJS) $(LIBS)
+	@echo "copying Mesa dynamic link library to lib directory..."
+	-copy $(MESADLL) ..\lib
+	@echo "copying Mesa import library to lib directory..."
+	-copy $(MESALIB) ..\lib
+
+$(SUBDIRS)	:
+	@echo.
+	@echo Making in $* directory
+	@cd $*
+	@nmake -f Makefile.win -nologo
+	@cd ..
+
+install	: $(MESADLL)
+	@echo "copying Mesa dynamic link library to system directory..."
+	-copy $(MESADLL) $(DLLINSTALL)
+	@echo "copying Mesa header files to include directory..."
+	-copy ..\..\include\GL\gl.h $(INCLUDEINSTALL)
+	-copy ..\..\include\GL\glext.h $(INCLUDEINSTALL)
+	@echo "copying Mesa import library to library directory..."
+	-copy $(MESALIB) $(LIBINSTALL)
+
+clean	::
+	@del /f tnl\*.obj
+	@del /f swrast_setup\*.obj
+	@del /f math\*.obj
+	@del /f array_cache\*.obj
+	@del /f swrast\*.obj
+	@del /f Trace\*.obj
+	@del /f osmesa\*.obj
+	@del /f Windows\*.obj
+
+# override default inference rule with one that writes the object to
+# the correct subdir
+.c.obj	:
+	$(cc) $(CFLAGS) -I. $< /Fo$*.obj
diff --git a/src/mesa/main/mesa.def b/src/mesa/main/mesa.def
index 0c384210b32..6a5e420734f 100644
--- a/src/mesa/main/mesa.def
+++ b/src/mesa/main/mesa.def
@@ -1,473 +1,473 @@
-DESCRIPTION 'Mesa (OpenGL work-alike) for Win32'

-VERSION 3.5

-

-EXPORTS

-	glAccum

-	glAlphaFunc

-	glAreTexturesResident

-	glAreTexturesResidentEXT

-	glArrayElement

-	glArrayElementEXT

-	glBegin

-	glBindTexture

-	glBindTextureEXT

-	glBitmap

-	glBlendColorEXT

-	glBlendEquationEXT

-	glBlendFunc

-	glCallList

-	glCallLists

-	glClear

-	glClearAccum

-	glClearColor

-	glClearDepth

-	glClearIndex

-	glClearStencil

-	glClipPlane

-	glColor3b

-	glColor3bv

-	glColor3d

-	glColor3dv

-	glColor3f

-	glColor3fv

-	glColor3i

-	glColor3iv

-	glColor3s

-	glColor3sv

-	glColor3ub

-	glColor3ubv

-	glColor3ui

-	glColor3uiv

-	glColor3us

-	glColor3usv

-	glColor4b

-	glColor4bv

-	glColor4d

-	glColor4dv

-	glColor4f

-	glColor4fv

-	glColor4i

-	glColor4iv

-	glColor4s

-	glColor4sv

-	glColor4ub

-	glColor4ubv

-	glColor4ui

-	glColor4uiv

-	glColor4us

-	glColor4usv

-	glColorMask

-	glColorMaterial

-	glColorPointer

-	glColorPointerEXT

-	glColorSubTableEXT

-	glColorTableEXT

-	glCopyPixels

-	glCopyTexImage1D

-	glCopyTexImage2D

-	glCopyTexSubImage1D

-	glCopyTexSubImage2D

-	glCopyTexSubImage3DEXT

-	glCullFace

-	glDeleteLists

-	glDeleteTextures

-	glDeleteTexturesEXT

-	glDepthFunc

-	glDepthMask

-	glDepthRange

-	glDisable

-	glDisableClientState

-	glDrawArrays

-	glDrawArraysEXT

-	glDrawBuffer

-	glDrawElements

-	glDrawPixels

-	glEdgeFlag

-	glEdgeFlagPointer

-	glEdgeFlagPointerEXT

-	glEdgeFlagv

-	glEnable

-	glEnableClientState

-	glEnd

-	glEndList

-	glEvalCoord1d

-	glEvalCoord1dv

-	glEvalCoord1f

-	glEvalCoord1fv

-	glEvalCoord2d

-	glEvalCoord2dv

-	glEvalCoord2f

-	glEvalCoord2fv

-	glEvalMesh1

-	glEvalMesh2

-	glEvalPoint1

-	glEvalPoint2

-	glFeedbackBuffer

-	glFinish

-	glFlush

-	glFogf

-	glFogfv

-	glFogi

-	glFogiv

-	glFrontFace

-	glFrustum

-	glGenLists

-	glGenTextures

-	glGenTexturesEXT

-	glGetBooleanv

-	glGetClipPlane

-	glGetColorTableEXT

-	glGetColorTableParameterfvEXT

-	glGetColorTableParameterivEXT

-	glGetDoublev

-	glGetError

-	glGetFloatv

-	glGetIntegerv

-	glGetLightfv

-	glGetLightiv

-	glGetMapdv

-	glGetMapfv

-	glGetMapiv

-	glGetMaterialfv

-	glGetMaterialiv

-	glGetPixelMapfv

-	glGetPixelMapuiv

-	glGetPixelMapusv

-	glGetPointerv

-	glGetPointervEXT

-	glGetPolygonStipple

-	glGetString

-	glGetTexEnvfv

-	glGetTexEnviv

-	glGetTexGendv

-	glGetTexGenfv

-	glGetTexGeniv

-	glGetTexImage

-	glGetTexLevelParameterfv

-	glGetTexLevelParameteriv

-	glGetTexParameterfv

-	glGetTexParameteriv

-	glHint

-	glIndexd

-	glIndexdv

-	glIndexf

-	glIndexfv

-	glIndexi

-	glIndexiv

-	glIndexMask

-	glIndexPointer

-	glIndexPointerEXT

-	glIndexs

-	glIndexsv

-	glIndexub

-	glIndexubv

-	glInitNames

-	glInterleavedArrays

-	glIsEnabled

-	glIsList

-	glIsTexture

-	glIsTextureEXT

-	glLightf

-	glLightfv

-	glLighti

-	glLightiv

-	glLightModelf

-	glLightModelfv

-	glLightModeli

-	glLightModeliv

-	glLineStipple

-	glLineWidth

-	glListBase

-	glLoadIdentity

-	glLoadMatrixd

-	glLoadMatrixf

-	glLoadName

-	glLogicOp

-	glMap1d

-	glMap1f

-	glMap2d

-	glMap2f

-	glMapGrid1d

-	glMapGrid1f

-	glMapGrid2d

-	glMapGrid2f

-	glMaterialf

-	glMaterialfv

-	glMateriali

-	glMaterialiv

-	glMatrixMode

-	glMultMatrixd

-	glMultMatrixf

-	glNewList

-	glNormal3b

-	glNormal3bv

-	glNormal3d

-	glNormal3dv

-	glNormal3f

-	glNormal3fv

-	glNormal3i

-	glNormal3iv

-	glNormal3s

-	glNormal3sv

-	glNormalPointer

-	glNormalPointerEXT

-	glOrtho

-	glPassThrough

-	glPixelMapfv

-	glPixelMapuiv

-	glPixelMapusv

-	glPixelStoref

-	glPixelStorei

-	glPixelTransferf

-	glPixelTransferi

-	glPixelZoom

-	glPointParameterfEXT

-	glPointParameterfvEXT

-	glPointSize

-	glPolygonMode

-	glPolygonOffset

-	glPolygonOffsetEXT

-	glPolygonStipple

-	glPopAttrib

-	glPopClientAttrib

-	glPopMatrix

-	glPopName

-	glPrioritizeTextures

-	glPrioritizeTexturesEXT

-	glPushAttrib

-	glPushClientAttrib

-	glPushMatrix

-	glPushName

-	glRasterPos2d

-	glRasterPos2dv

-	glRasterPos2f

-	glRasterPos2fv

-	glRasterPos2i

-	glRasterPos2iv

-	glRasterPos2s

-	glRasterPos2sv

-	glRasterPos3d

-	glRasterPos3dv

-	glRasterPos3f

-	glRasterPos3fv

-	glRasterPos3i

-	glRasterPos3iv

-	glRasterPos3s

-	glRasterPos3sv

-	glRasterPos4d

-	glRasterPos4dv

-	glRasterPos4f

-	glRasterPos4fv

-	glRasterPos4i

-	glRasterPos4iv

-	glRasterPos4s

-	glRasterPos4sv

-	glReadBuffer

-	glReadPixels

-	glRectd

-	glRectdv

-	glRectf

-	glRectfv

-	glRecti

-	glRectiv

-	glRects

-	glRectsv

-	glRenderMode

-	glResizeBuffersMESA

-	glRotated

-	glRotatef

-	glScaled

-	glScalef

-	glScissor

-	glSelectBuffer

-	glShadeModel

-	glStencilFunc

-	glStencilMask

-	glStencilOp

-	glTexCoord1d

-	glTexCoord1dv

-	glTexCoord1f

-	glTexCoord1fv

-	glTexCoord1i

-	glTexCoord1iv

-	glTexCoord1s

-	glTexCoord1sv

-	glTexCoord2d

-	glTexCoord2dv

-	glTexCoord2f

-	glTexCoord2fv

-	glTexCoord2i

-	glTexCoord2iv

-	glTexCoord2s

-	glTexCoord2sv

-	glTexCoord3d

-	glTexCoord3dv

-	glTexCoord3f

-	glTexCoord3fv

-	glTexCoord3i

-	glTexCoord3iv

-	glTexCoord3s

-	glTexCoord3sv

-	glTexCoord4d

-	glTexCoord4dv

-	glTexCoord4f

-	glTexCoord4fv

-	glTexCoord4i

-	glTexCoord4iv

-	glTexCoord4s

-	glTexCoord4sv

-	glTexCoordPointer

-	glTexCoordPointerEXT

-	glTexEnvf

-	glTexEnvfv

-	glTexEnvi

-	glTexEnviv

-	glTexGend

-	glTexGendv

-	glTexGenf

-	glTexGenfv

-	glTexGeni

-	glTexGeniv

-	glTexImage1D

-	glTexImage2D

-	glTexImage3DEXT

-	glTexParameterf

-	glTexParameterfv

-	glTexParameteri

-	glTexParameteriv

-	glTexSubImage1D

-	glTexSubImage2D

-	glTexSubImage3DEXT

-	glTranslated

-	glTranslatef

-	glVertex2d

-	glVertex2dv

-	glVertex2f

-	glVertex2fv

-	glVertex2i

-	glVertex2iv

-	glVertex2s

-	glVertex2sv

-	glVertex3d

-	glVertex3dv

-	glVertex3f

-	glVertex3fv

-	glVertex3i

-	glVertex3iv

-	glVertex3s

-	glVertex3sv

-	glVertex4d

-	glVertex4dv

-	glVertex4f

-	glVertex4fv

-	glVertex4i

-	glVertex4iv

-	glVertex4s

-	glVertex4sv

-	glVertexPointer

-	glVertexPointerEXT

-	glViewport

-	glWindowPos2dMESA

-	glWindowPos2dvMESA

-	glWindowPos2fMESA

-	glWindowPos2fvMESA

-	glWindowPos2iMESA

-	glWindowPos2ivMESA

-	glWindowPos2sMESA

-	glWindowPos2svMESA

-	glWindowPos3dMESA

-	glWindowPos3dvMESA

-	glWindowPos3fMESA

-	glWindowPos3fvMESA

-	glWindowPos3iMESA

-	glWindowPos3ivMESA

-	glWindowPos3sMESA

-	glWindowPos3svMESA

-	glWindowPos4dMESA

-	glWindowPos4dvMESA

-	glWindowPos4fMESA

-	glWindowPos4fvMESA

-	glWindowPos4iMESA

-	glWindowPos4ivMESA

-	glWindowPos4sMESA

-	glWindowPos4svMESA

-	_swsetup_Wakeup

-	_swsetup_CreateContext

-	_tnl_CreateContext

-	_ac_CreateContext

-	_swrast_CreateContext

-	_mesa_free_context_data

-	_mesa_create_framebuffer

-	_mesa_enable_1_3_extensions

-	_mesa_enable_sw_extensions

-	_mesa_destroy_visual

-	_mesa_initialize_context

-	_mesa_create_visual

-	_mesa_destroy_framebuffer

-	_swrast_DestroyContext

-	_ac_DestroyContext

-	_tnl_DestroyContext

-	_swsetup_DestroyContext

-	_mesa_Viewport

-	_mesa_make_current

-	_mesa_get_current_context

-	_mesa_error

-	_swrast_choose_triangle

-	_mesa_zbuffer_address

-	_swrast_choose_line

-	_tnl_InvalidateState

-	_ac_InvalidateState

-	_swsetup_InvalidateState

-	_swrast_InvalidateState

-	_tnl_run_pipeline

-	_swrast_CopyConvolutionFilter2D

-	_swrast_CopyConvolutionFilter1D

-	_swrast_CopyColorSubTable

-	_swrast_CopyColorTable

-	_swrast_copy_texsubimage3d

-	_swrast_copy_texsubimage2d

-	_swrast_copy_texsubimage1d

-	_swrast_copy_teximage2d

-	_swrast_copy_teximage1d

-	_mesa_test_proxy_teximage

-	_mesa_store_texsubimage3d

-	_mesa_store_texsubimage2d

-	_mesa_store_texsubimage1d

-	_mesa_store_teximage3d

-	_mesa_store_teximage2d

-	_mesa_store_teximage1d

-	_mesa_choose_tex_format

-	_mesa_base_compressed_texformat

-	_mesa_compressed_texture_size

-	_mesa_get_compressed_teximage

-	_swrast_ReadPixels

-	_swrast_DrawPixels

-	_swrast_CopyPixels

-	_swrast_Bitmap

-	_swrast_Accum

-	_swrast_alloc_buffers

-	_swrast_GetDeviceDriverReference

-	_swrast_Clear

-	wglCopyContext

-	wglCreateContext

-	wglDeleteContext

-	wglCreateLayerContext

-	wglGetCurrentContext

-	wglGetCurrentDC

-	wglMakeCurrent

-	wglShareLists

-	wglUseFontBitmapsA

-	wglUseFontBitmapsW

-	wglUseFontOutlinesA

-	wglUseFontOutlinesW

-	wglDescribeLayerPlane

-	wglSetLayerPaletteEntries

-	wglGetLayerPaletteEntries

-	wglRealizeLayerPalette

-	wglSwapLayerBuffers

-	wglChoosePixelFormat

-	wglDescribePixelFormat

-	wglGetProcAddress

-	wglGetPixelFormat

-	wglSetPixelFormat

-	wglSwapBuffers

+DESCRIPTION 'Mesa (OpenGL work-alike) for Win32'
+VERSION 3.5
+
+EXPORTS
+	glAccum
+	glAlphaFunc
+	glAreTexturesResident
+	glAreTexturesResidentEXT
+	glArrayElement
+	glArrayElementEXT
+	glBegin
+	glBindTexture
+	glBindTextureEXT
+	glBitmap
+	glBlendColorEXT
+	glBlendEquationEXT
+	glBlendFunc
+	glCallList
+	glCallLists
+	glClear
+	glClearAccum
+	glClearColor
+	glClearDepth
+	glClearIndex
+	glClearStencil
+	glClipPlane
+	glColor3b
+	glColor3bv
+	glColor3d
+	glColor3dv
+	glColor3f
+	glColor3fv
+	glColor3i
+	glColor3iv
+	glColor3s
+	glColor3sv
+	glColor3ub
+	glColor3ubv
+	glColor3ui
+	glColor3uiv
+	glColor3us
+	glColor3usv
+	glColor4b
+	glColor4bv
+	glColor4d
+	glColor4dv
+	glColor4f
+	glColor4fv
+	glColor4i
+	glColor4iv
+	glColor4s
+	glColor4sv
+	glColor4ub
+	glColor4ubv
+	glColor4ui
+	glColor4uiv
+	glColor4us
+	glColor4usv
+	glColorMask
+	glColorMaterial
+	glColorPointer
+	glColorPointerEXT
+	glColorSubTableEXT
+	glColorTableEXT
+	glCopyPixels
+	glCopyTexImage1D
+	glCopyTexImage2D
+	glCopyTexSubImage1D
+	glCopyTexSubImage2D
+	glCopyTexSubImage3DEXT
+	glCullFace
+	glDeleteLists
+	glDeleteTextures
+	glDeleteTexturesEXT
+	glDepthFunc
+	glDepthMask
+	glDepthRange
+	glDisable
+	glDisableClientState
+	glDrawArrays
+	glDrawArraysEXT
+	glDrawBuffer
+	glDrawElements
+	glDrawPixels
+	glEdgeFlag
+	glEdgeFlagPointer
+	glEdgeFlagPointerEXT
+	glEdgeFlagv
+	glEnable
+	glEnableClientState
+	glEnd
+	glEndList
+	glEvalCoord1d
+	glEvalCoord1dv
+	glEvalCoord1f
+	glEvalCoord1fv
+	glEvalCoord2d
+	glEvalCoord2dv
+	glEvalCoord2f
+	glEvalCoord2fv
+	glEvalMesh1
+	glEvalMesh2
+	glEvalPoint1
+	glEvalPoint2
+	glFeedbackBuffer
+	glFinish
+	glFlush
+	glFogf
+	glFogfv
+	glFogi
+	glFogiv
+	glFrontFace
+	glFrustum
+	glGenLists
+	glGenTextures
+	glGenTexturesEXT
+	glGetBooleanv
+	glGetClipPlane
+	glGetColorTableEXT
+	glGetColorTableParameterfvEXT
+	glGetColorTableParameterivEXT
+	glGetDoublev
+	glGetError
+	glGetFloatv
+	glGetIntegerv
+	glGetLightfv
+	glGetLightiv
+	glGetMapdv
+	glGetMapfv
+	glGetMapiv
+	glGetMaterialfv
+	glGetMaterialiv
+	glGetPixelMapfv
+	glGetPixelMapuiv
+	glGetPixelMapusv
+	glGetPointerv
+	glGetPointervEXT
+	glGetPolygonStipple
+	glGetString
+	glGetTexEnvfv
+	glGetTexEnviv
+	glGetTexGendv
+	glGetTexGenfv
+	glGetTexGeniv
+	glGetTexImage
+	glGetTexLevelParameterfv
+	glGetTexLevelParameteriv
+	glGetTexParameterfv
+	glGetTexParameteriv
+	glHint
+	glIndexd
+	glIndexdv
+	glIndexf
+	glIndexfv
+	glIndexi
+	glIndexiv
+	glIndexMask
+	glIndexPointer
+	glIndexPointerEXT
+	glIndexs
+	glIndexsv
+	glIndexub
+	glIndexubv
+	glInitNames
+	glInterleavedArrays
+	glIsEnabled
+	glIsList
+	glIsTexture
+	glIsTextureEXT
+	glLightf
+	glLightfv
+	glLighti
+	glLightiv
+	glLightModelf
+	glLightModelfv
+	glLightModeli
+	glLightModeliv
+	glLineStipple
+	glLineWidth
+	glListBase
+	glLoadIdentity
+	glLoadMatrixd
+	glLoadMatrixf
+	glLoadName
+	glLogicOp
+	glMap1d
+	glMap1f
+	glMap2d
+	glMap2f
+	glMapGrid1d
+	glMapGrid1f
+	glMapGrid2d
+	glMapGrid2f
+	glMaterialf
+	glMaterialfv
+	glMateriali
+	glMaterialiv
+	glMatrixMode
+	glMultMatrixd
+	glMultMatrixf
+	glNewList
+	glNormal3b
+	glNormal3bv
+	glNormal3d
+	glNormal3dv
+	glNormal3f
+	glNormal3fv
+	glNormal3i
+	glNormal3iv
+	glNormal3s
+	glNormal3sv
+	glNormalPointer
+	glNormalPointerEXT
+	glOrtho
+	glPassThrough
+	glPixelMapfv
+	glPixelMapuiv
+	glPixelMapusv
+	glPixelStoref
+	glPixelStorei
+	glPixelTransferf
+	glPixelTransferi
+	glPixelZoom
+	glPointParameterfEXT
+	glPointParameterfvEXT
+	glPointSize
+	glPolygonMode
+	glPolygonOffset
+	glPolygonOffsetEXT
+	glPolygonStipple
+	glPopAttrib
+	glPopClientAttrib
+	glPopMatrix
+	glPopName
+	glPrioritizeTextures
+	glPrioritizeTexturesEXT
+	glPushAttrib
+	glPushClientAttrib
+	glPushMatrix
+	glPushName
+	glRasterPos2d
+	glRasterPos2dv
+	glRasterPos2f
+	glRasterPos2fv
+	glRasterPos2i
+	glRasterPos2iv
+	glRasterPos2s
+	glRasterPos2sv
+	glRasterPos3d
+	glRasterPos3dv
+	glRasterPos3f
+	glRasterPos3fv
+	glRasterPos3i
+	glRasterPos3iv
+	glRasterPos3s
+	glRasterPos3sv
+	glRasterPos4d
+	glRasterPos4dv
+	glRasterPos4f
+	glRasterPos4fv
+	glRasterPos4i
+	glRasterPos4iv
+	glRasterPos4s
+	glRasterPos4sv
+	glReadBuffer
+	glReadPixels
+	glRectd
+	glRectdv
+	glRectf
+	glRectfv
+	glRecti
+	glRectiv
+	glRects
+	glRectsv
+	glRenderMode
+	glResizeBuffersMESA
+	glRotated
+	glRotatef
+	glScaled
+	glScalef
+	glScissor
+	glSelectBuffer
+	glShadeModel
+	glStencilFunc
+	glStencilMask
+	glStencilOp
+	glTexCoord1d
+	glTexCoord1dv
+	glTexCoord1f
+	glTexCoord1fv
+	glTexCoord1i
+	glTexCoord1iv
+	glTexCoord1s
+	glTexCoord1sv
+	glTexCoord2d
+	glTexCoord2dv
+	glTexCoord2f
+	glTexCoord2fv
+	glTexCoord2i
+	glTexCoord2iv
+	glTexCoord2s
+	glTexCoord2sv
+	glTexCoord3d
+	glTexCoord3dv
+	glTexCoord3f
+	glTexCoord3fv
+	glTexCoord3i
+	glTexCoord3iv
+	glTexCoord3s
+	glTexCoord3sv
+	glTexCoord4d
+	glTexCoord4dv
+	glTexCoord4f
+	glTexCoord4fv
+	glTexCoord4i
+	glTexCoord4iv
+	glTexCoord4s
+	glTexCoord4sv
+	glTexCoordPointer
+	glTexCoordPointerEXT
+	glTexEnvf
+	glTexEnvfv
+	glTexEnvi
+	glTexEnviv
+	glTexGend
+	glTexGendv
+	glTexGenf
+	glTexGenfv
+	glTexGeni
+	glTexGeniv
+	glTexImage1D
+	glTexImage2D
+	glTexImage3DEXT
+	glTexParameterf
+	glTexParameterfv
+	glTexParameteri
+	glTexParameteriv
+	glTexSubImage1D
+	glTexSubImage2D
+	glTexSubImage3DEXT
+	glTranslated
+	glTranslatef
+	glVertex2d
+	glVertex2dv
+	glVertex2f
+	glVertex2fv
+	glVertex2i
+	glVertex2iv
+	glVertex2s
+	glVertex2sv
+	glVertex3d
+	glVertex3dv
+	glVertex3f
+	glVertex3fv
+	glVertex3i
+	glVertex3iv
+	glVertex3s
+	glVertex3sv
+	glVertex4d
+	glVertex4dv
+	glVertex4f
+	glVertex4fv
+	glVertex4i
+	glVertex4iv
+	glVertex4s
+	glVertex4sv
+	glVertexPointer
+	glVertexPointerEXT
+	glViewport
+	glWindowPos2dMESA
+	glWindowPos2dvMESA
+	glWindowPos2fMESA
+	glWindowPos2fvMESA
+	glWindowPos2iMESA
+	glWindowPos2ivMESA
+	glWindowPos2sMESA
+	glWindowPos2svMESA
+	glWindowPos3dMESA
+	glWindowPos3dvMESA
+	glWindowPos3fMESA
+	glWindowPos3fvMESA
+	glWindowPos3iMESA
+	glWindowPos3ivMESA
+	glWindowPos3sMESA
+	glWindowPos3svMESA
+	glWindowPos4dMESA
+	glWindowPos4dvMESA
+	glWindowPos4fMESA
+	glWindowPos4fvMESA
+	glWindowPos4iMESA
+	glWindowPos4ivMESA
+	glWindowPos4sMESA
+	glWindowPos4svMESA
+	_swsetup_Wakeup
+	_swsetup_CreateContext
+	_tnl_CreateContext
+	_ac_CreateContext
+	_swrast_CreateContext
+	_mesa_free_context_data
+	_mesa_create_framebuffer
+	_mesa_enable_1_3_extensions
+	_mesa_enable_sw_extensions
+	_mesa_destroy_visual
+	_mesa_initialize_context
+	_mesa_create_visual
+	_mesa_destroy_framebuffer
+	_swrast_DestroyContext
+	_ac_DestroyContext
+	_tnl_DestroyContext
+	_swsetup_DestroyContext
+	_mesa_Viewport
+	_mesa_make_current
+	_mesa_get_current_context
+	_mesa_error
+	_swrast_choose_triangle
+	_mesa_zbuffer_address
+	_swrast_choose_line
+	_tnl_InvalidateState
+	_ac_InvalidateState
+	_swsetup_InvalidateState
+	_swrast_InvalidateState
+	_tnl_run_pipeline
+	_swrast_CopyConvolutionFilter2D
+	_swrast_CopyConvolutionFilter1D
+	_swrast_CopyColorSubTable
+	_swrast_CopyColorTable
+	_swrast_copy_texsubimage3d
+	_swrast_copy_texsubimage2d
+	_swrast_copy_texsubimage1d
+	_swrast_copy_teximage2d
+	_swrast_copy_teximage1d
+	_mesa_test_proxy_teximage
+	_mesa_store_texsubimage3d
+	_mesa_store_texsubimage2d
+	_mesa_store_texsubimage1d
+	_mesa_store_teximage3d
+	_mesa_store_teximage2d
+	_mesa_store_teximage1d
+	_mesa_choose_tex_format
+	_mesa_base_compressed_texformat
+	_mesa_compressed_texture_size
+	_mesa_get_compressed_teximage
+	_swrast_ReadPixels
+	_swrast_DrawPixels
+	_swrast_CopyPixels
+	_swrast_Bitmap
+	_swrast_Accum
+	_swrast_alloc_buffers
+	_swrast_GetDeviceDriverReference
+	_swrast_Clear
+	wglCopyContext
+	wglCreateContext
+	wglDeleteContext
+	wglCreateLayerContext
+	wglGetCurrentContext
+	wglGetCurrentDC
+	wglMakeCurrent
+	wglShareLists
+	wglUseFontBitmapsA
+	wglUseFontBitmapsW
+	wglUseFontOutlinesA
+	wglUseFontOutlinesW
+	wglDescribeLayerPlane
+	wglSetLayerPaletteEntries
+	wglGetLayerPaletteEntries
+	wglRealizeLayerPalette
+	wglSwapLayerBuffers
+	wglChoosePixelFormat
+	wglDescribePixelFormat
+	wglGetProcAddress
+	wglGetPixelFormat
+	wglSetPixelFormat
+	wglSwapBuffers