#ifndef INLINE_GLU_H
#define INLINE_GLU_H

/*
    *** Automatically generated from '/home/aros/ABIv0/Build/20110803/AROS/workbench/libs/mesa/src/aros/glu/glu.conf'. Edits will be lost. ***
    Copyright © 1995-2011, The AROS Development Team. All rights reserved.
*/

/*
    Desc: Inline function for glu
*/

#include <aros/libcall.h>
#include <exec/types.h>
#include <aros/preprocessor/variadic/cast2iptr.hpp>


static inline void __inline_Glu_gluBeginCurve(GLUnurbs * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluBeginCurve,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        struct Library *, (__GluBase), 35, Glu    );
}

#define gluBeginCurve(arg1) \
    __inline_Glu_gluBeginCurve((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluBeginPolygon(GLUtesselator * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluBeginPolygon,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        struct Library *, (__GluBase), 36, Glu    );
}

#define gluBeginPolygon(arg1) \
    __inline_Glu_gluBeginPolygon((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluBeginSurface(GLUnurbs * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluBeginSurface,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        struct Library *, (__GluBase), 37, Glu    );
}

#define gluBeginSurface(arg1) \
    __inline_Glu_gluBeginSurface((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluBeginTrim(GLUnurbs * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluBeginTrim,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        struct Library *, (__GluBase), 38, Glu    );
}

#define gluBeginTrim(arg1) \
    __inline_Glu_gluBeginTrim((arg1), (APTR)GluBase)

static inline GLint __inline_Glu_gluBuild1DMipmapLevels(GLenum __arg1, GLint __arg2, GLsizei __arg3, GLenum __arg4, GLenum __arg5, GLint __arg6, GLint __arg7, GLint __arg8, const void * __arg9, APTR __GluBase)
{
    return AROS_LC9(GLint, gluBuild1DMipmapLevels,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLint,(__arg8),D7),
        AROS_LCA(const void *,(__arg9),A0),
        struct Library *, (__GluBase), 39, Glu    );
}

#define gluBuild1DMipmapLevels(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Glu_gluBuild1DMipmapLevels((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)GluBase)

static inline GLint __inline_Glu_gluBuild1DMipmaps(GLenum __arg1, GLint __arg2, GLsizei __arg3, GLenum __arg4, GLenum __arg5, const void * __arg6, APTR __GluBase)
{
    return AROS_LC6(GLint, gluBuild1DMipmaps,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const void *,(__arg6),A0),
        struct Library *, (__GluBase), 40, Glu    );
}

#define gluBuild1DMipmaps(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Glu_gluBuild1DMipmaps((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)GluBase)

static inline GLint __inline_Glu_gluBuild2DMipmapLevels(GLenum __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, GLenum __arg5, GLenum __arg6, GLint __arg7, GLint __arg8, GLint __arg9, const void * __arg10, APTR __GluBase)
{
    return AROS_LC10(GLint, gluBuild2DMipmapLevels,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLint,(__arg8),D7),
        AROS_LCA(GLint,(__arg9),A0),
        AROS_LCA(const void *,(__arg10),A1),
        struct Library *, (__GluBase), 41, Glu    );
}

#define gluBuild2DMipmapLevels(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Glu_gluBuild2DMipmapLevels((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)GluBase)

static inline GLint __inline_Glu_gluBuild2DMipmaps(GLenum __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, GLenum __arg5, GLenum __arg6, const void * __arg7, APTR __GluBase)
{
    return AROS_LC7(GLint, gluBuild2DMipmaps,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(const void *,(__arg7),A0),
        struct Library *, (__GluBase), 42, Glu    );
}

#define gluBuild2DMipmaps(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Glu_gluBuild2DMipmaps((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)GluBase)

static inline GLint __inline_Glu_gluBuild3DMipmapLevels(GLenum __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, GLsizei __arg5, GLenum __arg6, GLenum __arg7, GLint __arg8, GLint __arg9, GLint __arg10, const void * __arg11, APTR __GluBase)
{
    return AROS_LC11(GLint, gluBuild3DMipmapLevels,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(GLenum,(__arg7),D6),
        AROS_LCA(GLint,(__arg8),D7),
        AROS_LCA(GLint,(__arg9),A0),
        AROS_LCA(GLint,(__arg10),A1),
        AROS_LCA(const void *,(__arg11),A2),
        struct Library *, (__GluBase), 43, Glu    );
}

#define gluBuild3DMipmapLevels(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) \
    __inline_Glu_gluBuild3DMipmapLevels((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11), (APTR)GluBase)

static inline GLint __inline_Glu_gluBuild3DMipmaps(GLenum __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, GLsizei __arg5, GLenum __arg6, GLenum __arg7, const void * __arg8, APTR __GluBase)
{
    return AROS_LC8(GLint, gluBuild3DMipmaps,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(GLenum,(__arg7),D6),
        AROS_LCA(const void *,(__arg8),A0),
        struct Library *, (__GluBase), 44, Glu    );
}

#define gluBuild3DMipmaps(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Glu_gluBuild3DMipmaps((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)GluBase)

static inline GLboolean __inline_Glu_gluCheckExtension(const GLubyte * __arg1, const GLubyte * __arg2, APTR __GluBase)
{
    return AROS_LC2(GLboolean, gluCheckExtension,
        AROS_LCA(const GLubyte *,(__arg1),A0),
        AROS_LCA(const GLubyte *,(__arg2),A1),
        struct Library *, (__GluBase), 45, Glu    );
}

#define gluCheckExtension(arg1, arg2) \
    __inline_Glu_gluCheckExtension((arg1), (arg2), (APTR)GluBase)

static inline void __inline_Glu_gluCylinder(GLUquadric * __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLint __arg5, GLint __arg6, APTR __GluBase)
{
    AROS_LC6NR(void, gluCylinder,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        AROS_LCA(GLdouble,(__arg2),D0),
        AROS_LCA(GLdouble,(__arg3),D1),
        AROS_LCA(GLdouble,(__arg4),D2),
        AROS_LCA(GLint,(__arg5),D3),
        AROS_LCA(GLint,(__arg6),D4),
        struct Library *, (__GluBase), 46, Glu    );
}

#define gluCylinder(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Glu_gluCylinder((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)GluBase)

static inline void __inline_Glu_gluDeleteNurbsRenderer(GLUnurbs * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluDeleteNurbsRenderer,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        struct Library *, (__GluBase), 47, Glu    );
}

#define gluDeleteNurbsRenderer(arg1) \
    __inline_Glu_gluDeleteNurbsRenderer((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluDeleteQuadric(GLUquadric * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluDeleteQuadric,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        struct Library *, (__GluBase), 48, Glu    );
}

#define gluDeleteQuadric(arg1) \
    __inline_Glu_gluDeleteQuadric((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluDeleteTess(GLUtesselator * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluDeleteTess,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        struct Library *, (__GluBase), 49, Glu    );
}

#define gluDeleteTess(arg1) \
    __inline_Glu_gluDeleteTess((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluDisk(GLUquadric * __arg1, GLdouble __arg2, GLdouble __arg3, GLint __arg4, GLint __arg5, APTR __GluBase)
{
    AROS_LC5NR(void, gluDisk,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        AROS_LCA(GLdouble,(__arg2),D0),
        AROS_LCA(GLdouble,(__arg3),D1),
        AROS_LCA(GLint,(__arg4),D2),
        AROS_LCA(GLint,(__arg5),D3),
        struct Library *, (__GluBase), 50, Glu    );
}

#define gluDisk(arg1, arg2, arg3, arg4, arg5) \
    __inline_Glu_gluDisk((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)GluBase)

static inline void __inline_Glu_gluEndCurve(GLUnurbs * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluEndCurve,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        struct Library *, (__GluBase), 51, Glu    );
}

#define gluEndCurve(arg1) \
    __inline_Glu_gluEndCurve((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluEndPolygon(GLUtesselator * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluEndPolygon,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        struct Library *, (__GluBase), 52, Glu    );
}

#define gluEndPolygon(arg1) \
    __inline_Glu_gluEndPolygon((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluEndSurface(GLUnurbs * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluEndSurface,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        struct Library *, (__GluBase), 53, Glu    );
}

#define gluEndSurface(arg1) \
    __inline_Glu_gluEndSurface((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluEndTrim(GLUnurbs * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluEndTrim,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        struct Library *, (__GluBase), 54, Glu    );
}

#define gluEndTrim(arg1) \
    __inline_Glu_gluEndTrim((arg1), (APTR)GluBase)

static inline const GLubyte * __inline_Glu_gluErrorString(GLenum __arg1, APTR __GluBase)
{
    return AROS_LC1(const GLubyte *, gluErrorString,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__GluBase), 55, Glu    );
}

#define gluErrorString(arg1) \
    __inline_Glu_gluErrorString((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluGetNurbsProperty(GLUnurbs * __arg1, GLenum __arg2, GLfloat * __arg3, APTR __GluBase)
{
    AROS_LC3NR(void, gluGetNurbsProperty,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        AROS_LCA(GLfloat *,(__arg3),A1),
        struct Library *, (__GluBase), 56, Glu    );
}

#define gluGetNurbsProperty(arg1, arg2, arg3) \
    __inline_Glu_gluGetNurbsProperty((arg1), (arg2), (arg3), (APTR)GluBase)

static inline const GLubyte * __inline_Glu_gluGetString(GLenum __arg1, APTR __GluBase)
{
    return AROS_LC1(const GLubyte *, gluGetString,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__GluBase), 57, Glu    );
}

#define gluGetString(arg1) \
    __inline_Glu_gluGetString((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluGetTessProperty(GLUtesselator * __arg1, GLenum __arg2, GLdouble * __arg3, APTR __GluBase)
{
    AROS_LC3NR(void, gluGetTessProperty,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        AROS_LCA(GLdouble *,(__arg3),A1),
        struct Library *, (__GluBase), 58, Glu    );
}

#define gluGetTessProperty(arg1, arg2, arg3) \
    __inline_Glu_gluGetTessProperty((arg1), (arg2), (arg3), (APTR)GluBase)

static inline void __inline_Glu_gluLoadSamplingMatrices(GLUnurbs * __arg1, const GLfloat * __arg2, const GLfloat * __arg3, const GLint * __arg4, APTR __GluBase)
{
    AROS_LC4NR(void, gluLoadSamplingMatrices,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        AROS_LCA(const GLfloat *,(__arg2),A1),
        AROS_LCA(const GLfloat *,(__arg3),A2),
        AROS_LCA(const GLint *,(__arg4),A3),
        struct Library *, (__GluBase), 59, Glu    );
}

#define gluLoadSamplingMatrices(arg1, arg2, arg3, arg4) \
    __inline_Glu_gluLoadSamplingMatrices((arg1), (arg2), (arg3), (arg4), (APTR)GluBase)

static inline void __inline_Glu_gluLookAt(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, GLdouble __arg6, GLdouble __arg7, GLdouble __arg8, GLdouble __arg9, APTR __GluBase)
{
    AROS_LC9NR(void, gluLookAt,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        AROS_LCA(GLdouble,(__arg6),D5),
        AROS_LCA(GLdouble,(__arg7),D6),
        AROS_LCA(GLdouble,(__arg8),D7),
        AROS_LCA(GLdouble,(__arg9),A0),
        struct Library *, (__GluBase), 60, Glu    );
}

#define gluLookAt(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Glu_gluLookAt((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)GluBase)

static inline GLUnurbs* __inline_Glu_gluNewNurbsRenderer(APTR __GluBase)
{
    return AROS_LC0(GLUnurbs*, gluNewNurbsRenderer,
        struct Library *, (__GluBase), 61, Glu    );
}

#define gluNewNurbsRenderer() \
    __inline_Glu_gluNewNurbsRenderer((APTR)GluBase)

static inline GLUquadric* __inline_Glu_gluNewQuadric(APTR __GluBase)
{
    return AROS_LC0(GLUquadric*, gluNewQuadric,
        struct Library *, (__GluBase), 62, Glu    );
}

#define gluNewQuadric() \
    __inline_Glu_gluNewQuadric((APTR)GluBase)

static inline GLUtesselator* __inline_Glu_gluNewTess(APTR __GluBase)
{
    return AROS_LC0(GLUtesselator*, gluNewTess,
        struct Library *, (__GluBase), 63, Glu    );
}

#define gluNewTess() \
    __inline_Glu_gluNewTess((APTR)GluBase)

static inline void __inline_Glu_gluNextContour(GLUtesselator * __arg1, GLenum __arg2, APTR __GluBase)
{
    AROS_LC2NR(void, gluNextContour,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        struct Library *, (__GluBase), 64, Glu    );
}

#define gluNextContour(arg1, arg2) \
    __inline_Glu_gluNextContour((arg1), (arg2), (APTR)GluBase)

static inline void __inline_Glu_gluNurbsCallback(GLUnurbs * __arg1, GLenum __arg2, _GLUfuncptr __arg3, APTR __GluBase)
{
    AROS_LC3NR(void, gluNurbsCallback,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        AROS_LCA(_GLUfuncptr,(__arg3),D1),
        struct Library *, (__GluBase), 65, Glu    );
}

#define gluNurbsCallback(arg1, arg2, arg3) \
    __inline_Glu_gluNurbsCallback((arg1), (arg2), (arg3), (APTR)GluBase)

static inline void __inline_Glu_gluNurbsCallbackData(GLUnurbs * __arg1, GLvoid * __arg2, APTR __GluBase)
{
    AROS_LC2NR(void, gluNurbsCallbackData,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        AROS_LCA(GLvoid *,(__arg2),A1),
        struct Library *, (__GluBase), 66, Glu    );
}

#define gluNurbsCallbackData(arg1, arg2) \
    __inline_Glu_gluNurbsCallbackData((arg1), (arg2), (APTR)GluBase)

static inline void __inline_Glu_gluNurbsCallbackDataEXT(GLUnurbs * __arg1, GLvoid * __arg2, APTR __GluBase)
{
    AROS_LC2NR(void, gluNurbsCallbackDataEXT,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        AROS_LCA(GLvoid *,(__arg2),A1),
        struct Library *, (__GluBase), 67, Glu    );
}

#define gluNurbsCallbackDataEXT(arg1, arg2) \
    __inline_Glu_gluNurbsCallbackDataEXT((arg1), (arg2), (APTR)GluBase)

static inline void __inline_Glu_gluNurbsCurve(GLUnurbs * __arg1, GLint __arg2, GLfloat * __arg3, GLint __arg4, GLfloat * __arg5, GLint __arg6, GLenum __arg7, APTR __GluBase)
{
    AROS_LC7NR(void, gluNurbsCurve,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        AROS_LCA(GLint,(__arg2),D0),
        AROS_LCA(GLfloat *,(__arg3),A1),
        AROS_LCA(GLint,(__arg4),D1),
        AROS_LCA(GLfloat *,(__arg5),A2),
        AROS_LCA(GLint,(__arg6),D2),
        AROS_LCA(GLenum,(__arg7),D3),
        struct Library *, (__GluBase), 68, Glu    );
}

#define gluNurbsCurve(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Glu_gluNurbsCurve((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)GluBase)

static inline void __inline_Glu_gluNurbsProperty(GLUnurbs * __arg1, GLenum __arg2, GLfloat __arg3, APTR __GluBase)
{
    AROS_LC3NR(void, gluNurbsProperty,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        AROS_LCA(GLfloat,(__arg3),D1),
        struct Library *, (__GluBase), 69, Glu    );
}

#define gluNurbsProperty(arg1, arg2, arg3) \
    __inline_Glu_gluNurbsProperty((arg1), (arg2), (arg3), (APTR)GluBase)

static inline void __inline_Glu_gluNurbsSurface(GLUnurbs * __arg1, GLint __arg2, GLfloat * __arg3, GLint __arg4, GLfloat * __arg5, GLint __arg6, GLint __arg7, GLfloat * __arg8, GLint __arg9, GLint __arg10, GLenum __arg11, APTR __GluBase)
{
    AROS_LC11NR(void, gluNurbsSurface,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        AROS_LCA(GLint,(__arg2),D0),
        AROS_LCA(GLfloat *,(__arg3),A1),
        AROS_LCA(GLint,(__arg4),D1),
        AROS_LCA(GLfloat *,(__arg5),A2),
        AROS_LCA(GLint,(__arg6),D2),
        AROS_LCA(GLint,(__arg7),D3),
        AROS_LCA(GLfloat *,(__arg8),A3),
        AROS_LCA(GLint,(__arg9),D4),
        AROS_LCA(GLint,(__arg10),D5),
        AROS_LCA(GLenum,(__arg11),D6),
        struct Library *, (__GluBase), 70, Glu    );
}

#define gluNurbsSurface(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) \
    __inline_Glu_gluNurbsSurface((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11), (APTR)GluBase)

static inline void __inline_Glu_gluOrtho2D(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __GluBase)
{
    AROS_LC4NR(void, gluOrtho2D,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__GluBase), 71, Glu    );
}

#define gluOrtho2D(arg1, arg2, arg3, arg4) \
    __inline_Glu_gluOrtho2D((arg1), (arg2), (arg3), (arg4), (APTR)GluBase)

static inline void __inline_Glu_gluPartialDisk(GLUquadric * __arg1, GLdouble __arg2, GLdouble __arg3, GLint __arg4, GLint __arg5, GLdouble __arg6, GLdouble __arg7, APTR __GluBase)
{
    AROS_LC7NR(void, gluPartialDisk,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        AROS_LCA(GLdouble,(__arg2),D0),
        AROS_LCA(GLdouble,(__arg3),D1),
        AROS_LCA(GLint,(__arg4),D2),
        AROS_LCA(GLint,(__arg5),D3),
        AROS_LCA(GLdouble,(__arg6),D4),
        AROS_LCA(GLdouble,(__arg7),D5),
        struct Library *, (__GluBase), 72, Glu    );
}

#define gluPartialDisk(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Glu_gluPartialDisk((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)GluBase)

static inline void __inline_Glu_gluPerspective(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __GluBase)
{
    AROS_LC4NR(void, gluPerspective,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__GluBase), 73, Glu    );
}

#define gluPerspective(arg1, arg2, arg3, arg4) \
    __inline_Glu_gluPerspective((arg1), (arg2), (arg3), (arg4), (APTR)GluBase)

static inline void __inline_Glu_gluPickMatrix(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLint * __arg5, APTR __GluBase)
{
    AROS_LC5NR(void, gluPickMatrix,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLint *,(__arg5),A0),
        struct Library *, (__GluBase), 74, Glu    );
}

#define gluPickMatrix(arg1, arg2, arg3, arg4, arg5) \
    __inline_Glu_gluPickMatrix((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)GluBase)

static inline GLint __inline_Glu_gluProject(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, const GLdouble * __arg4, const GLdouble * __arg5, const GLint * __arg6, GLdouble * __arg7, GLdouble * __arg8, GLdouble * __arg9, APTR __GluBase)
{
    return AROS_LC9(GLint, gluProject,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(const GLdouble *,(__arg4),A0),
        AROS_LCA(const GLdouble *,(__arg5),A1),
        AROS_LCA(const GLint *,(__arg6),A2),
        AROS_LCA(GLdouble *,(__arg7),A3),
        AROS_LCA(GLdouble *,(__arg8),A4),
        AROS_LCA(GLdouble *,(__arg9),A5),
        struct Library *, (__GluBase), 75, Glu    );
}

#define gluProject(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Glu_gluProject((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)GluBase)

static inline void __inline_Glu_gluPwlCurve(GLUnurbs * __arg1, GLint __arg2, GLfloat * __arg3, GLint __arg4, GLenum __arg5, APTR __GluBase)
{
    AROS_LC5NR(void, gluPwlCurve,
        AROS_LCA(GLUnurbs *,(__arg1),A0),
        AROS_LCA(GLint,(__arg2),D0),
        AROS_LCA(GLfloat *,(__arg3),A1),
        AROS_LCA(GLint,(__arg4),D1),
        AROS_LCA(GLenum,(__arg5),D2),
        struct Library *, (__GluBase), 76, Glu    );
}

#define gluPwlCurve(arg1, arg2, arg3, arg4, arg5) \
    __inline_Glu_gluPwlCurve((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)GluBase)

static inline void __inline_Glu_gluQuadricCallback(GLUquadric * __arg1, GLenum __arg2, _GLUfuncptr __arg3, APTR __GluBase)
{
    AROS_LC3NR(void, gluQuadricCallback,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        AROS_LCA(_GLUfuncptr,(__arg3),D1),
        struct Library *, (__GluBase), 77, Glu    );
}

#define gluQuadricCallback(arg1, arg2, arg3) \
    __inline_Glu_gluQuadricCallback((arg1), (arg2), (arg3), (APTR)GluBase)

static inline void __inline_Glu_gluQuadricDrawStyle(GLUquadric * __arg1, GLenum __arg2, APTR __GluBase)
{
    AROS_LC2NR(void, gluQuadricDrawStyle,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        struct Library *, (__GluBase), 78, Glu    );
}

#define gluQuadricDrawStyle(arg1, arg2) \
    __inline_Glu_gluQuadricDrawStyle((arg1), (arg2), (APTR)GluBase)

static inline void __inline_Glu_gluQuadricNormals(GLUquadric * __arg1, GLenum __arg2, APTR __GluBase)
{
    AROS_LC2NR(void, gluQuadricNormals,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        struct Library *, (__GluBase), 79, Glu    );
}

#define gluQuadricNormals(arg1, arg2) \
    __inline_Glu_gluQuadricNormals((arg1), (arg2), (APTR)GluBase)

static inline void __inline_Glu_gluQuadricOrientation(GLUquadric * __arg1, GLenum __arg2, APTR __GluBase)
{
    AROS_LC2NR(void, gluQuadricOrientation,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        struct Library *, (__GluBase), 80, Glu    );
}

#define gluQuadricOrientation(arg1, arg2) \
    __inline_Glu_gluQuadricOrientation((arg1), (arg2), (APTR)GluBase)

static inline void __inline_Glu_gluQuadricTexture(GLUquadric * __arg1, GLboolean __arg2, APTR __GluBase)
{
    AROS_LC2NR(void, gluQuadricTexture,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        AROS_LCA(GLboolean,(__arg2),D0),
        struct Library *, (__GluBase), 81, Glu    );
}

#define gluQuadricTexture(arg1, arg2) \
    __inline_Glu_gluQuadricTexture((arg1), (arg2), (APTR)GluBase)

static inline GLint __inline_Glu_gluScaleImage(GLenum __arg1, GLsizei __arg2, GLsizei __arg3, GLenum __arg4, const void * __arg5, GLsizei __arg6, GLsizei __arg7, GLenum __arg8, GLvoid * __arg9, APTR __GluBase)
{
    return AROS_LC9(GLint, gluScaleImage,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(const void *,(__arg5),A0),
        AROS_LCA(GLsizei,(__arg6),D4),
        AROS_LCA(GLsizei,(__arg7),D5),
        AROS_LCA(GLenum,(__arg8),D6),
        AROS_LCA(GLvoid *,(__arg9),A1),
        struct Library *, (__GluBase), 82, Glu    );
}

#define gluScaleImage(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Glu_gluScaleImage((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)GluBase)

static inline void __inline_Glu_gluSphere(GLUquadric * __arg1, GLdouble __arg2, GLint __arg3, GLint __arg4, APTR __GluBase)
{
    AROS_LC4NR(void, gluSphere,
        AROS_LCA(GLUquadric *,(__arg1),A0),
        AROS_LCA(GLdouble,(__arg2),D0),
        AROS_LCA(GLint,(__arg3),D1),
        AROS_LCA(GLint,(__arg4),D2),
        struct Library *, (__GluBase), 83, Glu    );
}

#define gluSphere(arg1, arg2, arg3, arg4) \
    __inline_Glu_gluSphere((arg1), (arg2), (arg3), (arg4), (APTR)GluBase)

static inline void __inline_Glu_gluTessBeginContour(GLUtesselator * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluTessBeginContour,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        struct Library *, (__GluBase), 84, Glu    );
}

#define gluTessBeginContour(arg1) \
    __inline_Glu_gluTessBeginContour((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluTessBeginPolygon(GLUtesselator * __arg1, GLvoid * __arg2, APTR __GluBase)
{
    AROS_LC2NR(void, gluTessBeginPolygon,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        AROS_LCA(GLvoid *,(__arg2),A1),
        struct Library *, (__GluBase), 85, Glu    );
}

#define gluTessBeginPolygon(arg1, arg2) \
    __inline_Glu_gluTessBeginPolygon((arg1), (arg2), (APTR)GluBase)

static inline void __inline_Glu_gluTessCallback(GLUtesselator * __arg1, GLenum __arg2, _GLUfuncptr __arg3, APTR __GluBase)
{
    AROS_LC3NR(void, gluTessCallback,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        AROS_LCA(_GLUfuncptr,(__arg3),D1),
        struct Library *, (__GluBase), 86, Glu    );
}

#define gluTessCallback(arg1, arg2, arg3) \
    __inline_Glu_gluTessCallback((arg1), (arg2), (arg3), (APTR)GluBase)

static inline void __inline_Glu_gluTessEndContour(GLUtesselator * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluTessEndContour,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        struct Library *, (__GluBase), 87, Glu    );
}

#define gluTessEndContour(arg1) \
    __inline_Glu_gluTessEndContour((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluTessEndPolygon(GLUtesselator * __arg1, APTR __GluBase)
{
    AROS_LC1NR(void, gluTessEndPolygon,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        struct Library *, (__GluBase), 88, Glu    );
}

#define gluTessEndPolygon(arg1) \
    __inline_Glu_gluTessEndPolygon((arg1), (APTR)GluBase)

static inline void __inline_Glu_gluTessNormal(GLUtesselator * __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __GluBase)
{
    AROS_LC4NR(void, gluTessNormal,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        AROS_LCA(GLdouble,(__arg2),D0),
        AROS_LCA(GLdouble,(__arg3),D1),
        AROS_LCA(GLdouble,(__arg4),D2),
        struct Library *, (__GluBase), 89, Glu    );
}

#define gluTessNormal(arg1, arg2, arg3, arg4) \
    __inline_Glu_gluTessNormal((arg1), (arg2), (arg3), (arg4), (APTR)GluBase)

static inline void __inline_Glu_gluTessProperty(GLUtesselator * __arg1, GLenum __arg2, GLdouble __arg3, APTR __GluBase)
{
    AROS_LC3NR(void, gluTessProperty,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        AROS_LCA(GLdouble,(__arg3),D1),
        struct Library *, (__GluBase), 90, Glu    );
}

#define gluTessProperty(arg1, arg2, arg3) \
    __inline_Glu_gluTessProperty((arg1), (arg2), (arg3), (APTR)GluBase)

static inline void __inline_Glu_gluTessVertex(GLUtesselator * __arg1, GLdouble * __arg2, GLvoid * __arg3, APTR __GluBase)
{
    AROS_LC3NR(void, gluTessVertex,
        AROS_LCA(GLUtesselator *,(__arg1),A0),
        AROS_LCA(GLdouble *,(__arg2),A1),
        AROS_LCA(GLvoid *,(__arg3),A2),
        struct Library *, (__GluBase), 91, Glu    );
}

#define gluTessVertex(arg1, arg2, arg3) \
    __inline_Glu_gluTessVertex((arg1), (arg2), (arg3), (APTR)GluBase)

static inline GLint __inline_Glu_gluUnProject(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, const GLdouble * __arg4, const GLdouble * __arg5, const GLint * __arg6, GLdouble * __arg7, GLdouble * __arg8, GLdouble * __arg9, APTR __GluBase)
{
    return AROS_LC9(GLint, gluUnProject,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(const GLdouble *,(__arg4),A0),
        AROS_LCA(const GLdouble *,(__arg5),A1),
        AROS_LCA(const GLint *,(__arg6),A2),
        AROS_LCA(GLdouble *,(__arg7),A3),
        AROS_LCA(GLdouble *,(__arg8),A4),
        AROS_LCA(GLdouble *,(__arg9),A5),
        struct Library *, (__GluBase), 92, Glu    );
}

#define gluUnProject(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Glu_gluUnProject((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)GluBase)

#endif /* INLINE_GLU_H*/
