GLU32 patch (yep, again)

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

 



Finally gotten around to install autoconf 2.53, so this patch includes
the modified configure and config.h.in in addition to the stuff I had
already modified.

The modification of the prototypes (and spec file) are in accordance
with MSDN and the glu32.dll file that I could get my hands on
(Microsoft's Opengl95.exe). The GLU version implemented by MS is 1.2, so
I dropped gluCheckExtension as it's a 1.3 API.

glu32 can now be built with a libGLU 1.1 or 1.2. If a 1.1 version is
used, some functions only issue a WARN. It should become more and more
rare to only have a libGLU 1.1.

If there's still something preventing this from being applied, please
let me know.

Changelog:
 - #include'd GL/glu.h instead of redefining the GLU functions in
glu_main.c.
 - Modified the libGLU.so check in configure to also check for GL/glu.h.
 - Modified the glu32 prototypes to match MSDN's documentation.
 - The building of glu32.dll can now accept a libGLU 1.1 or 1.2.

Vincent
diff -urN wine-orig/configure wine-pas-compilé/configure
--- wine-orig/configure	Thu Jun 13 22:52:40 2002
+++ wine-pas-compilé/configure	Sat Jun 15 21:49:10 2002
@@ -7296,7 +7296,8 @@
 			fi
 
 		fi
-	        		echo "$as_me:$LINENO: checking for gluLookAt in -lGLU" >&5
+				wine_cv_warn_gl_glu_h=no
+		echo "$as_me:$LINENO: checking for gluLookAt in -lGLU" >&5
 echo $ECHO_N "checking for gluLookAt in -lGLU... $ECHO_C" >&6
 if test "${ac_cv_lib_GLU_gluLookAt+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -7353,8 +7354,123 @@
 echo "$as_me:$LINENO: result: $ac_cv_lib_GLU_gluLookAt" >&5
 echo "${ECHO_T}$ac_cv_lib_GLU_gluLookAt" >&6
 if test $ac_cv_lib_GLU_gluLookAt = yes; then
-  X_PRE_LIBS="$X_PRE_LIBS -lGLU"
-			     GLU32FILES='$(GLU32FILES)'
+
+for ac_header in GL/glu.h
+do
+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+else
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking $ac_header usability" >&5
+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+#include "confdefs.h"
+$ac_includes_default
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+         { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+cat conftest.$ac_ext >&5
+ac_header_compiler=no
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking $ac_header presence" >&5
+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+#include "confdefs.h"
+#include <$ac_header>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  egrep -v '^ *\+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  ac_header_preproc=yes
+else
+  echo "$as_me: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc in
+  yes:no )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
+  no:yes )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
+esac
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  eval "$as_ac_Header=$ac_header_preproc"
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+
+fi
+if test `eval echo '${'$as_ac_Header'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+ X_PRE_LIBS="$X_PRE_LIBS -lGLU"
+				GLU32FILES='$(GLU32FILES)'
+else
+  wine_cv_warn_gl_glu_h=yes
+fi
+
+done
+
 
 fi
 
@@ -14577,6 +14693,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/configure.ac wine-pas-compilé/configure.ac
--- wine-orig/configure.ac	Thu Jun 13 22:52:40 2002
+++ wine-pas-compilé/configure.ac	Sat Jun 15 15:51:24 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
@@ -1422,6 +1425,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	Sat Jun 15 15:51:24 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	Sat Jun 15 15:51:24 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
diff -urN wine-orig/include/config.h.in wine-pas-compilé/include/config.h.in
--- wine-orig/include/config.h.in	Tue May 21 09:59:47 2002
+++ wine-pas-compilé/include/config.h.in	Sat Jun 15 21:45:24 2002
@@ -146,6 +146,9 @@
 /* Define to 1 if you have the <GL/glext.h> header file. */
 #undef HAVE_GL_GLEXT_H
 
+/* Define to 1 if you have the <GL/glu.h> header file. */
+#undef HAVE_GL_GLU_H
+
 /* Define to 1 if you have the <GL/glx.h> header file. */
 #undef HAVE_GL_GLX_H
 

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

  Powered by Linux