GLAPI void APIENTRY glMatrixMode(GLenum mode)
{
   IGL_glMatrixMode(GPIGL,mode);
}

GLAPI void APIENTRY glMultMatrixx(const GLfixed *m)
{
   IGL_glMultMatrixx(GPIGL,m);
}

GLAPI void APIENTRY glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
{
   IGL_glMultiTexCoord4x(GPIGL,target, s,  t,  r,  q);
}

GLAPI void APIENTRY glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
{
   IGL_glNormal3x(GPIGL,nx,ny,nz);
}

GLAPI void APIENTRY glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
{
   IGL_glNormalPointer(GPIGL,type,stride,pointer);
}

GLAPI void APIENTRY glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
{
   IGL_glOrthox(GPIGL,left,right,bottom,top,zNear,zFar);
}
GLAPI void APIENTRY glPixelStorei(GLenum pname, GLint param)
{
   IGL_glPixelStorei(GPIGL,pname,param);
}


GLAPI void APIENTRY glPointSizex(GLfixed size)
{
   IGL_glPointSizex(GPIGL,size);
}



GLAPI void APIENTRY glPolygonOffsetx(GLfixed factor, GLfixed units)
{
   IGL_glPolygonOffsetx(GPIGL,factor,units);
}

GLAPI void APIENTRY glPopMatrix(void)
{
   IGL_glPopMatrix(GPIGL);
}

GLAPI void APIENTRY glPushMatrix(void)
{
   IGL_glPushMatrix(GPIGL);
}

GLAPI void APIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
{
   IGL_glReadPixels(GPIGL,x,y,width,height,format,type,pixels);
}

GLAPI void APIENTRY glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
{
   IGL_glRotatex(GPIGL,angle, x, y, z);
}

GLAPI void APIENTRY glSampleCoveragex(GLclampx value, GLboolean invert)
{
   IGL_glSampleCoveragex(GPIGL,value,invert);
}


GLAPI void APIENTRY glScalex(GLfixed x, GLfixed y, GLfixed z)
{
   IGL_glScalex(GPIGL,x,y,z);
}

GLAPI void APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
   IGL_glScissor(GPIGL,x,y,width,height);
}

GLAPI void APIENTRY glShadeModel(GLenum mode)
{
   IGL_glShadeModel(GPIGL,mode);
}

GLAPI void APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
   IGL_glStencilFunc(GPIGL,func, ref, mask);
}

GLAPI void APIENTRY glStencilMask(GLuint mask)
{
   IGL_glStencilMask(GPIGL,mask);
}

GLAPI void APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
   IGL_glStencilOp(GPIGL,fail,zfail,zpass);
}

GLAPI void APIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
   IGL_glTexCoordPointer(GPIGL,size,type,stride,pointer);
}

GLAPI void APIENTRY glTexEnvx(GLenum target, GLenum pname, GLfixed param)
{
   IGL_glTexEnvx(GPIGL,target,pname,param);
}

GLAPI void APIENTRY glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
{
   IGL_glTexEnvxv(GPIGL,target,pname,params);
}

GLAPI void APIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
   IGL_glTexImage2D(GPIGL,target,level,internalformat,width,height,border,format,type,pixels);
}

GLAPI void APIENTRY glTexParameterx(GLenum target, GLenum pname, GLfixed param)
{
   IGL_glTexParameterx(GPIGL,target,pname,param);
}

GLAPI void APIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{   
   IGL_glTexSubImage2D(GPIGL,target, level, xoffset, yoffset, width, height, format, type, pixels);
}

GLAPI void APIENTRY glTranslatex(GLfixed x, GLfixed y, GLfixed z)
{
   IGL_glTranslatex(GPIGL,x, y, z);
}

GLAPI void APIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
   IGL_glVertexPointer(GPIGL,size, type, stride, pointer);
}

GLAPI void APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
   IGL_glViewport(GPIGL,x, y, width, height);
}



/***************************************
          E G L   FUNCTIONS

****************************************/

GLAPI EGLint APIENTRY eglGetError (void)
{
   return(IEGL_eglGetError(GPIEGL));
}

GLAPI EGLDisplay APIENTRY eglGetDisplay (NativeDisplayType display)
{
   return(IEGL_eglGetDisplay(GPIEGL,display));
}

GLAPI EGLBoolean APIENTRY eglInitialize (EGLDisplay dpy, EGLint *major, EGLint *minor)
{
   return(IEGL_eglInitialize(GPIEGL,dpy,major,minor));
}

GLAPI EGLBoolean APIENTRY eglTerminate (EGLDisplay dpy)
{
   return(IEGL_eglTerminate(GPIEGL,dpy));
}

GLAPI const char * APIENTRY eglQueryString (EGLDisplay dpy, EGLint name)
{
   return(IEGL_eglQueryString(GPIEGL,dpy,name));
}

GLAPI void (* APIENTRY eglGetProcAddress (const char *procname))()
{
   return(IEGL_eglGetProcAddress(GPIEGL,procname));
}

GLAPI EGLBoolean APIENTRY eglGetConfigs (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
   return(IEGL_eglGetConfigs(GPIEGL,dpy, configs, config_size, num_config));
}

GLAPI EGLBoolean APIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
   return(IEGL_eglChooseConfig(GPIEGL,dpy, attrib_list, configs, config_size, num_config));
}

GLAPI EGLBoolean APIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
{
   return(IEGL_eglGetConfigAttrib(GPIEGL,dpy, config, attribute, value));
}

GLAPI EGLSurface APIENTRY eglCreateWindowSurface (EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list)
{
   return(IEGL_eglCreateWindowSurface(GPIEGL,dpy, config, window, attrib_list));
}

GLAPI EGLSurface APIENTRY eglCreatePixmapSurface (EGLDisplay dpy, EGLConfig config, NativePixmapType pixmap, const EGLint *attrib_list)
{
   return(IEGL_eglCreatePixmapSurface(GPIEGL,dpy, config,  pixmap, attrib_list));
}

GLAPI EGLSurface APIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
{
   return(IEGL_eglCreatePbufferSurface(GPIEGL,dpy, config, attrib_list));
}

GLAPI EGLBoolean APIENTRY eglDestroySurface (EGLDisplay dpy, EGLSurface surface)
{
   return(IEGL_eglDestroySurface (GPIEGL,dpy, surface));
}

GLAPI EGLBoolean APIENTRY eglQuerySurface (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
{
   return(IEGL_eglQuerySurface(GPIEGL,dpy,surface,attribute,value));
}

GLAPI EGLContext APIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list)
{
   return(IEGL_eglCreateContext(GPIEGL,dpy,config,share_list,attrib_list));
}

GLAPI EGLBoolean APIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
{
   return(IEGL_eglDestroyContext(GPIEGL,dpy,ctx));
}

GLAPI EGLBoolean APIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
{
   return(IEGL_eglMakeCurrent(GPIEGL,dpy,draw,read,ctx));
}

GLAPI EGLContext APIENTRY eglGetCurrentContext(void)
{
   return(IEGL_eglGetCurrentContext(GPIEGL));
}

GLAPI EGLSurface APIENTRY eglGetCurrentSurface(EGLint readdraw)
{
   return(IEGL_eglGetCurrentSurface(GPIEGL,readdraw));
}

GLAPI EGLDisplay APIENTRY eglGetCurrentDisplay(void)
{
   return(IEGL_eglGetCurrentDisplay(GPIEGL));
}

GLAPI EGLBoolean APIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
{
   return(IEGL_eglQueryContext(GPIEGL,dpy,ctx,attribute,value));
}

GLAPI EGLBoolean APIENTRY eglWaitGL (void)
{
   return(IEGL_eglWaitGL(GPIEGL));
}

GLAPI EGLBoolean APIENTRY eglWaitNative(EGLint engine)
{
   return(IEGL_eglWaitNative(GPIEGL,engine));
}

GLAPI EGLBoolean APIENTRY eglSwapBuffers (EGLDisplay dpy, EGLSurface draw)
{
   return(IEGL_eglSwapBuffers(GPIEGL,dpy, draw));
}

GLAPI EGLBoolean APIENTRY eglCopyBuffers (EGLDisplay dpy, EGLSurface surface, NativePixmapType target)
{
   return(IEGL_eglCopyBuffers(GPIEGL,dpy, surface, target));
}

GLAPI EGLDisplay APIENTRY _eglGetDisplay (void *display)
{
   return(IEGL_eglGetDisplay(GPIEGL,display));
}

GLAPI EGLSurface APIENTRY _eglCreateWindowSurface (EGLDisplay dpy, EGLConfig config, void *window, const EGLint *attrib_list)
{
   return(IEGL_eglCreateWindowSurface(GPIEGL,dpy, config, window, attrib_list));
}


GLAPI EGLSurface APIENTRY _eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, void *pixmap, const EGLint *attrib_list)
{
   return(IEGL_eglCreatePixmapSurface(GPIEGL,dpy, config, pixmap, attrib_list));
}

GLAPI EGLBoolean APIENTRY _eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, void *target)
{
   return(IEGL_eglCopyBuffers(GPIEGL,dpy, surface, target));
}