gl.c

openGL开发brew程序又一扩展例子

{
   IGL_glScissor(GPIGL,x,y,width,height);
}

GL_API void GL_APIENTRY glShadeModel(GLenum mode)
{
   IGL_glShadeModel(GPIGL,mode);
}

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

GL_API void GL_APIENTRY glStencilMask(GLuint mask)
{
   IGL_glStencilMask(GPIGL,mask);
}

GL_API void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
   IGL_glStencilOp(GPIGL,fail,zfail,zpass);
}

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

GL_API void GL_APIENTRY glTexEnvx(GLenum target, GLenum pname, GLfixed param)
{
   IGL_glTexEnvx(GPIGL,target,pname,param);
}

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

GL_API void GL_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);
}

GL_API void GL_APIENTRY glTexParameterx(GLenum target, GLenum pname, GLfixed param)
{
   IGL_glTexParameterx(GPIGL,target,pname,param);
}

GL_API void GL_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);
}

GL_API void GL_APIENTRY glTranslatex(GLfixed x, GLfixed y, GLfixed z)
{
   IGL_glTranslatex(GPIGL,x, y, z);
}

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

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



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

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

GL_API EGLint GL_APIENTRY eglGetError (void)
{
   return(IEGL_eglGetError(GPIEGL));
}

GL_API EGLDisplay GL_APIENTRY eglGetDisplay (NativeDisplayType display)
{
   return(IEGL_eglGetDisplay(GPIEGL,display));
}

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

GL_API EGLBoolean GL_APIENTRY eglTerminate (EGLDisplay dpy)
{
   return(IEGL_eglTerminate(GPIEGL,dpy));
}

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

GL_API void (* GL_APIENTRY eglGetProcAddress (const char *procname))()
{
   return(IEGL_eglGetProcAddress(GPIEGL,procname));
}

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

GL_API EGLBoolean GL_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));
}

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

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

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

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

GL_API EGLBoolean GL_APIENTRY eglDestroySurface (EGLDisplay dpy, EGLSurface surface)
{
   return(IEGL_eglDestroySurface (GPIEGL,dpy, surface));
}

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

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

GL_API EGLBoolean GL_APIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
{
   return(IEGL_eglDestroyContext(GPIEGL,dpy,ctx));
}

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

GL_API EGLContext GL_APIENTRY eglGetCurrentContext(void)
{
   return(IEGL_eglGetCurrentContext(GPIEGL));
}

GL_API EGLSurface GL_APIENTRY eglGetCurrentSurface(EGLint readdraw)
{
   return(IEGL_eglGetCurrentSurface(GPIEGL,readdraw));
}

GL_API EGLDisplay GL_APIENTRY eglGetCurrentDisplay(void)
{
   return(IEGL_eglGetCurrentDisplay(GPIEGL));
}

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

GL_API EGLBoolean GL_APIENTRY eglWaitGL (void)
{
   return(IEGL_eglWaitGL(GPIEGL));
}

GL_API EGLBoolean GL_APIENTRY eglWaitNative(EGLint engine)
{
   return(IEGL_eglWaitNative(GPIEGL,engine));
}

GL_API EGLBoolean GL_APIENTRY eglSwapBuffers (EGLDisplay dpy, EGLSurface draw)
{
   return(IEGL_eglSwapBuffers(GPIEGL,dpy, draw));
}

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

GL_API EGLDisplay GL_APIENTRY _eglGetDisplay (void *display)
{
   return(IEGL_eglGetDisplay(GPIEGL,display));
}

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


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

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


/*-------------------------------------------------------------------------------*
 *                     GLES COMMON FUNCTIONS FOR ATI COMPATIBILITY               *
 *-------------------------------------------------------------------------------*/
#ifdef OGLES_USE_COMMON_PROFILE
GL_API void   GL_APIENTRY glAlphaFunc(GLenum func, GLclampf ref)
{
   IGL_glAlphaFunc(GPIGL, func,  ref);
}

GL_API void   GL_APIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
   IGL_glClearColor(GPIGL, red,  green,  blue,  alpha);
}

GL_API void   GL_APIENTRY glClearDepthf(GLclampf depth)
{
   IGL_glClearDepthf(GPIGL, depth);
}

GL_API void   GL_APIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
   IGL_glColor4f(GPIGL, red,  green,  blue,  alpha);
}

GL_API void   GL_APIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar)
{
   IGL_glDepthRangef(GPIGL, zNear,  zFar);
}

GL_API void   GL_APIENTRY glFogf(GLenum pname, GLfloat param)
{
   IGL_glFogf(GPIGL, pname,  param);
}

GL_API void   GL_APIENTRY glFogfv(GLenum pname, const GLfloat *params)
{
   IGL_glFogfv(GPIGL, pname, params);
}

GL_API void   GL_APIENTRY glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
{
   IGL_glFrustumf(GPIGL, left,  right,  bottom,  top,  zNear,  zFar);
}

GL_API void   GL_APIENTRY glLightf(GLenum light, GLenum pname, GLfloat param)
{
   IGL_glLightf(GPIGL, light,  pname,  param);
}

GL_API void   GL_APIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params)
{
   IGL_glLightfv(GPIGL, light,  pname, params);
}

GL_API void   GL_APIENTRY glLightModelf(GLenum pname, GLfloat param)
{
   IGL_glLightModelf(GPIGL, pname,  param);
}

GL_API void   GL_APIENTRY glLightModelfv(GLenum pname, const GLfloat *params)
{
   IGL_glLightModelfv(GPIGL, pname, params);
}
GL_API void   GL_APIENTRY glLineWidth(GLfloat width)
{
   IGL_glLineWidth(GPIGL, width);
}

GL_API void   GL_APIENTRY glLoadMatrixf(const GLfloat *m)
{
   IGL_glLoadMatrixf(GPIGL,m);
}

GL_API void   GL_APIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param)
{
   IGL_glMaterialf(GPIGL, face,  pname,  param);
}
GL_API void   GL_APIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
{
   IGL_glMaterialfv(GPIGL, face,  pname, params);
}

GL_API void   GL_APIENTRY glMultiTexCoord4f(GLenum texture, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
   IGL_glMultiTexCoord4f(GPIGL, texture,  s,  t,  r,  q);
}

GL_API void   GL_APIENTRY glMultMatrixf(const GLfloat *m)
{
   IGL_glMultMatrixf(GPIGL,m);
}
GL_API void   GL_APIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
   IGL_glNormal3f(GPIGL, nx,  ny,  nz);
}

GL_API void   GL_APIENTRY glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
{
   IGL_glOrthof(GPIGL, left,  right,  bottom,  top,  zNear,  zFar);
}

GL_API void   GL_APIENTRY glPointSize(GLfloat size)
{
   IGL_glPointSize(GPIGL, size);
}

GL_API void   GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units)
{
   IGL_glPolygonOffset(GPIGL, factor,  units);
}

GL_API void   GL_APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
   IGL_glRotatef(GPIGL, angle,  x,  y,  z);
}

GL_API void   GL_APIENTRY glSampleCoverage(GLclampf value, GLboolean invert)
{
   IGL_glSampleCoverage(GPIGL, value, invert);
}

GL_API void   GL_APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z)
{
   IGL_glScalef(GPIGL, x,  y,  z);
}

GL_API void   GL_APIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param)
{
   IGL_glTexEnvf(GPIGL, target,  pname,  param);
}

GL_API void   GL_APIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
{
   IGL_glTexEnvfv(GPIGL, target,  pname, params);
}

GL_API void   GL_APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
   IGL_glTexParameterf(GPIGL, target,  pname,  param);
}

GL_API void   GL_APIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z)
{
   IGL_glTranslatef (GPIGL, x,  y,  z);
}

/* functions defined by ATI not in the Khronos spec: ONLY SUPPORTED ON ATI HARDWARE */
GL_API void   GL_APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
{
   IGL_glTexParameterfv(GPIGL, target,  pname, params);
}

GL_API void   GL_APIENTRY glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
{
   IGL_glTexParameterxv(GPIGL, target, pname, params);
}
#endif