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
