GLU32 patch (hopefully final take)

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Remodified the configure.ac bit. It now spits out a warning if the lib
is there and not the header (same thing as CUPS support).

Changelog:
 - Modified the glu32 prototypes to match MSDN
 - Made it work with libGLU 1.1 and 1.2
 - #include'd GL/glu.h instead of redefining the glu functions, and
added a check for it in configure.ac. If it's absent, don't build
glu32.dll.so.

Vincent
diff -urN wine-orig/configure.ac wine-pas-compilé/configure.ac
--- wine-orig/configure.ac	Tue Jun  4 20:15:28 2002
+++ wine-pas-compilé/configure.ac	Wed Jun 12 11:32:30 2002
@@ -300,12 +300,15 @@
 			fi
 
 		fi
-	        dnl Check for GLU32 library.
+		dnl Check for GLU library.
+		wine_cv_warn_gl_glu_h=no
 		AC_CHECK_LIB(GLU,gluLookAt,
-			     [X_PRE_LIBS="$X_PRE_LIBS -lGLU"
-			     GLU32FILES='$(GLU32FILES)']
-			     ,,
-			     $X_LIBS $X_PRE_LIBS -lXext -lX11 -lm $X_EXTRA_LIBS
+			    [AC_CHECK_HEADERS(GL/glu.h,
+				[X_PRE_LIBS="$X_PRE_LIBS -lGLU"
+				GLU32FILES='$(GLU32FILES)'],
+				wine_cv_warn_gl_glu_h=yes)]
+				,,
+				$X_LIBS $X_PRE_LIBS -lXext -lX11 -lm $X_EXTRA_LIBS
 		)
 	     fi
 	 fi
@@ -1421,6 +1424,14 @@
   echo "*** support before reporting bugs."
 fi
 
+if test "$wine_cv_warn_gl_glu_h" = "yes"
+then
+  echo
+  echo "*** Note: You have GLU runtime libraries, but no development"
+  echo "*** libraries. Install the GLU-devel package or whichever package"
+  echo "*** contains GL/glu.h to enable GLU support in Wine."
+fi
+
 if test "$wine_cv_warn_cups_h" = "yes"
 then
   echo
diff -urN wine-orig/dlls/glu32/glu.c wine-pas-compilé/dlls/glu32/glu.c
--- wine-orig/dlls/glu32/glu.c	Sat Mar  9 18:33:03 2002
+++ wine-pas-compilé/dlls/glu32/glu.c	Tue Jun 11 12:19:23 2002
@@ -1,5 +1,6 @@
 /*
  * Copyright 2001 Marcus Meissner
+ * Copyright 2002 Vincent Béron
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -18,362 +19,436 @@
 
 #include "winbase.h"
 
+#include "config.h"
+#include "wine_gl.h"
+#include <GL/glu.h>
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(opengl);
+
+#ifndef GLU_VERSION_1_2
+typedef GLUtriangulatorObj GLUtesselator;
+#endif /* GLU_VERSION_1_2 */
+
 /***********************************************************************
  *		gluLookAt (GLU32.@)
  */
-extern int gluLookAt(double arg0,double arg1,double arg2,double arg3,double arg4,double arg5,double arg6,double arg7,double arg8);
-int WINAPI wine_gluLookAt(double arg0,double arg1,double arg2,double arg3,double arg4,double arg5,double arg6,double arg7,double arg8) {
-	return gluLookAt(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+void WINAPI wine_gluLookAt( GLdouble eyex, GLdouble eyey, GLdouble eyez,
+			    GLdouble centerx, GLdouble centery,
+			    GLdouble centerz,
+			    GLdouble upx, GLdouble upy, GLdouble upz ) {
+	gluLookAt(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz);
 }
 
 /***********************************************************************
  *		gluOrtho2D (GLU32.@)
  */
-extern int gluOrtho2D(double arg0,double arg1,double arg2,double arg3);
-int WINAPI wine_gluOrtho2D(double arg0,double arg1,double arg2,double arg3) {
-	return gluOrtho2D(arg0,arg1,arg2,arg3);
+void WINAPI wine_gluOrtho2D( GLdouble left, GLdouble right,
+			     GLdouble bottom, GLdouble top ) {
+	gluOrtho2D(left, right, bottom, top);
 }
 
 /***********************************************************************
  *		gluPerspective (GLU32.@)
  */
-extern int gluPerspective(double arg0,double arg1,double arg2,double arg3);
-int WINAPI wine_gluPerspective(double arg0,double arg1,double arg2,double arg3) {
-	return gluPerspective(arg0,arg1,arg2,arg3);
+void WINAPI wine_gluPerspective( GLdouble fovy, GLdouble aspect,
+				 GLdouble zNear, GLdouble zFar ) {
+	gluPerspective(fovy, aspect, zNear, zFar);
 }
 
 /***********************************************************************
  *		gluPickMatrix (GLU32.@)
  */
-extern int gluPickMatrix(double arg0,double arg1,double arg2,double arg3,void *arg4);
-int WINAPI wine_gluPickMatrix(double arg0,double arg1,double arg2,double arg3,void *arg4) {
-	return gluPickMatrix(arg0,arg1,arg2,arg3,arg4);
+void WINAPI wine_gluPickMatrix( GLdouble x, GLdouble y,
+				GLdouble width, GLdouble height,
+				GLint viewport[4] ) {
+	gluPickMatrix(x, y, width, height, viewport);
 }
 
 /***********************************************************************
  *		gluProject (GLU32.@)
  */
-extern int gluProject(double arg0,double arg1,double arg2,void *arg3,void *arg4,void *arg5,void *arg6,void *arg7,void *arg8);
-int WINAPI wine_gluProject(double arg0,double arg1,double arg2,void *arg3,void *arg4,void *arg5,void *arg6,void *arg7,void *arg8) {
-	return gluProject(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+int WINAPI wine_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 ) {
+	return gluProject(objx, objy, objz, modelMatrix, projMatrix, viewport, winx, winy, winz);
 }
 
 /***********************************************************************
  *		gluUnProject (GLU32.@)
  */
-extern int gluUnProject(double arg0,double arg1,double arg2,void *arg3,void *arg4,void *arg5,void *arg6,void *arg7,void *arg8);
-int WINAPI wine_gluUnProject(double arg0,double arg1,double arg2,void *arg3,void *arg4,void *arg5,void *arg6,void *arg7,void *arg8) {
-	return gluUnProject(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+int WINAPI wine_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 ) {
+	return gluUnProject(winx, winy, winz, modelMatrix, projMatrix, viewport, objx, objy, objz);
 }
 
 /***********************************************************************
  *		gluErrorString (GLU32.@)
  */
-extern int gluErrorString(int arg0);
-int WINAPI wine_gluErrorString(int arg0) {
-	return gluErrorString(arg0);
+const GLubyte* WINAPI wine_gluErrorString( GLenum errorCode ) {
+	return gluErrorString(errorCode);
 }
 
 /***********************************************************************
  *		gluScaleImage (GLU32.@)
  */
-extern int gluScaleImage(int arg0,int arg1,int arg2,int arg3,void *arg4,int arg5,int arg6,int arg7,void *arg8);
-int WINAPI wine_gluScaleImage(int arg0,int arg1,int arg2,int arg3,void *arg4,int arg5,int arg6,int arg7,void *arg8) {
-	return gluScaleImage(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+int WINAPI wine_gluScaleImage( GLenum format,
+			       GLint widthin, GLint heightin,
+			       GLenum typein, const void *datain,
+			       GLint widthout, GLint heightout,
+			       GLenum typeout, void *dataout ) {
+	return gluScaleImage(format, widthin, heightin, typein, datain, widthout, heightout, typeout, dataout);
 }
 
 /***********************************************************************
  *		gluBuild1DMipmaps (GLU32.@)
  */
-extern int gluBuild1DMipmaps(int arg0,int arg1,int arg2,int arg3,int arg4,void *arg5);
-int WINAPI wine_gluBuild1DMipmaps(int arg0,int arg1,int arg2,int arg3,int arg4,void *arg5) {
-	return gluBuild1DMipmaps(arg0,arg1,arg2,arg3,arg4,arg5);
+int WINAPI wine_gluBuild1DMipmaps( GLenum target, GLint components,
+				   GLint width, GLenum format,
+				   GLenum type, const void *data ) {
+	return gluBuild1DMipmaps(target, components, width, format, type, data);
 }
 
 /***********************************************************************
  *		gluBuild2DMipmaps (GLU32.@)
  */
-extern int gluBuild2DMipmaps(int arg0,int arg1,int arg2,int arg3,int arg4,int arg5,void *arg6);
-int WINAPI wine_gluBuild2DMipmaps(int arg0,int arg1,int arg2,int arg3,int arg4,int arg5,void *arg6) {
-	return gluBuild2DMipmaps(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
+int WINAPI wine_gluBuild2DMipmaps( GLenum target, GLint components,
+				   GLint width, GLint height,
+				   GLenum format,
+				   GLenum type, const void *data ) {
+	return gluBuild2DMipmaps(target, components, width, height, format, type, data);
 }
 
 /***********************************************************************
  *		gluNewQuadric (GLU32.@)
  */
-extern int gluNewQuadric();
-int WINAPI wine_gluNewQuadric() {
+GLUquadricObj* WINAPI wine_gluNewQuadric( void ) {
 	return gluNewQuadric();
 }
 
 /***********************************************************************
  *		gluDeleteQuadric (GLU32.@)
  */
-extern int gluDeleteQuadric(void *arg0);
-int WINAPI wine_gluDeleteQuadric(void *arg0) {
-	return gluDeleteQuadric(arg0);
+void WINAPI wine_gluDeleteQuadric( GLUquadricObj *state ) {
+	gluDeleteQuadric(state);
 }
 
 /***********************************************************************
  *		gluQuadricDrawStyle (GLU32.@)
  */
-extern int gluQuadricDrawStyle(void *arg0,int arg1);
-int WINAPI wine_gluQuadricDrawStyle(void *arg0,int arg1) {
-	return gluQuadricDrawStyle(arg0,arg1);
+void WINAPI wine_gluQuadricDrawStyle( GLUquadricObj *qobj,
+				      GLenum drawStyle ) {
+	gluQuadricDrawStyle(qobj, drawStyle);
 }
 
 /***********************************************************************
  *		gluQuadricOrientation (GLU32.@)
  */
-extern int gluQuadricOrientation(void *arg0,int arg1);
-int WINAPI wine_gluQuadricOrientation(void *arg0,int arg1) {
-	return gluQuadricOrientation(arg0,arg1);
+void WINAPI wine_gluQuadricOrientation( GLUquadricObj *quadObject,
+					GLenum orientation ) {
+	gluQuadricOrientation(quadObject, orientation);
 }
 
 /***********************************************************************
  *		gluQuadricNormals (GLU32.@)
  */
-extern int gluQuadricNormals(void *arg0,int arg1);
-int WINAPI wine_gluQuadricNormals(void *arg0,int arg1) {
-	return gluQuadricNormals(arg0,arg1);
+void WINAPI wine_gluQuadricNormals( GLUquadricObj *qobj,
+				    GLenum normals ) {
+	gluQuadricNormals(qobj, normals);
 }
 
 /***********************************************************************
  *		gluQuadricTexture (GLU32.@)
  */
-extern int gluQuadricTexture(void *arg0,int arg1);
-int WINAPI wine_gluQuadricTexture(void *arg0,int arg1) {
-	return gluQuadricTexture(arg0,arg1);
+void WINAPI wine_gluQuadricTexture( GLUquadricObj *quadObject,
+				    GLboolean textureCoords ) {
+	gluQuadricTexture(quadObject, textureCoords);
 }
 
 /***********************************************************************
  *		gluQuadricCallback (GLU32.@)
  */
-extern int gluQuadricCallback(void *arg0,int arg1,void *arg2);
-int WINAPI wine_gluQuadricCallback(void *arg0,int arg1,void *arg2) {
-	return gluQuadricCallback(arg0,arg1,arg2);
+void WINAPI wine_gluQuadricCallback( GLUquadricObj *qobj,
+				     GLenum which,
+				     void (* fn)() ) {
+	gluQuadricCallback(qobj, which, fn);
 }
 
 /***********************************************************************
  *		gluCylinder (GLU32.@)
  */
-extern int gluCylinder(void *arg0,double arg1,double arg2,double arg3,int arg4,int arg5);
-int WINAPI wine_gluCylinder(void *arg0,double arg1,double arg2,double arg3,int arg4,int arg5) {
-	return gluCylinder(arg0,arg1,arg2,arg3,arg4,arg5);
+void WINAPI wine_gluCylinder( GLUquadricObj *qobj,
+			      GLdouble baseRadius,
+			      GLdouble topRadius,
+			      GLdouble height,
+			      GLint slices, GLint stacks ) {
+	gluCylinder(qobj, baseRadius, topRadius, height, slices, stacks);
 }
 
 /***********************************************************************
  *		gluSphere (GLU32.@)
  */
-extern int gluSphere(void *arg0,double arg1,int arg2,int arg3);
-int WINAPI wine_gluSphere(void *arg0,double arg1,int arg2,int arg3) {
-	return gluSphere(arg0,arg1,arg2,arg3);
+void WINAPI wine_gluSphere( GLUquadricObj *qobj,
+			    GLdouble radius,
+			    GLint slices, GLint stacks ) {
+	gluSphere(qobj, radius, slices, stacks);
 }
 
 /***********************************************************************
  *		gluDisk (GLU32.@)
  */
-extern int gluDisk(void *arg0,double arg1,double arg2,int arg3,int arg4);
-int WINAPI wine_gluDisk(void *arg0,double arg1,double arg2,int arg3,int arg4) {
-	return gluDisk(arg0,arg1,arg2,arg3,arg4);
+void WINAPI wine_gluDisk( GLUquadricObj *qobj,
+			  GLdouble innerRadius, GLdouble outerRadius,
+			  GLint slices, GLint loops ) {
+	gluDisk(qobj, innerRadius, outerRadius, slices, loops);
 }
 
 /***********************************************************************
  *		gluPartialDisk (GLU32.@)
  */
-extern int gluPartialDisk(void *arg0,double arg1,double arg2,int arg3,int arg4,double arg5,double arg6);
-int WINAPI wine_gluPartialDisk(void *arg0,double arg1,double arg2,int arg3,int arg4,double arg5,double arg6) {
-	return gluPartialDisk(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
+void WINAPI wine_gluPartialDisk( GLUquadricObj *qobj,
+				 GLdouble innerRadius,
+				 GLdouble outerRadius, GLint slices,
+				 GLint loops, GLdouble startAngle,
+				 GLdouble sweepAngle ) {
+	gluPartialDisk(qobj, innerRadius, outerRadius, slices, loops, startAngle, sweepAngle);
 }
 
 /***********************************************************************
  *		gluNewNurbsRenderer (GLU32.@)
  */
-extern int gluNewNurbsRenderer();
-int WINAPI wine_gluNewNurbsRenderer() {
+GLUnurbsObj* WINAPI wine_gluNewNurbsRenderer( void ) {
 	return gluNewNurbsRenderer();
 }
 
 /***********************************************************************
  *		gluDeleteNurbsRenderer (GLU32.@)
  */
-extern int gluDeleteNurbsRenderer(void *arg0);
-int WINAPI wine_gluDeleteNurbsRenderer(void *arg0) {
-	return gluDeleteNurbsRenderer(arg0);
+void WINAPI wine_gluDeleteNurbsRenderer( GLUnurbsObj *nobj ) {
+	gluDeleteNurbsRenderer(nobj);
 }
 
 /***********************************************************************
  *		gluLoadSamplingMatrices (GLU32.@)
  */
-extern int gluLoadSamplingMatrices(void *arg0,void *arg1,void *arg2,void *arg3);
-int WINAPI wine_gluLoadSamplingMatrices(void *arg0,void *arg1,void *arg2,void *arg3) {
-	return gluLoadSamplingMatrices(arg0,arg1,arg2,arg3);
+void WINAPI wine_gluLoadSamplingMatrices( GLUnurbsObj *nobj,
+					  const GLfloat modelMatrix[16],
+					  const GLfloat projMatrix[16],
+					  const GLint viewport[4] ) {
+	gluLoadSamplingMatrices(nobj, modelMatrix, projMatrix, viewport);
 }
 
 /***********************************************************************
  *		gluNurbsProperty (GLU32.@)
  */
-extern int gluNurbsProperty(void *arg0,int arg1,int arg2);
-int WINAPI wine_gluNurbsProperty(void *arg0,int arg1,int arg2) {
-	return gluNurbsProperty(arg0,arg1,arg2);
+void WINAPI wine_gluNurbsProperty( GLUnurbsObj *nobj, GLenum property,
+				   GLfloat value ) {
+	gluNurbsProperty(nobj, property, value);
 }
 
 /***********************************************************************
  *		gluGetNurbsProperty (GLU32.@)
  */
-extern int gluGetNurbsProperty(void *arg0,int arg1,void *arg2);
-int WINAPI wine_gluGetNurbsProperty(void *arg0,int arg1,void *arg2) {
-	return gluGetNurbsProperty(arg0,arg1,arg2);
+void WINAPI wine_gluGetNurbsProperty( GLUnurbsObj *nobj, GLenum property,
+				      GLfloat *value ) {
+	gluGetNurbsProperty(nobj, property, value);
 }
 
 /***********************************************************************
  *		gluBeginCurve (GLU32.@)
  */
-extern int gluBeginCurve(void *arg0);
-int WINAPI wine_gluBeginCurve(void *arg0) {
-	return gluBeginCurve(arg0);
+void WINAPI wine_gluBeginCurve( GLUnurbsObj *nobj ) {
+	gluBeginCurve(nobj);
 }
 
 /***********************************************************************
  *		gluEndCurve (GLU32.@)
  */
-extern int gluEndCurve(void *arg0);
-int WINAPI wine_gluEndCurve(void *arg0) {
-	return gluEndCurve(arg0);
+void WINAPI wine_gluEndCurve( GLUnurbsObj *nobj ) {
+	gluEndCurve(nobj);
 }
 
 /***********************************************************************
  *		gluNurbsCurve (GLU32.@)
  */
-extern int gluNurbsCurve(void *arg0,int arg1,void *arg2,int arg3,void *arg4,int arg5,int arg6);
-int WINAPI wine_gluNurbsCurve(void *arg0,int arg1,void *arg2,int arg3,void *arg4,int arg5,int arg6) {
-	return gluNurbsCurve(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
+void WINAPI wine_gluNurbsCurve( GLUnurbsObj *nobj, GLint nknots,
+				GLfloat *knot, GLint stride,
+				GLfloat *ctlarray, GLint order,
+				GLenum type ) {
+	gluNurbsCurve(nobj, nknots, knot, stride, ctlarray, order, type);
 }
 
 /***********************************************************************
  *		gluBeginSurface (GLU32.@)
  */
-extern int gluBeginSurface(void *arg0);
-int WINAPI wine_gluBeginSurface(void *arg0) {
-	return gluBeginSurface(arg0);
+void WINAPI wine_gluBeginSurface( GLUnurbsObj *nobj ) {
+	gluBeginSurface(nobj);
 }
 
 /***********************************************************************
  *		gluEndSurface (GLU32.@)
  */
-extern int gluEndSurface(void *arg0);
-int WINAPI wine_gluEndSurface(void *arg0) {
-	return gluEndSurface(arg0);
+void WINAPI wine_gluEndSurface( GLUnurbsObj *nobj ) {
+	gluEndSurface(nobj);
 }
 
 /***********************************************************************
  *		gluNurbsSurface (GLU32.@)
  */
-extern int gluNurbsSurface(void *arg0,int arg1,void *arg2,int arg3,void *arg4,int arg5,int arg6,void *arg7,int arg8,int arg9,int arg10);
-int WINAPI wine_gluNurbsSurface(void *arg0,int arg1,void *arg2,int arg3,void *arg4,int arg5,int arg6,void *arg7,int arg8,int arg9,int arg10) {
-	return gluNurbsSurface(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+void WINAPI wine_gluNurbsSurface( GLUnurbsObj *nobj,
+				  GLint sknot_count, GLfloat *sknot,
+				  GLint tknot_count, GLfloat *tknot,
+				  GLint s_stride, GLint t_stride,
+				  GLfloat *ctlarray,
+				  GLint sorder, GLint torder,
+				  GLenum type ) {
+	gluNurbsSurface(nobj, sknot_count, sknot, tknot_count, tknot, s_stride, t_stride, ctlarray, sorder, torder, type);
 }
 
 /***********************************************************************
  *		gluBeginTrim (GLU32.@)
  */
-extern int gluBeginTrim(void *arg0);
-int WINAPI wine_gluBeginTrim(void *arg0) {
-	return gluBeginTrim(arg0);
+void WINAPI wine_gluBeginTrim( GLUnurbsObj *nobj ) {
+	gluBeginTrim(nobj);
 }
 
 /***********************************************************************
  *		gluEndTrim (GLU32.@)
  */
-extern int gluEndTrim(void *arg0);
-int WINAPI wine_gluEndTrim(void *arg0) {
-	return gluEndTrim(arg0);
+void WINAPI wine_gluEndTrim( GLUnurbsObj *nobj ) {
+	gluEndTrim(nobj);
 }
 
 /***********************************************************************
  *		gluPwlCurve (GLU32.@)
  */
-extern int gluPwlCurve(void *arg0,int arg1,void *arg2,int arg3,int arg4);
-int WINAPI wine_gluPwlCurve(void *arg0,int arg1,void *arg2,int arg3,int arg4) {
-	return gluPwlCurve(arg0,arg1,arg2,arg3,arg4);
+void WINAPI wine_gluPwlCurve( GLUnurbsObj *nobj, GLint count,
+			      GLfloat *array,
+			      GLint stride, GLenum type ) {
+	gluPwlCurve(nobj, count, array, stride, type);
 }
 
 /***********************************************************************
  *		gluNurbsCallback (GLU32.@)
  */
-extern int gluNurbsCallback(void *arg0,int arg1,void *arg2);
-int WINAPI wine_gluNurbsCallback(void *arg0,int arg1,void *arg2) {
-	return gluNurbsCallback(arg0,arg1,arg2);
+void WINAPI wine_gluNurbsCallback( GLUnurbsObj *nobj, GLenum which,
+				   void (* fn)() ) {
+	gluNurbsCallback(nobj, which, fn);
 }
 
 /***********************************************************************
  *		gluNewTess (GLU32.@)
  */
-extern int gluNewTess();
-int WINAPI wine_gluNewTess() {
+GLUtesselator* WINAPI wine_gluNewTess( void ) {
 	return gluNewTess();
 }
 
 /***********************************************************************
  *		gluDeleteTess (GLU32.@)
  */
-extern int gluDeleteTess(void *arg0);
-int WINAPI wine_gluDeleteTess(void *arg0) {
-	return gluDeleteTess(arg0);
+void WINAPI wine_gluDeleteTess( GLUtesselator *tess ) {
+	gluDeleteTess(tess);
 }
 
 /***********************************************************************
  *		gluTessVertex (GLU32.@)
  */
-extern int gluTessVertex(void *arg0,void *arg1,void *arg2);
-int WINAPI wine_gluTessVertex(void *arg0,void *arg1,void *arg2) {
-	return gluTessVertex(arg0,arg1,arg2);
+void WINAPI wine_gluTessVertex( GLUtesselator *tess, GLdouble coords[3],
+				void *data ) {
+	gluTessVertex(tess, coords, data);
 }
 
 /***********************************************************************
  *		gluTessCallback (GLU32.@)
  */
-extern int gluTessCallback(void *arg0,int arg1,void *arg2);
-int WINAPI wine_gluTessCallback(void *arg0,int arg1,void *arg2) {
-	return gluTessCallback(arg0,arg1,arg2);
+void WINAPI wine_gluTessCallback( GLUtesselator *tess, GLenum which,
+				  void (* fn)() ) {
+	gluTessCallback(tess, which, fn);
 }
 
 /***********************************************************************
  *		gluBeginPolygon (GLU32.@)
  */
-extern int gluBeginPolygon(void *arg0);
-int WINAPI wine_gluBeginPolygon(void *arg0) {
-	return gluBeginPolygon(arg0);
+void WINAPI wine_gluBeginPolygon( GLUtesselator *tess ) {
+#ifdef GLU_VERSION_1_2
+	gluTessBeginPolygon(tess, NULL);
+	gluTessBeginContour(tess);
+#else
+	gluBeginPolygon(tess);
+#endif /* GLU_VERSION_1_2 */
 }
 
 /***********************************************************************
  *		gluEndPolygon (GLU32.@)
  */
-extern int gluEndPolygon(void *arg0);
-int WINAPI wine_gluEndPolygon(void *arg0) {
-	return gluEndPolygon(arg0);
+void WINAPI wine_gluEndPolygon( GLUtesselator *tess ) {
+#ifdef GLU_VERSION_1_2
+	gluTessEndContour(tess);
+	gluTessEndPolygon(tess);
+#else
+	gluEndPolygon(tess);
+#endif /* GLU_VERSION_1_2 */
 }
 
 /***********************************************************************
  *		gluNextContour (GLU32.@)
  */
-extern int gluNextContour(void *arg0,int arg1);
-int WINAPI wine_gluNextContour(void *arg0,int arg1) {
-	return gluNextContour(arg0,arg1);
+void WINAPI wine_gluNextContour( GLUtesselator *tess, GLenum type ) {
+#ifdef GLU_VERSION_1_2
+	gluTessEndContour(tess);
+	gluTessBeginContour(tess);
+#else
+	gluNextContour(tess, type);
+#endif /* GLU_VERSION_1_2 */
+}
+
+/***********************************************************************
+ *		gluTessProperty (GLU32.@)
+ */
+void WINAPI wine_gluTessProperty( GLUtesselator *tess, GLenum which,
+				  GLdouble value ) {
+#ifdef GLU_VERSION_1_2
+	gluTessProperty(tess, which, value);
+#else
+	WARN("(%p, %d, %.06f): no libGLU 1.2 found\n", tess, which, value);
+#endif /* GLU_VERSION_1_2 */
+}
+
+/***********************************************************************
+ *		gluGetTessProperty (GLU32.@)
+ */
+void WINAPI wine_gluGetTessProperty( GLUtesselator *tess, GLenum which,
+				     GLdouble *value ) {
+#ifdef GLU_VERSION_1_2
+	gluGetTessProperty(tess, which, value);
+#else
+	WARN("(%p, %d, %p): no libGLU 1.2 found\n", tess, which, value);
+#endif /* GLU_VERSION_1_2 */
 }
 
 /***********************************************************************
  *		gluGetString (GLU32.@)
  */
-extern int gluGetString(int arg0);
-int WINAPI wine_gluGetString(int arg0) {
-	return gluGetString(arg0);
+void WINAPI wine_gluTessNormal( GLUtesselator *tess, GLdouble x,
+				GLdouble y, GLdouble z ) {
+#ifdef GLU_VERSION_1_2
+	gluTessNormal(tess, x, y, z);
+#else
+	WARN("(%p, %.06f, %.06f, %.06f): no libGLU 1.2 found\n", tess, x, y, z);
+#endif /* GLU_VERSION_1_2 */
 }
 
 /***********************************************************************
- *		gluCheckExtension (GLU32.@)
+ *		gluGetString (GLU32.@)
  */
-int WINAPI
-wine_gluCheckExtension( const char *extName, void *extString ) {
-    return 0;
+const GLubyte* WINAPI wine_gluGetString( GLenum name ) {
+	return gluGetString(name);
 }
diff -urN wine-orig/dlls/glu32/glu32.spec wine-pas-compilé/dlls/glu32/glu32.spec
--- wine-orig/dlls/glu32/glu32.spec	Tue May 14 17:13:54 2002
+++ wine-pas-compilé/dlls/glu32/glu32.spec	Mon Jun 10 23:26:48 2002
@@ -43,5 +43,7 @@
 @ stdcall gluBeginPolygon(ptr) wine_gluBeginPolygon
 @ stdcall gluEndPolygon(ptr) wine_gluEndPolygon
 @ stdcall gluNextContour(ptr long) wine_gluNextContour
+@ stdcall gluTessProperty(ptr long double) wine_gluTessProperty
+@ stdcall gluGetTessProperty(ptr long ptr) wine_gluGetTessProperty
+@ stdcall gluTessNormal(ptr double double double) wine_gluTessNormal
 @ stdcall gluGetString(long) wine_gluGetString
-@ stdcall gluCheckExtension(str ptr) wine_gluCheckExtension

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux