#ifndef INLINE_EGL_H
#define INLINE_EGL_H

/*
    *** Automatically generated from '/data/deadwood/gitAROS/AROS/workbench/libs/mesa/src/aros/egl/egl.conf'. Edits will be lost. ***
    Copyright © 1995-2011, The AROS Development Team. All rights reserved.
*/

/*
    Desc: Inline function for egl
*/

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


static inline EGLint __inline_Egl_eglGetError(APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC0(EGLint, eglGetError,
        struct Library *, (__EglBase), 35, Egl    );
}

#define eglGetError() \
    __inline_Egl_eglGetError((APTR)EglBase)

static inline EGLDisplay __inline_Egl_eglGetDisplay(EGLNativeDisplayType __arg1, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC1(EGLDisplay, eglGetDisplay,
        AROS_LCA(EGLNativeDisplayType,(__arg1),D0),
        struct Library *, (__EglBase), 36, Egl    );
}

#define eglGetDisplay(arg1) \
    __inline_Egl_eglGetDisplay((arg1), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglInitialize(EGLDisplay __arg1, EGLint * __arg2, EGLint * __arg3, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC3(EGLBoolean, eglInitialize,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLint *,(__arg2),A0),
        AROS_LCA(EGLint *,(__arg3),A1),
        struct Library *, (__EglBase), 37, Egl    );
}

#define eglInitialize(arg1, arg2, arg3) \
    __inline_Egl_eglInitialize((arg1), (arg2), (arg3), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglTerminate(EGLDisplay __arg1, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC1(EGLBoolean, eglTerminate,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        struct Library *, (__EglBase), 38, Egl    );
}

#define eglTerminate(arg1) \
    __inline_Egl_eglTerminate((arg1), (APTR)EglBase)

static inline const char * __inline_Egl_eglQueryString(EGLDisplay __arg1, EGLint __arg2, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC2(const char *, eglQueryString,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLint,(__arg2),D1),
        struct Library *, (__EglBase), 39, Egl    );
}

#define eglQueryString(arg1, arg2) \
    __inline_Egl_eglQueryString((arg1), (arg2), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglGetConfigs(EGLDisplay __arg1, EGLConfig * __arg2, EGLint __arg3, EGLint * __arg4, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC4(EGLBoolean, eglGetConfigs,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLConfig *,(__arg2),A0),
        AROS_LCA(EGLint,(__arg3),D1),
        AROS_LCA(EGLint *,(__arg4),A1),
        struct Library *, (__EglBase), 40, Egl    );
}

#define eglGetConfigs(arg1, arg2, arg3, arg4) \
    __inline_Egl_eglGetConfigs((arg1), (arg2), (arg3), (arg4), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglChooseConfig(EGLDisplay __arg1, const EGLint * __arg2, EGLConfig * __arg3, EGLint __arg4, EGLint * __arg5, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC5(EGLBoolean, eglChooseConfig,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(const EGLint *,(__arg2),A0),
        AROS_LCA(EGLConfig *,(__arg3),A1),
        AROS_LCA(EGLint,(__arg4),D1),
        AROS_LCA(EGLint *,(__arg5),A2),
        struct Library *, (__EglBase), 41, Egl    );
}

#define eglChooseConfig(arg1, arg2, arg3, arg4, arg5) \
    __inline_Egl_eglChooseConfig((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglGetConfigAttrib(EGLDisplay __arg1, EGLConfig __arg2, EGLint __arg3, EGLint * __arg4, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC4(EGLBoolean, eglGetConfigAttrib,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLConfig,(__arg2),D1),
        AROS_LCA(EGLint,(__arg3),D2),
        AROS_LCA(EGLint *,(__arg4),A0),
        struct Library *, (__EglBase), 42, Egl    );
}

#define eglGetConfigAttrib(arg1, arg2, arg3, arg4) \
    __inline_Egl_eglGetConfigAttrib((arg1), (arg2), (arg3), (arg4), (APTR)EglBase)

static inline EGLSurface __inline_Egl_eglCreateWindowSurface(EGLDisplay __arg1, EGLConfig __arg2, EGLNativeWindowType __arg3, const EGLint * __arg4, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC4(EGLSurface, eglCreateWindowSurface,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLConfig,(__arg2),D1),
        AROS_LCA(EGLNativeWindowType,(__arg3),D2),
        AROS_LCA(const EGLint *,(__arg4),A0),
        struct Library *, (__EglBase), 43, Egl    );
}

#define eglCreateWindowSurface(arg1, arg2, arg3, arg4) \
    __inline_Egl_eglCreateWindowSurface((arg1), (arg2), (arg3), (arg4), (APTR)EglBase)

static inline EGLSurface __inline_Egl_eglCreatePbufferSurface(EGLDisplay __arg1, EGLConfig __arg2, const EGLint * __arg3, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC3(EGLSurface, eglCreatePbufferSurface,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLConfig,(__arg2),D1),
        AROS_LCA(const EGLint *,(__arg3),A0),
        struct Library *, (__EglBase), 44, Egl    );
}

#define eglCreatePbufferSurface(arg1, arg2, arg3) \
    __inline_Egl_eglCreatePbufferSurface((arg1), (arg2), (arg3), (APTR)EglBase)

static inline EGLSurface __inline_Egl_eglCreatePixmapSurface(EGLDisplay __arg1, EGLConfig __arg2, EGLNativePixmapType __arg3, const EGLint * __arg4, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC4(EGLSurface, eglCreatePixmapSurface,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLConfig,(__arg2),D1),
        AROS_LCA(EGLNativePixmapType,(__arg3),D2),
        AROS_LCA(const EGLint *,(__arg4),A0),
        struct Library *, (__EglBase), 45, Egl    );
}

#define eglCreatePixmapSurface(arg1, arg2, arg3, arg4) \
    __inline_Egl_eglCreatePixmapSurface((arg1), (arg2), (arg3), (arg4), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglDestroySurface(EGLDisplay __arg1, EGLSurface __arg2, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC2(EGLBoolean, eglDestroySurface,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLSurface,(__arg2),D1),
        struct Library *, (__EglBase), 46, Egl    );
}

#define eglDestroySurface(arg1, arg2) \
    __inline_Egl_eglDestroySurface((arg1), (arg2), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglQuerySurface(EGLDisplay __arg1, EGLSurface __arg2, EGLint __arg3, EGLint * __arg4, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC4(EGLBoolean, eglQuerySurface,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLSurface,(__arg2),D1),
        AROS_LCA(EGLint,(__arg3),D2),
        AROS_LCA(EGLint *,(__arg4),A0),
        struct Library *, (__EglBase), 47, Egl    );
}

#define eglQuerySurface(arg1, arg2, arg3, arg4) \
    __inline_Egl_eglQuerySurface((arg1), (arg2), (arg3), (arg4), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglBindAPI(EGLenum __arg1, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC1(EGLBoolean, eglBindAPI,
        AROS_LCA(EGLenum,(__arg1),D0),
        struct Library *, (__EglBase), 48, Egl    );
}

#define eglBindAPI(arg1) \
    __inline_Egl_eglBindAPI((arg1), (APTR)EglBase)

static inline EGLenum __inline_Egl_eglQueryAPI(APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC0(EGLenum, eglQueryAPI,
        struct Library *, (__EglBase), 49, Egl    );
}

#define eglQueryAPI() \
    __inline_Egl_eglQueryAPI((APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglWaitClient(APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC0(EGLBoolean, eglWaitClient,
        struct Library *, (__EglBase), 50, Egl    );
}

#define eglWaitClient() \
    __inline_Egl_eglWaitClient((APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglReleaseThread(APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC0(EGLBoolean, eglReleaseThread,
        struct Library *, (__EglBase), 51, Egl    );
}

#define eglReleaseThread() \
    __inline_Egl_eglReleaseThread((APTR)EglBase)

static inline EGLSurface __inline_Egl_eglCreatePbufferFromClientBuffer(EGLDisplay __arg1, EGLenum __arg2, EGLClientBuffer __arg3, EGLConfig __arg4, const EGLint * __arg5, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC5(EGLSurface, eglCreatePbufferFromClientBuffer,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLenum,(__arg2),D1),
        AROS_LCA(EGLClientBuffer,(__arg3),D2),
        AROS_LCA(EGLConfig,(__arg4),D3),
        AROS_LCA(const EGLint *,(__arg5),A0),
        struct Library *, (__EglBase), 52, Egl    );
}

#define eglCreatePbufferFromClientBuffer(arg1, arg2, arg3, arg4, arg5) \
    __inline_Egl_eglCreatePbufferFromClientBuffer((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglSurfaceAttrib(EGLDisplay __arg1, EGLSurface __arg2, EGLint __arg3, EGLint __arg4, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC4(EGLBoolean, eglSurfaceAttrib,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLSurface,(__arg2),D1),
        AROS_LCA(EGLint,(__arg3),D2),
        AROS_LCA(EGLint,(__arg4),D3),
        struct Library *, (__EglBase), 53, Egl    );
}

#define eglSurfaceAttrib(arg1, arg2, arg3, arg4) \
    __inline_Egl_eglSurfaceAttrib((arg1), (arg2), (arg3), (arg4), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglBindTexImage(EGLDisplay __arg1, EGLSurface __arg2, EGLint __arg3, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC3(EGLBoolean, eglBindTexImage,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLSurface,(__arg2),D1),
        AROS_LCA(EGLint,(__arg3),D2),
        struct Library *, (__EglBase), 54, Egl    );
}

#define eglBindTexImage(arg1, arg2, arg3) \
    __inline_Egl_eglBindTexImage((arg1), (arg2), (arg3), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglReleaseTexImage(EGLDisplay __arg1, EGLSurface __arg2, EGLint __arg3, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC3(EGLBoolean, eglReleaseTexImage,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLSurface,(__arg2),D1),
        AROS_LCA(EGLint,(__arg3),D2),
        struct Library *, (__EglBase), 55, Egl    );
}

#define eglReleaseTexImage(arg1, arg2, arg3) \
    __inline_Egl_eglReleaseTexImage((arg1), (arg2), (arg3), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglSwapInterval(EGLDisplay __arg1, EGLint __arg2, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC2(EGLBoolean, eglSwapInterval,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLint,(__arg2),D1),
        struct Library *, (__EglBase), 56, Egl    );
}

#define eglSwapInterval(arg1, arg2) \
    __inline_Egl_eglSwapInterval((arg1), (arg2), (APTR)EglBase)

static inline EGLContext __inline_Egl_eglCreateContext(EGLDisplay __arg1, EGLConfig __arg2, EGLContext __arg3, const EGLint * __arg4, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC4(EGLContext, eglCreateContext,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLConfig,(__arg2),D1),
        AROS_LCA(EGLContext,(__arg3),D2),
        AROS_LCA(const EGLint *,(__arg4),A0),
        struct Library *, (__EglBase), 57, Egl    );
}

#define eglCreateContext(arg1, arg2, arg3, arg4) \
    __inline_Egl_eglCreateContext((arg1), (arg2), (arg3), (arg4), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglDestroyContext(EGLDisplay __arg1, EGLContext __arg2, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC2(EGLBoolean, eglDestroyContext,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLContext,(__arg2),D1),
        struct Library *, (__EglBase), 58, Egl    );
}

#define eglDestroyContext(arg1, arg2) \
    __inline_Egl_eglDestroyContext((arg1), (arg2), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglMakeCurrent(EGLDisplay __arg1, EGLSurface __arg2, EGLSurface __arg3, EGLContext __arg4, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC4(EGLBoolean, eglMakeCurrent,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLSurface,(__arg2),D1),
        AROS_LCA(EGLSurface,(__arg3),D2),
        AROS_LCA(EGLContext,(__arg4),D3),
        struct Library *, (__EglBase), 59, Egl    );
}

#define eglMakeCurrent(arg1, arg2, arg3, arg4) \
    __inline_Egl_eglMakeCurrent((arg1), (arg2), (arg3), (arg4), (APTR)EglBase)

static inline EGLContext __inline_Egl_eglGetCurrentContext(APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC0(EGLContext, eglGetCurrentContext,
        struct Library *, (__EglBase), 60, Egl    );
}

#define eglGetCurrentContext() \
    __inline_Egl_eglGetCurrentContext((APTR)EglBase)

static inline EGLSurface __inline_Egl_eglGetCurrentSurface(EGLint __arg1, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC1(EGLSurface, eglGetCurrentSurface,
        AROS_LCA(EGLint,(__arg1),D0),
        struct Library *, (__EglBase), 61, Egl    );
}

#define eglGetCurrentSurface(arg1) \
    __inline_Egl_eglGetCurrentSurface((arg1), (APTR)EglBase)

static inline EGLDisplay __inline_Egl_eglGetCurrentDisplay(APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC0(EGLDisplay, eglGetCurrentDisplay,
        struct Library *, (__EglBase), 62, Egl    );
}

#define eglGetCurrentDisplay() \
    __inline_Egl_eglGetCurrentDisplay((APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglQueryContext(EGLDisplay __arg1, EGLContext __arg2, EGLint __arg3, EGLint * __arg4, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC4(EGLBoolean, eglQueryContext,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLContext,(__arg2),D1),
        AROS_LCA(EGLint,(__arg3),D2),
        AROS_LCA(EGLint *,(__arg4),A0),
        struct Library *, (__EglBase), 63, Egl    );
}

#define eglQueryContext(arg1, arg2, arg3, arg4) \
    __inline_Egl_eglQueryContext((arg1), (arg2), (arg3), (arg4), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglWaitGL(APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC0(EGLBoolean, eglWaitGL,
        struct Library *, (__EglBase), 64, Egl    );
}

#define eglWaitGL() \
    __inline_Egl_eglWaitGL((APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglWaitNative(EGLint __arg1, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC1(EGLBoolean, eglWaitNative,
        AROS_LCA(EGLint,(__arg1),D0),
        struct Library *, (__EglBase), 65, Egl    );
}

#define eglWaitNative(arg1) \
    __inline_Egl_eglWaitNative((arg1), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglSwapBuffers(EGLDisplay __arg1, EGLSurface __arg2, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC2(EGLBoolean, eglSwapBuffers,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLSurface,(__arg2),D1),
        struct Library *, (__EglBase), 66, Egl    );
}

#define eglSwapBuffers(arg1, arg2) \
    __inline_Egl_eglSwapBuffers((arg1), (arg2), (APTR)EglBase)

static inline EGLBoolean __inline_Egl_eglCopyBuffers(EGLDisplay __arg1, EGLSurface __arg2, EGLNativePixmapType __arg3, APTR __EglBase)
{
    AROS_LIBREQ(EglBase, 0)
    return AROS_LC3(EGLBoolean, eglCopyBuffers,
        AROS_LCA(EGLDisplay,(__arg1),D0),
        AROS_LCA(EGLSurface,(__arg2),D1),
        AROS_LCA(EGLNativePixmapType,(__arg3),D2),
        struct Library *, (__EglBase), 67, Egl    );
}

#define eglCopyBuffers(arg1, arg2, arg3) \
    __inline_Egl_eglCopyBuffers((arg1), (arg2), (arg3), (APTR)EglBase)

#endif /* INLINE_EGL_H*/
