#ifndef _MGLFunctionTable_h_ #define _MGLFunctionTable_h_ // //- // ========================================================================== // Copyright (C) 1995 - 2006 Autodesk, Inc., and/or its licensors. All // rights reserved. // // The coded instructions, statements, computer programs, and/or related // material (collectively the "Data") in these files contain unpublished // information proprietary to Autodesk, Inc. ("Autodesk") and/or its // licensors, which is protected by U.S. and Canadian federal copyright law // and by international treaties. // // The Data may not be disclosed or distributed to third parties or be // copied or duplicated, in whole or in part, without the prior written // consent of Autodesk. // // The copyright notices in the Software and this entire statement, // including the above license grant, this restriction and the following // disclaimer, must be included in all copies of the Software, in whole // or in part, and all derivative works of the Software, unless such copies // or derivative works are solely in the form of machine-executable object // code generated by a source language processor. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND. // AUTODESK DOES NOT MAKE AND HEREBY DISCLAIMS ANY EXPRESS OR IMPLIED // WARRANTIES INCLUDING, BUT NOT LIMITED TO, THE WARRANTIES OF // NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, // OR ARISING FROM A COURSE OF DEALING, USAGE, OR TRADE PRACTICE. IN NO // EVENT WILL AUTODESK AND/OR ITS LICENSORS BE LIABLE FOR ANY LOST // REVENUES, DATA, OR PROFITS, OR SPECIAL, DIRECT, INDIRECT, OR // CONSEQUENTIAL DAMAGES, EVEN IF AUTODESK AND/OR ITS LICENSORS HAS // BEEN ADVISED OF THE POSSIBILITY OR PROBABILITY OF SUCH DAMAGES. // ========================================================================== //+ // // CLASS: MGlFunctionTable // // **************************************************************************** // // CLASS DESCRIPTION (MGlFunctionTable) // // MGlFunctionTable is a utility class which provides wrappers for the OpenGL // API. Refer to an OpenGL reference for usage of the OpenGL API. // // **************************************************************************** #if defined __cplusplus // **************************************************************************** // INCLUDED HEADER FILES #include // **************************************************************************** // CLASS DECLARATION (MGLFunctionTable) // DECLARATIONS class MHardwareRenderer; enum MGLExtension { //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 1.2 // Extensions that were promoted to the core features 1.1 // are always assumed to exist. For completeness, they // are enumerated in comment only: // // EXT_vertex_array, EXT_polygon_offset, EXT_blend_logic_op, // EXT_texture, EXT_copy_texture, EXT_subtexture, // EXT_texture_object. // //--------------------------------------------------------------- /// Version 1.2 Extensions /// kMGLext_bgra, // aka EXT_bgra /// kMGLext_draw_range_elements, // aka EXT_draw_range_elements /// kMGLext_packed_pixels, // aka EXT_packed_pixels /// kMGLext_rescale_normal, // aka EXT_rescale_normal /// kMGLext_separate_specular_color, // aka EXT_separate_specular_color /// kMGLext_texture3D, // aka EXT_texture3D /// kMGLext_texture_edge_clamp, // aka SGIS_texture_edge_clamp /// kMGLext_texture_lod, // aka SGIS_texture_lod //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 1.2.1 // //--------------------------------------------------------------- /// kMGLext_multitexture, //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 1.3 // //--------------------------------------------------------------- /// kMGLext_multisample, // subset of EXT_multisample /// kMGLext_texture_compression, // aka MGL_ARB_texture_compression /// kMGLext_texture_cube_map, // aka ARB_texture_cube_map /// kMGLext_texture_env_add, // aka MGL_ARB_texture_env_add /// kMGLext_texture_env_combine, // aka MGL_ARB_texture_env_combine /// kMGLext_texture_env_dot3, // aka MGL_ARB_texture_env_dot3 /// kMGLext_texture_border_clamp, // aka MGL_ARB_texture_border_clamp /// kMGLext_transpose_matrix, // aka MGL_ARB_transpose_matrix //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 1.4 // //--------------------------------------------------------------- /// kMGLext_multi_draw_arrays, // //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 1.5 // //--------------------------------------------------------------- /// kMGLext_ARB_texture_non_power_of_two, // Non-power-of-two textures /// kMGLext_ARB_texture_rectangle, // Rectangular textures //--------------------------------------------------------------- // // IMAGING SUBSET CORE EXTENSIONS // //--------------------------------------------------------------- /// kMGLext_imaging_subset, // combination of the following optional extensions: /// kMGLext_blend_color, // aka EXT_blend_color, /// kMGLext_blend_minmax, // aka EXT_blend_minmax, /// kMGLext_blend_subtract, // aka EXT_blend_subtract, /// kMGLext_histogram, // aka EXT_histogram, /// kMGLext_color_matrix, // aka SGI_color_matrix, /// kMGLext_color_table, // aka EXT_color_table and // EXT_color_subtable. /// kMGLext_convolution, // aka EXT_convolution and // HP_convolution_border_modes. //--------------------------------------------------------------- // // OPTIONAL ARB/CORE EXTENSIONS // //--------------------------------------------------------------- /// kMGLext_ARB_vertex_blend, /// kMGLext_ARB_matrix_palette, /// kMGLext_ARB_point_parameters, // aka EXT_point_parameters /// kMGLext_ARB_texture_env_crossbar, /// kMGLext_ARB_depth_texture, // ARB depth textures - not SGIX ! /// kMGLext_ARB_shadow, // ARB shadows - not SGIX ! /// kMGLext_ARB_shadow_ambient, // ARB shadows - not SGIX ! /// kMGLext_SGIX_depth_texture, // SGIX depth textures /// kMGLext_SGIX_shadow, /// kMGLext_ARB_texgen_reflection, // reflection texture coord generation /// kMGLext_ARB_vertex_program, // ARB vertex program /// kMGLext_ARB_fragment_program, // ARB fragment program /// kMGLext_ARB_occlusion_query, // ARB occlusion query /// kMGLext_ARB_vertex_buffer_object, // ARB vertex buffer objects /// kMGLext_ARB_half_float_pixel, // ARB half float pixel /// kMGLext_ARB_texture_float, // ARB texture float /// kMGLext_ARB_color_buffer_float, // ARB color buffer float /// kMGLext_ARB_fragment_program_shadow, // ARB fragment program shadow /// kMGLext_ATI_pixel_format_float, // ATI float buffer /// kMGLext_NV_float_buffer, // nVidia float buffer //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 2.0 // //--------------------------------------------------------------- /// kMGLext_ARB_OpenMGL20, //--------------------------------------------------------------- // // OTHER OPTIONAL EXTENSIONS // //--------------------------------------------------------------- /// kMGLext_EXT_compiled_vertex_array, /// kMGLext_EXT_cull_vertex, /// kMGLext_EXT_secondary_color, /// kMGLext_EXT_fog_coord, /// kMGLext_EXT_vertex_weighting, /// kMGLext_EXT_vertex_shader, // used by ATI, but also reportedly by Matrox and 3DLabs /// kMGLext_EXT_texture_filter_anisotropic, /// kMGLext_texture_compression_s3tc, // lossy 4X texture compression // ATI-specific /// kMGLext_ATI_fragment_shader, // nVidia-specific /// kMGLext_NV_fence, /// kMGLext_NV_register_combiners, /// kMGLext_NV_texture_shader, /// kMGLext_NV_vertex_array_range, /// kMGLext_NV_vertex_program, /// kMGLext_NV_fragment_program, /// kMGLext_NV_occlusion_query, /// kMGLext_NV_primitive_restart, // SGI extensions /// kMGLext_SGIS_generate_mipmap, //--------------------------------------------------------------- // // CORE WMGL // //--------------------------------------------------------------- /// kMGLext_WMGL_ARB_extensions_string, // aka WMGL_EXT_extensions_string //--------------------------------------------------------------- // // NON-CORE WMGL EXTENSIONS // //--------------------------------------------------------------- /// kMGLext_WMGL_ARB_buffer_region, /// kMGLext_WMGL_ARB_pbuffer, // aka WMGL_EXT_pbuffer /// kMGLext_WMGL_ARB_pixel_format, // aka WMGL_EXT_pixel_format /// kMGLext_WMGL_ARB_make_current_read, // aka WMGL_EXT_make_current_read /// kMGLext_WMGL_ARB_render_texture, /// kMGLext_WMGL_NV_allocate_memory, //----------------------------------------------------------// // // // CORE MGLX // // // //----------------------------------------------------------// /// kMGLext_MGLX_create_pbuffer, /// kMGLext_MGLX_choose_fbconfig, /// kMGLext_MGLX_create_new_context, /// kMGLext_MGLX_destroy_window, /// kMGLext_MGLX_destroy_pbuffer, // older MGLX versions 1.2 /// kMGLext_MGLX_create_pbuffer_sgix, /// kMGLext_MGLX_choose_fbconfig_sgix, /// kMGLext_MGLX_create_context_with_config_sgix, /// kMGLext_MGLX_get_visual_from_fbconfig_sgix, // LAST ENTRY kMGLext_NUMBER_OF_EXTENSIONS }; // **************************************************************************** // CLASS DECLARATION (MGLFunctionTable) /// Utility class which provides wrappers for the OpenGL API. (OpenMayaRender) (OpenMayaRender.py) /** */ class OPENMAYARENDER_EXPORT MGLFunctionTable { public: // Version enumeration /// OpenGL versions checked. enum MGLversion { /// GL 1.1 kMGL_Version11, /// GL 1.2 kMGL_Version12, /// GL 1.2.1 kMGL_Version121, /// GL 1.3.1 kMGL_Version13, /// GL 1.4.1 kMGL_Version14, /// GL 1.5 kMGL_Version15, /// GL 2.0 kMGL_Version20 }; // // Buffer operations // void glClear(MGLbitfield mask); void glClearAccum(MGLfloat red, MGLfloat green, MGLfloat blue, MGLfloat alpha); void glClearColor(MGLclampf red, MGLclampf green, MGLclampf blue, MGLclampf alpha); void glClearDepth(MGLclampd depth); void glClearIndex(MGLfloat c); void glClearStencil(MGLint s); void glSampleCoverage(MGLclampf value, MGLboolean invert); // List of capabilities. /// bool extensionExists(MGLExtension extension); // Return the number of texture units supported by this device. // Equivalent to min(numTexInterpolants, numTexImageUnits). // /// unsigned int numTexUnits() const; // Return the number of texture interpolants. // These can be used to transfer texture coordinates. // /// unsigned int numTexInterpolants() const; // Return the max number of texture images. // These can be used to fetch texels from a texture. // /// unsigned int numTexImageUnits() const; // Return the maximum width or height of any texture // image (without borders). // /// unsigned int maxTextureSize() const; // Return the maximum number of vertex attributes // for vertex programming. /// unsigned int maxVertexAttributes() const; //--------------------------------------------------------------- // // CORE MGL FUNCTIONS // Version 1.0 - 1.1 // //--------------------------------------------------------------- void glAccum(MGLenum op, MGLfloat value); void glAlphaFunc(MGLenum func, MGLclampf ref); MGLboolean glAreTexturesResident(MGLsizei n, const MGLuint *textures, MGLboolean *residences); void glArrayElement(MGLint i); void glBegin(MGLenum mode); void glBindTexture(MGLenum target, MGLuint texture); void glBitmap(MGLsizei width, MGLsizei height, MGLfloat xorig, MGLfloat yorig, MGLfloat xmove, MGLfloat ymove, const MGLubyte *bitmap); void glBlendFunc(MGLenum sfactor, MGLenum dfactor); void glCallList(MGLuint list); void glCallLists(MGLsizei n, MGLenum type, const MGLvoid *lists); void glClipPlane(MGLenum plane, const MGLdouble *equation); void glColor3b(MGLbyte red, MGLbyte green, MGLbyte blue); void glColor3bv(const MGLbyte *v); void glColor3d(MGLdouble red, MGLdouble green, MGLdouble blue); void glColor3dv(const MGLdouble *v); void glColor3f(MGLfloat red, MGLfloat green, MGLfloat blue); void glColor3fv(const MGLfloat *v); void glColor3i(MGLint red, MGLint green, MGLint blue); void glColor3iv(const MGLint *v); void glColor3s(MGLshort red, MGLshort green, MGLshort blue); void glColor3sv(const MGLshort *v); void glColor3ub(MGLubyte red, MGLubyte green, MGLubyte blue); void glColor3ubv(const MGLubyte *v); void glColor3ui(MGLuint red, MGLuint green, MGLuint blue); void glColor3uiv(const MGLuint *v); void glColor3us(MGLushort red, MGLushort green, MGLushort blue); void glColor3usv(const MGLushort *v); void glColor4b(MGLbyte red, MGLbyte green, MGLbyte blue, MGLbyte alpha); void glColor4bv(const MGLbyte *v); void glColor4d(MGLdouble red, MGLdouble green, MGLdouble blue, MGLdouble alpha); void glColor4dv(const MGLdouble *v); void glColor4f(MGLfloat red, MGLfloat green, MGLfloat blue, MGLfloat alpha); void glColor4fv(const MGLfloat *v); void glColor4i(MGLint red, MGLint green, MGLint blue, MGLint alpha); void glColor4iv(const MGLint *v); void glColor4s(MGLshort red, MGLshort green, MGLshort blue, MGLshort alpha); void glColor4sv(const MGLshort *v); void glColor4ub(MGLubyte red, MGLubyte green, MGLubyte blue, MGLubyte alpha); void glColor4ubv(const MGLubyte *v); void glColor4ui(MGLuint red, MGLuint green, MGLuint blue, MGLuint alpha); void glColor4uiv(const MGLuint *v); void glColor4us(MGLushort red, MGLushort green, MGLushort blue, MGLushort alpha); void glColor4usv(const MGLushort *v); void glColorMask(MGLboolean red, MGLboolean green, MGLboolean blue, MGLboolean alpha); void glColorMaterial(MGLenum face, MGLenum mode); void glColorPointer(MGLint size, MGLenum type, MGLsizei stride, const MGLvoid *pointer); void glCopyPixels(MGLint x, MGLint y, MGLsizei width, MGLsizei height, MGLenum type); void glCopyTexImage1D(MGLenum target, MGLint level, MGLenum internalFormat, MGLint x, MGLint y, MGLsizei width, MGLint border); void glCopyTexImage2D(MGLenum target, MGLint level, MGLenum internalFormat, MGLint x, MGLint y, MGLsizei width, MGLsizei height, MGLint border); void glCopyTexSubImage1D(MGLenum target, MGLint level, MGLint xoffset, MGLint x, MGLint y, MGLsizei width); void glCopyTexSubImage2D(MGLenum target, MGLint level, MGLint xoffset, MGLint yoffset, MGLint x, MGLint y, MGLsizei width, MGLsizei height); void glCullFace(MGLenum mode); void glDeleteLists(MGLuint list, MGLsizei range); void glDeleteTextures(MGLsizei n, const MGLuint *textures); void glDepthFunc(MGLenum func); void glDepthMask(MGLboolean flag); void glDepthRange(MGLclampd zNear, MGLclampd zFar); void glDisable(MGLenum cap); void glDisableClientState(MGLenum array); void glDrawArrays(MGLenum mode, MGLint first, MGLsizei count); void glDrawBuffer(MGLenum mode); void glDrawElements(MGLenum mode, MGLsizei count, MGLenum type, const MGLvoid *indices); void glDrawPixels(MGLsizei width, MGLsizei height, MGLenum format, MGLenum type, const MGLvoid *pixels); void glEdgeFlag(MGLboolean flag); void glEdgeFlagPointer(MGLsizei stride, const MGLvoid *pointer); void glEdgeFlagv(const MGLboolean *flag); void glEnable(MGLenum cap); void glEnableClientState(MGLenum array); void glEnd(void); void glEndList(void); void glEvalCoord1d(MGLdouble u); void glEvalCoord1dv(const MGLdouble *u); void glEvalCoord1f(MGLfloat u); void glEvalCoord1fv(const MGLfloat *u); void glEvalCoord2d(MGLdouble u, MGLdouble v); void glEvalCoord2dv(const MGLdouble *u); void glEvalCoord2f(MGLfloat u, MGLfloat v); void glEvalCoord2fv(const MGLfloat *u); void glEvalMesh1(MGLenum mode, MGLint i1, MGLint i2); void glEvalMesh2(MGLenum mode, MGLint i1, MGLint i2, MGLint j1, MGLint j2); void glEvalPoint1(MGLint i); void glEvalPoint2(MGLint i, MGLint j); void glFeedbackBuffer(MGLsizei size, MGLenum type, MGLfloat *buffer); void glFinish(void); void glFlush(void); void glFogf(MGLenum pname, MGLfloat param); void glFogfv(MGLenum pname, const MGLfloat *params); void glFogi(MGLenum pname, MGLint param); void glFogiv(MGLenum pname, const MGLint *params); void glFrontFace(MGLenum mode); void glFrustum(MGLdouble left, MGLdouble right, MGLdouble bottom, MGLdouble top, MGLdouble zNear, MGLdouble zFar); MGLuint glGenLists(MGLsizei range); void glGenTextures(MGLsizei n, MGLuint *textures); void glGetBooleanv(MGLenum pname, MGLboolean *params); void glGetClipPlane(MGLenum plane, MGLdouble *equation); void glGetDoublev(MGLenum pname, MGLdouble *params); MGLenum glGetError(void); void glGetFloatv(MGLenum pname, MGLfloat *params); void glGetIntegerv(MGLenum pname, MGLint *params); void glGetLightfv(MGLenum light, MGLenum pname, MGLfloat *params); void glGetLightiv(MGLenum light, MGLenum pname, MGLint *params); void glGetMapdv(MGLenum target, MGLenum query, MGLdouble *v); void glGetMapfv(MGLenum target, MGLenum query, MGLfloat *v); void glGetMapiv(MGLenum target, MGLenum query, MGLint *v); void glGetMaterialfv(MGLenum face, MGLenum pname, MGLfloat *params); void glGetMaterialiv(MGLenum face, MGLenum pname, MGLint *params); void glGetPixelMapfv(MGLenum map, MGLfloat *values); void glGetPixelMapuiv(MGLenum map, MGLuint *values); void glGetPixelMapusv(MGLenum map, MGLushort *values); void glGetPointerv(MGLenum pname, MGLvoid* *params); void glGetPolygonStipple(MGLubyte *mask); const MGLubyte* glGetString(MGLenum name); void glGetTexEnvfv(MGLenum target, MGLenum pname, MGLfloat *params); void glGetTexEnviv(MGLenum target, MGLenum pname, MGLint *params); void glGetTexGendv(MGLenum coord, MGLenum pname, MGLdouble *params); void glGetTexGenfv(MGLenum coord, MGLenum pname, MGLfloat *params); void glGetTexGeniv(MGLenum coord, MGLenum pname, MGLint *params); void glGetTexImage(MGLenum target, MGLint level, MGLenum format, MGLenum type, MGLvoid *pixels); void glGetTexLevelParameterfv(MGLenum target, MGLint level, MGLenum pname, MGLfloat *params); void glGetTexLevelParameteriv(MGLenum target, MGLint level, MGLenum pname, MGLint *params); void glGetTexParameterfv(MGLenum target, MGLenum pname, MGLfloat *params); void glGetTexParameteriv(MGLenum target, MGLenum pname, MGLint *params); void glHint(MGLenum target, MGLenum mode); void glIndexMask(MGLuint mask); void glIndexPointer(MGLenum type, MGLsizei stride, const MGLvoid *pointer); void glIndexd(MGLdouble c); void glIndexdv(const MGLdouble *c); void glIndexf(MGLfloat c); void glIndexfv(const MGLfloat *c); void glIndexi(MGLint c); void glIndexiv(const MGLint *c); void glIndexs(MGLshort c); void glIndexsv(const MGLshort *c); void glIndexub(MGLubyte c); void glIndexubv(const MGLubyte *c); void glInitNames(void); void glInterleavedArrays(MGLenum format, MGLsizei stride, const MGLvoid *pointer); MGLboolean glIsEnabled(MGLenum cap); MGLboolean glIsList(MGLuint list); MGLboolean glIsTexture(MGLuint texture); void glLightModelf(MGLenum pname, MGLfloat param); void glLightModelfv(MGLenum pname, const MGLfloat *params); void glLightModeli(MGLenum pname, MGLint param); void glLightModeliv(MGLenum pname, const MGLint *params); void glLightf(MGLenum light, MGLenum pname, MGLfloat param); void glLightfv(MGLenum light, MGLenum pname, const MGLfloat *params); void glLighti(MGLenum light, MGLenum pname, MGLint param); void glLightiv(MGLenum light, MGLenum pname, const MGLint *params); void glLineStipple(MGLint factor, MGLushort pattern); void glLineWidth(MGLfloat width); void glListBase(MGLuint base); void glLoadIdentity(void); void glLoadMatrixd(const MGLdouble *m); void glLoadMatrixf(const MGLfloat *m); void glLoadName(MGLuint name); void glLogicOp(MGLenum opcode); void glMap1d(MGLenum target, MGLdouble u1, MGLdouble u2, MGLint stride, MGLint order, const MGLdouble *points); void glMap1f(MGLenum target, MGLfloat u1, MGLfloat u2, MGLint stride, MGLint order, const MGLfloat *points); void glMap2d(MGLenum target, MGLdouble u1, MGLdouble u2, MGLint ustride, MGLint uorder, MGLdouble v1, MGLdouble v2, MGLint vstride, MGLint vorder, const MGLdouble *points); void glMap2f(MGLenum target, MGLfloat u1, MGLfloat u2, MGLint ustride, MGLint uorder, MGLfloat v1, MGLfloat v2, MGLint vstride, MGLint vorder, const MGLfloat *points); void glMapGrid1d(MGLint un, MGLdouble u1, MGLdouble u2); void glMapGrid1f(MGLint un, MGLfloat u1, MGLfloat u2); void glMapGrid2d(MGLint un, MGLdouble u1, MGLdouble u2, MGLint vn, MGLdouble v1, MGLdouble v2); void glMapGrid2f(MGLint un, MGLfloat u1, MGLfloat u2, MGLint vn, MGLfloat v1, MGLfloat v2); void glMaterialf(MGLenum face, MGLenum pname, MGLfloat param); void glMaterialfv(MGLenum face, MGLenum pname, const MGLfloat *params); void glMateriali(MGLenum face, MGLenum pname, MGLint param); void glMaterialiv(MGLenum face, MGLenum pname, const MGLint *params); void glMatrixMode(MGLenum mode); void glMultMatrixd(const MGLdouble *m); void glMultMatrixf(const MGLfloat *m); void glNewList(MGLuint list, MGLenum mode); void glNormal3b(MGLbyte nx, MGLbyte ny, MGLbyte nz); void glNormal3bv(const MGLbyte *v); void glNormal3d(MGLdouble nx, MGLdouble ny, MGLdouble nz); void glNormal3dv(const MGLdouble *v); void glNormal3f(MGLfloat nx, MGLfloat ny, MGLfloat nz); void glNormal3fv(const MGLfloat *v); void glNormal3i(MGLint nx, MGLint ny, MGLint nz); void glNormal3iv(const MGLint *v); void glNormal3s(MGLshort nx, MGLshort ny, MGLshort nz); void glNormal3sv(const MGLshort *v); void glNormalPointer(MGLenum type, MGLsizei stride, const MGLvoid *pointer); void glOrtho(MGLdouble left, MGLdouble right, MGLdouble bottom, MGLdouble top, MGLdouble zNear, MGLdouble zFar); void glPassThrough(MGLfloat token); void glPixelMapfv(MGLenum map, MGLsizei mapsize, const MGLfloat *values); void glPixelMapuiv(MGLenum map, MGLsizei mapsize, const MGLuint *values); void glPixelMapusv(MGLenum map, MGLsizei mapsize, const MGLushort *values); void glPixelStoref(MGLenum pname, MGLfloat param); void glPixelStorei(MGLenum pname, MGLint param); void glPixelTransferf(MGLenum pname, MGLfloat param); void glPixelTransferi(MGLenum pname, MGLint param); void glPixelZoom(MGLfloat xfactor, MGLfloat yfactor); void glPointSize(MGLfloat size); void glPolygonMode(MGLenum face, MGLenum mode); void glPolygonOffset(MGLfloat factor, MGLfloat units); void glPolygonStipple(const MGLubyte *mask); void glPopAttrib(void); void glPopClientAttrib(void); void glPopMatrix(void); void glPopName(void); void glPrioritizeTextures(MGLsizei n, const MGLuint *textures, const MGLclampf *priorities); void glPushAttrib(MGLbitfield mask); void glPushClientAttrib(MGLbitfield mask); void glPushMatrix(void); void glPushName(MGLuint name); void glRasterPos2d(MGLdouble x, MGLdouble y); void glRasterPos2dv(const MGLdouble *v); void glRasterPos2f(MGLfloat x, MGLfloat y); void glRasterPos2fv(const MGLfloat *v); void glRasterPos2i(MGLint x, MGLint y); void glRasterPos2iv(const MGLint *v); void glRasterPos2s(MGLshort x, MGLshort y); void glRasterPos2sv(const MGLshort *v); void glRasterPos3d(MGLdouble x, MGLdouble y, MGLdouble z); void glRasterPos3dv(const MGLdouble *v); void glRasterPos3f(MGLfloat x, MGLfloat y, MGLfloat z); void glRasterPos3fv(const MGLfloat *v); void glRasterPos3i(MGLint x, MGLint y, MGLint z); void glRasterPos3iv(const MGLint *v); void glRasterPos3s(MGLshort x, MGLshort y, MGLshort z); void glRasterPos3sv(const MGLshort *v); void glRasterPos4d(MGLdouble x, MGLdouble y, MGLdouble z, MGLdouble w); void glRasterPos4dv(const MGLdouble *v); void glRasterPos4f(MGLfloat x, MGLfloat y, MGLfloat z, MGLfloat w); void glRasterPos4fv(const MGLfloat *v); void glRasterPos4i(MGLint x, MGLint y, MGLint z, MGLint w); void glRasterPos4iv(const MGLint *v); void glRasterPos4s(MGLshort x, MGLshort y, MGLshort z, MGLshort w); void glRasterPos4sv(const MGLshort *v); void glReadBuffer(MGLenum mode); void glReadPixels(MGLint x, MGLint y, MGLsizei width, MGLsizei height, MGLenum format, MGLenum type, MGLvoid *pixels); void glRectd(MGLdouble x1, MGLdouble y1, MGLdouble x2, MGLdouble y2); void glRectdv(const MGLdouble *v1, const MGLdouble *v2); void glRectf(MGLfloat x1, MGLfloat y1, MGLfloat x2, MGLfloat y2); void glRectfv(const MGLfloat *v1, const MGLfloat *v2); void glRecti(MGLint x1, MGLint y1, MGLint x2, MGLint y2); void glRectiv(const MGLint *v1, const MGLint *v2); void glRects(MGLshort x1, MGLshort y1, MGLshort x2, MGLshort y2); void glRectsv(const MGLshort *v1, const MGLshort *v2); MGLint glRenderMode(MGLenum mode); void glRotated(MGLdouble angle, MGLdouble x, MGLdouble y, MGLdouble z); void glRotatef(MGLfloat angle, MGLfloat x, MGLfloat y, MGLfloat z); void glScaled(MGLdouble x, MGLdouble y, MGLdouble z); void glScalef(MGLfloat x, MGLfloat y, MGLfloat z); void glScissor(MGLint x, MGLint y, MGLsizei width, MGLsizei height); void glSelectBuffer(MGLsizei size, MGLuint *buffer); void glShadeModel(MGLenum mode); void glStencilFunc(MGLenum func, MGLint ref, MGLuint mask); void glStencilMask(MGLuint mask); void glStencilOp(MGLenum fail, MGLenum zfail, MGLenum zpass); void glTexCoord1d(MGLdouble s); void glTexCoord1dv(const MGLdouble *v); void glTexCoord1f(MGLfloat s); void glTexCoord1fv(const MGLfloat *v); void glTexCoord1i(MGLint s); void glTexCoord1iv(const MGLint *v); void glTexCoord1s(MGLshort s); void glTexCoord1sv(const MGLshort *v); void glTexCoord2d(MGLdouble s, MGLdouble t); void glTexCoord2dv(const MGLdouble *v); void glTexCoord2f(MGLfloat s, MGLfloat t); void glTexCoord2fv(const MGLfloat *v); void glTexCoord2i(MGLint s, MGLint t); void glTexCoord2iv(const MGLint *v); void glTexCoord2s(MGLshort s, MGLshort t); void glTexCoord2sv(const MGLshort *v); void glTexCoord3d(MGLdouble s, MGLdouble t, MGLdouble r); void glTexCoord3dv(const MGLdouble *v); void glTexCoord3f(MGLfloat s, MGLfloat t, MGLfloat r); void glTexCoord3fv(const MGLfloat *v); void glTexCoord3i(MGLint s, MGLint t, MGLint r); void glTexCoord3iv(const MGLint *v); void glTexCoord3s(MGLshort s, MGLshort t, MGLshort r); void glTexCoord3sv(const MGLshort *v); void glTexCoord4d(MGLdouble s, MGLdouble t, MGLdouble r, MGLdouble q); void glTexCoord4dv(const MGLdouble *v); void glTexCoord4f(MGLfloat s, MGLfloat t, MGLfloat r, MGLfloat q); void glTexCoord4fv(const MGLfloat *v); void glTexCoord4i(MGLint s, MGLint t, MGLint r, MGLint q); void glTexCoord4iv(const MGLint *v); void glTexCoord4s(MGLshort s, MGLshort t, MGLshort r, MGLshort q); void glTexCoord4sv(const MGLshort *v); void glTexCoordPointer(MGLint size, MGLenum type, MGLsizei stride, const MGLvoid *pointer); void glTexEnvf(MGLenum target, MGLenum pname, MGLfloat param); void glTexEnvfv(MGLenum target, MGLenum pname, const MGLfloat *params); void glTexEnvi(MGLenum target, MGLenum pname, MGLint param); void glTexEnviv(MGLenum target, MGLenum pname, const MGLint *params); void glTexGend(MGLenum coord, MGLenum pname, MGLdouble param); void glTexGendv(MGLenum coord, MGLenum pname, const MGLdouble *params); void glTexGenf(MGLenum coord, MGLenum pname, MGLfloat param); void glTexGenfv(MGLenum coord, MGLenum pname, const MGLfloat *params); void glTexGeni(MGLenum coord, MGLenum pname, MGLint param); void glTexGeniv(MGLenum coord, MGLenum pname, const MGLint *params); void glTexImage1D(MGLenum target, MGLint level, MGLint internalformat, MGLsizei width, MGLint border, MGLenum format, MGLenum type, const MGLvoid *pixels); void glTexImage2D(MGLenum target, MGLint level, MGLint internalformat, MGLsizei width, MGLsizei height, MGLint border, MGLenum format, MGLenum type, const MGLvoid *pixels); void glTexParameterf(MGLenum target, MGLenum pname, MGLfloat param); void glTexParameterfv(MGLenum target, MGLenum pname, const MGLfloat *params); void glTexParameteri(MGLenum target, MGLenum pname, MGLint param); void glTexParameteriv(MGLenum target, MGLenum pname, const MGLint *params); void glTexSubImage1D(MGLenum target, MGLint level, MGLint xoffset, MGLsizei width, MGLenum format, MGLenum type, const MGLvoid *pixels); void glTexSubImage2D(MGLenum target, MGLint level, MGLint xoffset, MGLint yoffset, MGLsizei width, MGLsizei height, MGLenum format, MGLenum type, const MGLvoid *pixels); void glTranslated(MGLdouble x, MGLdouble y, MGLdouble z); void glTranslatef(MGLfloat x, MGLfloat y, MGLfloat z); void glVertex2d(MGLdouble x, MGLdouble y); void glVertex2dv(const MGLdouble *v); void glVertex2f(MGLfloat x, MGLfloat y); void glVertex2fv(const MGLfloat *v); void glVertex2i(MGLint x, MGLint y); void glVertex2iv(const MGLint *v); void glVertex2s(MGLshort x, MGLshort y); void glVertex2sv(const MGLshort *v); void glVertex3d(MGLdouble x, MGLdouble y, MGLdouble z); void glVertex3dv(const MGLdouble *v); void glVertex3f(MGLfloat x, MGLfloat y, MGLfloat z); void glVertex3fv(const MGLfloat *v); void glVertex3i(MGLint x, MGLint y, MGLint z); void glVertex3iv(const MGLint *v); void glVertex3s(MGLshort x, MGLshort y, MGLshort z); void glVertex3sv(const MGLshort *v); void glVertex4d(MGLdouble x, MGLdouble y, MGLdouble z, MGLdouble w); void glVertex4dv(const MGLdouble *v); void glVertex4f(MGLfloat x, MGLfloat y, MGLfloat z, MGLfloat w); void glVertex4fv(const MGLfloat *v); void glVertex4i(MGLint x, MGLint y, MGLint z, MGLint w); void glVertex4iv(const MGLint *v); void glVertex4s(MGLshort x, MGLshort y, MGLshort z, MGLshort w); void glVertex4sv(const MGLshort *v); void glVertexPointer(MGLint size, MGLenum type, MGLsizei stride, const MGLvoid *pointer); void glViewport(MGLint x, MGLint y, MGLsizei width, MGLsizei height); //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 1.2 // //--------------------------------------------------------------- // draw_range_elements void glDrawRangeElements(MGLenum mode, MGLuint start, MGLuint end, MGLsizei count, MGLenum type, const MGLvoid *indices); // texture3D void glTexImage3D(MGLenum target, MGLint level, MGLenum internalformat, MGLsizei width, MGLsizei height, MGLsizei depth, MGLint border, MGLenum format, MGLenum type, const MGLvoid *pixels); void glTexSubImage3D(MGLenum target, MGLint level, MGLint xoffset, MGLint yoffset, MGLint zoffset, MGLsizei width, MGLsizei height, MGLsizei depth, MGLenum format, MGLenum type, const MGLvoid *pixels); void glCopyTexSubImage3D(MGLenum target, MGLint level, MGLint xoffset, MGLint yoffset, MGLint zoffset, MGLint x, MGLint y, MGLsizei width, MGLsizei height); //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 1.2.1 // //--------------------------------------------------------------- // multitexture void glMultiTexCoord1d(MGLenum target, MGLdouble s); void glMultiTexCoord1dv(MGLenum target, const MGLdouble *v); void glMultiTexCoord1f(MGLenum target, MGLfloat s); void glMultiTexCoord1fv(MGLenum target, const MGLfloat *v); void glMultiTexCoord1i(MGLenum target, MGLint s); void glMultiTexCoord1iv(MGLenum target, const MGLint *v); void glMultiTexCoord1s(MGLenum target, MGLshort s); void glMultiTexCoord1sv(MGLenum target, const MGLshort *v); void glMultiTexCoord2d(MGLenum target, MGLdouble s, MGLdouble t); void glMultiTexCoord2dv(MGLenum target, const MGLdouble *v); void glMultiTexCoord2f(MGLenum target, MGLfloat s, MGLfloat t); void glMultiTexCoord2fv(MGLenum target, const MGLfloat *v); void glMultiTexCoord2i(MGLenum target, MGLint s, MGLint t); void glMultiTexCoord2iv(MGLenum target, const MGLint *v); void glMultiTexCoord2s(MGLenum target, MGLshort s, MGLshort t); void glMultiTexCoord2sv(MGLenum target, const MGLshort *v); void glMultiTexCoord3d(MGLenum target, MGLdouble s, MGLdouble t, MGLdouble r); void glMultiTexCoord3dv(MGLenum target, const MGLdouble *v); void glMultiTexCoord3f(MGLenum target, MGLfloat s, MGLfloat t, MGLfloat r); void glMultiTexCoord3fv(MGLenum target, const MGLfloat *v); void glMultiTexCoord3i(MGLenum target, MGLint s, MGLint t, MGLint r); void glMultiTexCoord3iv(MGLenum target, const MGLint *v); void glMultiTexCoord3s(MGLenum target, MGLshort s, MGLshort t, MGLshort r); void glMultiTexCoord3sv(MGLenum target, const MGLshort *v); void glMultiTexCoord4d(MGLenum target, MGLdouble s, MGLdouble t, MGLdouble r, MGLdouble q); void glMultiTexCoord4dv(MGLenum target, const MGLdouble *v); void glMultiTexCoord4f(MGLenum target, MGLfloat s, MGLfloat t, MGLfloat r, MGLfloat q); void glMultiTexCoord4fv(MGLenum target, const MGLfloat *v); void glMultiTexCoord4i(MGLenum target, MGLint s, MGLint t, MGLint r, MGLint q); void glMultiTexCoord4iv(MGLenum target, const MGLint *v); void glMultiTexCoord4s(MGLenum target, MGLshort s, MGLshort t, MGLshort r, MGLshort q); void glMultiTexCoord4sv(MGLenum target, const MGLshort *v); void glActiveTexture(MGLenum target); void glClientActiveTexture(MGLenum target); //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 1.3 // //--------------------------------------------------------------- // texture_compression void glCompressedTexImage1D(MGLenum target, MGLint level, MGLenum internalformat, MGLsizei width, MGLint border, MGLsizei imageSize, const void *data); void glCompressedTexImage2D(MGLenum target, MGLint level, MGLenum internalformat, MGLsizei width, MGLsizei height, MGLint border, MGLsizei imageSize, const void *data); void glCompressedTexImage3D(MGLenum target, MGLint level, MGLenum internalformat, MGLsizei width, MGLsizei height, MGLsizei depth, MGLint border, MGLsizei imageSize, const void *data); void glCompressedTexSubImage1D(MGLenum target, MGLint level, MGLint xoffset, MGLsizei width, MGLenum format, MGLsizei imageSize, const void *data); void glCompressedTexSubImage2D(MGLenum target, MGLint level, MGLint xoffset, MGLint yoffset, MGLsizei width, MGLsizei height, MGLenum format, MGLsizei imageSize, const void *data); void glCompressedTexSubImage3D(MGLenum target, MGLint level, MGLint xoffset, MGLint yoffset, MGLint zoffset, MGLsizei width, MGLsizei height, MGLsizei depth, MGLenum format, MGLsizei imageSize, const void *data); void glGetCompressedTexImage(MGLenum target, MGLint lod, void *img); // transpose_matrix void glLoadTransposeMatrixf(const MGLfloat m[16]); void glLoadTransposeMatrixd(const MGLdouble m[16]); void glMultTransposeMatrixf(const MGLfloat m[16]); void glMultTransposeMatrixd(const MGLdouble m[16]); //--------------------------------------------------------------- // // CORE MGL EXTENSIONS // Version 1.4 // //--------------------------------------------------------------- // Multi draw arrays void glMultiDrawArrays(MGLenum, MGLint *, MGLsizei *, MGLsizei); void glMultiDrawElements(MGLenum, const MGLsizei *, MGLenum, const MGLvoid* *, MGLsizei); //--------------------------------------------------------------- // // OPTIONAL ARB EXTENSIONS (alphabetical extension name order) // //--------------------------------------------------------------- // blend_minmax void glBlendEquationEXT(MGLenum mode); // ARB_point_parameters void glPointParameterf(MGLenum pname, MGLfloat param); void glPointParameterfv(MGLenum pname, const MGLfloat *params); // ARB_transpose_matrix void glLoadTransposeMatrixfARB(const MGLfloat *m); void glLoadTransposeMatrixdARB(const MGLdouble *m); void glMultTransposeMatrixfARB(const MGLfloat *m); void glMultTransposeMatrixdARB(const MGLdouble *m); // ARB_vertex_program void glVertexAttrib1s(MGLuint index, MGLshort x); void glVertexAttrib1f(MGLuint index, MGLfloat x); void glVertexAttrib1d(MGLuint index, MGLdouble x); void glVertexAttrib2s(MGLuint index, MGLshort x, MGLshort y); void glVertexAttrib2f(MGLuint index, MGLfloat x, MGLfloat y); void glVertexAttrib2d(MGLuint index, MGLdouble x, MGLdouble y); void glVertexAttrib3s(MGLuint index, MGLshort x, MGLshort y, MGLshort z); void glVertexAttrib3f(MGLuint index, MGLfloat x, MGLfloat y, MGLfloat z); void glVertexAttrib3d(MGLuint index, MGLdouble x, MGLdouble y, MGLdouble z); void glVertexAttrib4s(MGLuint index, MGLshort x, MGLshort y, MGLshort z, MGLshort w); void glVertexAttrib4f(MGLuint index, MGLfloat x, MGLfloat y, MGLfloat z, MGLfloat w); void glVertexAttrib4d(MGLuint index, MGLdouble x, MGLdouble y, MGLdouble z, MGLdouble w); void glVertexAttrib4Nub(MGLuint index, MGLubyte x, MGLubyte y, MGLubyte z, MGLubyte w); void glVertexAttrib1sv(MGLuint index, const MGLshort *v); void glVertexAttrib1fv(MGLuint index, const MGLfloat *v); void glVertexAttrib1dv(MGLuint index, const MGLdouble *v); void glVertexAttrib2sv(MGLuint index, const MGLshort *v); void glVertexAttrib2fv(MGLuint index, const MGLfloat *v); void glVertexAttrib2dv(MGLuint index, const MGLdouble *v); void glVertexAttrib3sv(MGLuint index, const MGLshort *v); void glVertexAttrib3fv(MGLuint index, const MGLfloat *v); void glVertexAttrib3dv(MGLuint index, const MGLdouble *v); void glVertexAttrib4bv(MGLuint index, const MGLbyte *v); void glVertexAttrib4sv(MGLuint index, const MGLshort *v); void glVertexAttrib4iv(MGLuint index, const MGLint *v); void glVertexAttrib4ubv(MGLuint index, const MGLubyte *v); void glVertexAttrib4usv(MGLuint index, const MGLushort *v); void glVertexAttrib4uiv(MGLuint index, const MGLuint *v); void glVertexAttrib4fv(MGLuint index, const MGLfloat *v); void glVertexAttrib4dv(MGLuint index, const MGLdouble *v); void glVertexAttrib4Nbv(MGLuint index, const MGLbyte *v); void glVertexAttrib4Nsv(MGLuint index, const MGLshort *v); void glVertexAttrib4Niv(MGLuint index, const MGLint *v); void glVertexAttrib4Nubv(MGLuint index, const MGLubyte *v); void glVertexAttrib4Nusv(MGLuint index, const MGLushort *v); void glVertexAttrib4Nuiv(MGLuint index, const MGLuint *v); void glVertexAttribPointer(MGLuint index, MGLint size, MGLenum type, MGLboolean normalized, MGLsizei stride, const void *pointer); void glEnableVertexAttribArray(MGLuint index); void glDisableVertexAttribArray(MGLuint index); void glProgramString(MGLenum target, MGLenum format, MGLsizei len, const void *string); void glBindProgram(MGLenum target, MGLuint program); void glDeletePrograms(MGLsizei n, const MGLuint *programs); void glGenPrograms(MGLsizei n, MGLuint *programs); void glProgramEnvParameter4d(MGLenum target, MGLuint index, MGLdouble x, MGLdouble y, MGLdouble z, MGLdouble w); void glProgramEnvParameter4dv(MGLenum target, MGLuint index, const MGLdouble *params); void glProgramEnvParameter4f(MGLenum target, MGLuint index, MGLfloat x, MGLfloat y, MGLfloat z, MGLfloat w); void glProgramEnvParameter4fv(MGLenum target, MGLuint index, const MGLfloat *params); void glProgramLocalParameter4d(MGLenum target, MGLuint index, MGLdouble x, MGLdouble y, MGLdouble z, MGLdouble w); void glProgramLocalParameter4dv(MGLenum target, MGLuint index, const MGLdouble *params); void glProgramLocalParameter4f(MGLenum target, MGLuint index, MGLfloat x, MGLfloat y, MGLfloat z, MGLfloat w); void glProgramLocalParameter4fv(MGLenum target, MGLuint index, const MGLfloat *params); void glGetProgramEnvParameterdv(MGLenum target, MGLuint index, MGLdouble *params); void glGetProgramEnvParameterfv(MGLenum target, MGLuint index, MGLfloat *params); void glGetProgramLocalParameterdv(MGLenum target, MGLuint index, MGLdouble *params); void glGetProgramLocalParameterfv(MGLenum target, MGLuint index, MGLfloat *params); void glGetProgramiv(MGLenum target, MGLenum pname, MGLint *params); void glGetProgramString(MGLenum target, MGLenum pname, void *string); void glGetVertexAttribdv(MGLuint index, MGLenum pname, MGLdouble *params); void glGetVertexAttribfv(MGLuint index, MGLenum pname, MGLfloat *params); void glGetVertexAttribiv(MGLuint index, MGLenum pname, MGLint *params); void glGetVertexAttribPointerv(MGLuint index, MGLenum pname, void **pointer); MGLboolean glIsProgram(MGLuint program); // ATI_fragment_shader MGLuint glGenFragmentShadersATI(MGLuint range); void glBindFragmentShaderATI(MGLuint id); void glDeleteFragmentShaderATI(MGLuint id); void glBeginFragmentShaderATI(); void glEndFragmentShaderATI(); void glPassTexCoordATI(MGLuint dst, MGLuint coord, MGLenum swizzle); void glSampleMapATI(MGLuint dst, MGLuint interp, MGLenum swizzle); void glColorFragmentOp1ATI(MGLenum op, MGLuint dst, MGLuint dstMask, MGLuint dstMod, MGLuint arg1, MGLuint arg1Rep, MGLuint arg1Mod); void glColorFragmentOp2ATI(MGLenum op, MGLuint dst, MGLuint dstMask, MGLuint dstMod, MGLuint arg1, MGLuint arg1Rep, MGLuint arg1Mod, MGLuint arg2, MGLuint arg2Rep, MGLuint arg2Mod); void glColorFragmentOp3ATI(MGLenum op, MGLuint dst, MGLuint dstMask, MGLuint dstMod, MGLuint arg1, MGLuint arg1Rep, MGLuint arg1Mod, MGLuint arg2, MGLuint arg2Rep, MGLuint arg2Mod, MGLuint arg3, MGLuint arg3Rep, MGLuint arg3Mod); void glAlphaFragmentOp1ATI(MGLenum op, MGLuint dst, MGLuint dstMod, MGLuint arg1, MGLuint arg1Rep, MGLuint arg1Mod); void glAlphaFragmentOp2ATI(MGLenum op, MGLuint dst, MGLuint dstMod, MGLuint arg1, MGLuint arg1Rep, MGLuint arg1Mod, MGLuint arg2, MGLuint arg2Rep, MGLuint arg2Mod); void glAlphaFragmentOp3ATI(MGLenum op, MGLuint dst, MGLuint dstMod, MGLuint arg1, MGLuint arg1Rep, MGLuint arg1Mod, MGLuint arg2, MGLuint arg2Rep, MGLuint arg2Mod, MGLuint arg3, MGLuint arg3Rep, MGLuint arg3Mod); void glSetFragmentShaderConstantATI(MGLuint dst, const float *value); // ATI_pn_triangles void glPNTrianglesiATI(MGLenum pname, MGLint param); void glPNTrianglesfATI(MGLenum pname, MGLfloat param); // EXT_compiled_vertex_array void glLockArraysEXT(MGLint first, MGLsizei count); void glUnlockArraysEXT(void); // EXT_cull_vertex void glCullParameterdvEXT(MGLenum pname, MGLdouble *params); void glCullParameterfvEXT(MGLenum pname, MGLfloat *params); // EXT_secondary_color void glSecondaryColor3bEXT(MGLbyte red, MGLbyte green, MGLbyte blue); void glSecondaryColor3bvEXT(const MGLbyte *components); void glSecondaryColor3dEXT(MGLdouble red, MGLdouble green, MGLdouble blue); void glSecondaryColor3dvEXT(const MGLdouble *components); void glSecondaryColor3fEXT(MGLfloat red, MGLfloat green, MGLfloat blue); void glSecondaryColor3fvEXT(const MGLfloat *components); void glSecondaryColor3iEXT(MGLint red, MGLint green, MGLint blue); void glSecondaryColor3ivEXT(const MGLint *components); void glSecondaryColor3sEXT(MGLshort red, MGLshort green, MGLshort blue); void glSecondaryColor3svEXT(const MGLshort *components); void glSecondaryColor3ubEXT(MGLubyte red, MGLubyte green, MGLubyte blue); void glSecondaryColor3ubvEXT(const MGLubyte *components); void glSecondaryColor3uiEXT(MGLuint red, MGLuint green, MGLuint blue); void glSecondaryColor3uivEXT(const MGLuint *components); void glSecondaryColor3usEXT(MGLushort red, MGLushort green, MGLushort blue); void glSecondaryColor3usvEXT(const MGLushort *components); void glSecondaryColorPointerEXT(MGLint size, MGLenum type, MGLsizei stride, MGLvoid *pointer); // EXT_fog_coord void glFogCoordfEXT(MGLfloat coord); void glFogCoordfvEXT(const MGLfloat *coord); void glFogCoorddEXT(MGLdouble coord); void glFogCoorddvEXT(const MGLdouble *coord); void glFogCoordPointerEXT(MGLenum type, MGLsizei stride, const MGLvoid *pointer); // EXT_vertex_shader (supported by ATI, Apple, Matrox, 3DLabs) void glBeginVertexShaderEXT(); void glEndVertexShaderEXT(); void glBindVertexShaderEXT(MGLuint id); MGLuint glGenVertexShadersEXT(MGLuint range); void glDeleteVertexShaderEXT(MGLuint id); void glShaderOp1EXT(MGLenum op, MGLuint res, MGLuint arg1); void glShaderOp2EXT(MGLenum op, MGLuint res, MGLuint arg1, MGLuint arg2); void glShaderOp3EXT(MGLenum op, MGLuint res, MGLuint arg1, MGLuint arg2, MGLuint arg3); void glSwizzleEXT(MGLuint res, MGLuint in, MGLenum outX, MGLenum outY, MGLenum outZ, MGLenum outW); void glWriteMaskEXT(MGLuint res, MGLuint in, MGLenum outX, MGLenum outY, MGLenum outZ, MGLenum outW); void glInsertComponentEXT(MGLuint res, MGLuint src, MGLuint num); void glExtractComponentEXT(MGLuint res, MGLuint src, MGLuint num); MGLuint glGenSymbolsEXT(MGLenum datatype, MGLenum storagetype, MGLenum range, MGLuint components); void glSetInvariantEXT(MGLuint id, MGLenum type, void *addr); void glSetLocalConstantEXT(MGLuint id, MGLenum type, void *addr); void glVariantbvEXT(MGLuint id, MGLbyte *addr); void glVariantsvEXT(MGLuint id, MGLshort *addr); void glVariantivEXT(MGLuint id, MGLint *addr); void glVariantfvEXT(MGLuint id, MGLfloat *addr); void glVariantdvEXT(MGLuint id, MGLdouble *addr); void glVariantubvEXT(MGLuint id, MGLubyte *addr); void glVariantusvEXT(MGLuint id, MGLushort *addr); void glVariantuivEXT(MGLuint id, MGLuint *addr); void glVariantPointerEXT(MGLuint id, MGLenum type, MGLuint stride, void *addr); void glEnableVariantClientStateEXT(MGLuint id); void glDisableVariantClientStateEXT(MGLuint id); MGLuint glBindLightParameterEXT(MGLenum light, MGLenum value); MGLuint glBindMaterialParameterEXT(MGLenum face, MGLenum value); MGLuint glBindTexGenParameterEXT(MGLenum unit, MGLenum coord, MGLenum value); MGLuint glBindTextureUnitParameterEXT(MGLenum unit, MGLenum value); MGLuint glBindParameterEXT(MGLenum value); MGLboolean glIsVariantEnabledEXT(MGLuint id, MGLenum cap); void glGetVariantBooleanvEXT(MGLuint id, MGLenum value, MGLboolean *data); void glGetVariantIntegervEXT(MGLuint id, MGLenum value, MGLint *data); void glGetVariantFloatvEXT(MGLuint id, MGLenum value, MGLfloat *data); void glGetVariantPointervEXT(MGLuint id, MGLenum value, void **data); void glGetInvariantBooleanvEXT(MGLuint id, MGLenum value, MGLboolean *data); void glGetInvariantIntegervEXT(MGLuint id, MGLenum value, MGLint *data); void glGetInvariantFloatvEXT(MGLuint id, MGLenum value, MGLfloat *data); void glGetLocalConstantBooleanvEXT(MGLuint id, MGLenum value, MGLboolean *data); void glGetLocalConstantIntegervEXT(MGLuint id, MGLenum value, MGLint *data); void glGetLocalConstantFloatvEXT(MGLuint id, MGLenum value, MGLfloat *data); // EXT_vertex_weighting void glVertexWeightfEXT(MGLfloat weight); void glVertexWeightfvEXT(MGLfloat *weight); void glVertexWeightPointerEXT(MGLint size, MGLenum type, MGLsizei stride, MGLvoid *pointer); // NV_vertex_array_range void glFlushVertexArrayRangeNV(); void glVertexArrayRangeNV(MGLsizei length, const MGLvoid *pointer); // NV_vertex_program void glBindProgramNV(MGLenum target, MGLuint id); void glDeleteProgramsNV(MGLsizei n, const MGLuint *ids); void glExecuteProgramNV(MGLenum target,MGLuint id, const MGLfloat *params); void glGenProgramsNV(MGLsizei n, MGLuint *ids); MGLboolean glAreProgramsResidentNV(MGLsizei n, const MGLuint *ids, MGLboolean *residences); void glRequestResidentProgramsNV(MGLsizei n, const MGLuint *ids); void glGetProgramParameterfvNV(MGLenum target, MGLuint index, MGLenum pname, MGLfloat *params); void glGetProgramParameterdvNV(MGLenum target, MGLuint index, MGLenum pname, MGLdouble *params); void glGetProgramivNV(MGLuint id, MGLenum pname, MGLint *params); void glGetProgramStringNV(MGLuint id, MGLenum pname, MGLubyte *program); void glGetTrackMatrixivNV(MGLenum target, MGLuint address, MGLenum pname, int *params); void glGetVertexAttribdvNV(MGLuint index, MGLenum pname, MGLdouble *params); void glGetVertexAttribfvNV(MGLuint index, MGLenum pname, MGLfloat *params); void glGetVertexAttribivNV(MGLuint index, MGLenum pname, MGLint *params); void glGetVertexAttribPointervNV(MGLuint index, MGLenum pname, void **pointer); MGLboolean glIsProgramNV(MGLuint id); void glLoadProgramNV(MGLenum target, MGLuint id, MGLsizei len, const MGLubyte *program); void glProgramParameter4fNV(MGLenum target, MGLuint index, MGLfloat x, MGLfloat y, MGLfloat z, MGLfloat w); void glProgramParameter4dNV(MGLenum target, MGLuint index, MGLdouble x, MGLdouble y, MGLdouble z, MGLdouble w); void glProgramParameter4dvNV(MGLenum target, MGLuint index, const MGLdouble *params); void glProgramParameter4fvNV(MGLenum target, MGLuint index, const MGLfloat *params); void glProgramParameters4dvNV(MGLenum target, MGLuint index, MGLsizei count, const MGLdouble *params); void glProgramParameters4fvNV(MGLenum target, MGLuint index, MGLsizei count, const MGLfloat *params); void glTrackMatrixNV(MGLenum target, MGLuint address, MGLenum matrix, MGLenum transform); void glVertexAttribPointerNV(MGLuint index, MGLint sizei, MGLenum type, MGLsizei stride, const void *pointer); void glVertexAttrib1sNV(MGLuint index, MGLshort x); void glVertexAttrib1fNV(MGLuint index, MGLfloat x); void glVertexAttrib1dNV(MGLuint index, MGLdouble x); void glVertexAttrib2sNV(MGLuint index, MGLshort x, MGLshort y); void glVertexAttrib2fNV(MGLuint index, MGLfloat x, MGLfloat y); void glVertexAttrib2dNV(MGLuint index, MGLdouble x, MGLdouble y); void glVertexAttrib3sNV(MGLuint index, MGLshort x, MGLshort y, MGLshort z); void glVertexAttrib3fNV(MGLuint index, MGLfloat x, MGLfloat y, MGLfloat z); void glVertexAttrib3dNV(MGLuint index, MGLdouble x, MGLdouble y, MGLdouble z); void glVertexAttrib4sNV(MGLuint index, MGLshort x, MGLshort y, MGLshort z, MGLshort w); void glVertexAttrib4fNV(MGLuint index, MGLfloat x, MGLfloat y, MGLfloat z, MGLfloat w); void glVertexAttrib4dNV(MGLuint index, MGLdouble x, MGLdouble y, MGLdouble z, MGLdouble w); void glVertexAttrib4ubNV(MGLuint index, MGLubyte x, MGLubyte y, MGLubyte z, MGLubyte w); void glVertexAttrib1svNV(MGLuint index, const MGLshort *v); void glVertexAttrib1fvNV(MGLuint index, const MGLfloat *v); void glVertexAttrib1dvNV(MGLuint index, const MGLdouble *v); void glVertexAttrib2svNV(MGLuint index, const MGLshort *v); void glVertexAttrib2fvNV(MGLuint index, const MGLfloat *v); void glVertexAttrib2dvNV(MGLuint index, const MGLdouble *v); void glVertexAttrib3svNV(MGLuint index, const MGLshort *v); void glVertexAttrib3fvNV(MGLuint index, const MGLfloat *v); void glVertexAttrib3dvNV(MGLuint index, const MGLdouble *v); void glVertexAttrib4svNV(MGLuint index, const MGLshort *v); void glVertexAttrib4fvNV(MGLuint index, const MGLfloat *v); void glVertexAttrib4dvNV(MGLuint index, const MGLdouble *v); void glVertexAttrib4ubvNV(MGLuint index, const MGLubyte *v); void glVertexAttribs1svNV(MGLuint index, MGLsizei n, const MGLshort *v); void glVertexAttribs1fvNV(MGLuint index, MGLsizei n, const MGLfloat *v); void glVertexAttribs1dvNV(MGLuint index, MGLsizei n, const MGLdouble *v); void glVertexAttribs2svNV(MGLuint index, MGLsizei n, const MGLshort *v); void glVertexAttribs2fvNV(MGLuint index, MGLsizei n, const MGLfloat *v); void glVertexAttribs2dvNV(MGLuint index, MGLsizei n, const MGLdouble *v); void glVertexAttribs3svNV(MGLuint index, MGLsizei n, const MGLshort *v); void glVertexAttribs3fvNV(MGLuint index, MGLsizei n, const MGLfloat *v); void glVertexAttribs3dvNV(MGLuint index, MGLsizei n, const MGLdouble *v); void glVertexAttribs4svNV(MGLuint index, MGLsizei n, const MGLshort *v); void glVertexAttribs4fvNV(MGLuint index, MGLsizei n, const MGLfloat *v); void glVertexAttribs4dvNV(MGLuint index, MGLsizei n, const MGLdouble *v); void glVertexAttribs4ubvNV(MGLuint index, MGLsizei n, const MGLubyte *v); // NV_fence void glGenFencesNV(MGLsizei n, MGLuint *fences); void glDeleteFencesNV(MGLsizei n, const MGLuint *fences); void glSetFenceNV(MGLuint fence, MGLenum condition); MGLboolean glTestFenceNV(MGLuint fence); void glFinishFenceNV(MGLuint fence); MGLboolean glIsFenceNV(MGLuint fence); void glGetFenceivNV(MGLuint fence, MGLenum pname, MGLint *params); // NV_register_combiners void glCombinerParameterfvNV(MGLenum pname, const MGLfloat *params); void glCombinerParameterfNV(MGLenum pname, MGLfloat param); void glCombinerParameterivNV(MGLenum pname, const MGLint *params); void glCombinerParameteriNV(MGLenum pname, MGLint param); void glCombinerInputNV(MGLenum stage, MGLenum portion, MGLenum variable, MGLenum input, MGLenum mapping, MGLenum componentUsage); void glCombinerOutputNV(MGLenum stage, MGLenum portion, MGLenum abOutput, MGLenum cdOutput, MGLenum sumOutput, MGLenum scale, MGLenum bias, MGLboolean abDotProduct, MGLboolean cdDotProduct, MGLboolean muxSum); void glFinalCombinerInputNV(MGLenum variable, MGLenum input, MGLenum mapping, MGLenum componentUsage); void glGetCombinerInputParameterfvNV(MGLenum stage, MGLenum portion, MGLenum variable, MGLenum pname, MGLfloat *params); void glGetCombinerInputParameterivNV(MGLenum stage, MGLenum portion, MGLenum variable, MGLenum pname, MGLint *params); void glGetCombinerOutputParameterfvNV(MGLenum stage, MGLenum portion, MGLenum pname, MGLfloat *params); void glGetCombinerOutputParameterivNV(MGLenum stage, MGLenum portion, MGLenum pname, MGLint *params); void glGetFinalCombinerInputParameterfvNV(MGLenum variable, MGLenum pname, MGLfloat *params); void glGetFinalCombinerInputParameterivNV(MGLenum variable, MGLenum pname, MGLint *params); // NV_occlusion_query void glGenOcclusionQueriesNV(MGLsizei n, MGLuint *ids); void glDeleteOcclusionQueriesNV(MGLsizei n, const MGLuint *ids); void glIsOcclusionQueryNV(MGLuint id); void glBeginOcclusionQueryNV(MGLuint id); void glEndOcclusionQueryNV(MGLvoid); void glGetOcclusionQueryivNV(MGLuint id, MGLenum pname, MGLint *params); void glGetOcclusionQueryuivNV(MGLuint id, MGLenum pname, MGLuint *params); // NV_primitive_restart void glPrimitiveRestartNV(MGLvoid); void glPrimitiveRestartIndexNV(MGLuint index); // ARB_occlusion_query void glGenQueriesARB (MGLsizei n, MGLuint *ids); void glDeleteQueriesARB (MGLsizei n, const MGLuint *ids); MGLboolean glIsQueryARB (MGLuint id); void glBeginQueryARB (MGLenum target, MGLuint id); void glEndQueryARB (MGLenum target); void glGetQueryivARB (MGLenum target, MGLenum pname, MGLint *params); void glGetQueryObjectivARB (MGLuint id, MGLenum pname, MGLint *params); void glGetQueryObjectuivARB (MGLuint id, MGLenum pname, MGLuint *params); // ARB_vertex_buffer_object void glBindBufferARB(MGLenum target, MGLuint buffer); void glDeleteBuffersARB(MGLsizei n, const MGLuint *buffers); void glGenBuffersARB(MGLsizei n, MGLuint *buffers); MGLboolean glIsBufferARB(MGLuint buffer); bool glBufferDataARB(MGLenum target, MGLsizeiptrARB size, const MGLvoid *data, MGLenum usage); bool glBufferSubDataARB(MGLenum target, MGLintptrARB offset, MGLsizeiptrARB size, const MGLvoid *data); void glGetBufferSubDataARB(MGLenum target, MGLintptrARB offset, MGLsizeiptrARB size, MGLvoid *data); void* glMapBufferARB(MGLenum target, MGLenum access); MGLboolean glUnmapBufferARB(MGLenum target); void glGetBufferParameterivARB(MGLenum target, MGLenum pname, MGLint *params); void glGetBufferPointervARB(MGLenum target, MGLenum pname, MGLvoid **params); // OpenGL 2.0 API // void glDeleteObjectARB(MGLhandleARB obj); MGLhandleARB glGetHandleARB(MGLenum pname); void glDetachObjectARB(MGLhandleARB containerObj, MGLhandleARB attachedObj); MGLhandleARB glCreateShaderObjectARB(MGLenum shaderType); void glShaderSourceARB(MGLhandleARB shaderObj, MGLsizei count, const MGLcharARB **string, const MGLint *length); void glCompileShaderARB(MGLhandleARB shaderObj); MGLhandleARB glCreateProgramObjectARB(MGLvoid); void glAttachObjectARB(MGLhandleARB containerObj, MGLhandleARB obj); void glLinkProgramARB(MGLhandleARB programObj); void glUseProgramObjectARB(MGLhandleARB programObj); void glValidateProgramARB(MGLhandleARB programObj); void glUniform1fARB(MGLint location, MGLfloat v0); void glUniform2fARB(MGLint location, MGLfloat v0, MGLfloat v1); void glUniform3fARB(MGLint location, MGLfloat v0, MGLfloat v1, MGLfloat v2); void glUniform4fARB(MGLint location, MGLfloat v0, MGLfloat v1, MGLfloat v2, MGLfloat v3); void glUniform1iARB(MGLint location, MGLint v0); void glUniform2iARB(MGLint location, MGLint v0, MGLint v1); void glUniform3iARB(MGLint location, MGLint v0, MGLint v1, MGLint v2); void glUniform4iARB(MGLint location, MGLint v0, MGLint v1, MGLint v2, MGLint v3); void glUniform1fvARB(MGLint location, MGLsizei count, MGLfloat *value); void glUniform2fvARB(MGLint location, MGLsizei count, MGLfloat *value); void glUniform3fvARB(MGLint location, MGLsizei count, MGLfloat *value); void glUniform4fvARB(MGLint location, MGLsizei count, MGLfloat *value); void glUniform1ivARB(MGLint location, MGLsizei count, MGLint *value); void glUniform2ivARB(MGLint location, MGLsizei count, MGLint *value); void glUniform3ivARB(MGLint location, MGLsizei count, MGLint *value); void glUniform4ivARB(MGLint location, MGLsizei count, MGLint *value); void glUniformMatrix2fvARB(MGLint location, MGLsizei count, MGLboolean transpose, MGLfloat *value); void glUniformMatrix3fvARB(MGLint location, MGLsizei count, MGLboolean transpose, MGLfloat *value); void glUniformMatrix4fvARB(MGLint location, MGLsizei count, MGLboolean transpose, MGLfloat *value); void glGetObjectParameterfvARB(MGLhandleARB obj, MGLenum pname, MGLfloat *params); void glGetObjectParameterivARB(MGLhandleARB obj, MGLenum pname, MGLint *params); void glGetInfoLogARB(MGLhandleARB obj, MGLsizei maxLength, MGLsizei *length, MGLcharARB *infoLog); void glGetAttachedObjectsARB(MGLhandleARB containerObj, MGLsizei maxCount, MGLsizei *count, MGLhandleARB *obj); MGLint glGetUniformLocationARB(MGLhandleARB programObj, const MGLcharARB *name); void glGetActiveUniformARB(MGLhandleARB programObj, MGLuint index, MGLsizei maxLength, MGLsizei *length, MGLint *size, MGLenum *type, MGLcharARB *name); void glGetUniformfvARB(MGLhandleARB programObj, MGLint location, MGLfloat *params); void glGetUniformivARB(MGLhandleARB programObj, MGLint location, MGLint *params); void glGetShaderSourceARB(MGLhandleARB obj, MGLsizei maxLength, MGLsizei *length, MGLcharARB *source); void glBindAttribLocationARB(MGLhandleARB programObj, MGLuint index, const MGLcharARB *name); void glGetActiveAttribARB(MGLhandleARB programObj, MGLuint index, MGLsizei maxLength, MGLsizei *length, MGLint *size, MGLenum *type, MGLcharARB *name); MGLint glGetAttribLocationARB(MGLhandleARB programObj, const MGLcharARB *name); protected: friend class MHardwareRenderer; MGLFunctionTable(); virtual ~MGLFunctionTable(); private: // No private members }; #endif /* __cplusplus */ #endif // _MGLFunctionTable_h_