OpenGL.tests.test_tess1 | index /var/pylive/src/OpenGL-dev/OpenGL-ctypes/OpenGL/tests/test_tess1.py

`Simple GLU Tess-object test w/out combine callback`

Modules
`` |  |
OpenGL.GL.3DFX OpenGL.GL.APPLE OpenGL.GL.ARB OpenGL.GL.ATI OpenGL.GL.DFX OpenGL.GLU.EXT OpenGL.GL OpenGL.GL.GREMEDY OpenGL.GL.HP OpenGL.GL.IBM OpenGL.GL.INGR OpenGL.GL.INTEL OpenGL.GL.MESA OpenGL.GL.NV OpenGL.GL.OES | OpenGL.GL.OML OpenGL.GL.PGI OpenGL.GL.REND OpenGL.GL.S3 OpenGL.GL.SGI OpenGL.GL.SGIS OpenGL.GL.SGIX OpenGL.GL.SUN OpenGL.GL.SUNX OpenGL.GL.VERSION OpenGL.GL.WIN OpenGL.arrays OpenGL.constant OpenGL.constants OpenGL.converters | copy copy_reg ctypes OpenGL.error OpenGL.GL.exceptional OpenGL.extensions OpenGL.GL.feedback OpenGL.GL.glget OpenGL.GLU.glunurbs OpenGL.GLU.glustruct OpenGL.GL.images OpenGL.raw.GL.ARB.imaging math multiarray pickle | OpenGL.platform OpenGL.GL.pointers OpenGLContext.scenegraph.polygontessellator OpenGL.GLU.projection OpenGL.GLU.quadrics OpenGL.GL.selection OpenGL.raw.GLU string OpenGL.GLU.tess OpenGLContext.testingcontext types OpenGLContext.scenegraph.vertex OpenGL.wrapper

Classes
`` |  | GLUTInteractiveContext(ViewPlatformMixin, InteractiveContext, GLUTContext) TestContext
class TestContext(GLUTInteractiveContext)
`` |  | Method resolution order: TestContext GLUTInteractiveContext ViewPlatformMixin InteractiveContext EventHandlerMixin GLUTContext EventHandlerMixin Context Methods defined here: OnInit(self) Render(self, mode=0) renderCap(self, scale=1.0) `The cap is generated with GLU tessellation routines...` Data and other attributes defined here: scale = 1.0 Methods inherited from ViewPlatformMixin: ViewPort(self, width, height) `Set the size of the OpenGL rendering viewport for the context Because the ViewPlatform provide support for "constant aspect ratio" in scenes, it is necessary to keep the ViewPlatform updated regarding the current aspect ratio of the ViewPort. This implementation merely calls the platform's setViewport, then calls the super-class ViewPort method. XXX Unfortunately, because Context objects may be old-style classes, we can't use super(), so this implementation actually calls context.Context.ViewPort directly.` Viewpoint(self, mode=None) `Customization point: Sets up the projection matrix This implementation potentially instantiates the view platform object, and then calls the object's render method with the mode as argument.` backward(self, event) `(callback) Move platform backward by STEPDISTANCE triggers redraw after completion` down(self, event) `(callback) Move platform downward by STEPDISTANCE triggers redraw after completion` forward(self, event) `(callback) Move platform forward by STEPDISTANCE triggers redraw after completion` getViewPlatform(self) `Customization Point: Instantiate ViewPlatform for this context The default implementation is to instantiate a viewplatform.ViewPlatform with position equal to self.initialPosition and orientation equal to self.initialOrientation. See: OpenGLContext.shadow.shadowcontext for example where this method is overridden` left(self, event) `(callback) Move platform left by STEPDISTANCE triggers redraw after completion` right(self, event) `(callback) Move platform right by STEPDISTANCE triggers redraw after completion` setupDefaultEventCallbacks(self) `Customization point: Setup application default callbacks This method binds a large number of callbacks which support the OpenGLContext default camera-manipulation modes. In particular: * unmodified arrow keys for x,z (in camera coordinate space) movement * Alt+arrow keys for x,y (in camera coordinate space) movement * Ctrl+up/down arrow keys for rotating the head backward/ forward * Mouse-button-2 (right) for entering "examine" mode * '-' for straightening the view platform` startExamineMode(self, event) `(callback) Create an examine mode interaction manager This callback creates an instance of examinemanager.ExamineManager, which will manage the user interaction during an "examination" of the scene. XXX Currently the "center" determination is broken, so rotation tends to occur around random points. I haven't yet figured out why :(` straighten(self, event) `(callback) Straightens the platform orientation Attempts to make the orientation equal to the y-axis orientation of the current orientation. In other words, tries to make the camera's horizon equal to the object-space horizon (the x,z plane) without altering the y-axis orientation. See: OpenGLContext.viewplatform.ViewPlatform.straighten triggers redraw after completion` turndown(self, event) `(callback) Rotates "head" forward (looks downward) by TURNANGLE triggers redraw after completion` turnleft(self, event) `(callback) Rotates "head" to the left by TURNANGLE triggers redraw after completion` turnright(self, event) `(callback) Rotates "head" to the right by TURNANGLE triggers redraw after completion` turnup(self, event) `(callback) Rotates "head" backward (looks upward) by TURNANGLE triggers redraw after completion` up(self, event) `(callback) Move platform upward by STEPDISTANCE triggers redraw after completion` Data and other attributes inherited from ViewPlatformMixin: STEPDISTANCE = 0.25 TURNANGLE = 0.098174770424681035 initialOrientation = (0, 1, 0, 0) initialPosition = (0, 0, 10) platform = None slider = None Data and other attributes inherited from InteractiveContext: EventManagerClasses = [('keyboard', <class 'OpenGLContext.events.keyboardevents.KeyboardEventManager'>), ('keypress', <class 'OpenGLContext.events.keyboardevents.KeypressEventManager'>), ('mousebutton', <class 'OpenGLContext.events.mouseevents.MouseButtonEventManager'>), ('mousemove', <class 'OpenGLContext.events.mouseevents.MouseMoveEventManager'>), ('mousein', <class 'OpenGLContext.events.mouseevents.MouseInEventManager'>), ('mouseout', <class 'OpenGLContext.events.mouseevents.MouseOutEventManager'>)] TimeManagerClass = <class 'OpenGLContext.events.timeeventgeneratormanager.TimeEventGeneratorManager'> `TimeEventGenerator EventManager object This object conforms to the EventManager interface, although it doesn't actually inherit from that class. It provides support for the InternalTime generators on which the Timer object is based.` Methods inherited from EventHandlerMixin: DoEventCascade(self) `Do pre-rendering event cascade Returns the total number of events generated by timesensors and/or processed from the event cascade queue` ProcessEvent(self, event) `Primary dispatch point for events. ProcessEvent uses the event's type attribute to determine the appropriate manager for processing, then dispatches to that manager's ProcessEvent method.` addEventHandler(self, eventType, *arguments, **namedarguments) `Add a new event handler function for the given event type This is the primary client API for dealing with the event system. Each event class will define a particular set of data values required to form the routing key for the event. Each event handler class will define a registerCallback function which converts its arguments into a matching key. This function merely determines the appropriate handler then dispatches to the handler's registerCallback method (without the eventType argument). See: mouseevents, keyboardevents` addEventManager(self, eventType, manager=None) `Add an event manager to the internal table of managers. The return value is the previous manager or None if there was no previous manager.` captureEvents(self, eventType, manager=None) `Temporarily capture events of a particular type. This temporarily replaces a particular manager within the dispatch set with provided manager. This will normally be used to create "modal" interfaces such as active drag functions (where the interface is in a different "interaction mode", so that actions have different meaning than in the "default mode"). Passing None as the manager will restore the previous manager to functioning. Note: this function does not perform a "system capture" of input (that is, mouse movements are only available if they occur over the context's window and that window has focus). Note: for capturing mouse input, you will likely want to capture both movement and button events, it should be possible to define a single handler to deal with both event types, and pass that handler twice, once for each event type.` getEventManager(self, eventType) `Retrieve an event manager from the internal table of managers Returns the appropriate manager, or None if there was no manager registered for the given event type.` getTimeManager(self) `Get the time-event manager for this context` initializeEventManagers(self) `Initialize the event manager classes for this context. This implementation iterates over self.EventManagerClasses (a list of (eventType, managerClass) values) and calls addEventManager for each item.` Methods inherited from GLUTContext: OnRedisplay(self) `windowing library has asked us to redisplay` OnResize(self, width, height) `Windowing library has resized the window` SwapBuffers(self) `Implementation: swap the buffers` __init__(self, definition=None, **named) setCurrent(self) `Acquire the GL "focus"` setupCallbacks(self) `Setup the various callbacks for this context` Class methods inherited from GLUTContext: ContextMainLoop(cls, *args, **named) from __builtin__.classobj `Mainloop for the GLUT testing context` glutFlagsFromDefinition(cls, definition) from __builtin__.classobj `Create our initialisation flags from a definition` Data and other attributes inherited from GLUTContext: CONTEXT_DEFINITION_FLAG_MAPPING = (('doubleBuffer', GLUT_DOUBLE, GLUT_SINGLE, GLUT_DOUBLE), ('depthBuffer', GLUT_DEPTH, 0, GLUT_DEPTH), ('accumulationBuffer', GLUT_ACCUM, 0, GLUT_ACCUM), ('stencilBuffer', GLUT_STENCIL, 0, GLUT_STENCIL), ('rgb', GLUT_RGB, GLUT_INDEX, GLUT_RGB), ('multisampleBuffer', GLUT_MULTISAMPLE, 0, 0), ('multisampleSamples', GLUT_MULTISAMPLE, 0, 0), ('stereo', GLUT_STEREO, 0, 0)) DISPLAYMODE = 18 currentModifiers = 0 Methods inherited from EventHandlerMixin: glutOnCharacter(self, character, x, y) `Convert character (non-control) press to context event` glutOnKeyDown(self, character, x, y) `Convert a key-press to a context-style event` glutOnKeyUp(self, character, x, y) `Convert a key-release to a context-style event` glutOnMouseButton(self, button, state, x, y) `Convert mouse-press-or-release to a Context-style event` glutOnMouseMove(self, x, y) `Convert mouse-movement to a Context-style event` Methods inherited from Context: Background(self, mode=None) `Customization point for clearing/drawing the background. The default implementation clears the color and depth buffers, using solid white for the clear color. Note: This method is only called if there is no scene graph, and if there is no SetupBindables( mode ) method available on the Context.` DoInit(self) `Call the OnInit method at a time when the context is valid This method provides a customization point where contexts which do not completely initialize during their __init__ method can arrange to have the OnInit method processed after their initialization has completed. The default implementation here simply calls OnInit directly w/ appropriate setCurrent and unsetCurrent calls. Note: The only context currently known to require this customization is the wxPython-on-GTK context, everything else completes context initialization before calling Context.__init__.` Lights(self, mode=None) `Customization point for setting up global illumination parameters Depending on the mode, should either enable or disable lighting for all of those lights in the scene. The default implementation enables lighting and light 0 if render mode is not select, disables them otherwise. Note: This method is only called if there is no scene graph, and if there is no SetupBindables( mode ) method available on the Context.` OnDraw(self, force=1, *arguments) `Callback for the rendering/drawing mechanism force -- if true, force a redraw. If false, then only do a redraw if the event cascade has generated events. return value is whether a visible change occured This implementation does the following: * calls lockScenegraph() o calls DoEventCascade() * calls unlockScenegraph() * calls setCurrent() * calls renderPasses( self ) See: visitor.py, rendervisitor.py, renderpass.py, shadow/passes.py for examples of render-pass-sets which can be triggered. The RenderPasses define the core of the rendering mechanism. The default rendering passes will defer most rendering options to the scenegraph returned by getSceneGraph(). If that value is None (default) then the pass will use the Context's callbacks. You can define new RenderPasses to replace the rendering algorithm, override the Context's various callbacks to write raw OpenGL code, or work by customizing the scene graph library. * if there was a visible change (which is the return value from the render-pass-set), calls SwapBuffers() * calls unsetCurrent()` OnIdle(self, *arguments) `Override to perform actions when the rendering loop is idle` addPickEvent(self, event) `Add event to list of events to be processed by selection-render-mode This is a method of the Context, rather than the rendering pass (which might seem more elegant given that it is the rendering pass which deals with the events being registered) because the requests to render a pick event occur outside of the rendering loop. As a result, there is (almost) never an active context when the pick-event-request comes in.` drawPoll(self, timeout=None) `Wait timeout seconds for a redraw request timeout -- timeout in seconds, if None, use self.drawPollTimeout returns 0 if timeout, 1 if true` getPickEvents(self) `Get the currently active pick-events` getSceneGraph(self) `Get the scene graph for the context (or None) You must return an instance of: OpenGLContext.scenegraph.scenegraph.SceneGraph Normally you would create that using either a loader from OpenGLContext.loader: from OpenGLContext.loader import vrml97 def OnInit( self ): self.sg = vrml97.load( 'c:\somefile\world.wrl' ) or by using the classes in OpenGLContext.scenegraph.basenodes: from OpenGLContext.scenegraph import basenodes def OnInit( self ): self.sg = basenodes.sceneGraph( children = [ basenodes.Transform(...) ], ) to define the scenegraph in Python code.` getTTFFiles(self) `Get TrueType font-file registry object` getViewPort(self) `Method to retrieve the current dimensions of the context Return value is a width, height tuple. See Context.ViewPort for setting of this value.` lockScenegraph(self, blocking=1) `Lock scenegraph locks to prevent other update/rendering actions Potentially this could be called from a thread other than the GUI thread, allowing the other thread to update structures in the scenegraph without mucking up any active rendering pass.` renderedChildren(self, types=None) `Get the rendered children of the scenegraph` setupCache(self) `Setup caching strutures for content This includes the general compiled-geometry caches and the texture cache` setupExtensionManager(self) `Create an extension manager for this context` setupFontProviders(self) `Load font providers for the context See the OpenGLContext.scenegraph.text package for the available font providers.` setupFrameRateCounter(self) `Setup structures for managing frame-rate This sets self.frameCounter to an instance of framecounter.FrameCounter, which is a simple node used to track frame-rate metadata during rendering. Updates to the framecounter are performed by OnDraw iff there is a visible change processed. Note: If you override this method, you need to either use an object which has the same API as a FrameCounter or use None, anything else will cause failures in the core rendering loop!` setupRedrawRequest(self) `Setup the redraw-request (threading) event` setupScenegraphLock(self) `Setup lock to protect scenegraph from updates during rendering` setupThreading(self) `Setup primitives (locks, events) for threading` shouldRedraw(self) `Return whether or not the context contents need to be redrawn` suppressRedraw(self) `Indicate to the context that there is no need to re-render This method signals to the context that there are no updates currently requiring redrawing of the context's contents. See: Context.shouldRedraw and Context.triggerRedraw` triggerPick(self) `Trigger a selection rendering pass If the context is not currently drawing, the selection render will occur immediately, otherwise it will occur the next time the rendering loop reaches the selection stage.` triggerRedraw(self, force=0) `Indicate to the context that it should redraw when possible If force is true, the rendering will begin immediately if the context is not already drawing. Otherwise only the indicator flag will be set.` unlockScenegraph(self) `Unlock scenegraph locks to allow other update/rendering actions Potentially this could be called from a thread other than the GUI thread, allowing the other thread to update structures in the scenegraph without mucking up any active rendering pass.` unsetCurrent(self) `Give up the OpenGL focus from this context` Class methods inherited from Context: getApplicationName(cls) from __builtin__.classobj `Retrieve the application name for configuration purposes` getDefaultContextType(cls) from __builtin__.classobj `Get the current user's preference for a default context type` getDefaultTTFFont(cls, type='sans') from __builtin__.classobj `Get the current user's preference for a default font` getUserAppDataDirectory(cls) from __builtin__.classobj `Retrieve user-specific configuration directory Default implementation gives a directory-name in the user's (system-specific) "application data" directory named` setDefaultContextType(cls, name) from __builtin__.classobj `Set the current user's preference for a default font` setDefaultTTFFont(cls, name, type='sans') from __builtin__.classobj `Set the current user's preference for a default font` Data and other attributes inherited from Context: APPLICATION_NAME = 'OpenGLContext' DEF = '#Context' PROTO = 'Context' allContexts = [] alreadyDrawn = None contextDefinition = None currentContext = None drawPollTimeout = 0.01 drawing = None frameCounter = None renderPasses = [<class 'OpenGLContext.renderpass.OpaqueRenderPa...ass 'OpenGLContext.renderpass.SelectRenderPass'>] `Callable list of sub-passes with associated OverallPass The PassSet is called once per render-cycle, and is responsible for creating the OverallPass which does the actual rendering. It simply creates the OverallPass with the given sub-passes and calls the OverallPass, returning the result.` ttfFileRegistry = None viewportDimensions = (0, 0)

Functions
> `` |  | base_glGetActiveUniform = glGetActiveUniform(...) `glGetActiveUniform( GLuint(program), GLuint(index), GLsizei(bufSize), GLsizeiArray(length), GLintArray(size), GLuintArray(type), GLcharArray(name) ) -> None` base_glGetShaderSource = glGetShaderSource(...) `glGetShaderSource( GLuint(shader), GLsizei(bufSize), GLsizeiArray(length), GLcharArray(source) ) -> None` glAccum(...) `glAccum( GLenum(op), GLfloat(value) ) -> None` glActiveTexture(...) `glActiveTexture( GLenum(texture) ) -> None` glAlphaFunc(...) `glAlphaFunc( GLenum(func), GLclampf(ref) ) -> None` glAreTexturesResident( n,textures,residences ) pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284c350>, residences=None cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x2aaab284a8c0>, residences=None cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glAreTexturesResident( GLsizei(n), arrays.GLuintArray(textures), POINTER(GLboolean)(residences) ) -> GLboolean
> glArrayElement(...) `glArrayElement( GLint(i) ) -> None` glAttachShader(...) `glAttachShader( GLuint(program), GLuint(shader) ) -> None` glBeginQuery(...) `glBeginQuery( GLenum(target), GLuint(id) ) -> None` glBindAttribLocation(...) `glBindAttribLocation( GLuint(program), GLuint(index), GLcharArray(name) ) -> None` glBindBuffer(...) `glBindBuffer( GLenum(target), GLuint(buffer) ) -> None` glBindTexture(...) `glBindTexture( GLenum(target), GLuint(texture) ) -> None` glBitmap( width,height,xorig,yorig,xmove,ymove,bitmap ) pyConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284c390> cConverters: width=None, height=None, xorig=None, yorig=None, xmove=None, ymove=None, bitmap=<OpenGL.converters.getPyArgsName object at 0x2aaab284a960> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glBitmap( GLsizei(width), GLsizei(height), GLfloat(xorig), GLfloat(yorig), GLfloat(xmove), GLfloat(ymove), arrays.GLubyteArray(bitmap) ) -> None
> glBlendColor(...) `glBlendColor( GLclampf(red), GLclampf(green), GLclampf(blue), GLclampf(alpha) ) -> None` glBlendEquation(...) `glBlendEquation( GLenum(mode) ) -> None` glBlendEquationSeparate(...) `glBlendEquationSeparate( GLenum(modeRGB), GLenum(modeAlpha) ) -> None` glBlendFunc(...) `glBlendFunc( GLenum(sfactor), GLenum(dfactor) ) -> None` glBlendFuncSeparate(...) `glBlendFuncSeparate( GLenum(sfactorRGB), GLenum(dfactorRGB), GLenum(sfactorAlpha), GLenum(dfactorAlpha) ) -> None` glBufferData(...) `glBufferData( GLenum(target), GLsizeiptr(size), c_void_p(data), GLenum(usage) ) -> None` glBufferSubData(...) `glBufferSubData( GLenum(target), GLintptr(offset), GLsizeiptr(size), c_void_p(data) ) -> None` glCallList(...) `glCallList( GLuint(list) ) -> None` glClear(...) `glClear( GLbitfield(mask) ) -> None` glClearAccum(...) `glClearAccum( GLfloat(red), GLfloat(green), GLfloat(blue), GLfloat(alpha) ) -> None` glClearColor(...) `glClearColor( GLclampf(red), GLclampf(green), GLclampf(blue), GLclampf(alpha) ) -> None` glClearDepth(...) `glClearDepth( GLclampd(depth) ) -> None` glClearIndex(...) `glClearIndex( GLfloat(c) ) -> None` glClearStencil(...) `glClearStencil( GLint(s) ) -> None` glClientActiveTexture(...) `glClientActiveTexture( GLenum(texture) ) -> None` glClipPlane( plane,equation ) pyConverters: plane=None, equation=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284c3d0> cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object at 0x2aaab284aa00> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glClipPlane( GLenum(plane), arrays.GLdoubleArray(equation) ) -> None
> glColor3b(...) `glColor3b( GLbyte(red), GLbyte(green), GLbyte(blue) ) -> None` glColor3bv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab284aaa0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3bv( arrays.GLbyteArray(v) ) -> None
> glColor3d(...) `glColor3d( GLdouble(red), GLdouble(green), GLdouble(blue) ) -> None` glColor3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab284ab90> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3dv( arrays.GLdoubleArray(v) ) -> None
> glColor3f(...) `glColor3f( GLfloat(red), GLfloat(green), GLfloat(blue) ) -> None` glColor3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab284ac80> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3fv( arrays.GLfloatArray(v) ) -> None
> glColor3i(...) `glColor3i( GLint(red), GLint(green), GLint(blue) ) -> None` glColor3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab284ad70> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3iv( arrays.GLintArray(v) ) -> None
> glColor3s(...) `glColor3s( GLshort(red), GLshort(green), GLshort(blue) ) -> None` glColor3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab284ae60> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3sv( arrays.GLshortArray(v) ) -> None
> glColor3ub(...) `glColor3ub( GLubyte(red), GLubyte(green), GLubyte(blue) ) -> None` glColor3ubv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab284af50> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3ubv( arrays.GLubyteArray(v) ) -> None
> glColor3ui(...) `glColor3ui( GLuint(red), GLuint(green), GLuint(blue) ) -> None` glColor3uiv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc0a0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3uiv( arrays.GLuintArray(v) ) -> None
> glColor3us(...) `glColor3us( GLushort(red), GLushort(green), GLushort(blue) ) -> None` glColor3usv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc190> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor3usv( arrays.GLushortArray(v) ) -> None
> glColor4b(...) `glColor4b( GLbyte(red), GLbyte(green), GLbyte(blue), GLbyte(alpha) ) -> None` glColor4bv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc280> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4bv( arrays.GLbyteArray(v) ) -> None
> glColor4d(...) `glColor4d( GLdouble(red), GLdouble(green), GLdouble(blue), GLdouble(alpha) ) -> None` glColor4dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc370> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4dv( arrays.GLdoubleArray(v) ) -> None
> glColor4f(...) `glColor4f( GLfloat(red), GLfloat(green), GLfloat(blue), GLfloat(alpha) ) -> None` glColor4fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc460> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4fv( arrays.GLfloatArray(v) ) -> None
> glColor4i(...) `glColor4i( GLint(red), GLint(green), GLint(blue), GLint(alpha) ) -> None` glColor4iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc550> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4iv( arrays.GLintArray(v) ) -> None
> glColor4s(...) `glColor4s( GLshort(red), GLshort(green), GLshort(blue), GLshort(alpha) ) -> None` glColor4sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc640> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4sv( arrays.GLshortArray(v) ) -> None
> glColor4ub(...) `glColor4ub( GLubyte(red), GLubyte(green), GLubyte(blue), GLubyte(alpha) ) -> None` glColor4ubv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc730> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4ubv( arrays.GLubyteArray(v) ) -> None
> glColor4ui(...) `glColor4ui( GLuint(red), GLuint(green), GLuint(blue), GLuint(alpha) ) -> None` glColor4uiv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc820> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4uiv( arrays.GLuintArray(v) ) -> None
> glColor4us(...) `glColor4us( GLushort(red), GLushort(green), GLushort(blue), GLushort(alpha) ) -> None` glColor4usv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28bc910> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColor4usv( arrays.GLushortArray(v) ) -> None
> glColorMask(...) `glColorMask( GLboolean(red), GLboolean(green), GLboolean(blue), GLboolean(alpha) ) -> None` glColorMaterial(...) `glColorMaterial( GLenum(face), GLenum(mode) ) -> None` glColorPointer( size,type,stride,pointer ) pyConverters: size=None, type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x2aaab28e7b90> cConverters: Not Used cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of type instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e7bd0> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e9780>
>     Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glColorPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28dad50> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28dcaa0> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28dae10> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28dcb40>
>     Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glColorPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28da850> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28dc2d0> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28da910> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28dc370>
>     Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glColorPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28da950> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28dc460> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28daa10> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28dc500>
>     Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glColorPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28daa50> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28dc5f0> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28dab10> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28dc690>
>     Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glColorPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28dab50> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28dc780> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28dac10> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28dc820>
>     Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glColorPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28dac50> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_UNSIGNED_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28dc910> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28dad10> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28dc9b0>
>     Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glColorPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28dae50> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_UNSIGNED_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28dcc30> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28daf10> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28dccd0>
>     Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glColorPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28daf50> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_UNSIGNED_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28dcdc0> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0050> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28dce60>
>     Wrapping Operation: glColorPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glColorSubTable( target,start,count,format,type,data ) pyConverters: target=None, start= asIntConverter(value, *args) , count= asIntConverter(value, *args) , format=None, type=None, data=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab295a750> cConverters: Not Used cResolvers: target=None, start=None, count=None, format=None, type=None, data= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glColorSubTable( GLenum(target), GLsizei(start), GLsizei(count), GLenum(format), GLenum(type), c_void_p(data) ) -> None
> glColorTable( target,internalformat,width,format,type,table ) pyConverters: target=None, internalformat=None, width= asIntConverter(value, *args) , format=None, type=None, table=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab295a690> cConverters: Not Used cResolvers: target=None, internalformat=None, width=None, format=None, type=None, table= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glColorTable( GLenum(target), GLenum(internalformat), GLsizei(width), GLenum(format), GLenum(type), c_void_p(table) ) -> None
> glColorTableParameterfv( target,pname,params ) pyConverters: target=None, pname=None, params= asArraySize(incoming, function, args) cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab295c5f0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glColorTableParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
> glColorTableParameteriv(...) `glColorTableParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None` glCompileShader(...) `glCompileShader( GLuint(shader) ) -> None` glCompressedTexImage1D( target,level,internalformat,width,border,data ) pyConverters: target=None, level=None, internalformat=None, width= asIntConverter(value, *args) , border=None, data=None cConverters: target=None, level=None, internalformat=None, width=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x2aaab296e090>, data=None cResolvers: Not Used storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glCompressedTexImage1D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None
> glCompressedTexImage2D( target,level,internalformat,width,height,border,data ) pyConverters: target=None, level=None, internalformat=None, width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , border=None, data=None cConverters: target=None, level=None, internalformat=None, width=None, height=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x2aaab296e150>, data=None cResolvers: Not Used storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glCompressedTexImage2D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None
> glCompressedTexImage3D( target,level,internalformat,width,height,depth,border,data ) pyConverters: target=None, level=None, internalformat=None, width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , depth= asIntConverter(value, *args) , border=None, data=None cConverters: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x2aaab296e250>, data=None cResolvers: Not Used storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glCompressedTexImage3D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None
> glCompressedTexSubImage1D( target,level,xoffset,width,format,data ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , width= asIntConverter(value, *args) , format=None, data=None cConverters: target=None, level=None, xoffset=None, width=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x2aaab296e0d0>, data=None cResolvers: Not Used storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glCompressedTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None
> glCompressedTexSubImage2D( target,level,xoffset,yoffset,width,height,format,data ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , format=None, data=None cConverters: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x2aaab296e190>, data=None cResolvers: Not Used storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glCompressedTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None
> glCompressedTexSubImage3D( target,level,xoffset,yoffset,zoffset,width,height,depth,format,data ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , zoffset= asIntConverter(value, *args) , width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , depth= asIntConverter(value, *args) , format=None, data=None cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x2aaab296e310>, data=None cResolvers: Not Used storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glCompressedTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None
> glConvolutionFilter1D( target,internalformat,width,format,type,image ) pyConverters: target=None, internalformat=None, width= asIntConverter(value, *args) , format=None, type=None, image=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab295a910> cConverters: Not Used cResolvers: target=None, internalformat=None, width=None, format=None, type=None, image= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glConvolutionFilter1D( GLenum(target), GLenum(internalformat), GLsizei(width), GLenum(format), GLenum(type), c_void_p(image) ) -> None
> glConvolutionFilter2D( target,internalformat,width,height,format,type,image ) pyConverters: target=None, internalformat=None, width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , format=None, type=None, image=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab295a9d0> cConverters: Not Used cResolvers: target=None, internalformat=None, width=None, height=None, format=None, type=None, image= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glConvolutionFilter2D( GLenum(target), GLenum(internalformat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), c_void_p(image) ) -> None
> glConvolutionParameterf(...) `glConvolutionParameterf( GLenum(target), GLenum(pname), GLfloat(params) ) -> None` glConvolutionParameterfv(...) `glConvolutionParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None` glConvolutionParameteri(...) `glConvolutionParameteri( GLenum(target), GLenum(pname), GLint(params) ) -> None` glConvolutionParameteriv(...) `glConvolutionParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None` glCopyColorSubTable(...) `glCopyColorSubTable( GLenum(target), GLsizei(start), GLint(x), GLint(y), GLsizei(width) ) -> None` glCopyColorTable(...) `glCopyColorTable( GLenum(target), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width) ) -> None` glCopyConvolutionFilter1D(...) `glCopyConvolutionFilter1D( GLenum(target), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width) ) -> None` glCopyConvolutionFilter2D(...) `glCopyConvolutionFilter2D( GLenum(target), GLenum(internalformat), GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None` glCopyPixels(...) `glCopyPixels( GLint(x), GLint(y), GLsizei(width), GLsizei(height), GLenum(type) ) -> None` glCopyTexImage1D(...) `glCopyTexImage1D( GLenum(target), GLint(level), GLenum(internalFormat), GLint(x), GLint(y), GLsizei(width), GLint(border) ) -> None` glCopyTexImage2D(...) `glCopyTexImage2D( GLenum(target), GLint(level), GLenum(internalFormat), GLint(x), GLint(y), GLsizei(width), GLsizei(height), GLint(border) ) -> None` glCopyTexSubImage1D(...) `glCopyTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLint(x), GLint(y), GLsizei(width) ) -> None` glCopyTexSubImage2D(...) `glCopyTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None` glCopyTexSubImage3D(...) `glCopyTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None` glCreateProgram(...) `glCreateProgram( ) -> constants.GLuint` glCreateShader(...) `glCreateShader( GLenum(type) ) -> constants.GLuint` glCullFace(...) `glCullFace( GLenum(mode) ) -> None` glDeleteBuffers(...) `glDeleteBuffers( GLsizei(n), GLuintArray(buffers) ) -> None` glDeleteLists(...) `glDeleteLists( GLuint(list), GLsizei(range) ) -> None` glDeleteProgram(...) `glDeleteProgram( GLuint(program) ) -> None` glDeleteQueries(...) `glDeleteQueries( GLsizei(n), GLuintArray(ids) ) -> None` glDeleteShader(...) `glDeleteShader( GLuint(shader) ) -> None` glDepthFunc(...) `glDepthFunc( GLenum(func) ) -> None` glDepthMask(...) `glDepthMask( GLboolean(flag) ) -> None` glDepthRange(...) `glDepthRange( GLclampd(zNear), GLclampd(zFar) ) -> None` glDetachShader(...) `glDetachShader( GLuint(program), GLuint(shader) ) -> None` glDisable(...) `glDisable( GLenum(cap) ) -> None` glDisableClientState(...) `glDisableClientState( GLenum(array) ) -> None` glDisableVertexAttribArray(...) `glDisableVertexAttribArray( GLuint(index) ) -> None` glDrawArrays(...) `glDrawArrays( GLenum(mode), GLint(first), GLsizei(count) ) -> None` glDrawBuffer(...) `glDrawBuffer( GLenum(mode) ) -> None` glDrawBuffers(...) `glDrawBuffers( GLsizei(n), GLuintArray(bufs) ) -> None` glDrawElements( mode,count,type,indices ) pyConverters: mode=None, count=None, type=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x2aaab28e7d50> cConverters: Not Used cResolvers: mode=None, count=None, type=None, indices= voidDataPointer(*args, **named) method of type instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: Not Used returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e9910>
>     Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
> glDrawElements( mode,indices ) pyConverters: mode=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayTyped object at 0x2aaab28e7e90> cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object at 0x2aaab28e7e50>, type=GL_UNSIGNED_BYTE, indices=None cResolvers: mode=None, count=None, type=None, indices= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: Not Used returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e9a50>
>     Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
> glDrawElements( mode,indices ) pyConverters: mode=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayTyped object at 0x2aaab28e7f90> cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object at 0x2aaab28e7f50>, type=GL_UNSIGNED_INT, indices=None cResolvers: mode=None, count=None, type=None, indices= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: Not Used returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e9b40>
>     Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
> glDrawElements( mode,indices ) pyConverters: mode=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayTyped object at 0x2aaab28eb0d0> cConverters: mode=None, count=<OpenGL.arrays.arrayhelpers.AsArrayTypedSize object at 0x2aaab28eb090>, type=GL_UNSIGNED_SHORT, indices=None cResolvers: mode=None, count=None, type=None, indices= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: Not Used returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e9c30>
>     Wrapping Operation: glDrawElements( GLenum(mode), GLsizei(count), GLenum(type), POINTER(GLvoid)(indices) ) -> None
> glDrawPixels( width,height,format,type,pixels ) pyConverters: width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab292ae90> cConverters: Not Used cResolvers: width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glDrawPixels( format,pixels ) pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935650> cConverters: width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glDrawPixels( format,pixels ) pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935a10> cConverters: width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glDrawPixels( format,pixels ) pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935dd0> cConverters: width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glDrawPixels( format,pixels ) pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b1d0> cConverters: width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glDrawPixels( format,pixels ) pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b610> cConverters: width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glDrawPixels( format,pixels ) pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293ba50> cConverters: width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glDrawPixels( format,pixels ) pyConverters: format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293be90> cConverters: width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glDrawPixels( GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glDrawRangeElements( mode,start,end,count,type,indices ) pyConverters: mode=None, start=None, end=None, count=None, type=None, indices=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x2aaab295ad50> cConverters: Not Used cResolvers: mode=None, start=None, end=None, count=None, type=None, indices= voidDataPointer(*args, **named) method of type instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: Not Used returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab295c9b0>
>     Wrapping Operation: glDrawRangeElements( GLenum(mode), GLuint(start), GLuint(end), GLsizei(count), GLenum(type), c_void_p(indices) ) -> None
> glEdgeFlag(...) `glEdgeFlag( GLboolean(flag) ) -> None` glEdgeFlagPointer( stride,pointer ) pyConverters: stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayTyped object at 0x2aaab28e7a90> cConverters: Not Used cResolvers: stride=None, pointer= voidDataPointer(*args, **named) method of type instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e7ad0> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e9690>
>     Wrapping Operation: glEdgeFlagPointer( GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glEdgeFlagPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0090> cConverters: stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28dcf50> cResolvers: stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0150> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e3050>
>     Wrapping Operation: glEdgeFlagPointer( GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glEdgeFlagv( flag ) pyConverters: flag= asArraySize(incoming, function, args) cConverters: flag=<OpenGL.converters.getPyArgsName object at 0x2aaab2944af0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glEdgeFlagv( POINTER(GLboolean)(flag) ) -> None
> glEnable(...) `glEnable( GLenum(cap) ) -> None` glEnableClientState(...) `glEnableClientState( GLenum(array) ) -> None` glEnableVertexAttribArray(...) `glEnableVertexAttribArray( GLuint(index) ) -> None` glEndList(...) `glEndList( ) -> None` glEndQuery(...) `glEndQuery( GLenum(target) ) -> None` glEvalCoord1d(...) `glEvalCoord1d( GLdouble(u) ) -> None` glEvalCoord1dv( u ) pyConverters: u= asArraySize(incoming, function, args) cConverters: u=<OpenGL.converters.getPyArgsName object at 0x2aaab28bcaa0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glEvalCoord1dv( arrays.GLdoubleArray(u) ) -> None
> glEvalCoord1f(...) `glEvalCoord1f( GLfloat(u) ) -> None` glEvalCoord1fv( u ) pyConverters: u= asArraySize(incoming, function, args) cConverters: u=<OpenGL.converters.getPyArgsName object at 0x2aaab28bcb90> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glEvalCoord1fv( arrays.GLfloatArray(u) ) -> None
> glEvalCoord2d(...) `glEvalCoord2d( GLdouble(u), GLdouble(v) ) -> None` glEvalCoord2dv( u ) pyConverters: u= asArraySize(incoming, function, args) cConverters: u=<OpenGL.converters.getPyArgsName object at 0x2aaab28bcc80> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glEvalCoord2dv( arrays.GLdoubleArray(u) ) -> None
> glEvalCoord2f(...) `glEvalCoord2f( GLfloat(u), GLfloat(v) ) -> None` glEvalCoord2fv( u ) pyConverters: u= asArraySize(incoming, function, args) cConverters: u=<OpenGL.converters.getPyArgsName object at 0x2aaab28bcd70> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glEvalCoord2fv( arrays.GLfloatArray(u) ) -> None
> glEvalMesh1(...) `glEvalMesh1( GLenum(mode), GLint(i1), GLint(i2) ) -> None` glEvalMesh2(...) `glEvalMesh2( GLenum(mode), GLint(i1), GLint(i2), GLint(j1), GLint(j2) ) -> None` glEvalPoint1(...) `glEvalPoint1( GLint(i) ) -> None` glEvalPoint2(...) `glEvalPoint2( GLint(i), GLint(j) ) -> None` glFinish(...) `glFinish( ) -> None` glFlush(...) `glFlush( ) -> None` glFogCoordPointer(...) `glFogCoordPointer( GLenum(type), GLsizei(stride), c_void_p(pointer) ) -> None` glFogCoordd(...) `glFogCoordd( GLdouble(coord) ) -> None` glFogCoorddv(...) `glFogCoorddv( GLdoubleArray(coord) ) -> None` glFogCoordf(...) `glFogCoordf( GLfloat(coord) ) -> None` glFogCoordfv(...) `glFogCoordfv( GLfloatArray(coord) ) -> None` glFogf(...) `glFogf( GLenum(pname), GLfloat(param) ) -> None` glFogfv( pname,params ) pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284c4d0> cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28bcf00> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glFogfv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glFogi(...) `glFogi( GLenum(pname), GLint(param) ) -> None` glFogiv( pname,params ) pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284c550> cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28bcfa0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glFogiv( GLenum(pname), arrays.GLintArray(params) ) -> None
> glFrontFace(...) `glFrontFace( GLenum(mode) ) -> None` glFrustum(...) `glFrustum( GLdouble(left), GLdouble(right), GLdouble(bottom), GLdouble(top), GLdouble(zNear), GLdouble(zFar) ) -> None` glGenBuffers(...) `glGenBuffers( GLsizei(n), GLuintArray(buffers) ) -> None` glGenLists(...) `glGenLists( GLsizei(range) ) -> GLuint` glGenQueries(...) `glGenQueries( GLsizei(n), GLuintArray(ids) ) -> None` glGetActiveAttrib(...) `glGetActiveAttrib( GLuint(program), GLuint(index), GLsizei(bufSize), GLsizeiArray(length), GLintArray(size), GLuintArray(type), GLcharArray(name) ) -> None` glGetAttachedShaders(...) `glGetAttachedShaders( GLuint(program), GLsizei(maxCount), GLsizeiArray(count), GLuintArray(obj) ) -> None` glGetAttribLocation(...) `glGetAttribLocation( GLuint(program), GLcharArray(name) ) -> constants.GLint` glGetIntegerv( pname ) pyConverters: pname=None cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1938> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetIntegerv( pname ) pyConverters: pname=None cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1938> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetBufferParameteriv(...) `glGetBufferParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None` glGetBufferPointerv(...) `glGetBufferPointerv( GLenum(target), GLenum(pname), POINTER(ctypes.c_void_p)(params) ) -> None` glGetBufferSubData(...) `glGetBufferSubData( GLenum(target), GLintptr(offset), GLsizeiptr(size), c_void_p(data) ) -> None` glGetClipPlane( plane,equation ) pyConverters: plane=None, equation=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284c5d0> cConverters: plane=None, equation=<OpenGL.converters.getPyArgsName object at 0x2aaab28c1140> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glGetClipPlane( GLenum(plane), arrays.GLdoubleArray(equation) ) -> None
> glGetColorTableParameterfv( target,pname ) pyConverters: target=None, pname=None cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab29559b0> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetColorTableParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
> glGetColorTableParameteriv( target,pname ) pyConverters: target=None, pname=None cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab2955a28> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetColorTableParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
> glGetConvolutionParameterfv( target,pname ) pyConverters: target=None, pname=None cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab2955b18> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetConvolutionParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
> glGetConvolutionParameteriv( target,pname ) pyConverters: target=None, pname=None cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab2955aa0> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetConvolutionParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
> glGetDoublev( pname ) pyConverters: pname=None cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1848> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetDoublev( GLenum(pname), arrays.GLdoubleArray(params) ) -> None
> glGetDoublev( pname ) pyConverters: pname=None cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1848> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetDoublev( GLenum(pname), arrays.GLdoubleArray(params) ) -> None
> glGetError(...) `glGetError( ) -> GLenum` glGetFloatv( pname ) pyConverters: pname=None cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e18c0> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetFloatv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glGetFloatv( pname ) pyConverters: pname=None cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e18c0> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetFloatv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glGetHistogramParameterfv( target,pname ) pyConverters: target=None, pname=None cConverters: target=None, pname=None, params=<OpenGL.converters.Output object at 0x2aaab2937c58> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetHistogramParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None
> glGetHistogramParameteriv( target,pname ) pyConverters: target=None, pname=None cConverters: target=None, pname=None, params=<OpenGL.converters.Output object at 0x2aaab2937ba8> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetHistogramParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None
> glGetIntegerv( pname ) pyConverters: pname=None cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1938> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetIntegerv( pname ) pyConverters: pname=None cConverters: pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1938> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetIntegerv( GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetLightfv( light,pname ) pyConverters: light=None, pname=None cConverters: light=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e19b0> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glGetLightiv( light,pname ) pyConverters: light=None, pname=None cConverters: light=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1a28> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetLightiv( GLenum(light), GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetMapdv( target,query,v ) pyConverters: target=None, query=None, v=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284c750> cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab28c15a0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glGetMapdv( GLenum(target), GLenum(query), arrays.GLdoubleArray(v) ) -> None
> glGetMapfv( target,query,v ) pyConverters: target=None, query=None, v=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284c790> cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab28c1690> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glGetMapfv( GLenum(target), GLenum(query), arrays.GLfloatArray(v) ) -> None
> glGetMapiv( target,query,v ) pyConverters: target=None, query=None, v=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284c7d0> cConverters: target=None, query=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab28c1780> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glGetMapiv( GLenum(target), GLenum(query), arrays.GLintArray(v) ) -> None
> glGetMaterialfv( face,pname ) pyConverters: face=None, pname=None cConverters: face=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1aa0> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetMaterialfv( GLenum(face), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glGetMaterialiv( face,pname ) pyConverters: face=None, pname=None cConverters: face=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1b18> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetMaterialiv( GLenum(face), GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetMinmaxParameterfv(...) `glGetMinmaxParameterfv( GLenum(target), GLenum(pname), GLfloatArray(params) ) -> None` glGetMinmaxParameteriv(...) `glGetMinmaxParameteriv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None` glGetPixelMapfv( map ) pyConverters: map=None cConverters: map=None, values=<OpenGL.converters.SizedOutput object at 0x2aaab28e1c08> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetPixelMapfv( GLenum(map), arrays.GLfloatArray(values) ) -> None
> glGetPixelMapuiv( map ) pyConverters: map=None cConverters: map=None, values=<OpenGL.converters.SizedOutput object at 0x2aaab28e1c80> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetPixelMapuiv( GLenum(map), arrays.GLuintArray(values) ) -> None
> glGetPixelMapusv( map ) pyConverters: map=None cConverters: map=None, values=<OpenGL.converters.SizedOutput object at 0x2aaab28e1cf8> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetPixelMapusv( GLenum(map), arrays.GLushortArray(values) ) -> None
> glGetPolygonStipple( ) pyConverters: cConverters: mask=<OpenGL.converters.Output object at 0x2aaab2927260> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetPolygonStipple( arrays.GLubyteArray(mask) ) -> None
> glGetPolygonStipple( ) pyConverters: cConverters: mask=<OpenGL.converters.Output object at 0x2aaab2927260> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetPolygonStipple( arrays.GLubyteArray(mask) ) -> None
> glGetProgramInfoLog(...) `glGetProgramInfoLog( GLuint(program), GLsizei(bufSize), GLsizeiArray(length), GLcharArray(infoLog) ) -> None` glGetProgramiv(...) `glGetProgramiv( GLuint(program), GLenum(pname), GLintArray(params) ) -> None` glGetQueryObjectiv(...) `glGetQueryObjectiv( GLuint(id), GLenum(pname), GLintArray(params) ) -> None` glGetQueryObjectuiv(...) `glGetQueryObjectuiv( GLuint(id), GLenum(pname), GLuintArray(params) ) -> None` glGetQueryiv(...) `glGetQueryiv( GLenum(target), GLenum(pname), GLintArray(params) ) -> None` glGetShaderInfoLog(...) `glGetShaderInfoLog( GLuint(shader), GLsizei(bufSize), GLsizeiArray(length), GLcharArray(infoLog) ) -> None` glGetShaderiv(...) `glGetShaderiv( GLuint(shader), GLenum(pname), GLintArray(params) ) -> None` glGetString(...) `glGetString( constant ) -> Current string value` glGetTexEnvfv( target,pname ) pyConverters: target=None, pname=None cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1d70> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetTexEnvfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glGetTexEnviv( target,pname ) pyConverters: target=None, pname=None cConverters: target=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1de8> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetTexEnviv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetTexGendv( coord,pname ) pyConverters: coord=None, pname=None cConverters: coord=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1e60> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetTexGendv( GLenum(coord), GLenum(pname), arrays.GLdoubleArray(params) ) -> None
> glGetTexGenfv( coord,pname ) pyConverters: coord=None, pname=None cConverters: coord=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1ed8> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetTexGenfv( GLenum(coord), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glGetTexGeniv( coord,pname ) pyConverters: coord=None, pname=None cConverters: coord=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab28e1f50> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetTexGeniv( GLenum(coord), GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetTexLevelParameterfv( target,level,pname ) pyConverters: target=None, level=None, pname=None cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.Output object at 0x2aaab2927680> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetTexLevelParameterfv( GLenum(target), GLint(level), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glGetTexLevelParameteriv( target,level,pname ) pyConverters: target=None, level=None, pname=None cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.Output object at 0x2aaab2927730> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of Output instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetTexLevelParameteriv( GLenum(target), GLint(level), GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetTexLevelParameterfv( target,level,pname ) pyConverters: target=None, level=None, pname=None cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab2929050> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetTexLevelParameterfv( GLenum(target), GLint(level), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glGetTexLevelParameteriv( target,level,pname ) pyConverters: target=None, level=None, pname=None cConverters: target=None, level=None, pname=None, params=<OpenGL.converters.SizedOutput object at 0x2aaab29290c8> cResolvers: Not Used storeValues: Not Used returnValues: oldStyleReturn(self, result, baseOperation, pyArgs, cArgs) method of SizedOutput instance `Retrieve cArgs[ self.index ]`
>     Wrapping Operation: glGetTexLevelParameteriv( GLenum(target), GLint(level), GLenum(pname), arrays.GLintArray(params) ) -> None
> glGetUniformLocation(...) `glGetUniformLocation( GLuint(program), GLcharArray(name) ) -> constants.GLint` glGetUniformfv(...) `glGetUniformfv( GLuint(program), GLint(location), GLfloatArray(params) ) -> None` glGetUniformiv(...) `glGetUniformiv( GLuint(program), GLint(location), GLintArray(params) ) -> None` glGetVertexAttribPointerv(...) `glGetVertexAttribPointerv( GLuint(index), GLenum(pname), POINTER(ctypes.c_void_p)(pointer) ) -> None` glGetVertexAttribdv(...) `glGetVertexAttribdv( GLuint(index), GLenum(pname), GLdoubleArray(params) ) -> None` glGetVertexAttribfv(...) `glGetVertexAttribfv( GLuint(index), GLenum(pname), GLfloatArray(params) ) -> None` glGetVertexAttribiv(...) `glGetVertexAttribiv( GLuint(index), GLenum(pname), GLintArray(params) ) -> None` glHint(...) `glHint( GLenum(target), GLenum(mode) ) -> None` glHistogram(...) `glHistogram( GLenum(target), GLsizei(width), GLenum(internalformat), GLboolean(sink) ) -> None` glIndexMask(...) `glIndexMask( GLuint(mask) ) -> None` glIndexPointer( type,stride,pointer ) pyConverters: type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x2aaab28e7990> cConverters: Not Used cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of type instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e79d0> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e95a0>
>     Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glIndexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0690> cConverters: type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e3910> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0750> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e39b0>
>     Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glIndexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0190> cConverters: type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e3140> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0250> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e31e0>
>     Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glIndexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0290> cConverters: type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e32d0> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0350> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e3370>
>     Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glIndexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0390> cConverters: type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e3460> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0450> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e3500>
>     Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glIndexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0590> cConverters: type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e3780> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0650> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e3820>
>     Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glIndexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0490> cConverters: type=GL_UNSIGNED_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e35f0> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0550> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e3690>
>     Wrapping Operation: glIndexPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glIndexd(...) `glIndexd( GLdouble(c) ) -> None` glIndexdv( c ) pyConverters: c= asArraySize(incoming, function, args) cConverters: c=<OpenGL.converters.getPyArgsName object at 0x2aaab2944640> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexdv( arrays.GLdoubleArray(c) ) -> None
> glIndexf(...) `glIndexf( GLfloat(c) ) -> None` glIndexfv( c ) pyConverters: c= asArraySize(incoming, function, args) cConverters: c=<OpenGL.converters.getPyArgsName object at 0x2aaab29447d0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexfv( arrays.GLfloatArray(c) ) -> None
> glIndexi(...) `glIndexi( GLint(c) ) -> None` glIndexiv( c ) pyConverters: c=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284cc90> cConverters: c=<OpenGL.converters.getPyArgsName object at 0x2aaab28c5320> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexiv( arrays.GLintArray(c) ) -> None
> glIndexs(...) `glIndexs( GLshort(c) ) -> None` glIndexsv( c ) pyConverters: c= asArraySize(incoming, function, args) cConverters: c=<OpenGL.converters.getPyArgsName object at 0x2aaab2944500> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexsv( arrays.GLshortArray(c) ) -> None
> glIndexub(...) `glIndexub( GLubyte(c) ) -> None` glIndexubv( c ) pyConverters: c= asArraySize(incoming, function, args) cConverters: c=<OpenGL.converters.getPyArgsName object at 0x2aaab2944960> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glIndexubv( arrays.GLubyteArray(c) ) -> None
> glInitNames(...) `glInitNames( ) -> None` glInterleavedArrays = <OpenGL.wrapper.glInterleavedArrays object at 0x2aaab28e8f80> glIsBuffer(...) `glIsBuffer( GLuint(buffer) ) -> constants.GLboolean` glIsEnabled(...) `glIsEnabled( GLenum(cap) ) -> GLboolean` glIsList(...) `glIsList( GLuint(list) ) -> GLboolean` glIsProgram(...) `glIsProgram( GLuint(program) ) -> constants.GLboolean` glIsQuery(...) `glIsQuery( GLuint(id) ) -> constants.GLboolean` glIsShader(...) `glIsShader( GLuint(shader) ) -> constants.GLboolean` glIsTexture(...) `glIsTexture( GLuint(texture) ) -> GLboolean` glLightfv( light,pname,params ) pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284cdd0> cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28c5690> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glLightModelf(...) `glLightModelf( GLenum(pname), GLfloat(param) ) -> None` glLightModelfv( pname,params ) pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284cd50> cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28c5500> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLightModelfv( GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glLightModeli(...) `glLightModeli( GLenum(pname), GLint(param) ) -> None` glLightModeliv( pname,params ) pyConverters: pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284cd90> cConverters: pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28c55a0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLightModeliv( GLenum(pname), arrays.GLintArray(params) ) -> None
> glLightf(...) `glLightf( GLenum(light), GLenum(pname), GLfloat(param) ) -> None` glLightfv( light,pname,params ) pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284cdd0> cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28c5690> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLightfv( GLenum(light), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glLighti(...) `glLighti( GLenum(light), GLenum(pname), GLint(param) ) -> None` glLightiv( light,pname,params ) pyConverters: light=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284ce10> cConverters: light=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28c5780> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLightiv( GLenum(light), GLenum(pname), arrays.GLintArray(params) ) -> None
> glLineStipple(...) `glLineStipple( GLint(factor), GLushort(pattern) ) -> None` glLineWidth(...) `glLineWidth( GLfloat(width) ) -> None` glLinkProgram(...) `glLinkProgram( GLuint(program) ) -> None` glListBase(...) `glListBase( GLuint(base) ) -> None` glLoadIdentity(...) `glLoadIdentity( ) -> None` glLoadMatrixd( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object at 0x2aaab28c5870> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLoadMatrixd( arrays.GLdoubleArray(m) ) -> None
> glLoadMatrixf( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object at 0x2aaab28c5a00> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLoadMatrixf( arrays.GLfloatArray(m) ) -> None
> glLoadName(...) `glLoadName( GLuint(name) ) -> None` glLoadTransposeMatrixd( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object at 0x2aaab2973780> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLoadTransposeMatrixd( GLdoubleArray(m) ) -> None
> glLoadTransposeMatrixf( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object at 0x2aaab2973aa0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glLoadTransposeMatrixf( GLfloatArray(m) ) -> None
> glLogicOp(...) `glLogicOp( GLenum(opcode) ) -> None` glMapBuffer(...) `glMapBuffer( GLenum(target), GLenum(access) ) -> ctypes.c_void_p` glMapGrid1d(...) `glMapGrid1d( GLint(un), GLdouble(u1), GLdouble(u2) ) -> None` glMapGrid1f(...) `glMapGrid1f( GLint(un), GLfloat(u1), GLfloat(u2) ) -> None` glMapGrid2d(...) `glMapGrid2d( GLint(un), GLdouble(u1), GLdouble(u2), GLint(vn), GLdouble(v1), GLdouble(v2) ) -> None` glMapGrid2f(...) `glMapGrid2f( GLint(un), GLfloat(u1), GLfloat(u2), GLint(vn), GLfloat(v1), GLfloat(v2) ) -> None` glMaterialf(...) `glMaterialf( GLenum(face), GLenum(pname), GLfloat(param) ) -> None` glMaterialfv( face,pname,params ) pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284cf50> cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28c5f00> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMaterialfv( GLenum(face), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glMateriali(...) `glMateriali( GLenum(face), GLenum(pname), GLint(param) ) -> None` glMaterialiv( face,pname,params ) pyConverters: face=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab284cf90> cConverters: face=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28c90a0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMaterialiv( GLenum(face), GLenum(pname), arrays.GLintArray(params) ) -> None
> glMatrixMode(...) `glMatrixMode( GLenum(mode) ) -> None` glMinmax(...) `glMinmax( GLenum(target), GLenum(internalformat), GLboolean(sink) ) -> None` glMultMatrixd( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object at 0x2aaab28c91e0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultMatrixd( arrays.GLdoubleArray(m) ) -> None
> glMultMatrixf( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object at 0x2aaab28c9370> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultMatrixf( arrays.GLfloatArray(m) ) -> None
> glMultTransposeMatrixd( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object at 0x2aaab2973910> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultTransposeMatrixd( GLdoubleArray(m) ) -> None
> glMultTransposeMatrixf( m ) pyConverters: m= asArraySize(incoming, function, args) cConverters: m=<OpenGL.converters.getPyArgsName object at 0x2aaab2973c30> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultTransposeMatrixf( GLfloatArray(m) ) -> None
> glMultiDrawArrays(...) `glMultiDrawArrays( GLenum(mode), GLintArray(first), GLsizeiArray(count), GLsizei(primcount) ) -> None` glMultiDrawElements(...) `glMultiDrawElements( GLenum(mode), GLsizeiArray(count), GLenum(type), POINTER(ctypes.c_void_p)(indices), GLsizei(primcount) ) -> None` glMultiTexCoord1d(...) `glMultiTexCoord1d( GLenum(target), GLdouble(s) ) -> None` glMultiTexCoord1dv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2963dc0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1dv( GLenum(target), GLdoubleArray(v) ) -> None
> glMultiTexCoord1f(...) `glMultiTexCoord1f( GLenum(target), GLfloat(s) ) -> None` glMultiTexCoord1fv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2970460> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1fv( GLenum(target), GLfloatArray(v) ) -> None
> glMultiTexCoord1i(...) `glMultiTexCoord1i( GLenum(target), GLint(s) ) -> None` glMultiTexCoord1iv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2970aa0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1iv( GLenum(target), GLintArray(v) ) -> None
> glMultiTexCoord1s(...) `glMultiTexCoord1s( GLenum(target), GLshort(s) ) -> None` glMultiTexCoord1sv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2973140> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord1sv( GLenum(target), GLshortArray(v) ) -> None
> glMultiTexCoord2d(...) `glMultiTexCoord2d( GLenum(target), GLdouble(s), GLdouble(t) ) -> None` glMultiTexCoord2dv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2963f50> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2dv( GLenum(target), GLdoubleArray(v) ) -> None
> glMultiTexCoord2f(...) `glMultiTexCoord2f( GLenum(target), GLfloat(s), GLfloat(t) ) -> None` glMultiTexCoord2fv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab29705f0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2fv( GLenum(target), GLfloatArray(v) ) -> None
> glMultiTexCoord2i(...) `glMultiTexCoord2i( GLenum(target), GLint(s), GLint(t) ) -> None` glMultiTexCoord2iv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2970c30> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2iv( GLenum(target), GLintArray(v) ) -> None
> glMultiTexCoord2s(...) `glMultiTexCoord2s( GLenum(target), GLshort(s), GLshort(t) ) -> None` glMultiTexCoord2sv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab29732d0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord2sv( GLenum(target), GLshortArray(v) ) -> None
> glMultiTexCoord3d(...) `glMultiTexCoord3d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r) ) -> None` glMultiTexCoord3dv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2970140> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3dv( GLenum(target), GLdoubleArray(v) ) -> None
> glMultiTexCoord3f(...) `glMultiTexCoord3f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r) ) -> None` glMultiTexCoord3fv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2970780> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3fv( GLenum(target), GLfloatArray(v) ) -> None
> glMultiTexCoord3i(...) `glMultiTexCoord3i( GLenum(target), GLint(s), GLint(t), GLint(r) ) -> None` glMultiTexCoord3iv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2970dc0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3iv( GLenum(target), GLintArray(v) ) -> None
> glMultiTexCoord3s(...) `glMultiTexCoord3s( GLenum(target), GLshort(s), GLshort(t), GLshort(r) ) -> None` glMultiTexCoord3sv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2973460> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord3sv( GLenum(target), GLshortArray(v) ) -> None
> glMultiTexCoord4d(...) `glMultiTexCoord4d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r), GLdouble(q) ) -> None` glMultiTexCoord4dv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab29702d0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4dv( GLenum(target), GLdoubleArray(v) ) -> None
> glMultiTexCoord4f(...) `glMultiTexCoord4f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r), GLfloat(q) ) -> None` glMultiTexCoord4fv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2970910> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4fv( GLenum(target), GLfloatArray(v) ) -> None
> glMultiTexCoord4i(...) `glMultiTexCoord4i( GLenum(target), GLint(s), GLint(t), GLint(r), GLint(q) ) -> None` glMultiTexCoord4iv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab2970f50> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4iv( GLenum(target), GLintArray(v) ) -> None
> glMultiTexCoord4s(...) `glMultiTexCoord4s( GLenum(target), GLshort(s), GLshort(t), GLshort(r), GLshort(q) ) -> None` glMultiTexCoord4sv( target,v ) pyConverters: target=None, v= asArraySize(incoming, function, args) cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x2aaab29735f0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glMultiTexCoord4sv( GLenum(target), GLshortArray(v) ) -> None
> glNewList(...) `glNewList( GLuint(list), GLenum(mode) ) -> None` glNormal = glNormal3d(...) `glNormal3d( GLdouble(nx), GLdouble(ny), GLdouble(nz) ) -> None` glNormal3b(...) `glNormal3b( GLbyte(nx), GLbyte(ny), GLbyte(nz) ) -> None` glNormal3bv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28c9500> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3bv( arrays.GLbyteArray(v) ) -> None
> glNormal3d(...) `glNormal3d( GLdouble(nx), GLdouble(ny), GLdouble(nz) ) -> None` glNormal3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28c9690> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3dv( arrays.GLdoubleArray(v) ) -> None
> glNormal3f(...) `glNormal3f( GLfloat(nx), GLfloat(ny), GLfloat(nz) ) -> None` glNormal3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28c9820> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3fv( arrays.GLfloatArray(v) ) -> None
> glNormal3i(...) `glNormal3i( GLint(nx), GLint(ny), GLint(nz) ) -> None` glNormal3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28c99b0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3iv( arrays.GLintArray(v) ) -> None
> glNormal3s(...) `glNormal3s( GLshort(nx), GLshort(ny), GLshort(nz) ) -> None` glNormal3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28c9b40> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glNormal3sv( arrays.GLshortArray(v) ) -> None
> glNormalPointer( type,stride,pointer ) pyConverters: type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x2aaab28e7890> cConverters: Not Used cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of type instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e78d0> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e94b0>
>     Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glNormalPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0a90> cConverters: type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e3f50> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0b50> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e6050>
>     Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glNormalPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0790> cConverters: type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e3aa0> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0850> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e3b40>
>     Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glNormalPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0890> cConverters: type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e3c30> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0950> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e3cd0>
>     Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glNormalPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0990> cConverters: type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e3dc0> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0a50> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e3e60>
>     Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glNormalPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0b90> cConverters: type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e6140> cResolvers: type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0c50> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e61e0>
>     Wrapping Operation: glNormalPointer( GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glOrtho(...) `glOrtho( GLdouble(left), GLdouble(right), GLdouble(bottom), GLdouble(top), GLdouble(zNear), GLdouble(zFar) ) -> None` glPassThrough(...) `glPassThrough( GLfloat(token) ) -> None` glPixelMapfv( map,mapsize,values ) pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28ca110> cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x2aaab28c9c80> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPixelMapfv( GLenum(map), GLsizei(mapsize), arrays.GLfloatArray(values) ) -> None
> glPixelMapuiv( map,mapsize,values ) pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28ca1d0> cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x2aaab28c9d70> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPixelMapuiv( GLenum(map), GLsizei(mapsize), arrays.GLuintArray(values) ) -> None
> glPixelMapusv( map,mapsize,values ) pyConverters: map=None, mapsize=None, values=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28ca290> cConverters: map=None, mapsize=None, values=<OpenGL.converters.getPyArgsName object at 0x2aaab28c9e60> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPixelMapusv( GLenum(map), GLsizei(mapsize), arrays.GLushortArray(values) ) -> None
> glPixelStoref(...) `glPixelStoref( GLenum(pname), GLfloat(param) ) -> None` glPixelStorei(...) `glPixelStorei( GLenum(pname), GLint(param) ) -> None` glPixelTransferf(...) `glPixelTransferf( GLenum(pname), GLfloat(param) ) -> None` glPixelTransferi(...) `glPixelTransferi( GLenum(pname), GLint(param) ) -> None` glPixelZoom(...) `glPixelZoom( GLfloat(xfactor), GLfloat(yfactor) ) -> None` glPointParameterf(...) `glPointParameterf( GLenum(pname), GLfloat(param) ) -> None` glPointParameterfv(...) `glPointParameterfv( GLenum(pname), GLfloatArray(params) ) -> None` glPointParameteri(...) `glPointParameteri( GLenum(pname), GLint(param) ) -> None` glPointParameteriv(...) `glPointParameteriv( GLenum(pname), GLintArray(params) ) -> None` glPointSize(...) `glPointSize( GLfloat(size) ) -> None` glPolygonMode(...) `glPolygonMode( GLenum(face), GLenum(mode) ) -> None` glPolygonOffset(...) `glPolygonOffset( GLfloat(factor), GLfloat(units) ) -> None` glPolygonStipple( mask ) pyConverters: mask=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28ca350> cConverters: mask=<OpenGL.converters.getPyArgsName object at 0x2aaab28c9f50> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPolygonStipple( arrays.GLubyteArray(mask) ) -> None
> glPopAttrib(...) `glPopAttrib( ) -> None` glPopClientAttrib(...) `glPopClientAttrib( ) -> None` glPopMatrix(...) `glPopMatrix( ) -> None` glPopName(...) `glPopName( ) -> None` glPrioritizeTextures( n,textures,priorities ) pyConverters: n=None, textures=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28ca410>, priorities=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28ca4d0> cConverters: n=None, textures=<OpenGL.converters.getPyArgsName object at 0x2aaab28cc0a0>, priorities=<OpenGL.converters.getPyArgsName object at 0x2aaab28cc140> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glPrioritizeTextures( GLsizei(n), arrays.GLuintArray(textures), arrays.GLclampfArray(priorities) ) -> None
> glPushAttrib(...) `glPushAttrib( GLbitfield(mask) ) -> None` glPushClientAttrib(...) `glPushClientAttrib( GLbitfield(mask) ) -> None` glPushMatrix(...) `glPushMatrix( ) -> None` glPushName(...) `glPushName( GLuint(name) ) -> None` glRasterPos2d(...) `glRasterPos2d( GLdouble(x), GLdouble(y) ) -> None` glRasterPos2dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cc280> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos2dv( arrays.GLdoubleArray(v) ) -> None
> glRasterPos2f(...) `glRasterPos2f( GLfloat(x), GLfloat(y) ) -> None` glRasterPos2fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cc410> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos2fv( arrays.GLfloatArray(v) ) -> None
> glRasterPos2i(...) `glRasterPos2i( GLint(x), GLint(y) ) -> None` glRasterPos2iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cc5a0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos2iv( arrays.GLintArray(v) ) -> None
> glRasterPos2s(...) `glRasterPos2s( GLshort(x), GLshort(y) ) -> None` glRasterPos2sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cc730> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos2sv( arrays.GLshortArray(v) ) -> None
> glRasterPos3d(...) `glRasterPos3d( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glRasterPos3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cc8c0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos3dv( arrays.GLdoubleArray(v) ) -> None
> glRasterPos3f(...) `glRasterPos3f( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glRasterPos3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cca50> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos3fv( arrays.GLfloatArray(v) ) -> None
> glRasterPos3i(...) `glRasterPos3i( GLint(x), GLint(y), GLint(z) ) -> None` glRasterPos3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28ccbe0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos3iv( arrays.GLintArray(v) ) -> None
> glRasterPos3s(...) `glRasterPos3s( GLshort(x), GLshort(y), GLshort(z) ) -> None` glRasterPos3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28ccd70> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos3sv( arrays.GLshortArray(v) ) -> None
> glRasterPos4d(...) `glRasterPos4d( GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None` glRasterPos4dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28ccf00> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos4dv( arrays.GLdoubleArray(v) ) -> None
> glRasterPos4f(...) `glRasterPos4f( GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None` glRasterPos4fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cf0f0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos4fv( arrays.GLfloatArray(v) ) -> None
> glRasterPos4i(...) `glRasterPos4i( GLint(x), GLint(y), GLint(z), GLint(w) ) -> None` glRasterPos4iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cf280> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos4iv( arrays.GLintArray(v) ) -> None
> glRasterPos4s(...) `glRasterPos4s( GLshort(x), GLshort(y), GLshort(z), GLshort(w) ) -> None` glRasterPos4sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cf410> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRasterPos4sv( arrays.GLshortArray(v) ) -> None
> glReadBuffer(...) `glReadBuffer( GLenum(mode) ) -> None` glRectd(...) `glRectd( GLdouble(x1), GLdouble(y1), GLdouble(x2), GLdouble(y2) ) -> None` glRectdv( v1,v2 ) pyConverters: v1=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28cab10>, v2=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28cabd0> cConverters: v1=<OpenGL.converters.getPyArgsName object at 0x2aaab28cf550>, v2=<OpenGL.converters.getPyArgsName object at 0x2aaab28cf5f0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRectdv( arrays.GLdoubleArray(v1), arrays.GLdoubleArray(v2) ) -> None
> glRectf(...) `glRectf( GLfloat(x1), GLfloat(y1), GLfloat(x2), GLfloat(y2) ) -> None` glRectfv( v1,v2 ) pyConverters: v1=None, v2= asArraySize(incoming, function, args) cConverters: v1=None, v2=<OpenGL.converters.getPyArgsName object at 0x2aaab29440a0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRectfv( arrays.GLfloatArray(v1), arrays.GLfloatArray(v2) ) -> None
> glRecti(...) `glRecti( GLint(x1), GLint(y1), GLint(x2), GLint(y2) ) -> None` glRectiv( v1,v2 ) pyConverters: v1=None, v2= asArraySize(incoming, function, args) cConverters: v1=None, v2=<OpenGL.converters.getPyArgsName object at 0x2aaab2944280> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRectiv( arrays.GLintArray(v1), arrays.GLintArray(v2) ) -> None
> glRects(...) `glRects( GLshort(x1), GLshort(y1), GLshort(x2), GLshort(y2) ) -> None` glRectsv( v1,v2 ) pyConverters: v1=None, v2= asArraySize(incoming, function, args) cConverters: v1=None, v2=<OpenGL.converters.getPyArgsName object at 0x2aaab2944460> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glRectsv( arrays.GLshortArray(v1), arrays.GLshortArray(v2) ) -> None
> glResetHistogram(...) `glResetHistogram( GLenum(target) ) -> None` glResetMinmax(...) `glResetMinmax( GLenum(target) ) -> None` glRotate = glRotated(...) `glRotated( GLdouble(angle), GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glRotated(...) `glRotated( GLdouble(angle), GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glRotatef(...) `glRotatef( GLfloat(angle), GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glSampleCoverage(...) `glSampleCoverage( GLclampf(value), GLboolean(invert) ) -> None` glScaled(...) `glScaled( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glScalef(...) `glScalef( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glScissor(...) `glScissor( GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None` glSecondaryColor3b(...) `glSecondaryColor3b( GLbyte(red), GLbyte(green), GLbyte(blue) ) -> None` glSecondaryColor3bv(...) `glSecondaryColor3bv( GLbyteArray(v) ) -> None` glSecondaryColor3d(...) `glSecondaryColor3d( GLdouble(red), GLdouble(green), GLdouble(blue) ) -> None` glSecondaryColor3dv(...) `glSecondaryColor3dv( GLdoubleArray(v) ) -> None` glSecondaryColor3f(...) `glSecondaryColor3f( GLfloat(red), GLfloat(green), GLfloat(blue) ) -> None` glSecondaryColor3fv(...) `glSecondaryColor3fv( GLfloatArray(v) ) -> None` glSecondaryColor3i(...) `glSecondaryColor3i( GLint(red), GLint(green), GLint(blue) ) -> None` glSecondaryColor3iv(...) `glSecondaryColor3iv( GLintArray(v) ) -> None` glSecondaryColor3s(...) `glSecondaryColor3s( GLshort(red), GLshort(green), GLshort(blue) ) -> None` glSecondaryColor3sv(...) `glSecondaryColor3sv( GLshortArray(v) ) -> None` glSecondaryColor3ub(...) `glSecondaryColor3ub( GLubyte(red), GLubyte(green), GLubyte(blue) ) -> None` glSecondaryColor3ubv(...) `glSecondaryColor3ubv( GLubyteArray(v) ) -> None` glSecondaryColor3ui(...) `glSecondaryColor3ui( GLuint(red), GLuint(green), GLuint(blue) ) -> None` glSecondaryColor3uiv(...) `glSecondaryColor3uiv( GLuintArray(v) ) -> None` glSecondaryColor3us(...) `glSecondaryColor3us( GLushort(red), GLushort(green), GLushort(blue) ) -> None` glSecondaryColor3usv(...) `glSecondaryColor3usv( GLushortArray(v) ) -> None` glSecondaryColorPointer(...) `glSecondaryColorPointer( GLint(size), GLenum(type), GLsizei(stride), c_void_p(pointer) ) -> None` glSeparableFilter2D( target,internalformat,width,height,format,type,row,column ) pyConverters: target=None, internalformat=None, width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , format=None, type=None, row=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab295a810>, column=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab295a850> cConverters: Not Used cResolvers: target=None, internalformat=None, width=None, height=None, format=None, type=None, row= cResolver(self, array) method of ImageInputConverter instance , column= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glSeparableFilter2D( GLenum(target), GLenum(internalformat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), c_void_p(row), c_void_p(column) ) -> None
> glShadeModel(...) `glShadeModel( GLenum(mode) ) -> None` glShaderSource( shaderObj,string ) pyConverters: shaderObj=None, string= stringArray(self, arg, baseOperation, args) method of StringLengths instance `Create basic array-of-strings object from pyArg` cConverters: shaderObj=None, count= totalCount(self, pyArgs, index, baseOperation) method of StringLengths instance `Get array of length integers for string contents` , string=None, length=<OpenGL.converters.StringLengths object at 0x2aaab29917d0> cResolvers: shaderObj=None, count=None, string= stringArrayForC(self, strings) method of StringLengths instance `Create a ctypes pointer to char-pointer set` , length=None storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glShaderSource( GLhandle(shaderObj), str( string) ) -> None
> glStencilFunc(...) `glStencilFunc( GLenum(func), GLint(ref), GLuint(mask) ) -> None` glStencilFuncSeparate(...) `glStencilFuncSeparate( GLenum(frontfunc), GLenum(backfunc), GLint(ref), GLuint(mask) ) -> None` glStencilMask(...) `glStencilMask( GLuint(mask) ) -> None` glStencilMaskSeparate(...) `glStencilMaskSeparate( GLenum(face), GLuint(mask) ) -> None` glStencilOp(...) `glStencilOp( GLenum(fail), GLenum(zfail), GLenum(zpass) ) -> None` glStencilOpSeparate(...) `glStencilOpSeparate( GLenum(face), GLenum(sfail), GLenum(dpfail), GLenum(dppass) ) -> None` glTexCoord1d(...) `glTexCoord1d( GLdouble(s) ) -> None` glTexCoord1dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cfcd0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord1dv( arrays.GLdoubleArray(v) ) -> None
> glTexCoord1f(...) `glTexCoord1f( GLfloat(s) ) -> None` glTexCoord1fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28cfe60> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord1fv( arrays.GLfloatArray(v) ) -> None
> glTexCoord1i(...) `glTexCoord1i( GLint(s) ) -> None` glTexCoord1iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d2050> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord1iv( arrays.GLintArray(v) ) -> None
> glTexCoord1s(...) `glTexCoord1s( GLshort(s) ) -> None` glTexCoord1sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d21e0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord1sv( arrays.GLshortArray(v) ) -> None
> glTexCoord2d(...) `glTexCoord2d( GLdouble(s), GLdouble(t) ) -> None` glTexCoord2dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d2370> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord2dv( arrays.GLdoubleArray(v) ) -> None
> glTexCoord2f(...) `glTexCoord2f( GLfloat(s), GLfloat(t) ) -> None` glTexCoord2fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d2500> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord2fv( arrays.GLfloatArray(v) ) -> None
> glTexCoord2i(...) `glTexCoord2i( GLint(s), GLint(t) ) -> None` glTexCoord2iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d2690> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord2iv( arrays.GLintArray(v) ) -> None
> glTexCoord2s(...) `glTexCoord2s( GLshort(s), GLshort(t) ) -> None` glTexCoord2sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d2820> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord2sv( arrays.GLshortArray(v) ) -> None
> glTexCoord3d(...) `glTexCoord3d( GLdouble(s), GLdouble(t), GLdouble(r) ) -> None` glTexCoord3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d29b0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord3dv( arrays.GLdoubleArray(v) ) -> None
> glTexCoord3f(...) `glTexCoord3f( GLfloat(s), GLfloat(t), GLfloat(r) ) -> None` glTexCoord3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d2b40> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord3fv( arrays.GLfloatArray(v) ) -> None
> glTexCoord3i(...) `glTexCoord3i( GLint(s), GLint(t), GLint(r) ) -> None` glTexCoord3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d2cd0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord3iv( arrays.GLintArray(v) ) -> None
> glTexCoord3s(...) `glTexCoord3s( GLshort(s), GLshort(t), GLshort(r) ) -> None` glTexCoord3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d2e60> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord3sv( arrays.GLshortArray(v) ) -> None
> glTexCoord4d(...) `glTexCoord4d( GLdouble(s), GLdouble(t), GLdouble(r), GLdouble(q) ) -> None` glTexCoord4dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5050> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord4dv( arrays.GLdoubleArray(v) ) -> None
> glTexCoord4f(...) `glTexCoord4f( GLfloat(s), GLfloat(t), GLfloat(r), GLfloat(q) ) -> None` glTexCoord4fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d51e0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord4fv( arrays.GLfloatArray(v) ) -> None
> glTexCoord4i(...) `glTexCoord4i( GLint(s), GLint(t), GLint(r), GLint(q) ) -> None` glTexCoord4iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5370> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord4iv( arrays.GLintArray(v) ) -> None
> glTexCoord4s(...) `glTexCoord4s( GLshort(s), GLshort(t), GLshort(r), GLshort(q) ) -> None` glTexCoord4sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5500> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexCoord4sv( arrays.GLshortArray(v) ) -> None
> glTexCoordPointer( size,type,stride,pointer ) pyConverters: size=None, type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x2aaab28e7790> cConverters: Not Used cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of type instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e77d0> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e93c0>
>     Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glTexCoordPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0f90> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_BYTE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e6780> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e7090> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e6820>
>     Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glTexCoordPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0c90> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e62d0> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0d50> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e6370>
>     Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glTexCoordPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0d90> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e6460> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0e50> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e6500>
>     Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glTexCoordPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e0e90> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e65f0> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e0f50> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e6690>
>     Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glTexCoordPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e70d0> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e6910> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e7190> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e69b0>
>     Wrapping Operation: glTexCoordPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glTexEnvf(...) `glTexEnvf( GLenum(target), GLenum(pname), GLfloat(param) ) -> None` glTexEnvfv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28d1810> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5640> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexEnvfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glTexEnvi(...) `glTexEnvi( GLenum(target), GLenum(pname), GLint(param) ) -> None` glTexEnviv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28d18d0> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5780> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexEnviv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
> glTexGend(...) `glTexGend( GLenum(coord), GLenum(pname), GLdouble(param) ) -> None` glTexGendv( coord,pname,params ) pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28d1990> cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5870> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexGendv( GLenum(coord), GLenum(pname), arrays.GLdoubleArray(params) ) -> None
> glTexGenf(...) `glTexGenf( GLenum(coord), GLenum(pname), GLfloat(param) ) -> None` glTexGenfv( coord,pname,params ) pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab2940a10> cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab2944c80> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexGenfv( GLenum(coord), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glTexGeni(...) `glTexGeni( GLenum(coord), GLenum(pname), GLint(param) ) -> None` glTexGeniv( coord,pname,params ) pyConverters: coord=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28d1b10> cConverters: coord=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5af0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexGeniv( GLenum(coord), GLenum(pname), arrays.GLintArray(params) ) -> None
> glTexImage1D( target,level,internalformat,width,border,format,type,pixels ) pyConverters: target=None, level=None, internalformat=None, width= asIntConverter(value, *args) , border=None, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab29351d0> cConverters: Not Used cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage1D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935350> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage1D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935710> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage1D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935ad0> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage1D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935e90> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage1D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b290> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage1D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b6d0> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage1D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293bb10> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage1D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage2D( target,level,internalformat,width,height,border,format,type,pixels ) pyConverters: target=None, level=None, internalformat=None, width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , border=None, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab2935110> cConverters: Not Used cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage2D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935410> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage2D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab29357d0> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage2D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935b90> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage2D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935f50> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage2D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b350> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage2D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b790> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage2D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293bbd0> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage2D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexImage3D( target,level,internalformat,width,height,depth,border,format,type,pixels ) pyConverters: target=None, level=None, internalformat=None, width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , depth= asIntConverter(value, *args) , border=None, format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab295a510> cConverters: Not Used cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexImage3D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2947a10> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexImage3D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2947b90> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexImage3D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2947d10> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexImage3D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2947e90> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexImage3D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab295a050> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexImage3D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab295a210> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexImage3D( target,level,internalformat,border,format,pixels ) pyConverters: target=None, level=None, internalformat=None, border=None, format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab295a3d0> cConverters: target=None, level=None, internalformat=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , border=None, format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexImage3D( GLenum(target), GLint(level), GLint(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexParameterf(...) `glTexParameterf( GLenum(target), GLenum(pname), GLfloat(param) ) -> None` glTexParameterfv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28d1bd0> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5be0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexParameterfv( GLenum(target), GLenum(pname), arrays.GLfloatArray(params) ) -> None
> glTexParameteri(...) `glTexParameteri( GLenum(target), GLenum(pname), GLint(param) ) -> None` glTexParameteriv( target,pname,params ) pyConverters: target=None, pname=None, params=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28d1c90> cConverters: target=None, pname=None, params=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5cd0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glTexParameteriv( GLenum(target), GLenum(pname), arrays.GLintArray(params) ) -> None
> glTexSubImage1D( target,level,xoffset,width,format,type,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , width= asIntConverter(value, *args) , format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab2935050> cConverters: Not Used cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage1D( target,level,xoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab29354d0> cConverters: target=None, level=None, xoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage1D( target,level,xoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935890> cConverters: target=None, level=None, xoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage1D( target,level,xoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935c50> cConverters: target=None, level=None, xoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage1D( target,level,xoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b050> cConverters: target=None, level=None, xoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage1D( target,level,xoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b410> cConverters: target=None, level=None, xoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage1D( target,level,xoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b850> cConverters: target=None, level=None, xoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage1D( target,level,xoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293bc90> cConverters: target=None, level=None, xoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, width=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage2D( target,level,xoffset,yoffset,width,height,format,type,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab292af50> cConverters: Not Used cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage2D( target,level,xoffset,yoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935590> cConverters: target=None, level=None, xoffset=None, yoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage2D( target,level,xoffset,yoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935950> cConverters: target=None, level=None, xoffset=None, yoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage2D( target,level,xoffset,yoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2935d10> cConverters: target=None, level=None, xoffset=None, yoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage2D( target,level,xoffset,yoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b110> cConverters: target=None, level=None, xoffset=None, yoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage2D( target,level,xoffset,yoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b510> cConverters: target=None, level=None, xoffset=None, yoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage2D( target,level,xoffset,yoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293b950> cConverters: target=None, level=None, xoffset=None, yoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage2D( target,level,xoffset,yoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab293bd90> cConverters: target=None, level=None, xoffset=None, yoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), POINTER(GLvoid)(pixels) ) -> None
> glTexSubImage3D( target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , zoffset= asIntConverter(value, *args) , width= asIntConverter(value, *args) , height= asIntConverter(value, *args) , depth= asIntConverter(value, *args) , format=None, type=None, pixels=<OpenGL.GL.images.ImageInputConverter object at 0x2aaab295a5d0> cConverters: Not Used cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels= cResolver(self, array) method of ImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , zoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2947ad0> cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , zoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2947c50> cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , zoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2947dd0> cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , zoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab2947f50> cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , zoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab295a110> cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , zoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab295a2d0> cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTexSubImage3D( target,level,xoffset,yoffset,zoffset,format,pixels ) pyConverters: target=None, level=None, xoffset= asIntConverter(value, *args) , yoffset= asIntConverter(value, *args) , zoffset= asIntConverter(value, *args) , format=None, pixels=<OpenGL.GL.images.TypedImageInputConverter object at 0x2aaab295a490> cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width= width(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the width from the pixels argument` , height= height(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the height from the pixels argument` , depth= depth(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Extract the depth from the pixels argument` , format=None, type= type(self, pyArgs, index, wrappedOperation) method of TypedImageInputConverter instance `Provide the item-type argument from our stored value This is used for pre-bound processing where we want to provide the type by implication...` , pixels=None cResolvers: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, type=None, pixels= cResolver(self, array) method of TypedImageInputConverter instance storeValues: Not Used returnValues: Not Used
>     Wrapping Operation: glTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(pixels) ) -> None
> glTranslate = glTranslated(...) `glTranslated( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glTranslated(...) `glTranslated( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glTranslatef(...) `glTranslatef( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glUniform1f(...) `glUniform1f( GLint(location), GLfloat(v0) ) -> None` glUniform1fv( location,count,value ) pyConverters: location=None, count=None, value= asArraySize(incoming, function, args) cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x2aaab299e280> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glUniform1fv( GLint(location), GLsizei(count), GLfloatArray(value) ) -> None
> glUniform1i(...) `glUniform1i( GLint(location), GLint(v0) ) -> None` glUniform1iv( location,count,value ) pyConverters: location=None, count=None, value= asArraySize(incoming, function, args) cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x2aaab299e3c0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glUniform1iv( GLint(location), GLsizei(count), GLintArray(value) ) -> None
> glUniform2f(...) `glUniform2f( GLint(location), GLfloat(v0), GLfloat(v1) ) -> None` glUniform2fv( location,count,value ) pyConverters: location=None, count=None, value= asArraySize(incoming, function, args) cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x2aaab299e500> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glUniform2fv( GLint(location), GLsizei(count), GLfloatArray(value) ) -> None
> glUniform2i(...) `glUniform2i( GLint(location), GLint(v0), GLint(v1) ) -> None` glUniform2iv( location,count,value ) pyConverters: location=None, count=None, value= asArraySize(incoming, function, args) cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x2aaab299e640> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glUniform2iv( GLint(location), GLsizei(count), GLintArray(value) ) -> None
> glUniform3f(...) `glUniform3f( GLint(location), GLfloat(v0), GLfloat(v1), GLfloat(v2) ) -> None` glUniform3fv( location,count,value ) pyConverters: location=None, count=None, value= asArraySize(incoming, function, args) cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x2aaab299e780> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glUniform3fv( GLint(location), GLsizei(count), GLfloatArray(value) ) -> None
> glUniform3i(...) `glUniform3i( GLint(location), GLint(v0), GLint(v1), GLint(v2) ) -> None` glUniform3iv( location,count,value ) pyConverters: location=None, count=None, value= asArraySize(incoming, function, args) cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x2aaab299e8c0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glUniform3iv( GLint(location), GLsizei(count), GLintArray(value) ) -> None
> glUniform4f(...) `glUniform4f( GLint(location), GLfloat(v0), GLfloat(v1), GLfloat(v2), GLfloat(v3) ) -> None` glUniform4fv( location,count,value ) pyConverters: location=None, count=None, value= asArraySize(incoming, function, args) cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x2aaab299ea00> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glUniform4fv( GLint(location), GLsizei(count), GLfloatArray(value) ) -> None
> glUniform4i(...) `glUniform4i( GLint(location), GLint(v0), GLint(v1), GLint(v2), GLint(v3) ) -> None` glUniform4iv( location,count,value ) pyConverters: location=None, count=None, value= asArraySize(incoming, function, args) cConverters: location=None, count=None, value=<OpenGL.converters.getPyArgsName object at 0x2aaab299eb40> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glUniform4iv( GLint(location), GLsizei(count), GLintArray(value) ) -> None
> glUniformMatrix2fv(...) `glUniformMatrix2fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None` glUniformMatrix3fv(...) `glUniformMatrix3fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None` glUniformMatrix4fv(...) `glUniformMatrix4fv( GLint(location), GLsizei(count), GLboolean(transpose), GLfloatArray(value) ) -> None` glUnmapBuffer(...) `glUnmapBuffer( GLenum(target) ) -> constants.GLboolean` glUseProgram(...) `glUseProgram( GLuint(program) ) -> None` glValidateProgram(...) `glValidateProgram( GLuint(program) ) -> None` glVertex2d(...) `glVertex2d( GLdouble(x), GLdouble(y) ) -> None` glVertex2dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5e10> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex2dv( arrays.GLdoubleArray(v) ) -> None
> glVertex2f(...) `glVertex2f( GLfloat(x), GLfloat(y) ) -> None` glVertex2fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d5fa0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex2fv( arrays.GLfloatArray(v) ) -> None
> glVertex2i(...) `glVertex2i( GLint(x), GLint(y) ) -> None` glVertex2iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d9190> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex2iv( arrays.GLintArray(v) ) -> None
> glVertex2s(...) `glVertex2s( GLshort(x), GLshort(y) ) -> None` glVertex2sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d9320> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex2sv( arrays.GLshortArray(v) ) -> None
> glVertex3d(...) `glVertex3d( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glVertex3dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d94b0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex3dv( arrays.GLdoubleArray(v) ) -> None
> glVertex3f(...) `glVertex3f( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glVertex3fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d9640> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex3fv( arrays.GLfloatArray(v) ) -> None
> glVertex3i(...) `glVertex3i( GLint(x), GLint(y), GLint(z) ) -> None` glVertex3iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d97d0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex3iv( arrays.GLintArray(v) ) -> None
> glVertex3s(...) `glVertex3s( GLshort(x), GLshort(y), GLshort(z) ) -> None` glVertex3sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d9960> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex3sv( arrays.GLshortArray(v) ) -> None
> glVertex4d(...) `glVertex4d( GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None` glVertex4dv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d9af0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex4dv( arrays.GLdoubleArray(v) ) -> None
> glVertex4f(...) `glVertex4f( GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None` glVertex4fv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d9c80> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex4fv( arrays.GLfloatArray(v) ) -> None
> glVertex4i(...) `glVertex4i( GLint(x), GLint(y), GLint(z), GLint(w) ) -> None` glVertex4iv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d9e10> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex4iv( arrays.GLintArray(v) ) -> None
> glVertex4s(...) `glVertex4s( GLshort(x), GLshort(y), GLshort(z), GLshort(w) ) -> None` glVertex4sv( v ) pyConverters: v= asArraySize(incoming, function, args) cConverters: v=<OpenGL.converters.getPyArgsName object at 0x2aaab28d9fa0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: glVertex4sv( arrays.GLshortArray(v) ) -> None
> glVertexAttrib1d(...) `glVertexAttrib1d( GLuint(index), GLdouble(x) ) -> None` glVertexAttrib1dv(...) `glVertexAttrib1dv( GLuint(index), GLdoubleArray(v) ) -> None` glVertexAttrib1f(...) `glVertexAttrib1f( GLuint(index), GLfloat(x) ) -> None` glVertexAttrib1fv(...) `glVertexAttrib1fv( GLuint(index), GLfloatArray(v) ) -> None` glVertexAttrib1s(...) `glVertexAttrib1s( GLuint(index), GLshort(x) ) -> None` glVertexAttrib1sv(...) `glVertexAttrib1sv( GLuint(index), GLshortArray(v) ) -> None` glVertexAttrib2d(...) `glVertexAttrib2d( GLuint(index), GLdouble(x), GLdouble(y) ) -> None` glVertexAttrib2dv(...) `glVertexAttrib2dv( GLuint(index), GLdoubleArray(v) ) -> None` glVertexAttrib2f(...) `glVertexAttrib2f( GLuint(index), GLfloat(x), GLfloat(y) ) -> None` glVertexAttrib2fv(...) `glVertexAttrib2fv( GLuint(index), GLfloatArray(v) ) -> None` glVertexAttrib2s(...) `glVertexAttrib2s( GLuint(index), GLshort(x), GLshort(y) ) -> None` glVertexAttrib2sv(...) `glVertexAttrib2sv( GLuint(index), GLshortArray(v) ) -> None` glVertexAttrib3d(...) `glVertexAttrib3d( GLuint(index), GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glVertexAttrib3dv(...) `glVertexAttrib3dv( GLuint(index), GLdoubleArray(v) ) -> None` glVertexAttrib3f(...) `glVertexAttrib3f( GLuint(index), GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glVertexAttrib3fv(...) `glVertexAttrib3fv( GLuint(index), GLfloatArray(v) ) -> None` glVertexAttrib3s(...) `glVertexAttrib3s( GLuint(index), GLshort(x), GLshort(y), GLshort(z) ) -> None` glVertexAttrib3sv(...) `glVertexAttrib3sv( GLuint(index), GLshortArray(v) ) -> None` glVertexAttrib4Nbv(...) `glVertexAttrib4Nbv( GLuint(index), GLbyteArray(v) ) -> None` glVertexAttrib4Niv(...) `glVertexAttrib4Niv( GLuint(index), GLintArray(v) ) -> None` glVertexAttrib4Nsv(...) `glVertexAttrib4Nsv( GLuint(index), GLshortArray(v) ) -> None` glVertexAttrib4Nub(...) `glVertexAttrib4Nub( GLuint(index), GLubyte(x), GLubyte(y), GLubyte(z), GLubyte(w) ) -> None` glVertexAttrib4Nubv(...) `glVertexAttrib4Nubv( GLuint(index), GLubyteArray(v) ) -> None` glVertexAttrib4Nuiv(...) `glVertexAttrib4Nuiv( GLuint(index), GLuintArray(v) ) -> None` glVertexAttrib4Nusv(...) `glVertexAttrib4Nusv( GLuint(index), GLushortArray(v) ) -> None` glVertexAttrib4bv(...) `glVertexAttrib4bv( GLuint(index), GLbyteArray(v) ) -> None` glVertexAttrib4d(...) `glVertexAttrib4d( GLuint(index), GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None` glVertexAttrib4dv(...) `glVertexAttrib4dv( GLuint(index), GLdoubleArray(v) ) -> None` glVertexAttrib4f(...) `glVertexAttrib4f( GLuint(index), GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None` glVertexAttrib4fv(...) `glVertexAttrib4fv( GLuint(index), GLfloatArray(v) ) -> None` glVertexAttrib4iv(...) `glVertexAttrib4iv( GLuint(index), GLintArray(v) ) -> None` glVertexAttrib4s(...) `glVertexAttrib4s( GLuint(index), GLshort(x), GLshort(y), GLshort(z), GLshort(w) ) -> None` glVertexAttrib4sv(...) `glVertexAttrib4sv( GLuint(index), GLshortArray(v) ) -> None` glVertexAttrib4ubv(...) `glVertexAttrib4ubv( GLuint(index), GLubyteArray(v) ) -> None` glVertexAttrib4uiv(...) `glVertexAttrib4uiv( GLuint(index), GLuintArray(v) ) -> None` glVertexAttrib4usv(...) `glVertexAttrib4usv( GLuint(index), GLushortArray(v) ) -> None` glVertexAttribPointer(...) `glVertexAttribPointer( GLuint(index), GLint(size), GLenum(type), GLboolean(normalized), GLsizei(stride), c_void_p(pointer) ) -> None` glVertexPointer( size,type,stride,pointer ) pyConverters: size=None, type=None, stride=None, pointer=<OpenGL.arrays.arrayhelpers.AsArrayOfType object at 0x2aaab28da7d0> cConverters: Not Used cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of type instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e76d0> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e92d0>
>     Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glVertexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e74d0> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e6f50> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e7590> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e9050>
>     Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glVertexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e71d0> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_DOUBLE, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e6aa0> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e7290> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e6b40>
>     Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glVertexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e72d0> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_FLOAT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e6c30> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e7390> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e6cd0>
>     Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glVertexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e73d0> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_INT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e6dc0> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e7490> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e6e60>
>     Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glVertexPointer( pointer ) pyConverters: pointer=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab28e75d0> cConverters: size= arraySizeOfFirst(pyArgs, index, baseOperation) `Return the array size of the first argument` , type=GL_SHORT, stride=0, pointer=<OpenGL.converters.getPyArgsName object at 0x2aaab28e9140> cResolvers: size=None, type=None, stride=None, pointer= voidDataPointer(*args, **named) method of _ctypes.PointerType instance `Given value in a known data-pointer type, return void_p for pointer` storeValues: <OpenGL.arrays.arrayhelpers.storePointerType object at 0x2aaab28e7690> returnValues: <OpenGL.converters.returnPyArgument object at 0x2aaab28e91e0>
>     Wrapping Operation: glVertexPointer( GLint(size), GLenum(type), GLsizei(stride), POINTER(GLvoid)(pointer) ) -> None
> glViewport(...) `glViewport( GLint(x), GLint(y), GLsizei(width), GLsizei(height) ) -> None` glWindowPos2d(...) `glWindowPos2d( GLdouble(x), GLdouble(y) ) -> None` glWindowPos2dv(...) `glWindowPos2dv( GLdoubleArray(v) ) -> None` glWindowPos2f(...) `glWindowPos2f( GLfloat(x), GLfloat(y) ) -> None` glWindowPos2fv(...) `glWindowPos2fv( GLfloatArray(v) ) -> None` glWindowPos2i(...) `glWindowPos2i( GLint(x), GLint(y) ) -> None` glWindowPos2iv(...) `glWindowPos2iv( GLintArray(v) ) -> None` glWindowPos2s(...) `glWindowPos2s( GLshort(x), GLshort(y) ) -> None` glWindowPos2sv(...) `glWindowPos2sv( GLshortArray(v) ) -> None` glWindowPos3d(...) `glWindowPos3d( GLdouble(x), GLdouble(y), GLdouble(z) ) -> None` glWindowPos3dv(...) `glWindowPos3dv( GLdoubleArray(v) ) -> None` glWindowPos3f(...) `glWindowPos3f( GLfloat(x), GLfloat(y), GLfloat(z) ) -> None` glWindowPos3fv(...) `glWindowPos3fv( GLfloatArray(v) ) -> None` glWindowPos3i(...) `glWindowPos3i( GLint(x), GLint(y), GLint(z) ) -> None` glWindowPos3iv(...) `glWindowPos3iv( GLintArray(v) ) -> None` glWindowPos3s(...) `glWindowPos3s( GLshort(x), GLshort(y), GLshort(z) ) -> None` glWindowPos3sv(...) `glWindowPos3sv( GLshortArray(v) ) -> None` gluBeginCurve(...) `gluBeginCurve( POINTER(GLUnurbs)(nurb) ) -> None` gluBeginPolygon(...) `gluBeginPolygon( POINTER(GLUtesselator)(tess) ) -> None (OBSOLETE see gluTessBeginPolygon)` gluBeginSurface(...) `gluBeginSurface( POINTER(GLUnurbs)(nurb) ) -> None` gluBeginTrim(...) `gluBeginTrim( POINTER(GLUnurbs)(nurb) ) -> None` gluBuild1DMipmapLevels(...) `gluBuild1DMipmapLevels( GLenum(target), GLint(internalFormat), GLsizei(width), GLenum(format), GLenum(type), GLint(level), GLint(base), GLint(max), c_void_p(data) ) -> GLint` gluBuild1DMipmaps(...) `gluBuild1DMipmaps( GLenum(target), GLint(internalFormat), GLsizei(width), GLenum(format), GLenum(type), c_void_p(data) ) -> GLint` gluBuild2DMipmapLevels(...) `gluBuild2DMipmapLevels( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), GLint(level), GLint(base), GLint(max), c_void_p(data) ) -> GLint` gluBuild2DMipmaps(...) `gluBuild2DMipmaps( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), c_void_p(data) ) -> GLint` gluBuild3DMipmapLevels(...) `gluBuild3DMipmapLevels( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), GLint(level), GLint(base), GLint(max), c_void_p(data) ) -> GLint` gluBuild3DMipmaps(...) `gluBuild3DMipmaps( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(data) ) -> GLint` gluCheckExtension( extName,extString ) pyConverters: extName=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29b9dd0>, extString=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29b9e10> cConverters: extName=<OpenGL.converters.getPyArgsName object at 0x2aaab29bdf00>, extString=<OpenGL.converters.getPyArgsName object at 0x2aaab29bdfa0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: gluCheckExtension( arrays.GLubyteArray(extName), arrays.GLubyteArray(extString) ) -> GLboolean
> gluCylinder(...) `gluCylinder( POINTER(GLUquadric)(quad), GLdouble(base), GLdouble(top), GLdouble(height), GLint(slices), GLint(stacks) ) -> None` gluDeleteNurbsRenderer(...) `gluDeleteNurbsRenderer( POINTER(GLUnurbs)(nurb) ) -> None` gluDeleteQuadric(...) `gluDeleteQuadric( POINTER(GLUquadric)(quad) ) -> None` gluDeleteTess(...) `gluDeleteTess( POINTER(GLUtesselator)(tess) ) -> None` gluDisk(...) `gluDisk( POINTER(GLUquadric)(quad), GLdouble(inner), GLdouble(outer), GLint(slices), GLint(loops) ) -> None` gluEndCurve(...) `gluEndCurve( POINTER(GLUnurbs)(nurb) ) -> None` gluEndPolygon(...) `gluEndPolygon( POINTER(GLUtesselator)(tess) ) -> None (OBSOLETE see gluTessEndPolygon)` gluEndSurface(...) `gluEndSurface( POINTER(GLUnurbs)(nurb) ) -> None` gluEndTrim(...) `gluEndTrim( POINTER(GLUnurbs)(nurb) ) -> None` gluErrorString(...) `gluErrorString( GLenum(error) ) -> POINTER(GLubyte)` gluGetString(...) `gluGetString( GLenum(name) ) -> POINTER(GLubyte)` gluGetTessPropertyBase = gluGetTessProperty(...) `gluGetTessProperty( POINTER(GLUtesselator)(tess), GLenum(which), POINTER(GLdouble)(data) ) -> None` gluLoadSamplingMatrices( nurb,model,perspective,view ) pyConverters: nurb=None, model=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29e4690>, perspective=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29e4750>, view=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29e4790> cConverters: nurb=None, model=<OpenGL.converters.getPyArgsName object at 0x2aaab29dc910>, perspective=<OpenGL.converters.getPyArgsName object at 0x2aaab29dc9b0>, view=<OpenGL.converters.getPyArgsName object at 0x2aaab29dca50> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: gluLoadSamplingMatrices( POINTER(GLUnurbs)(nurb), arrays.GLfloatArray(model), arrays.GLfloatArray(perspective), arrays.GLintArray(view) ) -> None
> gluLookAt(...) `gluLookAt( GLdouble(eyeX), GLdouble(eyeY), GLdouble(eyeZ), GLdouble(centerX), GLdouble(centerY), GLdouble(centerZ), GLdouble(upX), GLdouble(upY), GLdouble(upZ) ) -> None` gluNewQuadric(...) `gluNewQuadric( ) -> GLUQuadric Create a new GLUQuadric object` gluNewTessBase = gluNewTess(...) `gluNewTess( ) -> POINTER(GLUtesselator)` gluNextContour(...) `gluNextContour( POINTER(GLUtesselator)(tess), GLenum(type) ) -> None` gluNurbsProperty(...) `gluNurbsProperty( POINTER(GLUnurbs)(nurb), GLenum(property), GLfloat(value) ) -> None` gluOrtho2D(...) `gluOrtho2D( GLdouble(left), GLdouble(right), GLdouble(bottom), GLdouble(top) ) -> None` gluPartialDisk(...) `gluPartialDisk( POINTER(GLUquadric)(quad), GLdouble(inner), GLdouble(outer), GLint(slices), GLint(loops), GLdouble(start), GLdouble(sweep) ) -> None` gluPerspective(...) `gluPerspective( GLdouble(fovy), GLdouble(aspect), GLdouble(zNear), GLdouble(zFar) ) -> None` gluPickMatrix( x,y,delX,delY,viewport ) pyConverters: x=None, y=None, delX=None, delY=None, viewport=<OpenGL.converters.CallFuncPyConverter object at 0x2aaab29cb110> cConverters: x=None, y=None, delX=None, delY=None, viewport=<OpenGL.converters.getPyArgsName object at 0x2aaab29ca6e0> cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: gluPickMatrix( GLdouble(x), GLdouble(y), GLdouble(delX), GLdouble(delY), arrays.GLintArray(viewport) ) -> None
> gluProjectBase = gluProject(...) `gluProject( GLdouble(objX), GLdouble(objY), GLdouble(objZ), POINTER(GLdouble)(model), POINTER(GLdouble)(proj), POINTER(GLint)(view), POINTER(GLdouble)(winX), POINTER(GLdouble)(winY), POINTER(GLdouble)(winZ) ) -> GLint` gluQuadricDrawStyle(...) `gluQuadricDrawStyle( POINTER(GLUquadric)(quad), GLenum(draw) ) -> None` gluQuadricNormals(...) `gluQuadricNormals( POINTER(GLUquadric)(quad), GLenum(normal) ) -> None` gluQuadricOrientation(...) `gluQuadricOrientation( POINTER(GLUquadric)(quad), GLenum(orientation) ) -> None` gluQuadricTexture(...) `gluQuadricTexture( POINTER(GLUquadric)(quad), GLboolean(texture) ) -> None` gluScaleImage(...) `gluScaleImage( GLenum(format), GLsizei(wIn), GLsizei(hIn), GLenum(typeIn), c_void_p(dataIn), GLsizei(wOut), GLsizei(hOut), GLenum(typeOut), POINTER(GLvoid)(dataOut) ) -> GLint` gluSphere(...) `gluSphere( POINTER(GLUquadric)(quad), GLdouble(radius), GLint(slices), GLint(stacks) ) -> None` gluTessBeginContour(...) `gluTessBeginContour( POINTER(GLUtesselator)(tess) ) -> None` gluTessBeginPolygonBase = gluTessBeginPolygon(...) `gluTessBeginPolygon( POINTER(GLUtesselator)(tess), POINTER(GLvoid)(data) ) -> None` gluTessEndContour(...) `gluTessEndContour( POINTER(GLUtesselator)(tess) ) -> None` gluTessEndPolygon(...) `gluTessEndPolygon( POINTER(GLUtesselator)(tess) ) -> None` gluTessNormal(...) `gluTessNormal( POINTER(GLUtesselator)(tess), GLdouble(valueX), GLdouble(valueY), GLdouble(valueZ) ) -> None` gluTessProperty(...) `gluTessProperty( POINTER(GLUtesselator)(tess), GLenum(which), GLdouble(data) ) -> None` gluTessVertex( tess,location,data ) pyConverters: tess=None, location= asArraySize(incoming, function, args) , data=None cConverters: tess=None, location=<OpenGL.converters.getPyArgsName object at 0x2aaab29d3e10>, data=None cResolvers: Not Used storeValues: Not Used returnValues: returnPointer(result, baseOperation, pyArgs, cArgs) `Return the converted object as result of function Note: this is a hack that always returns pyArgs[0]!`
>     Wrapping Operation: gluTessVertex( POINTER(GLUtesselator)(tess), POINTER(GLdouble)(location), POINTER(GLvoid)(data) ) -> None
gluUnProject4Base = gluUnProject4(...) `gluUnProject4( GLdouble(winX), GLdouble(winY), GLdouble(winZ), GLdouble(clipW), POINTER(GLdouble)(model), POINTER(GLdouble)(proj), POINTER(GLint)(view), GLdouble(near), GLdouble(far), POINTER(GLdouble)(objX), POINTER(GLdouble)(objY), POINTER(GLdouble)(objZ), POINTER(GLdouble)(objW) ) -> GLint` gluUnProjectBase = gluUnProject(...) `gluUnProject( GLdouble(winX), GLdouble(winY), GLdouble(winZ), POINTER(GLdouble)(model), POINTER(GLdouble)(proj), POINTER(GLint)(view), POINTER(GLdouble)(objX), POINTER(GLdouble)(objY), POINTER(GLdouble)(objZ) ) -> GLint`

Data
`` |  | GLU = <CDLL 'libGLU.so.1', handle 614240 at 2b54fad04ad0> GLU_AUTO_LOAD_MATRIX = GLU_AUTO_LOAD_MATRIX GLU_BEGIN = GLU_BEGIN GLU_CCW = GLU_CCW GLU_CULLING = GLU_CULLING GLU_CW = GLU_CW GLU_DISPLAY_MODE = GLU_DISPLAY_MODE GLU_DOMAIN_DISTANCE = GLU_DOMAIN_DISTANCE GLU_EDGE_FLAG = GLU_EDGE_FLAG GLU_END = GLU_END GLU_ERROR = GLU_ERROR GLU_EXTENSIONS = GLU_EXTENSIONS GLU_EXTERIOR = GLU_EXTERIOR GLU_FALSE = GLU_FALSE GLU_FILL = GLU_FILL GLU_FLAT = GLU_FLAT GLU_INCOMPATIBLE_GL_VERSION = GLU_INCOMPATIBLE_GL_VERSION GLU_INSIDE = GLU_INSIDE GLU_INTERIOR = GLU_INTERIOR GLU_INVALID_ENUM = GLU_INVALID_ENUM GLU_INVALID_OPERATION = GLU_INVALID_OPERATION GLU_INVALID_VALUE = GLU_INVALID_VALUE GLU_LINE = GLU_LINE GLU_MAP1_TRIM_2 = GLU_MAP1_TRIM_2 GLU_MAP1_TRIM_3 = GLU_MAP1_TRIM_3 GLU_NONE = GLU_NONE GLU_NURBS_BEGIN = GLU_NURBS_BEGIN GLU_NURBS_BEGIN_DATA = GLU_NURBS_BEGIN_DATA GLU_NURBS_BEGIN_DATA_EXT = GLU_NURBS_BEGIN_DATA_EXT GLU_NURBS_BEGIN_EXT = GLU_NURBS_BEGIN_EXT GLU_NURBS_COLOR = GLU_NURBS_COLOR GLU_NURBS_COLOR_DATA = GLU_NURBS_COLOR_DATA GLU_NURBS_COLOR_DATA_EXT = GLU_NURBS_COLOR_DATA_EXT GLU_NURBS_COLOR_EXT = GLU_NURBS_COLOR_EXT GLU_NURBS_END = GLU_NURBS_END GLU_NURBS_END_DATA = GLU_NURBS_END_DATA GLU_NURBS_END_DATA_EXT = GLU_NURBS_END_DATA_EXT GLU_NURBS_END_EXT = GLU_NURBS_END_EXT GLU_NURBS_ERROR = GLU_NURBS_ERROR GLU_NURBS_ERROR1 = GLU_NURBS_ERROR1 GLU_NURBS_ERROR10 = GLU_NURBS_ERROR10 GLU_NURBS_ERROR11 = GLU_NURBS_ERROR11 GLU_NURBS_ERROR12 = GLU_NURBS_ERROR12 GLU_NURBS_ERROR13 = GLU_NURBS_ERROR13 GLU_NURBS_ERROR14 = GLU_NURBS_ERROR14 GLU_NURBS_ERROR15 = GLU_NURBS_ERROR15 GLU_NURBS_ERROR16 = GLU_NURBS_ERROR16 GLU_NURBS_ERROR17 = GLU_NURBS_ERROR17 GLU_NURBS_ERROR18 = GLU_NURBS_ERROR18 GLU_NURBS_ERROR19 = GLU_NURBS_ERROR19 GLU_NURBS_ERROR2 = GLU_NURBS_ERROR2 GLU_NURBS_ERROR20 = GLU_NURBS_ERROR20 GLU_NURBS_ERROR21 = GLU_NURBS_ERROR21 GLU_NURBS_ERROR22 = GLU_NURBS_ERROR22 GLU_NURBS_ERROR23 = GLU_NURBS_ERROR23 GLU_NURBS_ERROR24 = GLU_NURBS_ERROR24 GLU_NURBS_ERROR25 = GLU_NURBS_ERROR25 GLU_NURBS_ERROR26 = GLU_NURBS_ERROR26 GLU_NURBS_ERROR27 = GLU_NURBS_ERROR27 GLU_NURBS_ERROR28 = GLU_NURBS_ERROR28 GLU_NURBS_ERROR29 = GLU_NURBS_ERROR29 GLU_NURBS_ERROR3 = GLU_NURBS_ERROR3 GLU_NURBS_ERROR30 = GLU_NURBS_ERROR30 GLU_NURBS_ERROR31 = GLU_NURBS_ERROR31 GLU_NURBS_ERROR32 = GLU_NURBS_ERROR32 GLU_NURBS_ERROR33 = GLU_NURBS_ERROR33 GLU_NURBS_ERROR34 = GLU_NURBS_ERROR34 GLU_NURBS_ERROR35 = GLU_NURBS_ERROR35 GLU_NURBS_ERROR36 = GLU_NURBS_ERROR36 GLU_NURBS_ERROR37 = GLU_NURBS_ERROR37 GLU_NURBS_ERROR4 = GLU_NURBS_ERROR4 GLU_NURBS_ERROR5 = GLU_NURBS_ERROR5 GLU_NURBS_ERROR6 = GLU_NURBS_ERROR6 GLU_NURBS_ERROR7 = GLU_NURBS_ERROR7 GLU_NURBS_ERROR8 = GLU_NURBS_ERROR8 GLU_NURBS_ERROR9 = GLU_NURBS_ERROR9 GLU_NURBS_MODE = GLU_NURBS_MODE GLU_NURBS_MODE_EXT = GLU_NURBS_MODE_EXT GLU_NURBS_NORMAL = GLU_NURBS_NORMAL GLU_NURBS_NORMAL_DATA = GLU_NURBS_NORMAL_DATA GLU_NURBS_NORMAL_DATA_EXT = GLU_NURBS_NORMAL_DATA_EXT GLU_NURBS_NORMAL_EXT = GLU_NURBS_NORMAL_EXT GLU_NURBS_RENDERER = GLU_NURBS_RENDERER GLU_NURBS_RENDERER_EXT = GLU_NURBS_RENDERER_EXT GLU_NURBS_TESSELLATOR = GLU_NURBS_TESSELLATOR GLU_NURBS_TESSELLATOR_EXT = GLU_NURBS_TESSELLATOR_EXT GLU_NURBS_TEXTURE_COORD = GLU_NURBS_TEXTURE_COORD GLU_NURBS_TEXTURE_COORD_DATA = GLU_NURBS_TEXTURE_COORD_DATA GLU_NURBS_TEX_COORD_DATA_EXT = GLU_NURBS_TEX_COORD_DATA_EXT GLU_NURBS_TEX_COORD_EXT = GLU_NURBS_TEX_COORD_EXT GLU_NURBS_VERTEX = GLU_NURBS_VERTEX GLU_NURBS_VERTEX_DATA = GLU_NURBS_VERTEX_DATA GLU_NURBS_VERTEX_DATA_EXT = GLU_NURBS_VERTEX_DATA_EXT GLU_NURBS_VERTEX_EXT = GLU_NURBS_VERTEX_EXT GLU_OBJECT_PARAMETRIC_ERROR = GLU_OBJECT_PARAMETRIC_ERROR GLU_OBJECT_PARAMETRIC_ERROR_EXT = GLU_OBJECT_PARAMETRIC_ERROR_EXT GLU_OBJECT_PATH_LENGTH = GLU_OBJECT_PATH_LENGTH GLU_OBJECT_PATH_LENGTH_EXT = GLU_OBJECT_PATH_LENGTH_EXT GLU_OUTLINE_PATCH = GLU_OUTLINE_PATCH GLU_OUTLINE_POLYGON = GLU_OUTLINE_POLYGON GLU_OUTSIDE = GLU_OUTSIDE GLU_OUT_OF_MEMORY = GLU_OUT_OF_MEMORY GLU_PARAMETRIC_ERROR = GLU_PARAMETRIC_ERROR GLU_PARAMETRIC_TOLERANCE = GLU_PARAMETRIC_TOLERANCE GLU_PATH_LENGTH = GLU_PATH_LENGTH GLU_POINT = GLU_POINT GLU_SAMPLING_METHOD = GLU_SAMPLING_METHOD GLU_SAMPLING_TOLERANCE = GLU_SAMPLING_TOLERANCE GLU_SILHOUETTE = GLU_SILHOUETTE GLU_SMOOTH = GLU_SMOOTH GLU_TESS_BEGIN = GLU_TESS_BEGIN GLU_TESS_BEGIN_DATA = GLU_TESS_BEGIN_DATA GLU_TESS_BOUNDARY_ONLY = GLU_TESS_BOUNDARY_ONLY GLU_TESS_COMBINE = GLU_TESS_COMBINE GLU_TESS_COMBINE_DATA = GLU_TESS_COMBINE_DATA GLU_TESS_COORD_TOO_LARGE = GLU_TESS_COORD_TOO_LARGE GLU_TESS_EDGE_FLAG = GLU_TESS_EDGE_FLAG GLU_TESS_EDGE_FLAG_DATA = GLU_TESS_EDGE_FLAG_DATA GLU_TESS_END = GLU_TESS_END GLU_TESS_END_DATA = GLU_TESS_END_DATA GLU_TESS_ERROR = GLU_TESS_ERROR GLU_TESS_ERROR1 = GLU_TESS_ERROR1 GLU_TESS_ERROR2 = GLU_TESS_ERROR2 GLU_TESS_ERROR3 = GLU_TESS_ERROR3 GLU_TESS_ERROR4 = GLU_TESS_ERROR4 GLU_TESS_ERROR5 = GLU_TESS_ERROR5 GLU_TESS_ERROR6 = GLU_TESS_ERROR6 GLU_TESS_ERROR7 = GLU_TESS_ERROR7 GLU_TESS_ERROR8 = GLU_TESS_ERROR8 GLU_TESS_ERROR_DATA = GLU_TESS_ERROR_DATA GLU_TESS_MAX_COORD = GLU_TESS_MAX_COORD GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_MISSING_BEGIN_CONTOUR GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_MISSING_BEGIN_POLYGON GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_MISSING_END_CONTOUR GLU_TESS_MISSING_END_POLYGON = GLU_TESS_MISSING_END_POLYGON GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_NEED_COMBINE_CALLBACK GLU_TESS_TOLERANCE = GLU_TESS_TOLERANCE GLU_TESS_VERTEX = GLU_TESS_VERTEX GLU_TESS_VERTEX_DATA = GLU_TESS_VERTEX_DATA GLU_TESS_WINDING_ABS_GEQ_TWO = GLU_TESS_WINDING_ABS_GEQ_TWO GLU_TESS_WINDING_NEGATIVE = GLU_TESS_WINDING_NEGATIVE GLU_TESS_WINDING_NONZERO = GLU_TESS_WINDING_NONZERO GLU_TESS_WINDING_ODD = GLU_TESS_WINDING_ODD GLU_TESS_WINDING_POSITIVE = GLU_TESS_WINDING_POSITIVE GLU_TESS_WINDING_RULE = GLU_TESS_WINDING_RULE GLU_TRUE = GLU_TRUE GLU_UNKNOWN = GLU_UNKNOWN GLU_U_STEP = GLU_U_STEP GLU_VERSION = GLU_VERSION GLU_VERSION_1_1 = GLU_VERSION_1_1 GLU_VERSION_1_2 = GLU_VERSION_1_2 GLU_VERSION_1_3 = GLU_VERSION_1_3 GLU_VERTEX = GLU_VERTEX GLU_V_STEP = GLU_V_STEP GL_1PASS_EXT = GL_1PASS_EXT GL_1PASS_SGIS = GL_1PASS_SGIS GL_2D = GL_2D GL_2PASS_0_EXT = GL_2PASS_0_EXT GL_2PASS_0_SGIS = GL_2PASS_0_SGIS GL_2PASS_1_EXT = GL_2PASS_1_EXT GL_2PASS_1_SGIS = GL_2PASS_1_SGIS GL_2X_BIT_ATI = GL_2X_BIT_ATI GL_2_BYTES = GL_2_BYTES GL_3D = GL_3D GL_3D_COLOR = GL_3D_COLOR GL_3D_COLOR_TEXTURE = GL_3D_COLOR_TEXTURE GL_3_BYTES = GL_3_BYTES GL_422_AVERAGE_EXT = GL_422_AVERAGE_EXT GL_422_EXT = GL_422_EXT GL_422_REV_AVERAGE_EXT = GL_422_REV_AVERAGE_EXT GL_422_REV_EXT = GL_422_REV_EXT GL_4D_COLOR_TEXTURE = GL_4D_COLOR_TEXTURE GL_4PASS_0_EXT = GL_4PASS_0_EXT GL_4PASS_0_SGIS = GL_4PASS_0_SGIS GL_4PASS_1_EXT = GL_4PASS_1_EXT GL_4PASS_1_SGIS = GL_4PASS_1_SGIS GL_4PASS_2_EXT = GL_4PASS_2_EXT GL_4PASS_2_SGIS = GL_4PASS_2_SGIS GL_4PASS_3_EXT = GL_4PASS_3_EXT GL_4PASS_3_SGIS = GL_4PASS_3_SGIS GL_4X_BIT_ATI = GL_4X_BIT_ATI GL_4_BYTES = GL_4_BYTES GL_8X_BIT_ATI = GL_8X_BIT_ATI GL_ABGR_EXT = GL_ABGR_EXT GL_ACCUM = GL_ACCUM GL_ACCUM_ALPHA_BITS = GL_ACCUM_ALPHA_BITS GL_ACCUM_BLUE_BITS = GL_ACCUM_BLUE_BITS GL_ACCUM_BUFFER_BIT = GL_ACCUM_BUFFER_BIT GL_ACCUM_CLEAR_VALUE = GL_ACCUM_CLEAR_VALUE GL_ACCUM_GREEN_BITS = GL_ACCUM_GREEN_BITS GL_ACCUM_RED_BITS = GL_ACCUM_RED_BITS GL_ACTIVE_ATTRIBUTES = GL_ACTIVE_ATTRIBUTES GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = GL_ACTIVE_ATTRIBUTE_MAX_LENGTH GL_ACTIVE_STENCIL_FACE_EXT = GL_ACTIVE_STENCIL_FACE_EXT GL_ACTIVE_TEXTURE = GL_ACTIVE_TEXTURE GL_ACTIVE_TEXTURE_ARB = GL_ACTIVE_TEXTURE_ARB GL_ACTIVE_UNIFORMS = GL_ACTIVE_UNIFORMS GL_ACTIVE_UNIFORM_MAX_LENGTH = GL_ACTIVE_UNIFORM_MAX_LENGTH GL_ACTIVE_VERTEX_UNITS_ARB = GL_ACTIVE_VERTEX_UNITS_ARB GL_ADD = GL_ADD GL_ADD_ATI = GL_ADD_ATI GL_ADD_SIGNED = GL_ADD_SIGNED GL_ADD_SIGNED_ARB = GL_ADD_SIGNED_ARB GL_ADD_SIGNED_EXT = GL_ADD_SIGNED_EXT GL_ALIASED_LINE_WIDTH_RANGE = GL_ALIASED_LINE_WIDTH_RANGE GL_ALIASED_POINT_SIZE_RANGE = GL_ALIASED_POINT_SIZE_RANGE GL_ALLOW_DRAW_FRG_HINT_PGI = GL_ALLOW_DRAW_FRG_HINT_PGI GL_ALLOW_DRAW_MEM_HINT_PGI = GL_ALLOW_DRAW_MEM_HINT_PGI GL_ALLOW_DRAW_OBJ_HINT_PGI = GL_ALLOW_DRAW_OBJ_HINT_PGI GL_ALLOW_DRAW_WIN_HINT_PGI = GL_ALLOW_DRAW_WIN_HINT_PGI GL_ALL_ATTRIB_BITS = GL_ALL_ATTRIB_BITS GL_ALL_COMPLETED_NV = GL_ALL_COMPLETED_NV GL_ALPHA = GL_ALPHA GL_ALPHA12 = GL_ALPHA12 GL_ALPHA12_EXT = GL_ALPHA12_EXT GL_ALPHA16 = GL_ALPHA16 GL_ALPHA16F_ARB = GL_ALPHA16F_ARB GL_ALPHA16_EXT = GL_ALPHA16_EXT GL_ALPHA32F_ARB = GL_ALPHA32F_ARB GL_ALPHA4 = GL_ALPHA4 GL_ALPHA4_EXT = GL_ALPHA4_EXT GL_ALPHA8 = GL_ALPHA8 GL_ALPHA8_EXT = GL_ALPHA8_EXT GL_ALPHA_BIAS = GL_ALPHA_BIAS GL_ALPHA_BITS = GL_ALPHA_BITS GL_ALPHA_FLOAT16_ATI = GL_ALPHA_FLOAT16_ATI GL_ALPHA_FLOAT32_ATI = GL_ALPHA_FLOAT32_ATI GL_ALPHA_MAX_CLAMP_INGR = GL_ALPHA_MAX_CLAMP_INGR GL_ALPHA_MAX_SGIX = GL_ALPHA_MAX_SGIX GL_ALPHA_MIN_CLAMP_INGR = GL_ALPHA_MIN_CLAMP_INGR GL_ALPHA_MIN_SGIX = GL_ALPHA_MIN_SGIX GL_ALPHA_SCALE = GL_ALPHA_SCALE GL_ALPHA_TEST = GL_ALPHA_TEST GL_ALPHA_TEST_FUNC = GL_ALPHA_TEST_FUNC GL_ALPHA_TEST_REF = GL_ALPHA_TEST_REF GL_ALWAYS = GL_ALWAYS GL_ALWAYS_FAST_HINT_PGI = GL_ALWAYS_FAST_HINT_PGI GL_ALWAYS_SOFT_HINT_PGI = GL_ALWAYS_SOFT_HINT_PGI GL_AMBIENT = GL_AMBIENT GL_AMBIENT_AND_DIFFUSE = GL_AMBIENT_AND_DIFFUSE GL_AND = GL_AND GL_AND_INVERTED = GL_AND_INVERTED GL_AND_REVERSE = GL_AND_REVERSE GL_ARRAY_BUFFER = GL_ARRAY_BUFFER GL_ARRAY_BUFFER_ARB = GL_ARRAY_BUFFER_ARB GL_ARRAY_BUFFER_BINDING = GL_ARRAY_BUFFER_BINDING GL_ARRAY_BUFFER_BINDING_ARB = GL_ARRAY_BUFFER_BINDING_ARB GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = GL_ARRAY_ELEMENT_LOCK_COUNT_EXT GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = GL_ARRAY_ELEMENT_LOCK_FIRST_EXT GL_ARRAY_OBJECT_BUFFER_ATI = GL_ARRAY_OBJECT_BUFFER_ATI GL_ARRAY_OBJECT_OFFSET_ATI = GL_ARRAY_OBJECT_OFFSET_ATI GL_ASYNC_DRAW_PIXELS_SGIX = GL_ASYNC_DRAW_PIXELS_SGIX GL_ASYNC_HISTOGRAM_SGIX = GL_ASYNC_HISTOGRAM_SGIX GL_ASYNC_MARKER_SGIX = GL_ASYNC_MARKER_SGIX GL_ASYNC_READ_PIXELS_SGIX = GL_ASYNC_READ_PIXELS_SGIX GL_ASYNC_TEX_IMAGE_SGIX = GL_ASYNC_TEX_IMAGE_SGIX GL_ATTACHED_SHADERS = GL_ATTACHED_SHADERS GL_ATTENUATION_EXT = GL_ATTENUATION_EXT GL_ATTRIB_ARRAY_POINTER_NV = GL_ATTRIB_ARRAY_POINTER_NV GL_ATTRIB_ARRAY_SIZE_NV = GL_ATTRIB_ARRAY_SIZE_NV GL_ATTRIB_ARRAY_STRIDE_NV = GL_ATTRIB_ARRAY_STRIDE_NV GL_ATTRIB_ARRAY_TYPE_NV = GL_ATTRIB_ARRAY_TYPE_NV GL_ATTRIB_STACK_DEPTH = GL_ATTRIB_STACK_DEPTH GL_AUTO_NORMAL = GL_AUTO_NORMAL GL_AUX0 = GL_AUX0 GL_AUX1 = GL_AUX1 GL_AUX2 = GL_AUX2 GL_AUX3 = GL_AUX3 GL_AUX_BUFFERS = GL_AUX_BUFFERS GL_AVERAGE_EXT = GL_AVERAGE_EXT GL_AVERAGE_HP = GL_AVERAGE_HP GL_BACK = GL_BACK GL_BACK_LEFT = GL_BACK_LEFT GL_BACK_NORMALS_HINT_PGI = GL_BACK_NORMALS_HINT_PGI GL_BACK_RIGHT = GL_BACK_RIGHT GL_BGR = GL_BGR GL_BGRA = GL_BGRA GL_BGRA_EXT = GL_BGRA_EXT GL_BGR_EXT = GL_BGR_EXT GL_BIAS_BIT_ATI = GL_BIAS_BIT_ATI GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = GL_BIAS_BY_NEGATIVE_ONE_HALF_NV GL_BINORMAL_ARRAY_EXT = GL_BINORMAL_ARRAY_EXT GL_BINORMAL_ARRAY_POINTER_EXT = GL_BINORMAL_ARRAY_POINTER_EXT GL_BINORMAL_ARRAY_STRIDE_EXT = GL_BINORMAL_ARRAY_STRIDE_EXT GL_BINORMAL_ARRAY_TYPE_EXT = GL_BINORMAL_ARRAY_TYPE_EXT GL_BITMAP = GL_BITMAP GL_BITMAP_TOKEN = GL_BITMAP_TOKEN GL_BLEND = GL_BLEND GL_BLEND_COLOR = GL_BLEND_COLOR GL_BLEND_COLOR_EXT = GL_BLEND_COLOR_EXT GL_BLEND_DST = GL_BLEND_DST GL_BLEND_DST_ALPHA = GL_BLEND_DST_ALPHA GL_BLEND_DST_ALPHA_EXT = GL_BLEND_DST_ALPHA_EXT GL_BLEND_DST_RGB = GL_BLEND_DST_RGB GL_BLEND_DST_RGB_EXT = GL_BLEND_DST_RGB_EXT GL_BLEND_EQUATION = GL_BLEND_EQUATION GL_BLEND_EQUATION_ALPHA = GL_BLEND_EQUATION_ALPHA GL_BLEND_EQUATION_ALPHA_EXT = GL_BLEND_EQUATION_ALPHA_EXT GL_BLEND_EQUATION_EXT = GL_BLEND_EQUATION_EXT GL_BLEND_EQUATION_RGB = GL_BLEND_EQUATION GL_BLEND_EQUATION_RGB_EXT = GL_BLEND_EQUATION GL_BLEND_SRC = GL_BLEND_SRC GL_BLEND_SRC_ALPHA = GL_BLEND_SRC_ALPHA GL_BLEND_SRC_ALPHA_EXT = GL_BLEND_SRC_ALPHA_EXT GL_BLEND_SRC_RGB = GL_BLEND_SRC_RGB GL_BLEND_SRC_RGB_EXT = GL_BLEND_SRC_RGB_EXT GL_BLUE = GL_BLUE GL_BLUE_BIAS = GL_BLUE_BIAS GL_BLUE_BITS = GL_BLUE_BITS GL_BLUE_BIT_ATI = GL_BLUE_BIT_ATI GL_BLUE_MAX_CLAMP_INGR = GL_BLUE_MAX_CLAMP_INGR GL_BLUE_MIN_CLAMP_INGR = GL_BLUE_MIN_CLAMP_INGR GL_BLUE_SCALE = GL_BLUE_SCALE GL_BOOL = GL_BOOL GL_BOOL_ARB = GL_BOOL_ARB GL_BOOL_VEC2 = GL_BOOL_VEC2 GL_BOOL_VEC2_ARB = GL_BOOL_VEC2_ARB GL_BOOL_VEC3 = GL_BOOL_VEC3 GL_BOOL_VEC3_ARB = GL_BOOL_VEC3_ARB GL_BOOL_VEC4 = GL_BOOL_VEC4 GL_BOOL_VEC4_ARB = GL_BOOL_VEC4_ARB GL_BUFFER_ACCESS = GL_BUFFER_ACCESS GL_BUFFER_ACCESS_ARB = GL_BUFFER_ACCESS_ARB GL_BUFFER_MAPPED = GL_BUFFER_MAPPED GL_BUFFER_MAPPED_ARB = GL_BUFFER_MAPPED_ARB GL_BUFFER_MAP_POINTER = GL_BUFFER_MAP_POINTER GL_BUFFER_MAP_POINTER_ARB = GL_BUFFER_MAP_POINTER_ARB GL_BUFFER_SIZE = GL_BUFFER_SIZE GL_BUFFER_SIZE_ARB = GL_BUFFER_SIZE_ARB GL_BUFFER_USAGE = GL_BUFFER_USAGE GL_BUFFER_USAGE_ARB = GL_BUFFER_USAGE_ARB GL_BUMP_ENVMAP_ATI = GL_BUMP_ENVMAP_ATI GL_BUMP_NUM_TEX_UNITS_ATI = GL_BUMP_NUM_TEX_UNITS_ATI GL_BUMP_ROT_MATRIX_ATI = GL_BUMP_ROT_MATRIX_ATI GL_BUMP_ROT_MATRIX_SIZE_ATI = GL_BUMP_ROT_MATRIX_SIZE_ATI GL_BUMP_TARGET_ATI = GL_BUMP_TARGET_ATI GL_BUMP_TEX_UNITS_ATI = GL_BUMP_TEX_UNITS_ATI GL_BYTE = GL_BYTE GL_C3F_V3F = GL_C3F_V3F GL_C4F_N3F_V3F = GL_C4F_N3F_V3F GL_C4UB_V2F = GL_C4UB_V2F GL_C4UB_V3F = GL_C4UB_V3F GL_CALLIGRAPHIC_FRAGMENT_SGIX = GL_CALLIGRAPHIC_FRAGMENT_SGIX GL_CCW = GL_CCW GL_CLAMP = GL_CLAMP GL_CLAMP_FRAGMENT_COLOR_ARB = GL_CLAMP_FRAGMENT_COLOR_ARB GL_CLAMP_READ_COLOR_ARB = GL_CLAMP_READ_COLOR_ARB GL_CLAMP_TO_BORDER = GL_CLAMP_TO_BORDER GL_CLAMP_TO_BORDER_ARB = GL_CLAMP_TO_BORDER_ARB GL_CLAMP_TO_BORDER_SGIS = GL_CLAMP_TO_BORDER_SGIS GL_CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE GL_CLAMP_TO_EDGE_SGIS = GL_CLAMP_TO_EDGE_SGIS GL_CLAMP_VERTEX_COLOR_ARB = GL_CLAMP_VERTEX_COLOR_ARB GL_CLEAR = GL_CLEAR GL_CLIENT_ACTIVE_TEXTURE = GL_CLIENT_ACTIVE_TEXTURE GL_CLIENT_ACTIVE_TEXTURE_ARB = GL_CLIENT_ACTIVE_TEXTURE_ARB GL_CLIENT_ALL_ATTRIB_BITS = GL_CLIENT_ALL_ATTRIB_BITS GL_CLIENT_ATTRIB_STACK_DEPTH = GL_CLIENT_ATTRIB_STACK_DEPTH GL_CLIENT_PIXEL_STORE_BIT = GL_CLIENT_PIXEL_STORE_BIT GL_CLIENT_VERTEX_ARRAY_BIT = GL_CLIENT_VERTEX_ARRAY_BIT GL_CLIP_FAR_HINT_PGI = GL_CLIP_FAR_HINT_PGI GL_CLIP_NEAR_HINT_PGI = GL_CLIP_NEAR_HINT_PGI GL_CLIP_PLANE0 = GL_CLIP_PLANE0 GL_CLIP_PLANE1 = GL_CLIP_PLANE1 GL_CLIP_PLANE2 = GL_CLIP_PLANE2 GL_CLIP_PLANE3 = GL_CLIP_PLANE3 GL_CLIP_PLANE4 = GL_CLIP_PLANE4 GL_CLIP_PLANE5 = GL_CLIP_PLANE5 GL_CLIP_VOLUME_CLIPPING_HINT_EXT = GL_CLIP_VOLUME_CLIPPING_HINT_EXT GL_CMYKA_EXT = GL_CMYKA_EXT GL_CMYK_EXT = GL_CMYK_EXT GL_CND0_ATI = GL_CND0_ATI GL_CND_ATI = GL_CND_ATI GL_COEFF = GL_COEFF GL_COLOR = GL_COLOR GL_COLOR3_BIT_PGI = GL_COLOR3_BIT_PGI GL_COLOR4_BIT_PGI = GL_COLOR4_BIT_PGI GL_COLOR_ALPHA_PAIRING_ATI = GL_COLOR_ALPHA_PAIRING_ATI GL_COLOR_ARRAY = GL_COLOR_ARRAY GL_COLOR_ARRAY_BUFFER_BINDING = GL_COLOR_ARRAY_BUFFER_BINDING GL_COLOR_ARRAY_BUFFER_BINDING_ARB = GL_COLOR_ARRAY_BUFFER_BINDING_ARB GL_COLOR_ARRAY_COUNT_EXT = GL_COLOR_ARRAY_COUNT_EXT GL_COLOR_ARRAY_EXT = GL_COLOR_ARRAY_EXT GL_COLOR_ARRAY_LIST_IBM = GL_COLOR_ARRAY_LIST_IBM GL_COLOR_ARRAY_LIST_STRIDE_IBM = GL_COLOR_ARRAY_LIST_STRIDE_IBM GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL GL_COLOR_ARRAY_POINTER = GL_COLOR_ARRAY_POINTER GL_COLOR_ARRAY_POINTER_EXT = GL_COLOR_ARRAY_POINTER_EXT GL_COLOR_ARRAY_SIZE = GL_COLOR_ARRAY_SIZE GL_COLOR_ARRAY_SIZE_EXT = GL_COLOR_ARRAY_SIZE_EXT GL_COLOR_ARRAY_STRIDE = GL_COLOR_ARRAY_STRIDE GL_COLOR_ARRAY_STRIDE_EXT = GL_COLOR_ARRAY_STRIDE_EXT GL_COLOR_ARRAY_TYPE = GL_COLOR_ARRAY_TYPE GL_COLOR_ARRAY_TYPE_EXT = GL_COLOR_ARRAY_TYPE_EXT GL_COLOR_ATTACHMENT0_EXT = GL_COLOR_ATTACHMENT0_EXT GL_COLOR_ATTACHMENT10_EXT = GL_COLOR_ATTACHMENT10_EXT GL_COLOR_ATTACHMENT11_EXT = GL_COLOR_ATTACHMENT11_EXT GL_COLOR_ATTACHMENT12_EXT = GL_COLOR_ATTACHMENT12_EXT GL_COLOR_ATTACHMENT13_EXT = GL_COLOR_ATTACHMENT13_EXT GL_COLOR_ATTACHMENT14_EXT = GL_COLOR_ATTACHMENT14_EXT GL_COLOR_ATTACHMENT15_EXT = GL_COLOR_ATTACHMENT15_EXT GL_COLOR_ATTACHMENT1_EXT = GL_COLOR_ATTACHMENT1_EXT GL_COLOR_ATTACHMENT2_EXT = GL_COLOR_ATTACHMENT2_EXT GL_COLOR_ATTACHMENT3_EXT = GL_COLOR_ATTACHMENT3_EXT GL_COLOR_ATTACHMENT4_EXT = GL_COLOR_ATTACHMENT4_EXT GL_COLOR_ATTACHMENT5_EXT = GL_COLOR_ATTACHMENT5_EXT GL_COLOR_ATTACHMENT6_EXT = GL_COLOR_ATTACHMENT6_EXT GL_COLOR_ATTACHMENT7_EXT = GL_COLOR_ATTACHMENT7_EXT GL_COLOR_ATTACHMENT8_EXT = GL_COLOR_ATTACHMENT8_EXT GL_COLOR_ATTACHMENT9_EXT = GL_COLOR_ATTACHMENT9_EXT GL_COLOR_BUFFER_BIT = GL_COLOR_BUFFER_BIT GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI GL_COLOR_CLEAR_VALUE = GL_COLOR_CLEAR_VALUE GL_COLOR_INDEX = GL_COLOR_INDEX GL_COLOR_INDEX12_EXT = GL_COLOR_INDEX12_EXT GL_COLOR_INDEX16_EXT = GL_COLOR_INDEX16_EXT GL_COLOR_INDEX1_EXT = GL_COLOR_INDEX1_EXT GL_COLOR_INDEX2_EXT = GL_COLOR_INDEX2_EXT GL_COLOR_INDEX4_EXT = GL_COLOR_INDEX4_EXT GL_COLOR_INDEX8_EXT = GL_COLOR_INDEX8_EXT GL_COLOR_INDEXES = GL_COLOR_INDEXES GL_COLOR_LOGIC_OP = GL_COLOR_LOGIC_OP GL_COLOR_MATERIAL = GL_COLOR_MATERIAL GL_COLOR_MATERIAL_FACE = GL_COLOR_MATERIAL_FACE GL_COLOR_MATERIAL_PARAMETER = GL_COLOR_MATERIAL_PARAMETER GL_COLOR_MATRIX = GL_COLOR_MATRIX GL_COLOR_MATRIX_SGI = GL_COLOR_MATRIX_SGI GL_COLOR_MATRIX_STACK_DEPTH = GL_COLOR_MATRIX_STACK_DEPTH GL_COLOR_MATRIX_STACK_DEPTH_SGI = GL_COLOR_MATRIX_STACK_DEPTH_SGI GL_COLOR_SUM = GL_COLOR_SUM GL_COLOR_SUM_ARB = GL_COLOR_SUM_ARB GL_COLOR_SUM_CLAMP_NV = GL_COLOR_SUM_CLAMP_NV GL_COLOR_SUM_EXT = GL_COLOR_SUM_EXT GL_COLOR_TABLE = GL_COLOR_TABLE GL_COLOR_TABLE_ALPHA_SIZE = GL_COLOR_TABLE_ALPHA_SIZE GL_COLOR_TABLE_ALPHA_SIZE_SGI = GL_COLOR_TABLE_ALPHA_SIZE_SGI GL_COLOR_TABLE_BIAS = GL_COLOR_TABLE_BIAS GL_COLOR_TABLE_BIAS_SGI = GL_COLOR_TABLE_BIAS_SGI GL_COLOR_TABLE_BLUE_SIZE = GL_COLOR_TABLE_BLUE_SIZE GL_COLOR_TABLE_BLUE_SIZE_SGI = GL_COLOR_TABLE_BLUE_SIZE_SGI GL_COLOR_TABLE_FORMAT = GL_COLOR_TABLE_FORMAT GL_COLOR_TABLE_FORMAT_SGI = GL_COLOR_TABLE_FORMAT_SGI GL_COLOR_TABLE_GREEN_SIZE = GL_COLOR_TABLE_GREEN_SIZE GL_COLOR_TABLE_GREEN_SIZE_SGI = GL_COLOR_TABLE_GREEN_SIZE_SGI GL_COLOR_TABLE_INTENSITY_SIZE = GL_COLOR_TABLE_INTENSITY_SIZE GL_COLOR_TABLE_INTENSITY_SIZE_SGI = GL_COLOR_TABLE_INTENSITY_SIZE_SGI GL_COLOR_TABLE_LUMINANCE_SIZE = GL_COLOR_TABLE_LUMINANCE_SIZE GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = GL_COLOR_TABLE_LUMINANCE_SIZE_SGI GL_COLOR_TABLE_RED_SIZE = GL_COLOR_TABLE_RED_SIZE GL_COLOR_TABLE_RED_SIZE_SGI = GL_COLOR_TABLE_RED_SIZE_SGI GL_COLOR_TABLE_SCALE = GL_COLOR_TABLE_SCALE GL_COLOR_TABLE_SCALE_SGI = GL_COLOR_TABLE_SCALE_SGI GL_COLOR_TABLE_SGI = GL_COLOR_TABLE_SGI GL_COLOR_TABLE_WIDTH = GL_COLOR_TABLE_WIDTH GL_COLOR_TABLE_WIDTH_SGI = GL_COLOR_TABLE_WIDTH_SGI GL_COLOR_WRITEMASK = GL_COLOR_WRITEMASK GL_COMBINE = GL_COMBINE GL_COMBINE4_NV = GL_COMBINE4_NV GL_COMBINER0_NV = GL_COMBINER0_NV GL_COMBINER1_NV = GL_COMBINER1_NV GL_COMBINER2_NV = GL_COMBINER2_NV GL_COMBINER3_NV = GL_COMBINER3_NV GL_COMBINER4_NV = GL_COMBINER4_NV GL_COMBINER5_NV = GL_COMBINER5_NV GL_COMBINER6_NV = GL_COMBINER6_NV GL_COMBINER7_NV = GL_COMBINER7_NV GL_COMBINER_AB_DOT_PRODUCT_NV = GL_COMBINER_AB_DOT_PRODUCT_NV GL_COMBINER_AB_OUTPUT_NV = GL_COMBINER_AB_OUTPUT_NV GL_COMBINER_BIAS_NV = GL_COMBINER_BIAS_NV GL_COMBINER_CD_DOT_PRODUCT_NV = GL_COMBINER_CD_DOT_PRODUCT_NV GL_COMBINER_CD_OUTPUT_NV = GL_COMBINER_CD_OUTPUT_NV GL_COMBINER_COMPONENT_USAGE_NV = GL_COMBINER_COMPONENT_USAGE_NV GL_COMBINER_INPUT_NV = GL_COMBINER_INPUT_NV GL_COMBINER_MAPPING_NV = GL_COMBINER_MAPPING_NV GL_COMBINER_MUX_SUM_NV = GL_COMBINER_MUX_SUM_NV GL_COMBINER_SCALE_NV = GL_COMBINER_SCALE_NV GL_COMBINER_SUM_OUTPUT_NV = GL_COMBINER_SUM_OUTPUT_NV GL_COMBINE_ALPHA = GL_COMBINE_ALPHA GL_COMBINE_ALPHA_ARB = GL_COMBINE_ALPHA_ARB GL_COMBINE_ALPHA_EXT = GL_COMBINE_ALPHA_EXT GL_COMBINE_ARB = GL_COMBINE_ARB GL_COMBINE_EXT = GL_COMBINE_EXT GL_COMBINE_RGB = GL_COMBINE_RGB GL_COMBINE_RGB_ARB = GL_COMBINE_RGB_ARB GL_COMBINE_RGB_EXT = GL_COMBINE_RGB_EXT GL_COMPARE_R_TO_TEXTURE = GL_COMPARE_R_TO_TEXTURE GL_COMPARE_R_TO_TEXTURE_ARB = GL_COMPARE_R_TO_TEXTURE_ARB GL_COMPILE = GL_COMPILE GL_COMPILE_AND_EXECUTE = GL_COMPILE_AND_EXECUTE GL_COMPILE_STATUS = GL_COMPILE_STATUS GL_COMPRESSED_ALPHA = GL_COMPRESSED_ALPHA GL_COMPRESSED_ALPHA_ARB = GL_COMPRESSED_ALPHA_ARB GL_COMPRESSED_INTENSITY = GL_COMPRESSED_INTENSITY GL_COMPRESSED_INTENSITY_ARB = GL_COMPRESSED_INTENSITY_ARB GL_COMPRESSED_LUMINANCE = GL_COMPRESSED_LUMINANCE GL_COMPRESSED_LUMINANCE_ALPHA = GL_COMPRESSED_LUMINANCE_ALPHA GL_COMPRESSED_LUMINANCE_ALPHA_ARB = GL_COMPRESSED_LUMINANCE_ALPHA_ARB GL_COMPRESSED_LUMINANCE_ARB = GL_COMPRESSED_LUMINANCE_ARB GL_COMPRESSED_RGB = GL_COMPRESSED_RGB GL_COMPRESSED_RGBA = GL_COMPRESSED_RGBA GL_COMPRESSED_RGBA_ARB = GL_COMPRESSED_RGBA_ARB GL_COMPRESSED_RGBA_FXT1_3DFX = GL_COMPRESSED_RGBA_FXT1_3DFX GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT GL_COMPRESSED_RGB_ARB = GL_COMPRESSED_RGB_ARB GL_COMPRESSED_RGB_FXT1_3DFX = GL_COMPRESSED_RGB_FXT1_3DFX GL_COMPRESSED_RGB_S3TC_DXT1_EXT = GL_COMPRESSED_RGB_S3TC_DXT1_EXT GL_COMPRESSED_TEXTURE_FORMATS = GL_COMPRESSED_TEXTURE_FORMATS GL_COMPRESSED_TEXTURE_FORMATS_ARB = GL_COMPRESSED_TEXTURE_FORMATS_ARB GL_COMP_BIT_ATI = GL_COMP_BIT_ATI GL_CONSERVE_MEMORY_HINT_PGI = GL_CONSERVE_MEMORY_HINT_PGI GL_CONSTANT = GL_CONSTANT GL_CONSTANT_ALPHA = GL_CONSTANT_ALPHA GL_CONSTANT_ALPHA_EXT = GL_CONSTANT_ALPHA_EXT GL_CONSTANT_ARB = GL_CONSTANT_ARB GL_CONSTANT_ATTENUATION = GL_CONSTANT_ATTENUATION GL_CONSTANT_BORDER = GL_CONSTANT_BORDER GL_CONSTANT_BORDER_HP = GL_CONSTANT_BORDER_HP GL_CONSTANT_COLOR = GL_CONSTANT_COLOR GL_CONSTANT_COLOR0_NV = GL_CONSTANT_COLOR0_NV GL_CONSTANT_COLOR1_NV = GL_CONSTANT_COLOR1_NV GL_CONSTANT_COLOR_EXT = GL_CONSTANT_COLOR_EXT GL_CONSTANT_EXT = GL_CONSTANT_EXT GL_CONST_EYE_NV = GL_CONST_EYE_NV GL_CONVOLUTION_1D = GL_CONVOLUTION_1D GL_CONVOLUTION_1D_EXT = GL_CONVOLUTION_1D_EXT GL_CONVOLUTION_2D = GL_CONVOLUTION_2D GL_CONVOLUTION_2D_EXT = GL_CONVOLUTION_2D_EXT GL_CONVOLUTION_BORDER_COLOR = GL_CONVOLUTION_BORDER_COLOR GL_CONVOLUTION_BORDER_COLOR_HP = GL_CONVOLUTION_BORDER_COLOR_HP GL_CONVOLUTION_BORDER_MODE = GL_CONVOLUTION_BORDER_MODE GL_CONVOLUTION_BORDER_MODE_EXT = GL_CONVOLUTION_BORDER_MODE_EXT GL_CONVOLUTION_FILTER_BIAS = GL_CONVOLUTION_FILTER_BIAS GL_CONVOLUTION_FILTER_BIAS_EXT = GL_CONVOLUTION_FILTER_BIAS_EXT GL_CONVOLUTION_FILTER_SCALE = GL_CONVOLUTION_FILTER_SCALE GL_CONVOLUTION_FILTER_SCALE_EXT = GL_CONVOLUTION_FILTER_SCALE_EXT GL_CONVOLUTION_FORMAT = GL_CONVOLUTION_FORMAT GL_CONVOLUTION_FORMAT_EXT = GL_CONVOLUTION_FORMAT_EXT GL_CONVOLUTION_HEIGHT = GL_CONVOLUTION_HEIGHT GL_CONVOLUTION_HEIGHT_EXT = GL_CONVOLUTION_HEIGHT_EXT GL_CONVOLUTION_HINT_SGIX = GL_CONVOLUTION_HINT_SGIX GL_CONVOLUTION_WIDTH = GL_CONVOLUTION_WIDTH GL_CONVOLUTION_WIDTH_EXT = GL_CONVOLUTION_WIDTH_EXT GL_CON_0_ATI = GL_CON_0_ATI GL_CON_10_ATI = GL_CON_10_ATI GL_CON_11_ATI = GL_CON_11_ATI GL_CON_12_ATI = GL_CON_12_ATI GL_CON_13_ATI = GL_CON_13_ATI GL_CON_14_ATI = GL_CON_14_ATI GL_CON_15_ATI = GL_CON_15_ATI GL_CON_16_ATI = GL_CON_16_ATI GL_CON_17_ATI = GL_CON_17_ATI GL_CON_18_ATI = GL_CON_18_ATI GL_CON_19_ATI = GL_CON_19_ATI GL_CON_1_ATI = GL_CON_1_ATI GL_CON_20_ATI = GL_CON_20_ATI GL_CON_21_ATI = GL_CON_21_ATI GL_CON_22_ATI = GL_CON_22_ATI GL_CON_23_ATI = GL_CON_23_ATI GL_CON_24_ATI = GL_CON_24_ATI GL_CON_25_ATI = GL_CON_25_ATI GL_CON_26_ATI = GL_CON_26_ATI GL_CON_27_ATI = GL_CON_27_ATI GL_CON_28_ATI = GL_CON_28_ATI GL_CON_29_ATI = GL_CON_29_ATI GL_CON_2_ATI = GL_CON_2_ATI GL_CON_30_ATI = GL_CON_30_ATI GL_CON_31_ATI = GL_CON_31_ATI GL_CON_3_ATI = GL_CON_3_ATI GL_CON_4_ATI = GL_CON_4_ATI GL_CON_5_ATI = GL_CON_5_ATI GL_CON_6_ATI = GL_CON_6_ATI GL_CON_7_ATI = GL_CON_7_ATI GL_CON_8_ATI = GL_CON_8_ATI GL_CON_9_ATI = GL_CON_9_ATI GL_COORD_REPLACE = GL_COORD_REPLACE GL_COORD_REPLACE_ARB = GL_COORD_REPLACE_ARB GL_COORD_REPLACE_NV = GL_COORD_REPLACE_NV GL_COPY = GL_COPY GL_COPY_INVERTED = GL_COPY_INVERTED GL_COPY_PIXEL_TOKEN = GL_COPY_PIXEL_TOKEN GL_CUBIC_EXT = GL_CUBIC_EXT GL_CUBIC_HP = GL_CUBIC_HP GL_CULL_FACE = GL_CULL_FACE GL_CULL_FACE_MODE = GL_CULL_FACE_MODE GL_CULL_FRAGMENT_NV = GL_CULL_FRAGMENT_NV GL_CULL_MODES_NV = GL_CULL_MODES_NV GL_CULL_VERTEX_EXT = GL_CULL_VERTEX_EXT GL_CULL_VERTEX_EYE_POSITION_EXT = GL_CULL_VERTEX_EYE_POSITION_EXT GL_CULL_VERTEX_IBM = GL_CULL_VERTEX_IBM GL_CULL_VERTEX_OBJECT_POSITION_EXT = GL_CULL_VERTEX_OBJECT_POSITION_EXT GL_CURRENT_ATTRIB_NV = GL_CURRENT_ATTRIB_NV GL_CURRENT_BINORMAL_EXT = GL_CURRENT_BINORMAL_EXT GL_CURRENT_BIT = GL_CURRENT_BIT GL_CURRENT_COLOR = GL_CURRENT_COLOR GL_CURRENT_FOG_COORD = GL_CURRENT_FOG_COORDINATE GL_CURRENT_FOG_COORDINATE = GL_CURRENT_FOG_COORDINATE GL_CURRENT_FOG_COORDINATE_EXT = GL_CURRENT_FOG_COORDINATE_EXT GL_CURRENT_INDEX = GL_CURRENT_INDEX GL_CURRENT_MATRIX_ARB = GL_CURRENT_MATRIX_ARB GL_CURRENT_MATRIX_INDEX_ARB = GL_CURRENT_MATRIX_INDEX_ARB GL_CURRENT_MATRIX_NV = GL_CURRENT_MATRIX_NV GL_CURRENT_MATRIX_STACK_DEPTH_ARB = GL_CURRENT_MATRIX_STACK_DEPTH_ARB GL_CURRENT_MATRIX_STACK_DEPTH_NV = GL_CURRENT_MATRIX_STACK_DEPTH_NV GL_CURRENT_NORMAL = GL_CURRENT_NORMAL GL_CURRENT_OCCLUSION_QUERY_ID_NV = GL_CURRENT_OCCLUSION_QUERY_ID_NV GL_CURRENT_PALETTE_MATRIX_ARB = GL_CURRENT_PALETTE_MATRIX_ARB GL_CURRENT_PROGRAM = GL_CURRENT_PROGRAM GL_CURRENT_QUERY = GL_CURRENT_QUERY GL_CURRENT_QUERY_ARB = GL_CURRENT_QUERY_ARB GL_CURRENT_RASTER_COLOR = GL_CURRENT_RASTER_COLOR GL_CURRENT_RASTER_DISTANCE = GL_CURRENT_RASTER_DISTANCE GL_CURRENT_RASTER_INDEX = GL_CURRENT_RASTER_INDEX GL_CURRENT_RASTER_NORMAL_SGIX = GL_CURRENT_RASTER_NORMAL_SGIX GL_CURRENT_RASTER_POSITION = GL_CURRENT_RASTER_POSITION GL_CURRENT_RASTER_POSITION_VALID = GL_CURRENT_RASTER_POSITION_VALID GL_CURRENT_RASTER_TEXTURE_COORDS = GL_CURRENT_RASTER_TEXTURE_COORDS GL_CURRENT_SECONDARY_COLOR = GL_CURRENT_SECONDARY_COLOR GL_CURRENT_SECONDARY_COLOR_EXT = GL_CURRENT_SECONDARY_COLOR_EXT GL_CURRENT_TANGENT_EXT = GL_CURRENT_TANGENT_EXT GL_CURRENT_TEXTURE_COORDS = GL_CURRENT_TEXTURE_COORDS GL_CURRENT_VERTEX_ATTRIB = GL_CURRENT_VERTEX_ATTRIB GL_CURRENT_VERTEX_ATTRIB_ARB = GL_CURRENT_VERTEX_ATTRIB_ARB GL_CURRENT_VERTEX_EXT = GL_CURRENT_VERTEX_EXT GL_CURRENT_VERTEX_WEIGHT_EXT = GL_CURRENT_VERTEX_WEIGHT_EXT GL_CURRENT_WEIGHT_ARB = GL_CURRENT_WEIGHT_ARB GL_CW = GL_CW GL_DECAL = GL_DECAL GL_DECR = GL_DECR GL_DECR_WRAP = GL_DECR_WRAP GL_DECR_WRAP_EXT = GL_DECR_WRAP_EXT GL_DEFORMATIONS_MASK_SGIX = GL_DEFORMATIONS_MASK_SGIX GL_DELETE_STATUS = GL_DELETE_STATUS GL_DEPENDENT_AR_TEXTURE_2D_NV = GL_DEPENDENT_AR_TEXTURE_2D_NV GL_DEPENDENT_GB_TEXTURE_2D_NV = GL_DEPENDENT_GB_TEXTURE_2D_NV GL_DEPENDENT_HILO_TEXTURE_2D_NV = GL_DEPENDENT_HILO_TEXTURE_2D_NV GL_DEPENDENT_RGB_TEXTURE_3D_NV = GL_DEPENDENT_RGB_TEXTURE_3D_NV GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV GL_DEPTH = GL_DEPTH GL_DEPTH_ATTACHMENT_EXT = GL_DEPTH_ATTACHMENT_EXT GL_DEPTH_BIAS = GL_DEPTH_BIAS GL_DEPTH_BITS = GL_DEPTH_BITS GL_DEPTH_BOUNDS_EXT = GL_DEPTH_BOUNDS_EXT GL_DEPTH_BOUNDS_TEST_EXT = GL_DEPTH_BOUNDS_TEST_EXT GL_DEPTH_BUFFER_BIT = GL_DEPTH_BUFFER_BIT GL_DEPTH_CLAMP_NV = GL_DEPTH_CLAMP_NV GL_DEPTH_CLEAR_VALUE = GL_DEPTH_CLEAR_VALUE GL_DEPTH_COMPONENT = GL_DEPTH_COMPONENT GL_DEPTH_COMPONENT16 = GL_DEPTH_COMPONENT16 GL_DEPTH_COMPONENT16_ARB = GL_DEPTH_COMPONENT16_ARB GL_DEPTH_COMPONENT16_SGIX = GL_DEPTH_COMPONENT16_SGIX GL_DEPTH_COMPONENT24 = GL_DEPTH_COMPONENT24 GL_DEPTH_COMPONENT24_ARB = GL_DEPTH_COMPONENT24_ARB GL_DEPTH_COMPONENT24_SGIX = GL_DEPTH_COMPONENT24_SGIX GL_DEPTH_COMPONENT32 = GL_DEPTH_COMPONENT32 GL_DEPTH_COMPONENT32_ARB = GL_DEPTH_COMPONENT32_ARB GL_DEPTH_COMPONENT32_SGIX = GL_DEPTH_COMPONENT32_SGIX GL_DEPTH_FUNC = GL_DEPTH_FUNC GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX GL_DEPTH_PASS_INSTRUMENT_SGIX = GL_DEPTH_PASS_INSTRUMENT_SGIX GL_DEPTH_RANGE = GL_DEPTH_RANGE GL_DEPTH_SCALE = GL_DEPTH_SCALE GL_DEPTH_STENCIL_NV = GL_DEPTH_STENCIL_NV GL_DEPTH_STENCIL_TO_BGRA_NV = GL_DEPTH_STENCIL_TO_BGRA_NV GL_DEPTH_STENCIL_TO_RGBA_NV = GL_DEPTH_STENCIL_TO_RGBA_NV GL_DEPTH_TEST = GL_DEPTH_TEST GL_DEPTH_TEXTURE_MODE = GL_DEPTH_TEXTURE_MODE GL_DEPTH_TEXTURE_MODE_ARB = GL_DEPTH_TEXTURE_MODE_ARB GL_DEPTH_WRITEMASK = GL_DEPTH_WRITEMASK GL_DETAIL_TEXTURE_2D_BINDING_SGIS = GL_DETAIL_TEXTURE_2D_BINDING_SGIS GL_DETAIL_TEXTURE_2D_SGIS = GL_DETAIL_TEXTURE_2D_SGIS GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS GL_DETAIL_TEXTURE_LEVEL_SGIS = GL_DETAIL_TEXTURE_LEVEL_SGIS GL_DETAIL_TEXTURE_MODE_SGIS = GL_DETAIL_TEXTURE_MODE_SGIS GL_DIFFUSE = GL_DIFFUSE GL_DISCARD_ATI = GL_DISCARD_ATI GL_DISCARD_NV = GL_DISCARD_NV GL_DISTANCE_ATTENUATION_EXT = GL_DISTANCE_ATTENUATION_EXT GL_DISTANCE_ATTENUATION_SGIS = GL_DISTANCE_ATTENUATION_SGIS GL_DITHER = GL_DITHER GL_DOMAIN = GL_DOMAIN GL_DONT_CARE = GL_DONT_CARE GL_DOT2_ADD_ATI = GL_DOT2_ADD_ATI GL_DOT3_ATI = GL_DOT3_ATI GL_DOT3_RGB = GL_DOT3_RGB GL_DOT3_RGBA = GL_DOT3_RGBA GL_DOT3_RGBA_ARB = GL_DOT3_RGBA_ARB GL_DOT3_RGBA_EXT = GL_DOT3_RGBA_EXT GL_DOT3_RGB_ARB = GL_DOT3_RGB_ARB GL_DOT3_RGB_EXT = GL_DOT3_RGB_EXT GL_DOT4_ATI = GL_DOT4_ATI GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV GL_DOT_PRODUCT_DEPTH_REPLACE_NV = GL_DOT_PRODUCT_DEPTH_REPLACE_NV GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV GL_DOT_PRODUCT_NV = GL_DOT_PRODUCT_NV GL_DOT_PRODUCT_PASS_THROUGH_NV = GL_DOT_PRODUCT_PASS_THROUGH_NV GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV GL_DOT_PRODUCT_TEXTURE_1D_NV = GL_DOT_PRODUCT_TEXTURE_1D_NV GL_DOT_PRODUCT_TEXTURE_2D_NV = GL_DOT_PRODUCT_TEXTURE_2D_NV GL_DOT_PRODUCT_TEXTURE_3D_NV = GL_DOT_PRODUCT_TEXTURE_3D_NV GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV GL_DOUBLE = GL_DOUBLE GL_DOUBLEBUFFER = GL_DOUBLEBUFFER GL_DOUBLE_EXT = GL_DOUBLE_EXT GL_DRAW_BUFFER = GL_DRAW_BUFFER GL_DRAW_BUFFER0 = GL_DRAW_BUFFER0 GL_DRAW_BUFFER0_ARB = GL_DRAW_BUFFER0_ARB GL_DRAW_BUFFER0_ATI = GL_DRAW_BUFFER0_ATI GL_DRAW_BUFFER1 = GL_DRAW_BUFFER1 GL_DRAW_BUFFER10 = GL_DRAW_BUFFER10 GL_DRAW_BUFFER10_ARB = GL_DRAW_BUFFER10_ARB GL_DRAW_BUFFER10_ATI = GL_DRAW_BUFFER10_ATI GL_DRAW_BUFFER11 = GL_DRAW_BUFFER11 GL_DRAW_BUFFER11_ARB = GL_DRAW_BUFFER11_ARB GL_DRAW_BUFFER11_ATI = GL_DRAW_BUFFER11_ATI GL_DRAW_BUFFER12 = GL_DRAW_BUFFER12 GL_DRAW_BUFFER12_ARB = GL_DRAW_BUFFER12_ARB GL_DRAW_BUFFER12_ATI = GL_DRAW_BUFFER12_ATI GL_DRAW_BUFFER13 = GL_DRAW_BUFFER13 GL_DRAW_BUFFER13_ARB = GL_DRAW_BUFFER13_ARB GL_DRAW_BUFFER13_ATI = GL_DRAW_BUFFER13_ATI GL_DRAW_BUFFER14 = GL_DRAW_BUFFER14 GL_DRAW_BUFFER14_ARB = GL_DRAW_BUFFER14_ARB GL_DRAW_BUFFER14_ATI = GL_DRAW_BUFFER14_ATI GL_DRAW_BUFFER15 = GL_DRAW_BUFFER15 GL_DRAW_BUFFER15_ARB = GL_DRAW_BUFFER15_ARB GL_DRAW_BUFFER15_ATI = GL_DRAW_BUFFER15_ATI GL_DRAW_BUFFER1_ARB = GL_DRAW_BUFFER1_ARB GL_DRAW_BUFFER1_ATI = GL_DRAW_BUFFER1_ATI GL_DRAW_BUFFER2 = GL_DRAW_BUFFER2 GL_DRAW_BUFFER2_ARB = GL_DRAW_BUFFER2_ARB GL_DRAW_BUFFER2_ATI = GL_DRAW_BUFFER2_ATI GL_DRAW_BUFFER3 = GL_DRAW_BUFFER3 GL_DRAW_BUFFER3_ARB = GL_DRAW_BUFFER3_ARB GL_DRAW_BUFFER3_ATI = GL_DRAW_BUFFER3_ATI GL_DRAW_BUFFER4 = GL_DRAW_BUFFER4 GL_DRAW_BUFFER4_ARB = GL_DRAW_BUFFER4_ARB GL_DRAW_BUFFER4_ATI = GL_DRAW_BUFFER4_ATI GL_DRAW_BUFFER5 = GL_DRAW_BUFFER5 GL_DRAW_BUFFER5_ARB = GL_DRAW_BUFFER5_ARB GL_DRAW_BUFFER5_ATI = GL_DRAW_BUFFER5_ATI GL_DRAW_BUFFER6 = GL_DRAW_BUFFER6 GL_DRAW_BUFFER6_ARB = GL_DRAW_BUFFER6_ARB GL_DRAW_BUFFER6_ATI = GL_DRAW_BUFFER6_ATI GL_DRAW_BUFFER7 = GL_DRAW_BUFFER7 GL_DRAW_BUFFER7_ARB = GL_DRAW_BUFFER7_ARB GL_DRAW_BUFFER7_ATI = GL_DRAW_BUFFER7_ATI GL_DRAW_BUFFER8 = GL_DRAW_BUFFER8 GL_DRAW_BUFFER8_ARB = GL_DRAW_BUFFER8_ARB GL_DRAW_BUFFER8_ATI = GL_DRAW_BUFFER8_ATI GL_DRAW_BUFFER9 = GL_DRAW_BUFFER9 GL_DRAW_BUFFER9_ARB = GL_DRAW_BUFFER9_ARB GL_DRAW_BUFFER9_ATI = GL_DRAW_BUFFER9_ATI GL_DRAW_PIXELS_APPLE = GL_DRAW_PIXELS_APPLE GL_DRAW_PIXEL_TOKEN = GL_DRAW_PIXEL_TOKEN GL_DSDT8_MAG8_INTENSITY8_NV = GL_DSDT8_MAG8_INTENSITY8_NV GL_DSDT8_MAG8_NV = GL_DSDT8_MAG8_NV GL_DSDT8_NV = GL_DSDT8_NV GL_DSDT_MAG_INTENSITY_NV = GL_DSDT_MAG_INTENSITY_NV GL_DSDT_MAG_NV = GL_DSDT_MAG_NV GL_DSDT_MAG_VIB_NV = GL_DSDT_MAG_VIB_NV GL_DSDT_NV = GL_DSDT_NV GL_DST_ALPHA = GL_DST_ALPHA GL_DST_COLOR = GL_DST_COLOR GL_DS_BIAS_NV = GL_DS_BIAS_NV GL_DS_SCALE_NV = GL_DS_SCALE_NV GL_DT_BIAS_NV = GL_DT_BIAS_NV GL_DT_SCALE_NV = GL_DT_SCALE_NV GL_DU8DV8_ATI = GL_DU8DV8_ATI GL_DUAL_ALPHA12_SGIS = GL_DUAL_ALPHA12_SGIS GL_DUAL_ALPHA16_SGIS = GL_DUAL_ALPHA16_SGIS GL_DUAL_ALPHA4_SGIS = GL_DUAL_ALPHA4_SGIS GL_DUAL_ALPHA8_SGIS = GL_DUAL_ALPHA8_SGIS GL_DUAL_INTENSITY12_SGIS = GL_DUAL_INTENSITY12_SGIS GL_DUAL_INTENSITY16_SGIS = GL_DUAL_INTENSITY16_SGIS GL_DUAL_INTENSITY4_SGIS = GL_DUAL_INTENSITY4_SGIS GL_DUAL_INTENSITY8_SGIS = GL_DUAL_INTENSITY8_SGIS GL_DUAL_LUMINANCE12_SGIS = GL_DUAL_LUMINANCE12_SGIS GL_DUAL_LUMINANCE16_SGIS = GL_DUAL_LUMINANCE16_SGIS GL_DUAL_LUMINANCE4_SGIS = GL_DUAL_LUMINANCE4_SGIS GL_DUAL_LUMINANCE8_SGIS = GL_DUAL_LUMINANCE8_SGIS GL_DUAL_LUMINANCE_ALPHA4_SGIS = GL_DUAL_LUMINANCE_ALPHA4_SGIS GL_DUAL_LUMINANCE_ALPHA8_SGIS = GL_DUAL_LUMINANCE_ALPHA8_SGIS GL_DUAL_TEXTURE_SELECT_SGIS = GL_DUAL_TEXTURE_SELECT_SGIS GL_DUDV_ATI = GL_DUDV_ATI GL_DYNAMIC_ATI = GL_DYNAMIC_ATI GL_DYNAMIC_COPY = GL_DYNAMIC_COPY GL_DYNAMIC_COPY_ARB = GL_DYNAMIC_COPY_ARB GL_DYNAMIC_DRAW = GL_DYNAMIC_DRAW GL_DYNAMIC_DRAW_ARB = GL_DYNAMIC_DRAW_ARB GL_DYNAMIC_READ = GL_DYNAMIC_READ GL_DYNAMIC_READ_ARB = GL_DYNAMIC_READ_ARB GL_EDGEFLAG_BIT_PGI = GL_EDGEFLAG_BIT_PGI GL_EDGE_FLAG = GL_EDGE_FLAG GL_EDGE_FLAG_ARRAY = GL_EDGE_FLAG_ARRAY GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = GL_EDGE_FLAG_ARRAY_BUFFER_BINDING GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB GL_EDGE_FLAG_ARRAY_COUNT_EXT = GL_EDGE_FLAG_ARRAY_COUNT_EXT GL_EDGE_FLAG_ARRAY_EXT = GL_EDGE_FLAG_ARRAY_EXT GL_EDGE_FLAG_ARRAY_LIST_IBM = GL_EDGE_FLAG_ARRAY_LIST_IBM GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM GL_EDGE_FLAG_ARRAY_POINTER = GL_EDGE_FLAG_ARRAY_POINTER GL_EDGE_FLAG_ARRAY_POINTER_EXT = GL_EDGE_FLAG_ARRAY_POINTER_EXT GL_EDGE_FLAG_ARRAY_STRIDE = GL_EDGE_FLAG_ARRAY_STRIDE GL_EDGE_FLAG_ARRAY_STRIDE_EXT = GL_EDGE_FLAG_ARRAY_STRIDE_EXT GL_EIGHTH_BIT_ATI = GL_EIGHTH_BIT_ATI GL_ELEMENT_ARRAY_APPLE = GL_ELEMENT_ARRAY_APPLE GL_ELEMENT_ARRAY_ATI = GL_ELEMENT_ARRAY_ATI GL_ELEMENT_ARRAY_BUFFER = GL_ELEMENT_ARRAY_BUFFER GL_ELEMENT_ARRAY_BUFFER_ARB = GL_ELEMENT_ARRAY_BUFFER_ARB GL_ELEMENT_ARRAY_BUFFER_BINDING = GL_ELEMENT_ARRAY_BUFFER_BINDING GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB GL_ELEMENT_ARRAY_POINTER_APPLE = GL_ELEMENT_ARRAY_POINTER_APPLE GL_ELEMENT_ARRAY_POINTER_ATI = GL_ELEMENT_ARRAY_POINTER_ATI GL_ELEMENT_ARRAY_TYPE_APPLE = GL_ELEMENT_ARRAY_TYPE_APPLE GL_ELEMENT_ARRAY_TYPE_ATI = GL_ELEMENT_ARRAY_TYPE_ATI GL_EMBOSS_CONSTANT_NV = GL_EMBOSS_CONSTANT_NV GL_EMBOSS_LIGHT_NV = GL_EMBOSS_LIGHT_NV GL_EMBOSS_MAP_NV = GL_EMBOSS_MAP_NV GL_EMISSION = GL_EMISSION GL_ENABLE_BIT = GL_ENABLE_BIT GL_EQUAL = GL_EQUAL GL_EQUIV = GL_EQUIV GL_EVAL_2D_NV = GL_EVAL_2D_NV GL_EVAL_BIT = GL_EVAL_BIT GL_EVAL_FRACTIONAL_TESSELLATION_NV = GL_EVAL_FRACTIONAL_TESSELLATION_NV GL_EVAL_TRIANGULAR_2D_NV = GL_EVAL_TRIANGULAR_2D_NV GL_EVAL_VERTEX_ATTRIB0_NV = GL_EVAL_VERTEX_ATTRIB0_NV GL_EVAL_VERTEX_ATTRIB10_NV = GL_EVAL_VERTEX_ATTRIB10_NV GL_EVAL_VERTEX_ATTRIB11_NV = GL_EVAL_VERTEX_ATTRIB11_NV GL_EVAL_VERTEX_ATTRIB12_NV = GL_EVAL_VERTEX_ATTRIB12_NV GL_EVAL_VERTEX_ATTRIB13_NV = GL_EVAL_VERTEX_ATTRIB13_NV GL_EVAL_VERTEX_ATTRIB14_NV = GL_EVAL_VERTEX_ATTRIB14_NV GL_EVAL_VERTEX_ATTRIB15_NV = GL_EVAL_VERTEX_ATTRIB15_NV GL_EVAL_VERTEX_ATTRIB1_NV = GL_EVAL_VERTEX_ATTRIB1_NV GL_EVAL_VERTEX_ATTRIB2_NV = GL_EVAL_VERTEX_ATTRIB2_NV GL_EVAL_VERTEX_ATTRIB3_NV = GL_EVAL_VERTEX_ATTRIB3_NV GL_EVAL_VERTEX_ATTRIB4_NV = GL_EVAL_VERTEX_ATTRIB4_NV GL_EVAL_VERTEX_ATTRIB5_NV = GL_EVAL_VERTEX_ATTRIB5_NV GL_EVAL_VERTEX_ATTRIB6_NV = GL_EVAL_VERTEX_ATTRIB6_NV GL_EVAL_VERTEX_ATTRIB7_NV = GL_EVAL_VERTEX_ATTRIB7_NV GL_EVAL_VERTEX_ATTRIB8_NV = GL_EVAL_VERTEX_ATTRIB8_NV GL_EVAL_VERTEX_ATTRIB9_NV = GL_EVAL_VERTEX_ATTRIB9_NV GL_EXP = GL_EXP GL_EXP2 = GL_EXP2 GL_EXPAND_NEGATE_NV = GL_EXPAND_NEGATE_NV GL_EXPAND_NORMAL_NV = GL_EXPAND_NORMAL_NV GL_EXTENSIONS = GL_EXTENSIONS GL_EYE_DISTANCE_TO_LINE_SGIS = GL_EYE_DISTANCE_TO_LINE_SGIS GL_EYE_DISTANCE_TO_POINT_SGIS = GL_EYE_DISTANCE_TO_POINT_SGIS GL_EYE_LINEAR = GL_EYE_LINEAR GL_EYE_LINE_SGIS = GL_EYE_LINE_SGIS GL_EYE_PLANE = GL_EYE_PLANE GL_EYE_PLANE_ABSOLUTE_NV = GL_EYE_PLANE_ABSOLUTE_NV GL_EYE_POINT_SGIS = GL_EYE_POINT_SGIS GL_EYE_RADIAL_NV = GL_EYE_RADIAL_NV GL_E_TIMES_F_NV = GL_E_TIMES_F_NV GL_FALSE = GL_FALSE GL_FASTEST = GL_FASTEST GL_FEEDBACK = GL_FEEDBACK GL_FEEDBACK_BUFFER_POINTER = GL_FEEDBACK_BUFFER_POINTER GL_FEEDBACK_BUFFER_SIZE = GL_FEEDBACK_BUFFER_SIZE GL_FEEDBACK_BUFFER_TYPE = GL_FEEDBACK_BUFFER_TYPE GL_FENCE_APPLE = GL_FENCE_APPLE GL_FENCE_CONDITION_NV = GL_FENCE_CONDITION_NV GL_FENCE_STATUS_NV = GL_FENCE_STATUS_NV GL_FILL = GL_FILL GL_FILTER4_SGIS = GL_FILTER4_SGIS GL_FIXED_ONLY_ARB = GL_FIXED_ONLY_ARB GL_FLAT = GL_FLAT GL_FLOAT = GL_FLOAT GL_FLOAT_CLEAR_COLOR_VALUE_NV = GL_FLOAT_CLEAR_COLOR_VALUE_NV GL_FLOAT_MAT2 = GL_FLOAT_MAT2 GL_FLOAT_MAT2_ARB = GL_FLOAT_MAT2_ARB GL_FLOAT_MAT3 = GL_FLOAT_MAT3 GL_FLOAT_MAT3_ARB = GL_FLOAT_MAT3_ARB GL_FLOAT_MAT4 = GL_FLOAT_MAT4 GL_FLOAT_MAT4_ARB = GL_FLOAT_MAT4_ARB GL_FLOAT_R16_NV = GL_FLOAT_R16_NV GL_FLOAT_R32_NV = GL_FLOAT_R32_NV GL_FLOAT_RG16_NV = GL_FLOAT_RG16_NV GL_FLOAT_RG32_NV = GL_FLOAT_RG32_NV GL_FLOAT_RGB16_NV = GL_FLOAT_RGB16_NV GL_FLOAT_RGB32_NV = GL_FLOAT_RGB32_NV GL_FLOAT_RGBA16_NV = GL_FLOAT_RGBA16_NV GL_FLOAT_RGBA32_NV = GL_FLOAT_RGBA32_NV GL_FLOAT_RGBA_MODE_NV = GL_FLOAT_RGBA_MODE_NV GL_FLOAT_RGBA_NV = GL_FLOAT_RGBA_NV GL_FLOAT_RGB_NV = GL_FLOAT_RGB_NV GL_FLOAT_RG_NV = GL_FLOAT_RG_NV GL_FLOAT_R_NV = GL_FLOAT_R_NV GL_FLOAT_VEC2 = GL_FLOAT_VEC2 GL_FLOAT_VEC2_ARB = GL_FLOAT_VEC2_ARB GL_FLOAT_VEC3 = GL_FLOAT_VEC3 GL_FLOAT_VEC3_ARB = GL_FLOAT_VEC3_ARB GL_FLOAT_VEC4 = GL_FLOAT_VEC4 GL_FLOAT_VEC4_ARB = GL_FLOAT_VEC4_ARB GL_FOG = GL_FOG GL_FOG_BIT = GL_FOG_BIT GL_FOG_COLOR = GL_FOG_COLOR GL_FOG_COORD = GL_FOG_COORDINATE GL_FOG_COORDINATE = GL_FOG_COORDINATE GL_FOG_COORDINATE_ARRAY = GL_FOG_COORDINATE_ARRAY GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB GL_FOG_COORDINATE_ARRAY_EXT = GL_FOG_COORDINATE_ARRAY_EXT GL_FOG_COORDINATE_ARRAY_LIST_IBM = GL_FOG_COORDINATE_ARRAY_LIST_IBM GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM GL_FOG_COORDINATE_ARRAY_POINTER = GL_FOG_COORDINATE_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER_EXT = GL_FOG_COORDINATE_ARRAY_POINTER_EXT GL_FOG_COORDINATE_ARRAY_STRIDE = GL_FOG_COORDINATE_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = GL_FOG_COORDINATE_ARRAY_STRIDE_EXT GL_FOG_COORDINATE_ARRAY_TYPE = GL_FOG_COORDINATE_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE_EXT = GL_FOG_COORDINATE_ARRAY_TYPE_EXT GL_FOG_COORDINATE_EXT = GL_FOG_COORDINATE_EXT GL_FOG_COORDINATE_SOURCE = GL_FOG_COORDINATE_SOURCE GL_FOG_COORDINATE_SOURCE_EXT = GL_FOG_COORDINATE_SOURCE_EXT GL_FOG_COORD_ARRAY = GL_FOG_COORDINATE_ARRAY GL_FOG_COORD_ARRAY_BUFFER_BINDING = GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING GL_FOG_COORD_ARRAY_POINTER = GL_FOG_COORDINATE_ARRAY_POINTER GL_FOG_COORD_ARRAY_STRIDE = GL_FOG_COORDINATE_ARRAY_STRIDE GL_FOG_COORD_ARRAY_TYPE = GL_FOG_COORDINATE_ARRAY_TYPE GL_FOG_COORD_SRC = GL_FOG_COORDINATE_SOURCE GL_FOG_DENSITY = GL_FOG_DENSITY GL_FOG_DISTANCE_MODE_NV = GL_FOG_DISTANCE_MODE_NV GL_FOG_END = GL_FOG_END GL_FOG_FUNC_POINTS_SGIS = GL_FOG_FUNC_POINTS_SGIS GL_FOG_FUNC_SGIS = GL_FOG_FUNC_SGIS GL_FOG_HINT = GL_FOG_HINT GL_FOG_INDEX = GL_FOG_INDEX GL_FOG_MODE = GL_FOG_MODE GL_FOG_OFFSET_SGIX = GL_FOG_OFFSET_SGIX GL_FOG_OFFSET_VALUE_SGIX = GL_FOG_OFFSET_VALUE_SGIX GL_FOG_SCALE_SGIX = GL_FOG_SCALE_SGIX GL_FOG_SCALE_VALUE_SGIX = GL_FOG_SCALE_VALUE_SGIX GL_FOG_SPECULAR_TEXTURE_WIN = GL_FOG_SPECULAR_TEXTURE_WIN GL_FOG_START = GL_FOG_START GL_FORCE_BLUE_TO_ONE_NV = GL_FORCE_BLUE_TO_ONE_NV GL_FORMAT_SUBSAMPLE_244_244_OML = GL_FORMAT_SUBSAMPLE_244_244_OML GL_FORMAT_SUBSAMPLE_24_24_OML = GL_FORMAT_SUBSAMPLE_24_24_OML GL_FRAGMENT_COLOR_EXT = GL_FRAGMENT_COLOR_EXT GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX GL_FRAGMENT_COLOR_MATERIAL_SGIX = GL_FRAGMENT_COLOR_MATERIAL_SGIX GL_FRAGMENT_DEPTH = GL_FRAGMENT_DEPTH GL_FRAGMENT_DEPTH_EXT = GL_FRAGMENT_DEPTH_EXT GL_FRAGMENT_LIGHT0_SGIX = GL_FRAGMENT_LIGHT0_SGIX GL_FRAGMENT_LIGHT1_SGIX = GL_FRAGMENT_LIGHT1_SGIX GL_FRAGMENT_LIGHT2_SGIX = GL_FRAGMENT_LIGHT2_SGIX GL_FRAGMENT_LIGHT3_SGIX = GL_FRAGMENT_LIGHT3_SGIX GL_FRAGMENT_LIGHT4_SGIX = GL_FRAGMENT_LIGHT4_SGIX GL_FRAGMENT_LIGHT5_SGIX = GL_FRAGMENT_LIGHT5_SGIX GL_FRAGMENT_LIGHT6_SGIX = GL_FRAGMENT_LIGHT6_SGIX GL_FRAGMENT_LIGHT7_SGIX = GL_FRAGMENT_LIGHT7_SGIX GL_FRAGMENT_LIGHTING_SGIX = GL_FRAGMENT_LIGHTING_SGIX GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX GL_FRAGMENT_MATERIAL_EXT = GL_FRAGMENT_MATERIAL_EXT GL_FRAGMENT_NORMAL_EXT = GL_FRAGMENT_NORMAL_EXT GL_FRAGMENT_PROGRAM_ARB = GL_FRAGMENT_PROGRAM_ARB GL_FRAGMENT_PROGRAM_BINDING_NV = GL_FRAGMENT_PROGRAM_BINDING_NV GL_FRAGMENT_PROGRAM_NV = GL_FRAGMENT_PROGRAM_NV GL_FRAGMENT_SHADER = GL_FRAGMENT_SHADER GL_FRAGMENT_SHADER_ARB = GL_FRAGMENT_SHADER_ARB GL_FRAGMENT_SHADER_ATI = GL_FRAGMENT_SHADER_ATI GL_FRAGMENT_SHADER_DERIVATIVE_HINT = GL_FRAGMENT_SHADER_DERIVATIVE_HINT GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT GL_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT GL_FRAMEBUFFER_COMPLETE_EXT = GL_FRAMEBUFFER_COMPLETE_EXT GL_FRAMEBUFFER_EXT = GL_FRAMEBUFFER_EXT GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT GL_FRAMEBUFFER_UNSUPPORTED_EXT = GL_FRAMEBUFFER_UNSUPPORTED_EXT GL_FRAMEZOOM_FACTOR_SGIX = GL_FRAMEZOOM_FACTOR_SGIX GL_FRAMEZOOM_SGIX = GL_FRAMEZOOM_SGIX GL_FRONT = GL_FRONT GL_FRONT_AND_BACK = GL_FRONT_AND_BACK GL_FRONT_FACE = GL_FRONT_FACE GL_FRONT_LEFT = GL_FRONT_LEFT GL_FRONT_RIGHT = GL_FRONT_RIGHT GL_FULL_RANGE_EXT = GL_FULL_RANGE_EXT GL_FULL_STIPPLE_HINT_PGI = GL_FULL_STIPPLE_HINT_PGI GL_FUNC_ADD = GL_FUNC_ADD GL_FUNC_ADD_EXT = GL_FUNC_ADD_EXT GL_FUNC_REVERSE_SUBTRACT = GL_FUNC_REVERSE_SUBTRACT GL_FUNC_REVERSE_SUBTRACT_EXT = GL_FUNC_REVERSE_SUBTRACT_EXT GL_FUNC_SUBTRACT = GL_FUNC_SUBTRACT GL_FUNC_SUBTRACT_EXT = GL_FUNC_SUBTRACT_EXT GL_GENERATE_MIPMAP = GL_GENERATE_MIPMAP GL_GENERATE_MIPMAP_HINT = GL_GENERATE_MIPMAP_HINT GL_GENERATE_MIPMAP_HINT_SGIS = GL_GENERATE_MIPMAP_HINT_SGIS GL_GENERATE_MIPMAP_SGIS = GL_GENERATE_MIPMAP_SGIS GL_GEOMETRY_DEFORMATION_BIT_SGIX = GL_GEOMETRY_DEFORMATION_BIT_SGIX GL_GEOMETRY_DEFORMATION_SGIX = GL_GEOMETRY_DEFORMATION_SGIX GL_GEQUAL = GL_GEQUAL GL_GET_CP_SIZES = {GL_CONVOLUTION_BORDER_MODE: 1, GL_CONVOLUTION_FILTER_SCALE: 4, GL_CONVOLUTION_FILTER_BIAS: 4, GL_CONVOLUTION_FORMAT: 1, GL_CONVOLUTION_WIDTH: 1, GL_CONVOLUTION_HEIGHT: 1, GL_MAX_CONVOLUTION_WIDTH: 1, GL_MAX_CONVOLUTION_HEIGHT: 1, GL_CONVOLUTION_BORDER_COLOR: 4} GL_GET_CTP_SIZES = {GL_COLOR_TABLE_FORMAT: 1, GL_COLOR_TABLE_WIDTH: 1, GL_COLOR_TABLE_RED_SIZE: 1, GL_COLOR_TABLE_GREEN_SIZE: 1, GL_COLOR_TABLE_BLUE_SIZE: 1, GL_COLOR_TABLE_ALPHA_SIZE: 1, GL_COLOR_TABLE_LUMINANCE_SIZE: 1, GL_COLOR_TABLE_INTENSITY_SIZE: 1} GL_GLEXT_VERSION = GL_GLEXT_VERSION GL_GLOBAL_ALPHA_FACTOR_SUN = GL_GLOBAL_ALPHA_FACTOR_SUN GL_GLOBAL_ALPHA_SUN = GL_GLOBAL_ALPHA_SUN GL_GREATER = GL_GREATER GL_GREEN = GL_GREEN GL_GREEN_BIAS = GL_GREEN_BIAS GL_GREEN_BITS = GL_GREEN_BITS GL_GREEN_BIT_ATI = GL_GREEN_BIT_ATI GL_GREEN_MAX_CLAMP_INGR = GL_GREEN_MAX_CLAMP_INGR GL_GREEN_MIN_CLAMP_INGR = GL_GREEN_MIN_CLAMP_INGR GL_GREEN_SCALE = GL_GREEN_SCALE GL_HALF_BIAS_NEGATE_NV = GL_HALF_BIAS_NEGATE_NV GL_HALF_BIAS_NORMAL_NV = GL_HALF_BIAS_NORMAL_NV GL_HALF_BIT_ATI = GL_HALF_BIT_ATI GL_HALF_FLOAT_ARB = GL_HALF_FLOAT_ARB GL_HALF_FLOAT_NV = GL_HALF_FLOAT_NV GL_HILO16_NV = GL_HILO16_NV GL_HILO8_NV = GL_HILO8_NV GL_HILO_NV = GL_HILO_NV GL_HINT_BIT = GL_HINT_BIT GL_HISTOGRAM = GL_HISTOGRAM GL_HISTOGRAM_ALPHA_SIZE = GL_HISTOGRAM_ALPHA_SIZE GL_HISTOGRAM_ALPHA_SIZE_EXT = GL_HISTOGRAM_ALPHA_SIZE_EXT GL_HISTOGRAM_BLUE_SIZE = GL_HISTOGRAM_BLUE_SIZE GL_HISTOGRAM_BLUE_SIZE_EXT = GL_HISTOGRAM_BLUE_SIZE_EXT GL_HISTOGRAM_EXT = GL_HISTOGRAM_EXT GL_HISTOGRAM_FORMAT = GL_HISTOGRAM_FORMAT GL_HISTOGRAM_FORMAT_EXT = GL_HISTOGRAM_FORMAT_EXT GL_HISTOGRAM_GREEN_SIZE = GL_HISTOGRAM_GREEN_SIZE GL_HISTOGRAM_GREEN_SIZE_EXT = GL_HISTOGRAM_GREEN_SIZE_EXT GL_HISTOGRAM_LUMINANCE_SIZE = GL_HISTOGRAM_LUMINANCE_SIZE GL_HISTOGRAM_LUMINANCE_SIZE_EXT = GL_HISTOGRAM_LUMINANCE_SIZE_EXT GL_HISTOGRAM_RED_SIZE = GL_HISTOGRAM_RED_SIZE GL_HISTOGRAM_RED_SIZE_EXT = GL_HISTOGRAM_RED_SIZE_EXT GL_HISTOGRAM_SINK = GL_HISTOGRAM_SINK GL_HISTOGRAM_SINK_EXT = GL_HISTOGRAM_SINK_EXT GL_HISTOGRAM_WIDTH = GL_HISTOGRAM_WIDTH GL_HISTOGRAM_WIDTH_EXT = GL_HISTOGRAM_WIDTH_EXT GL_HI_BIAS_NV = GL_HI_BIAS_NV GL_HI_SCALE_NV = GL_HI_SCALE_NV GL_IDENTITY_NV = GL_IDENTITY_NV GL_IGNORE_BORDER_HP = GL_IGNORE_BORDER_HP GL_IMAGE_CUBIC_WEIGHT_HP = GL_IMAGE_CUBIC_WEIGHT_HP GL_IMAGE_MAG_FILTER_HP = GL_IMAGE_MAG_FILTER_HP GL_IMAGE_MIN_FILTER_HP = GL_IMAGE_MIN_FILTER_HP GL_IMAGE_ROTATE_ANGLE_HP = GL_IMAGE_ROTATE_ANGLE_HP GL_IMAGE_ROTATE_ORIGIN_X_HP = GL_IMAGE_ROTATE_ORIGIN_X_HP GL_IMAGE_ROTATE_ORIGIN_Y_HP = GL_IMAGE_ROTATE_ORIGIN_Y_HP GL_IMAGE_SCALE_X_HP = GL_IMAGE_SCALE_X_HP GL_IMAGE_SCALE_Y_HP = GL_IMAGE_SCALE_Y_HP GL_IMAGE_TRANSFORM_2D_HP = GL_IMAGE_TRANSFORM_2D_HP GL_IMAGE_TRANSLATE_X_HP = GL_IMAGE_TRANSLATE_X_HP GL_IMAGE_TRANSLATE_Y_HP = GL_IMAGE_TRANSLATE_Y_HP GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES = GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES GL_IMPLEMENTATION_COLOR_READ_TYPE_OES = GL_IMPLEMENTATION_COLOR_READ_TYPE_OES GL_INCR = GL_INCR GL_INCR_WRAP = GL_INCR_WRAP GL_INCR_WRAP_EXT = GL_INCR_WRAP_EXT GL_INDEX_ARRAY = GL_INDEX_ARRAY GL_INDEX_ARRAY_BUFFER_BINDING = GL_INDEX_ARRAY_BUFFER_BINDING GL_INDEX_ARRAY_BUFFER_BINDING_ARB = GL_INDEX_ARRAY_BUFFER_BINDING_ARB GL_INDEX_ARRAY_COUNT_EXT = GL_INDEX_ARRAY_COUNT_EXT GL_INDEX_ARRAY_EXT = GL_INDEX_ARRAY_EXT GL_INDEX_ARRAY_LIST_IBM = GL_INDEX_ARRAY_LIST_IBM GL_INDEX_ARRAY_LIST_STRIDE_IBM = GL_INDEX_ARRAY_LIST_STRIDE_IBM GL_INDEX_ARRAY_POINTER = GL_INDEX_ARRAY_POINTER GL_INDEX_ARRAY_POINTER_EXT = GL_INDEX_ARRAY_POINTER_EXT GL_INDEX_ARRAY_STRIDE = GL_INDEX_ARRAY_STRIDE GL_INDEX_ARRAY_STRIDE_EXT = GL_INDEX_ARRAY_STRIDE_EXT GL_INDEX_ARRAY_TYPE = GL_INDEX_ARRAY_TYPE GL_INDEX_ARRAY_TYPE_EXT = GL_INDEX_ARRAY_TYPE_EXT GL_INDEX_BITS = GL_INDEX_BITS GL_INDEX_BIT_PGI = GL_INDEX_BIT_PGI GL_INDEX_CLEAR_VALUE = GL_INDEX_CLEAR_VALUE GL_INDEX_LOGIC_OP = GL_INDEX_LOGIC_OP GL_INDEX_MATERIAL_EXT = GL_INDEX_MATERIAL_EXT GL_INDEX_MATERIAL_FACE_EXT = GL_INDEX_MATERIAL_FACE_EXT GL_INDEX_MATERIAL_PARAMETER_EXT = GL_INDEX_MATERIAL_PARAMETER_EXT GL_INDEX_MODE = GL_INDEX_MODE GL_INDEX_OFFSET = GL_INDEX_OFFSET GL_INDEX_SHIFT = GL_INDEX_SHIFT GL_INDEX_TEST_EXT = GL_INDEX_TEST_EXT GL_INDEX_TEST_FUNC_EXT = GL_INDEX_TEST_FUNC_EXT GL_INDEX_TEST_REF_EXT = GL_INDEX_TEST_REF_EXT GL_INDEX_WRITEMASK = GL_INDEX_WRITEMASK GL_INFO_LOG_LENGTH = GL_INFO_LOG_LENGTH GL_INSTRUMENT_BUFFER_POINTER_SGIX = GL_INSTRUMENT_BUFFER_POINTER_SGIX GL_INSTRUMENT_MEASUREMENTS_SGIX = GL_INSTRUMENT_MEASUREMENTS_SGIX GL_INT = GL_INT GL_INTENSITY = GL_INTENSITY GL_INTENSITY12 = GL_INTENSITY12 GL_INTENSITY12_EXT = GL_INTENSITY12_EXT GL_INTENSITY16 = GL_INTENSITY16 GL_INTENSITY16F_ARB = GL_INTENSITY16F_ARB GL_INTENSITY16_EXT = GL_INTENSITY16_EXT GL_INTENSITY32F_ARB = GL_INTENSITY32F_ARB GL_INTENSITY4 = GL_INTENSITY4 GL_INTENSITY4_EXT = GL_INTENSITY4_EXT GL_INTENSITY8 = GL_INTENSITY8 GL_INTENSITY8_EXT = GL_INTENSITY8_EXT GL_INTENSITY_EXT = GL_INTENSITY_EXT GL_INTENSITY_FLOAT16_ATI = GL_INTENSITY_FLOAT16_ATI GL_INTENSITY_FLOAT32_ATI = GL_INTENSITY_FLOAT32_ATI GL_INTERLACE_OML = GL_INTERLACE_OML GL_INTERLACE_READ_INGR = GL_INTERLACE_READ_INGR GL_INTERLACE_READ_OML = GL_INTERLACE_READ_OML GL_INTERLACE_SGIX = GL_INTERLACE_SGIX GL_INTERLEAVED_ARRAY_POINTER = GL_INTERLEAVED_ARRAY_POINTER GL_INTERPOLATE = GL_INTERPOLATE GL_INTERPOLATE_ARB = GL_INTERPOLATE_ARB GL_INTERPOLATE_EXT = GL_INTERPOLATE_EXT GL_INT_VEC2 = GL_INT_VEC2 GL_INT_VEC2_ARB = GL_INT_VEC2_ARB GL_INT_VEC3 = GL_INT_VEC3 GL_INT_VEC3_ARB = GL_INT_VEC3_ARB GL_INT_VEC4 = GL_INT_VEC4 GL_INT_VEC4_ARB = GL_INT_VEC4_ARB GL_INVALID_ENUM = GL_INVALID_ENUM GL_INVALID_FRAMEBUFFER_OPERATION_EXT = GL_INVALID_FRAMEBUFFER_OPERATION_EXT GL_INVALID_OPERATION = GL_INVALID_OPERATION GL_INVALID_VALUE = GL_INVALID_VALUE GL_INVARIANT_DATATYPE_EXT = GL_INVARIANT_DATATYPE_EXT GL_INVARIANT_EXT = GL_INVARIANT_EXT GL_INVARIANT_VALUE_EXT = GL_INVARIANT_VALUE_EXT GL_INVERSE_NV = GL_INVERSE_NV GL_INVERSE_TRANSPOSE_NV = GL_INVERSE_TRANSPOSE_NV GL_INVERT = GL_INVERT GL_INVERTED_SCREEN_W_REND = GL_INVERTED_SCREEN_W_REND GL_IR_INSTRUMENT1_SGIX = GL_IR_INSTRUMENT1_SGIX GL_IUI_N3F_V2F_EXT = GL_IUI_N3F_V2F_EXT GL_IUI_N3F_V3F_EXT = GL_IUI_N3F_V3F_EXT GL_IUI_V2F_EXT = GL_IUI_V2F_EXT GL_IUI_V3F_EXT = GL_IUI_V3F_EXT GL_KEEP = GL_KEEP GL_LEFT = GL_LEFT GL_LEQUAL = GL_LEQUAL GL_LERP_ATI = GL_LERP_ATI GL_LESS = GL_LESS GL_LIGHT0 = GL_LIGHT0 GL_LIGHT1 = GL_LIGHT1 GL_LIGHT2 = GL_LIGHT2 GL_LIGHT3 = GL_LIGHT3 GL_LIGHT4 = GL_LIGHT4 GL_LIGHT5 = GL_LIGHT5 GL_LIGHT6 = GL_LIGHT6 GL_LIGHT7 = GL_LIGHT7 GL_LIGHTING = GL_LIGHTING GL_LIGHTING_BIT = GL_LIGHTING_BIT GL_LIGHT_ENV_MODE_SGIX = GL_LIGHT_ENV_MODE_SGIX GL_LIGHT_MODEL_AMBIENT = GL_LIGHT_MODEL_AMBIENT GL_LIGHT_MODEL_COLOR_CONTROL = GL_LIGHT_MODEL_COLOR_CONTROL GL_LIGHT_MODEL_COLOR_CONTROL_EXT = GL_LIGHT_MODEL_COLOR_CONTROL_EXT GL_LIGHT_MODEL_LOCAL_VIEWER = GL_LIGHT_MODEL_LOCAL_VIEWER GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE GL_LIGHT_MODEL_TWO_SIDE = GL_LIGHT_MODEL_TWO_SIDE GL_LINE = GL_LINE GL_LINEAR = GL_LINEAR GL_LINEAR_ATTENUATION = GL_LINEAR_ATTENUATION GL_LINEAR_CLIPMAP_LINEAR_SGIX = GL_LINEAR_CLIPMAP_LINEAR_SGIX GL_LINEAR_CLIPMAP_NEAREST_SGIX = GL_LINEAR_CLIPMAP_NEAREST_SGIX GL_LINEAR_DETAIL_ALPHA_SGIS = GL_LINEAR_DETAIL_ALPHA_SGIS GL_LINEAR_DETAIL_COLOR_SGIS = GL_LINEAR_DETAIL_COLOR_SGIS GL_LINEAR_DETAIL_SGIS = GL_LINEAR_DETAIL_SGIS GL_LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR GL_LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST GL_LINEAR_SHARPEN_ALPHA_SGIS = GL_LINEAR_SHARPEN_ALPHA_SGIS GL_LINEAR_SHARPEN_COLOR_SGIS = GL_LINEAR_SHARPEN_COLOR_SGIS GL_LINEAR_SHARPEN_SGIS = GL_LINEAR_SHARPEN_SGIS GL_LINES = GL_LINES GL_LINE_BIT = GL_LINE_BIT GL_LINE_LOOP = GL_LINE_LOOP GL_LINE_RESET_TOKEN = GL_LINE_RESET_TOKEN GL_LINE_SMOOTH = GL_LINE_SMOOTH GL_LINE_SMOOTH_HINT = GL_LINE_SMOOTH_HINT GL_LINE_STIPPLE = GL_LINE_STIPPLE GL_LINE_STIPPLE_PATTERN = GL_LINE_STIPPLE_PATTERN GL_LINE_STIPPLE_REPEAT = GL_LINE_STIPPLE_REPEAT GL_LINE_STRIP = GL_LINE_STRIP GL_LINE_TOKEN = GL_LINE_TOKEN GL_LINE_WIDTH = GL_LINE_WIDTH GL_LINE_WIDTH_GRANULARITY = GL_SMOOTH_LINE_WIDTH_GRANULARITY GL_LINE_WIDTH_RANGE = GL_SMOOTH_LINE_WIDTH_RANGE GL_LINK_STATUS = GL_LINK_STATUS GL_LIST_BASE = GL_LIST_BASE GL_LIST_BIT = GL_LIST_BIT GL_LIST_INDEX = GL_LIST_INDEX GL_LIST_MODE = GL_LIST_MODE GL_LIST_PRIORITY_SGIX = GL_LIST_PRIORITY_SGIX GL_LOAD = GL_LOAD GL_LOCAL_CONSTANT_DATATYPE_EXT = GL_LOCAL_CONSTANT_DATATYPE_EXT GL_LOCAL_CONSTANT_EXT = GL_LOCAL_CONSTANT_EXT GL_LOCAL_CONSTANT_VALUE_EXT = GL_LOCAL_CONSTANT_VALUE_EXT GL_LOCAL_EXT = GL_LOCAL_EXT GL_LOGIC_OP = GL_INDEX_LOGIC_OP GL_LOGIC_OP_MODE = GL_LOGIC_OP_MODE GL_LOWER_LEFT = GL_LOWER_LEFT GL_LO_BIAS_NV = GL_LO_BIAS_NV GL_LO_SCALE_NV = GL_LO_SCALE_NV GL_LUMINANCE = GL_LUMINANCE GL_LUMINANCE12 = GL_LUMINANCE12 GL_LUMINANCE12_ALPHA12 = GL_LUMINANCE12_ALPHA12 GL_LUMINANCE12_ALPHA12_EXT = GL_LUMINANCE12_ALPHA12_EXT GL_LUMINANCE12_ALPHA4 = GL_LUMINANCE12_ALPHA4 GL_LUMINANCE12_ALPHA4_EXT = GL_LUMINANCE12_ALPHA4_EXT GL_LUMINANCE12_EXT = GL_LUMINANCE12_EXT GL_LUMINANCE16 = GL_LUMINANCE16 GL_LUMINANCE16F_ARB = GL_LUMINANCE16F_ARB GL_LUMINANCE16_ALPHA16 = GL_LUMINANCE16_ALPHA16 GL_LUMINANCE16_ALPHA16_EXT = GL_LUMINANCE16_ALPHA16_EXT GL_LUMINANCE16_EXT = GL_LUMINANCE16_EXT GL_LUMINANCE32F_ARB = GL_LUMINANCE32F_ARB GL_LUMINANCE4 = GL_LUMINANCE4 GL_LUMINANCE4_ALPHA4 = GL_LUMINANCE4_ALPHA4 GL_LUMINANCE4_ALPHA4_EXT = GL_LUMINANCE4_ALPHA4_EXT GL_LUMINANCE4_EXT = GL_LUMINANCE4_EXT GL_LUMINANCE6_ALPHA2 = GL_LUMINANCE6_ALPHA2 GL_LUMINANCE6_ALPHA2_EXT = GL_LUMINANCE6_ALPHA2_EXT GL_LUMINANCE8 = GL_LUMINANCE8 GL_LUMINANCE8_ALPHA8 = GL_LUMINANCE8_ALPHA8 GL_LUMINANCE8_ALPHA8_EXT = GL_LUMINANCE8_ALPHA8_EXT GL_LUMINANCE8_EXT = GL_LUMINANCE8_EXT GL_LUMINANCE_ALPHA = GL_LUMINANCE_ALPHA GL_LUMINANCE_ALPHA16F_ARB = GL_LUMINANCE_ALPHA16F_ARB GL_LUMINANCE_ALPHA32F_ARB = GL_LUMINANCE_ALPHA32F_ARB GL_LUMINANCE_ALPHA_FLOAT16_ATI = GL_LUMINANCE_ALPHA_FLOAT16_ATI GL_LUMINANCE_ALPHA_FLOAT32_ATI = GL_LUMINANCE_ALPHA_FLOAT32_ATI GL_LUMINANCE_FLOAT16_ATI = GL_LUMINANCE_FLOAT16_ATI GL_LUMINANCE_FLOAT32_ATI = GL_LUMINANCE_FLOAT32_ATI GL_MAD_ATI = GL_MAD_ATI GL_MAGNITUDE_BIAS_NV = GL_MAGNITUDE_BIAS_NV GL_MAGNITUDE_SCALE_NV = GL_MAGNITUDE_SCALE_NV GL_MAP1_BINORMAL_EXT = GL_MAP1_BINORMAL_EXT GL_MAP1_COLOR_4 = GL_MAP1_COLOR_4 GL_MAP1_GRID_DOMAIN = GL_MAP1_GRID_DOMAIN GL_MAP1_GRID_SEGMENTS = GL_MAP1_GRID_SEGMENTS GL_MAP1_INDEX = GL_MAP1_INDEX GL_MAP1_NORMAL = GL_MAP1_NORMAL GL_MAP1_TANGENT_EXT = GL_MAP1_TANGENT_EXT GL_MAP1_TEXTURE_COORD_1 = GL_MAP1_TEXTURE_COORD_1 GL_MAP1_TEXTURE_COORD_2 = GL_MAP1_TEXTURE_COORD_2 GL_MAP1_TEXTURE_COORD_3 = GL_MAP1_TEXTURE_COORD_3 GL_MAP1_TEXTURE_COORD_4 = GL_MAP1_TEXTURE_COORD_4 GL_MAP1_VERTEX_3 = GL_MAP1_VERTEX_3 GL_MAP1_VERTEX_4 = GL_MAP1_VERTEX_4 GL_MAP1_VERTEX_ATTRIB0_4_NV = GL_MAP1_VERTEX_ATTRIB0_4_NV GL_MAP1_VERTEX_ATTRIB10_4_NV = GL_MAP1_VERTEX_ATTRIB10_4_NV GL_MAP1_VERTEX_ATTRIB11_4_NV = GL_MAP1_VERTEX_ATTRIB11_4_NV GL_MAP1_VERTEX_ATTRIB12_4_NV = GL_MAP1_VERTEX_ATTRIB12_4_NV GL_MAP1_VERTEX_ATTRIB13_4_NV = GL_MAP1_VERTEX_ATTRIB13_4_NV GL_MAP1_VERTEX_ATTRIB14_4_NV = GL_MAP1_VERTEX_ATTRIB14_4_NV GL_MAP1_VERTEX_ATTRIB15_4_NV = GL_MAP1_VERTEX_ATTRIB15_4_NV GL_MAP1_VERTEX_ATTRIB1_4_NV = GL_MAP1_VERTEX_ATTRIB1_4_NV GL_MAP1_VERTEX_ATTRIB2_4_NV = GL_MAP1_VERTEX_ATTRIB2_4_NV GL_MAP1_VERTEX_ATTRIB3_4_NV = GL_MAP1_VERTEX_ATTRIB3_4_NV GL_MAP1_VERTEX_ATTRIB4_4_NV = GL_MAP1_VERTEX_ATTRIB4_4_NV GL_MAP1_VERTEX_ATTRIB5_4_NV = GL_MAP1_VERTEX_ATTRIB5_4_NV GL_MAP1_VERTEX_ATTRIB6_4_NV = GL_MAP1_VERTEX_ATTRIB6_4_NV GL_MAP1_VERTEX_ATTRIB7_4_NV = GL_MAP1_VERTEX_ATTRIB7_4_NV GL_MAP1_VERTEX_ATTRIB8_4_NV = GL_MAP1_VERTEX_ATTRIB8_4_NV GL_MAP1_VERTEX_ATTRIB9_4_NV = GL_MAP1_VERTEX_ATTRIB9_4_NV GL_MAP2_BINORMAL_EXT = GL_MAP2_BINORMAL_EXT GL_MAP2_COLOR_4 = GL_MAP2_COLOR_4 GL_MAP2_GRID_DOMAIN = GL_MAP2_GRID_DOMAIN GL_MAP2_GRID_SEGMENTS = GL_MAP2_GRID_SEGMENTS GL_MAP2_INDEX = GL_MAP2_INDEX GL_MAP2_NORMAL = GL_MAP2_NORMAL GL_MAP2_TANGENT_EXT = GL_MAP2_TANGENT_EXT GL_MAP2_TEXTURE_COORD_1 = GL_MAP2_TEXTURE_COORD_1 GL_MAP2_TEXTURE_COORD_2 = GL_MAP2_TEXTURE_COORD_2 GL_MAP2_TEXTURE_COORD_3 = GL_MAP2_TEXTURE_COORD_3 GL_MAP2_TEXTURE_COORD_4 = GL_MAP2_TEXTURE_COORD_4 GL_MAP2_VERTEX_3 = GL_MAP2_VERTEX_3 GL_MAP2_VERTEX_4 = GL_MAP2_VERTEX_4 GL_MAP2_VERTEX_ATTRIB0_4_NV = GL_MAP2_VERTEX_ATTRIB0_4_NV GL_MAP2_VERTEX_ATTRIB10_4_NV = GL_MAP2_VERTEX_ATTRIB10_4_NV GL_MAP2_VERTEX_ATTRIB11_4_NV = GL_MAP2_VERTEX_ATTRIB11_4_NV GL_MAP2_VERTEX_ATTRIB12_4_NV = GL_MAP2_VERTEX_ATTRIB12_4_NV GL_MAP2_VERTEX_ATTRIB13_4_NV = GL_MAP2_VERTEX_ATTRIB13_4_NV GL_MAP2_VERTEX_ATTRIB14_4_NV = GL_MAP2_VERTEX_ATTRIB14_4_NV GL_MAP2_VERTEX_ATTRIB15_4_NV = GL_MAP2_VERTEX_ATTRIB15_4_NV GL_MAP2_VERTEX_ATTRIB1_4_NV = GL_MAP2_VERTEX_ATTRIB1_4_NV GL_MAP2_VERTEX_ATTRIB2_4_NV = GL_MAP2_VERTEX_ATTRIB2_4_NV GL_MAP2_VERTEX_ATTRIB3_4_NV = GL_MAP2_VERTEX_ATTRIB3_4_NV GL_MAP2_VERTEX_ATTRIB4_4_NV = GL_MAP2_VERTEX_ATTRIB4_4_NV GL_MAP2_VERTEX_ATTRIB5_4_NV = GL_MAP2_VERTEX_ATTRIB5_4_NV GL_MAP2_VERTEX_ATTRIB6_4_NV = GL_MAP2_VERTEX_ATTRIB6_4_NV GL_MAP2_VERTEX_ATTRIB7_4_NV = GL_MAP2_VERTEX_ATTRIB7_4_NV GL_MAP2_VERTEX_ATTRIB8_4_NV = GL_MAP2_VERTEX_ATTRIB8_4_NV GL_MAP2_VERTEX_ATTRIB9_4_NV = GL_MAP2_VERTEX_ATTRIB9_4_NV GL_MAP_ATTRIB_U_ORDER_NV = GL_MAP_ATTRIB_U_ORDER_NV GL_MAP_ATTRIB_V_ORDER_NV = GL_MAP_ATTRIB_V_ORDER_NV GL_MAP_COLOR = GL_MAP_COLOR GL_MAP_STENCIL = GL_MAP_STENCIL GL_MAP_TESSELLATION_NV = GL_MAP_TESSELLATION_NV GL_MATERIAL_SIDE_HINT_PGI = GL_MATERIAL_SIDE_HINT_PGI GL_MATRIX0_ARB = GL_MATRIX0_ARB GL_MATRIX0_NV = GL_MATRIX0_NV GL_MATRIX10_ARB = GL_MATRIX10_ARB GL_MATRIX11_ARB = GL_MATRIX11_ARB GL_MATRIX12_ARB = GL_MATRIX12_ARB GL_MATRIX13_ARB = GL_MATRIX13_ARB GL_MATRIX14_ARB = GL_MATRIX14_ARB GL_MATRIX15_ARB = GL_MATRIX15_ARB GL_MATRIX16_ARB = GL_MATRIX16_ARB GL_MATRIX17_ARB = GL_MATRIX17_ARB GL_MATRIX18_ARB = GL_MATRIX18_ARB GL_MATRIX19_ARB = GL_MATRIX19_ARB GL_MATRIX1_ARB = GL_MATRIX1_ARB GL_MATRIX1_NV = GL_MATRIX1_NV GL_MATRIX20_ARB = GL_MATRIX20_ARB GL_MATRIX21_ARB = GL_MATRIX21_ARB GL_MATRIX22_ARB = GL_MATRIX22_ARB GL_MATRIX23_ARB = GL_MATRIX23_ARB GL_MATRIX24_ARB = GL_MATRIX24_ARB GL_MATRIX25_ARB = GL_MATRIX25_ARB GL_MATRIX26_ARB = GL_MATRIX26_ARB GL_MATRIX27_ARB = GL_MATRIX27_ARB GL_MATRIX28_ARB = GL_MATRIX28_ARB GL_MATRIX29_ARB = GL_MATRIX29_ARB GL_MATRIX2_ARB = GL_MATRIX2_ARB GL_MATRIX2_NV = GL_MATRIX2_NV GL_MATRIX30_ARB = GL_MATRIX30_ARB GL_MATRIX31_ARB = GL_MATRIX31_ARB GL_MATRIX3_ARB = GL_MATRIX3_ARB GL_MATRIX3_NV = GL_MATRIX3_NV GL_MATRIX4_ARB = GL_MATRIX4_ARB GL_MATRIX4_NV = GL_MATRIX4_NV GL_MATRIX5_ARB = GL_MATRIX5_ARB GL_MATRIX5_NV = GL_MATRIX5_NV GL_MATRIX6_ARB = GL_MATRIX6_ARB GL_MATRIX6_NV = GL_MATRIX6_NV GL_MATRIX7_ARB = GL_MATRIX7_ARB GL_MATRIX7_NV = GL_MATRIX7_NV GL_MATRIX8_ARB = GL_MATRIX8_ARB GL_MATRIX9_ARB = GL_MATRIX9_ARB GL_MATRIX_EXT = GL_MATRIX_EXT GL_MATRIX_INDEX_ARRAY_ARB = GL_MATRIX_INDEX_ARRAY_ARB GL_MATRIX_INDEX_ARRAY_POINTER_ARB = GL_MATRIX_INDEX_ARRAY_POINTER_ARB GL_MATRIX_INDEX_ARRAY_SIZE_ARB = GL_MATRIX_INDEX_ARRAY_SIZE_ARB GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = GL_MATRIX_INDEX_ARRAY_STRIDE_ARB GL_MATRIX_INDEX_ARRAY_TYPE_ARB = GL_MATRIX_INDEX_ARRAY_TYPE_ARB GL_MATRIX_MODE = GL_MATRIX_MODE GL_MATRIX_PALETTE_ARB = GL_MATRIX_PALETTE_ARB GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI GL_MAT_AMBIENT_BIT_PGI = GL_MAT_AMBIENT_BIT_PGI GL_MAT_COLOR_INDEXES_BIT_PGI = GL_MAT_COLOR_INDEXES_BIT_PGI GL_MAT_DIFFUSE_BIT_PGI = GL_MAT_DIFFUSE_BIT_PGI GL_MAT_EMISSION_BIT_PGI = GL_MAT_EMISSION_BIT_PGI GL_MAT_SHININESS_BIT_PGI = GL_MAT_SHININESS_BIT_PGI GL_MAT_SPECULAR_BIT_PGI = GL_MAT_SPECULAR_BIT_PGI GL_MAX = GL_MAX GL_MAX_3D_TEXTURE_SIZE = GL_MAX_3D_TEXTURE_SIZE GL_MAX_3D_TEXTURE_SIZE_EXT = GL_MAX_3D_TEXTURE_SIZE_EXT GL_MAX_4D_TEXTURE_SIZE_SGIS = GL_MAX_4D_TEXTURE_SIZE_SGIS GL_MAX_ACTIVE_LIGHTS_SGIX = GL_MAX_ACTIVE_LIGHTS_SGIX GL_MAX_ASYNC_DRAW_PIXELS_SGIX = GL_MAX_ASYNC_DRAW_PIXELS_SGIX GL_MAX_ASYNC_HISTOGRAM_SGIX = GL_MAX_ASYNC_HISTOGRAM_SGIX GL_MAX_ASYNC_READ_PIXELS_SGIX = GL_MAX_ASYNC_READ_PIXELS_SGIX GL_MAX_ASYNC_TEX_IMAGE_SGIX = GL_MAX_ASYNC_TEX_IMAGE_SGIX GL_MAX_ATTRIB_STACK_DEPTH = GL_MAX_ATTRIB_STACK_DEPTH GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = GL_MAX_CLIENT_ATTRIB_STACK_DEPTH GL_MAX_CLIPMAP_DEPTH_SGIX = GL_MAX_CLIPMAP_DEPTH_SGIX GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX GL_MAX_CLIP_PLANES = GL_MAX_CLIP_PLANES GL_MAX_COLOR_ATTACHMENTS_EXT = GL_MAX_COLOR_ATTACHMENTS_EXT GL_MAX_COLOR_MATRIX_STACK_DEPTH = GL_MAX_COLOR_MATRIX_STACK_DEPTH GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB GL_MAX_CONVOLUTION_HEIGHT = GL_MAX_CONVOLUTION_HEIGHT GL_MAX_CONVOLUTION_HEIGHT_EXT = GL_MAX_CONVOLUTION_HEIGHT_EXT GL_MAX_CONVOLUTION_WIDTH = GL_MAX_CONVOLUTION_WIDTH GL_MAX_CONVOLUTION_WIDTH_EXT = GL_MAX_CONVOLUTION_WIDTH_EXT GL_MAX_CUBE_MAP_TEXTURE_SIZE = GL_MAX_CUBE_MAP_TEXTURE_SIZE GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT GL_MAX_DEFORMATION_ORDER_SGIX = GL_MAX_DEFORMATION_ORDER_SGIX GL_MAX_DRAW_BUFFERS = GL_MAX_DRAW_BUFFERS GL_MAX_DRAW_BUFFERS_ARB = GL_MAX_DRAW_BUFFERS_ARB GL_MAX_DRAW_BUFFERS_ATI = GL_MAX_DRAW_BUFFERS_ATI GL_MAX_ELEMENTS_INDICES = GL_MAX_ELEMENTS_INDICES GL_MAX_ELEMENTS_INDICES_EXT = GL_MAX_ELEMENTS_INDICES_EXT GL_MAX_ELEMENTS_VERTICES = GL_MAX_ELEMENTS_VERTICES GL_MAX_ELEMENTS_VERTICES_EXT = GL_MAX_ELEMENTS_VERTICES_EXT GL_MAX_EVAL_ORDER = GL_MAX_EVAL_ORDER GL_MAX_EXT = GL_MAX_EXT GL_MAX_FOG_FUNC_POINTS_SGIS = GL_MAX_FOG_FUNC_POINTS_SGIS GL_MAX_FRAGMENT_LIGHTS_SGIX = GL_MAX_FRAGMENT_LIGHTS_SGIX GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = GL_MAX_FRAGMENT_UNIFORM_COMPONENTS GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB GL_MAX_FRAMEZOOM_FACTOR_SGIX = GL_MAX_FRAMEZOOM_FACTOR_SGIX GL_MAX_GENERAL_COMBINERS_NV = GL_MAX_GENERAL_COMBINERS_NV GL_MAX_LIGHTS = GL_MAX_LIGHTS GL_MAX_LIST_NESTING = GL_MAX_LIST_NESTING GL_MAX_MAP_TESSELLATION_NV = GL_MAX_MAP_TESSELLATION_NV GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB GL_MAX_MODELVIEW_STACK_DEPTH = GL_MAX_MODELVIEW_STACK_DEPTH GL_MAX_NAME_STACK_DEPTH = GL_MAX_NAME_STACK_DEPTH GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT GL_MAX_PALETTE_MATRICES_ARB = GL_MAX_PALETTE_MATRICES_ARB GL_MAX_PIXEL_MAP_TABLE = GL_MAX_PIXEL_MAP_TABLE GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB GL_MAX_PROGRAM_ATTRIBS_ARB = GL_MAX_PROGRAM_ATTRIBS_ARB GL_MAX_PROGRAM_CALL_DEPTH_NV = GL_MAX_PROGRAM_CALL_DEPTH_NV GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = GL_MAX_PROGRAM_ENV_PARAMETERS_ARB GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV GL_MAX_PROGRAM_IF_DEPTH_NV = GL_MAX_PROGRAM_IF_DEPTH_NV GL_MAX_PROGRAM_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_INSTRUCTIONS_ARB GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB GL_MAX_PROGRAM_LOOP_COUNT_NV = GL_MAX_PROGRAM_LOOP_COUNT_NV GL_MAX_PROGRAM_LOOP_DEPTH_NV = GL_MAX_PROGRAM_LOOP_DEPTH_NV GL_MAX_PROGRAM_MATRICES_ARB = GL_MAX_PROGRAM_MATRICES_ARB GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB GL_MAX_PROGRAM_PARAMETERS_ARB = GL_MAX_PROGRAM_PARAMETERS_ARB GL_MAX_PROGRAM_TEMPORARIES_ARB = GL_MAX_PROGRAM_TEMPORARIES_ARB GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB GL_MAX_PROJECTION_STACK_DEPTH = GL_MAX_PROJECTION_STACK_DEPTH GL_MAX_RATIONAL_EVAL_ORDER_NV = GL_MAX_RATIONAL_EVAL_ORDER_NV GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = GL_MAX_RECTANGLE_TEXTURE_SIZE_NV GL_MAX_RENDERBUFFER_SIZE_EXT = GL_MAX_RENDERBUFFER_SIZE_EXT GL_MAX_SHININESS_NV = GL_MAX_SHININESS_NV GL_MAX_SPOT_EXPONENT_NV = GL_MAX_SPOT_EXPONENT_NV GL_MAX_TEXTURE_COORDS = GL_MAX_TEXTURE_COORDS GL_MAX_TEXTURE_COORDS_ARB = GL_MAX_TEXTURE_COORDS_ARB GL_MAX_TEXTURE_COORDS_NV = GL_MAX_TEXTURE_COORDS_NV GL_MAX_TEXTURE_IMAGE_UNITS = GL_MAX_TEXTURE_IMAGE_UNITS GL_MAX_TEXTURE_IMAGE_UNITS_ARB = GL_MAX_TEXTURE_IMAGE_UNITS_ARB GL_MAX_TEXTURE_IMAGE_UNITS_NV = GL_MAX_TEXTURE_IMAGE_UNITS_NV GL_MAX_TEXTURE_LOD_BIAS = GL_MAX_TEXTURE_LOD_BIAS GL_MAX_TEXTURE_LOD_BIAS_EXT = GL_MAX_TEXTURE_LOD_BIAS_EXT GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT GL_MAX_TEXTURE_SIZE = GL_MAX_TEXTURE_SIZE GL_MAX_TEXTURE_STACK_DEPTH = GL_MAX_TEXTURE_STACK_DEPTH GL_MAX_TEXTURE_UNITS = GL_MAX_TEXTURE_UNITS GL_MAX_TEXTURE_UNITS_ARB = GL_MAX_TEXTURE_UNITS_ARB GL_MAX_TRACK_MATRICES_NV = GL_MAX_TRACK_MATRICES_NV GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV GL_MAX_VARYING_FLOATS = GL_MAX_VARYING_FLOATS GL_MAX_VARYING_FLOATS_ARB = GL_MAX_VARYING_FLOATS_ARB GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV GL_MAX_VERTEX_ATTRIBS = GL_MAX_VERTEX_ATTRIBS GL_MAX_VERTEX_ATTRIBS_ARB = GL_MAX_VERTEX_ATTRIBS_ARB GL_MAX_VERTEX_HINT_PGI = GL_MAX_VERTEX_HINT_PGI GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = GL_MAX_VERTEX_SHADER_INVARIANTS_EXT GL_MAX_VERTEX_SHADER_LOCALS_EXT = GL_MAX_VERTEX_SHADER_LOCALS_EXT GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT GL_MAX_VERTEX_SHADER_VARIANTS_EXT = GL_MAX_VERTEX_SHADER_VARIANTS_EXT GL_MAX_VERTEX_STREAMS_ATI = GL_MAX_VERTEX_STREAMS_ATI GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB GL_MAX_VERTEX_UNIFORM_COMPONENTS = GL_MAX_VERTEX_UNIFORM_COMPONENTS GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB GL_MAX_VERTEX_UNITS_ARB = GL_MAX_VERTEX_UNITS_ARB GL_MAX_VIEWPORT_DIMS = GL_MAX_VIEWPORT_DIMS GL_MIN = GL_MIN GL_MINMAX = GL_MINMAX GL_MINMAX_EXT = GL_MINMAX_EXT GL_MINMAX_FORMAT = GL_MINMAX_FORMAT GL_MINMAX_FORMAT_EXT = GL_MINMAX_FORMAT_EXT GL_MINMAX_SINK = GL_MINMAX_SINK GL_MINMAX_SINK_EXT = GL_MINMAX_SINK_EXT GL_MIN_EXT = GL_MIN_EXT GL_MIRRORED_REPEAT = GL_MIRRORED_REPEAT GL_MIRRORED_REPEAT_ARB = GL_MIRRORED_REPEAT_ARB GL_MIRRORED_REPEAT_IBM = GL_MIRRORED_REPEAT_IBM GL_MIRROR_CLAMP_ATI = GL_MIRROR_CLAMP_ATI GL_MIRROR_CLAMP_EXT = GL_MIRROR_CLAMP_EXT GL_MIRROR_CLAMP_TO_BORDER_EXT = GL_MIRROR_CLAMP_TO_BORDER_EXT GL_MIRROR_CLAMP_TO_EDGE_ATI = GL_MIRROR_CLAMP_TO_EDGE_ATI GL_MIRROR_CLAMP_TO_EDGE_EXT = GL_MIRROR_CLAMP_TO_EDGE_EXT GL_MODELVIEW = GL_MODELVIEW GL_MODELVIEW0_ARB = GL_MODELVIEW0_ARB GL_MODELVIEW0_EXT = GL_MODELVIEW GL_MODELVIEW0_MATRIX_EXT = GL_MODELVIEW_MATRIX GL_MODELVIEW0_STACK_DEPTH_EXT = GL_MODELVIEW_STACK_DEPTH GL_MODELVIEW10_ARB = GL_MODELVIEW10_ARB GL_MODELVIEW11_ARB = GL_MODELVIEW11_ARB GL_MODELVIEW12_ARB = GL_MODELVIEW12_ARB GL_MODELVIEW13_ARB = GL_MODELVIEW13_ARB GL_MODELVIEW14_ARB = GL_MODELVIEW14_ARB GL_MODELVIEW15_ARB = GL_MODELVIEW15_ARB GL_MODELVIEW16_ARB = GL_MODELVIEW16_ARB GL_MODELVIEW17_ARB = GL_MODELVIEW17_ARB GL_MODELVIEW18_ARB = GL_MODELVIEW18_ARB GL_MODELVIEW19_ARB = GL_MODELVIEW19_ARB GL_MODELVIEW1_ARB = GL_MODELVIEW1_ARB GL_MODELVIEW1_EXT = GL_MODELVIEW1_EXT GL_MODELVIEW1_MATRIX_EXT = GL_MODELVIEW1_MATRIX_EXT GL_MODELVIEW1_STACK_DEPTH_EXT = GL_MODELVIEW1_STACK_DEPTH_EXT GL_MODELVIEW20_ARB = GL_MODELVIEW20_ARB GL_MODELVIEW21_ARB = GL_MODELVIEW21_ARB GL_MODELVIEW22_ARB = GL_MODELVIEW22_ARB GL_MODELVIEW23_ARB = GL_MODELVIEW23_ARB GL_MODELVIEW24_ARB = GL_MODELVIEW24_ARB GL_MODELVIEW25_ARB = GL_MODELVIEW25_ARB GL_MODELVIEW26_ARB = GL_MODELVIEW26_ARB GL_MODELVIEW27_ARB = GL_MODELVIEW27_ARB GL_MODELVIEW28_ARB = GL_MODELVIEW28_ARB GL_MODELVIEW29_ARB = GL_MODELVIEW29_ARB GL_MODELVIEW2_ARB = GL_MODELVIEW2_ARB GL_MODELVIEW30_ARB = GL_MODELVIEW30_ARB GL_MODELVIEW31_ARB = GL_MODELVIEW31_ARB GL_MODELVIEW3_ARB = GL_MODELVIEW3_ARB GL_MODELVIEW4_ARB = GL_MODELVIEW4_ARB GL_MODELVIEW5_ARB = GL_MODELVIEW5_ARB GL_MODELVIEW6_ARB = GL_MODELVIEW6_ARB GL_MODELVIEW7_ARB = GL_MODELVIEW7_ARB GL_MODELVIEW8_ARB = GL_MODELVIEW8_ARB GL_MODELVIEW9_ARB = GL_MODELVIEW9_ARB GL_MODELVIEW_MATRIX = GL_MODELVIEW_MATRIX GL_MODELVIEW_PROJECTION_NV = GL_MODELVIEW_PROJECTION_NV GL_MODELVIEW_STACK_DEPTH = GL_MODELVIEW_STACK_DEPTH GL_MODULATE = GL_MODULATE GL_MODULATE_ADD_ATI = GL_MODULATE_ADD_ATI GL_MODULATE_SIGNED_ADD_ATI = GL_MODULATE_SIGNED_ADD_ATI GL_MODULATE_SUBTRACT_ATI = GL_MODULATE_SUBTRACT_ATI GL_MOV_ATI = GL_MOV_ATI GL_MULT = GL_MULT GL_MULTISAMPLE = GL_MULTISAMPLE GL_MULTISAMPLE_3DFX = GL_MULTISAMPLE_3DFX GL_MULTISAMPLE_ARB = GL_MULTISAMPLE_ARB GL_MULTISAMPLE_BIT = GL_MULTISAMPLE_BIT GL_MULTISAMPLE_BIT_3DFX = GL_MULTISAMPLE_BIT_3DFX GL_MULTISAMPLE_BIT_ARB = GL_MULTISAMPLE_BIT_ARB GL_MULTISAMPLE_BIT_EXT = GL_MULTISAMPLE_BIT_EXT GL_MULTISAMPLE_EXT = GL_MULTISAMPLE_EXT GL_MULTISAMPLE_FILTER_HINT_NV = GL_MULTISAMPLE_FILTER_HINT_NV GL_MULTISAMPLE_SGIS = GL_MULTISAMPLE_SGIS GL_MUL_ATI = GL_MUL_ATI GL_MVP_MATRIX_EXT = GL_MVP_MATRIX_EXT GL_N3F_V3F = GL_N3F_V3F GL_NAME_STACK_DEPTH = GL_NAME_STACK_DEPTH GL_NAND = GL_NAND GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI GL_NATIVE_GRAPHICS_END_HINT_PGI = GL_NATIVE_GRAPHICS_END_HINT_PGI GL_NATIVE_GRAPHICS_HANDLE_PGI = GL_NATIVE_GRAPHICS_HANDLE_PGI GL_NEAREST = GL_NEAREST GL_NEAREST_CLIPMAP_LINEAR_SGIX = GL_NEAREST_CLIPMAP_LINEAR_SGIX GL_NEAREST_CLIPMAP_NEAREST_SGIX = GL_NEAREST_CLIPMAP_NEAREST_SGIX GL_NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR GL_NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST GL_NEGATE_BIT_ATI = GL_NEGATE_BIT_ATI GL_NEGATIVE_ONE_EXT = GL_NEGATIVE_ONE_EXT GL_NEGATIVE_W_EXT = GL_NEGATIVE_W_EXT GL_NEGATIVE_X_EXT = GL_NEGATIVE_X_EXT GL_NEGATIVE_Y_EXT = GL_NEGATIVE_Y_EXT GL_NEGATIVE_Z_EXT = GL_NEGATIVE_Z_EXT GL_NEVER = GL_NEVER GL_NICEST = GL_NICEST GL_NONE = GL_NONE GL_NOOP = GL_NOOP GL_NOR = GL_NOR GL_NORMALIZE = GL_NORMALIZE GL_NORMALIZED_RANGE_EXT = GL_NORMALIZED_RANGE_EXT GL_NORMAL_ARRAY = GL_NORMAL_ARRAY GL_NORMAL_ARRAY_BUFFER_BINDING = GL_NORMAL_ARRAY_BUFFER_BINDING GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = GL_NORMAL_ARRAY_BUFFER_BINDING_ARB GL_NORMAL_ARRAY_COUNT_EXT = GL_NORMAL_ARRAY_COUNT_EXT GL_NORMAL_ARRAY_EXT = GL_NORMAL_ARRAY_EXT GL_NORMAL_ARRAY_LIST_IBM = GL_NORMAL_ARRAY_LIST_IBM GL_NORMAL_ARRAY_LIST_STRIDE_IBM = GL_NORMAL_ARRAY_LIST_STRIDE_IBM GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL GL_NORMAL_ARRAY_POINTER = GL_NORMAL_ARRAY_POINTER GL_NORMAL_ARRAY_POINTER_EXT = GL_NORMAL_ARRAY_POINTER_EXT GL_NORMAL_ARRAY_STRIDE = GL_NORMAL_ARRAY_STRIDE GL_NORMAL_ARRAY_STRIDE_EXT = GL_NORMAL_ARRAY_STRIDE_EXT GL_NORMAL_ARRAY_TYPE = GL_NORMAL_ARRAY_TYPE GL_NORMAL_ARRAY_TYPE_EXT = GL_NORMAL_ARRAY_TYPE_EXT GL_NORMAL_BIT_PGI = GL_NORMAL_BIT_PGI GL_NORMAL_MAP = GL_NORMAL_MAP GL_NORMAL_MAP_ARB = GL_NORMAL_MAP_ARB GL_NORMAL_MAP_EXT = GL_NORMAL_MAP_EXT GL_NORMAL_MAP_NV = GL_NORMAL_MAP_NV GL_NOTEQUAL = GL_NOTEQUAL GL_NO_ERROR = GL_NO_ERROR GL_NUM_COMPRESSED_TEXTURE_FORMATS = GL_NUM_COMPRESSED_TEXTURE_FORMATS GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB GL_NUM_FRAGMENT_CONSTANTS_ATI = GL_NUM_FRAGMENT_CONSTANTS_ATI GL_NUM_FRAGMENT_REGISTERS_ATI = GL_NUM_FRAGMENT_REGISTERS_ATI GL_NUM_GENERAL_COMBINERS_NV = GL_NUM_GENERAL_COMBINERS_NV GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI GL_NUM_INSTRUCTIONS_PER_PASS_ATI = GL_NUM_INSTRUCTIONS_PER_PASS_ATI GL_NUM_INSTRUCTIONS_TOTAL_ATI = GL_NUM_INSTRUCTIONS_TOTAL_ATI GL_NUM_LOOPBACK_COMPONENTS_ATI = GL_NUM_LOOPBACK_COMPONENTS_ATI GL_NUM_PASSES_ATI = GL_NUM_PASSES_ATI GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = GL_OBJECT_ACTIVE_ATTRIBUTES_ARB GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB GL_OBJECT_ACTIVE_UNIFORMS_ARB = GL_OBJECT_ACTIVE_UNIFORMS_ARB GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB GL_OBJECT_ATTACHED_OBJECTS_ARB = GL_OBJECT_ATTACHED_OBJECTS_ARB GL_OBJECT_BUFFER_SIZE_ATI = GL_OBJECT_BUFFER_SIZE_ATI GL_OBJECT_BUFFER_USAGE_ATI = GL_OBJECT_BUFFER_USAGE_ATI GL_OBJECT_COMPILE_STATUS = GL_OBJECT_COMPILE_STATUS_ARB GL_OBJECT_COMPILE_STATUS_ARB = GL_OBJECT_COMPILE_STATUS_ARB GL_OBJECT_DELETE_STATUS_ARB = GL_OBJECT_DELETE_STATUS_ARB GL_OBJECT_DISTANCE_TO_LINE_SGIS = GL_OBJECT_DISTANCE_TO_LINE_SGIS GL_OBJECT_DISTANCE_TO_POINT_SGIS = GL_OBJECT_DISTANCE_TO_POINT_SGIS GL_OBJECT_INFO_LOG_LENGTH_ARB = GL_OBJECT_INFO_LOG_LENGTH_ARB GL_OBJECT_LINEAR = GL_OBJECT_LINEAR GL_OBJECT_LINE_SGIS = GL_OBJECT_LINE_SGIS GL_OBJECT_LINK_STATUS = GL_OBJECT_LINK_STATUS_ARB GL_OBJECT_LINK_STATUS_ARB = GL_OBJECT_LINK_STATUS_ARB GL_OBJECT_PLANE = GL_OBJECT_PLANE GL_OBJECT_POINT_SGIS = GL_OBJECT_POINT_SGIS GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = GL_OBJECT_SHADER_SOURCE_LENGTH_ARB GL_OBJECT_SUBTYPE_ARB = GL_OBJECT_SUBTYPE_ARB GL_OBJECT_TYPE_ARB = GL_OBJECT_TYPE_ARB GL_OBJECT_VALIDATE_STATUS_ARB = GL_OBJECT_VALIDATE_STATUS_ARB GL_OCCLUSION_TEST_HP = GL_OCCLUSION_TEST_HP GL_OCCLUSION_TEST_RESULT_HP = GL_OCCLUSION_TEST_RESULT_HP GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV GL_OFFSET_HILO_TEXTURE_2D_NV = GL_OFFSET_HILO_TEXTURE_2D_NV GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV GL_OFFSET_TEXTURE_2D_NV = GL_OFFSET_TEXTURE_2D_NV GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV GL_OFFSET_TEXTURE_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV GL_OFFSET_TEXTURE_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV GL_OFFSET_TEXTURE_RECTANGLE_NV = GL_OFFSET_TEXTURE_RECTANGLE_NV GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV GL_OFFSET_TEXTURE_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV GL_ONE = GL_ONE GL_ONE_EXT = GL_ONE_EXT GL_ONE_MINUS_CONSTANT_ALPHA = GL_ONE_MINUS_CONSTANT_ALPHA GL_ONE_MINUS_CONSTANT_ALPHA_EXT = GL_ONE_MINUS_CONSTANT_ALPHA_EXT GL_ONE_MINUS_CONSTANT_COLOR = GL_ONE_MINUS_CONSTANT_COLOR GL_ONE_MINUS_CONSTANT_COLOR_EXT = GL_ONE_MINUS_CONSTANT_COLOR_EXT GL_ONE_MINUS_DST_ALPHA = GL_ONE_MINUS_DST_ALPHA GL_ONE_MINUS_DST_COLOR = GL_ONE_MINUS_DST_COLOR GL_ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA GL_ONE_MINUS_SRC_COLOR = GL_ONE_MINUS_SRC_COLOR GL_OPERAND0_ALPHA = GL_OPERAND0_ALPHA GL_OPERAND0_ALPHA_ARB = GL_OPERAND0_ALPHA_ARB GL_OPERAND0_ALPHA_EXT = GL_OPERAND0_ALPHA_EXT GL_OPERAND0_RGB = GL_OPERAND0_RGB GL_OPERAND0_RGB_ARB = GL_OPERAND0_RGB_ARB GL_OPERAND0_RGB_EXT = GL_OPERAND0_RGB_EXT GL_OPERAND1_ALPHA = GL_OPERAND1_ALPHA GL_OPERAND1_ALPHA_ARB = GL_OPERAND1_ALPHA_ARB GL_OPERAND1_ALPHA_EXT = GL_OPERAND1_ALPHA_EXT GL_OPERAND1_RGB = GL_OPERAND1_RGB GL_OPERAND1_RGB_ARB = GL_OPERAND1_RGB_ARB GL_OPERAND1_RGB_EXT = GL_OPERAND1_RGB_EXT GL_OPERAND2_ALPHA = GL_OPERAND2_ALPHA GL_OPERAND2_ALPHA_ARB = GL_OPERAND2_ALPHA_ARB GL_OPERAND2_ALPHA_EXT = GL_OPERAND2_ALPHA_EXT GL_OPERAND2_RGB = GL_OPERAND2_RGB GL_OPERAND2_RGB_ARB = GL_OPERAND2_RGB_ARB GL_OPERAND2_RGB_EXT = GL_OPERAND2_RGB_EXT GL_OPERAND3_ALPHA_NV = GL_OPERAND3_ALPHA_NV GL_OPERAND3_RGB_NV = GL_OPERAND3_RGB_NV GL_OP_ADD_EXT = GL_OP_ADD_EXT GL_OP_CLAMP_EXT = GL_OP_CLAMP_EXT GL_OP_CROSS_PRODUCT_EXT = GL_OP_CROSS_PRODUCT_EXT GL_OP_DOT3_EXT = GL_OP_DOT3_EXT GL_OP_DOT4_EXT = GL_OP_DOT4_EXT GL_OP_EXP_BASE_2_EXT = GL_OP_EXP_BASE_2_EXT GL_OP_FLOOR_EXT = GL_OP_FLOOR_EXT GL_OP_FRAC_EXT = GL_OP_FRAC_EXT GL_OP_INDEX_EXT = GL_OP_INDEX_EXT GL_OP_LOG_BASE_2_EXT = GL_OP_LOG_BASE_2_EXT GL_OP_MADD_EXT = GL_OP_MADD_EXT GL_OP_MAX_EXT = GL_OP_MAX_EXT GL_OP_MIN_EXT = GL_OP_MIN_EXT GL_OP_MOV_EXT = GL_OP_MOV_EXT GL_OP_MULTIPLY_MATRIX_EXT = GL_OP_MULTIPLY_MATRIX_EXT GL_OP_MUL_EXT = GL_OP_MUL_EXT GL_OP_NEGATE_EXT = GL_OP_NEGATE_EXT GL_OP_POWER_EXT = GL_OP_POWER_EXT GL_OP_RECIP_EXT = GL_OP_RECIP_EXT GL_OP_RECIP_SQRT_EXT = GL_OP_RECIP_SQRT_EXT GL_OP_ROUND_EXT = GL_OP_ROUND_EXT GL_OP_SET_GE_EXT = GL_OP_SET_GE_EXT GL_OP_SET_LT_EXT = GL_OP_SET_LT_EXT GL_OP_SUB_EXT = GL_OP_SUB_EXT GL_OR = GL_OR GL_ORDER = GL_ORDER GL_OR_INVERTED = GL_OR_INVERTED GL_OR_REVERSE = GL_OR_REVERSE GL_OUTPUT_COLOR0_EXT = GL_OUTPUT_COLOR0_EXT GL_OUTPUT_COLOR1_EXT = GL_OUTPUT_COLOR1_EXT GL_OUTPUT_FOG_EXT = GL_OUTPUT_FOG_EXT GL_OUTPUT_TEXTURE_COORD0_EXT = GL_OUTPUT_TEXTURE_COORD0_EXT GL_OUTPUT_TEXTURE_COORD10_EXT = GL_OUTPUT_TEXTURE_COORD10_EXT GL_OUTPUT_TEXTURE_COORD11_EXT = GL_OUTPUT_TEXTURE_COORD11_EXT GL_OUTPUT_TEXTURE_COORD12_EXT = GL_OUTPUT_TEXTURE_COORD12_EXT GL_OUTPUT_TEXTURE_COORD13_EXT = GL_OUTPUT_TEXTURE_COORD13_EXT GL_OUTPUT_TEXTURE_COORD14_EXT = GL_OUTPUT_TEXTURE_COORD14_EXT GL_OUTPUT_TEXTURE_COORD15_EXT = GL_OUTPUT_TEXTURE_COORD15_EXT GL_OUTPUT_TEXTURE_COORD16_EXT = GL_OUTPUT_TEXTURE_COORD16_EXT GL_OUTPUT_TEXTURE_COORD17_EXT = GL_OUTPUT_TEXTURE_COORD17_EXT GL_OUTPUT_TEXTURE_COORD18_EXT = GL_OUTPUT_TEXTURE_COORD18_EXT GL_OUTPUT_TEXTURE_COORD19_EXT = GL_OUTPUT_TEXTURE_COORD19_EXT GL_OUTPUT_TEXTURE_COORD1_EXT = GL_OUTPUT_TEXTURE_COORD1_EXT GL_OUTPUT_TEXTURE_COORD20_EXT = GL_OUTPUT_TEXTURE_COORD20_EXT GL_OUTPUT_TEXTURE_COORD21_EXT = GL_OUTPUT_TEXTURE_COORD21_EXT GL_OUTPUT_TEXTURE_COORD22_EXT = GL_OUTPUT_TEXTURE_COORD22_EXT GL_OUTPUT_TEXTURE_COORD23_EXT = GL_OUTPUT_TEXTURE_COORD23_EXT GL_OUTPUT_TEXTURE_COORD24_EXT = GL_OUTPUT_TEXTURE_COORD24_EXT GL_OUTPUT_TEXTURE_COORD25_EXT = GL_OUTPUT_TEXTURE_COORD25_EXT GL_OUTPUT_TEXTURE_COORD26_EXT = GL_OUTPUT_TEXTURE_COORD26_EXT GL_OUTPUT_TEXTURE_COORD27_EXT = GL_OUTPUT_TEXTURE_COORD27_EXT GL_OUTPUT_TEXTURE_COORD28_EXT = GL_OUTPUT_TEXTURE_COORD28_EXT GL_OUTPUT_TEXTURE_COORD29_EXT = GL_OUTPUT_TEXTURE_COORD29_EXT GL_OUTPUT_TEXTURE_COORD2_EXT = GL_OUTPUT_TEXTURE_COORD2_EXT GL_OUTPUT_TEXTURE_COORD30_EXT = GL_OUTPUT_TEXTURE_COORD30_EXT GL_OUTPUT_TEXTURE_COORD31_EXT = GL_OUTPUT_TEXTURE_COORD31_EXT GL_OUTPUT_TEXTURE_COORD3_EXT = GL_OUTPUT_TEXTURE_COORD3_EXT GL_OUTPUT_TEXTURE_COORD4_EXT = GL_OUTPUT_TEXTURE_COORD4_EXT GL_OUTPUT_TEXTURE_COORD5_EXT = GL_OUTPUT_TEXTURE_COORD5_EXT GL_OUTPUT_TEXTURE_COORD6_EXT = GL_OUTPUT_TEXTURE_COORD6_EXT GL_OUTPUT_TEXTURE_COORD7_EXT = GL_OUTPUT_TEXTURE_COORD7_EXT GL_OUTPUT_TEXTURE_COORD8_EXT = GL_OUTPUT_TEXTURE_COORD8_EXT GL_OUTPUT_TEXTURE_COORD9_EXT = GL_OUTPUT_TEXTURE_COORD9_EXT GL_OUTPUT_VERTEX_EXT = GL_OUTPUT_VERTEX_EXT GL_OUT_OF_MEMORY = GL_OUT_OF_MEMORY GL_PACK_ALIGNMENT = GL_PACK_ALIGNMENT GL_PACK_CMYK_HINT_EXT = GL_PACK_CMYK_HINT_EXT GL_PACK_IMAGE_DEPTH_SGIS = GL_PACK_IMAGE_DEPTH_SGIS GL_PACK_IMAGE_HEIGHT = GL_PACK_IMAGE_HEIGHT GL_PACK_IMAGE_HEIGHT_EXT = GL_PACK_IMAGE_HEIGHT_EXT GL_PACK_INVERT_MESA = GL_PACK_INVERT_MESA GL_PACK_LSB_FIRST = GL_PACK_LSB_FIRST GL_PACK_RESAMPLE_OML = GL_PACK_RESAMPLE_OML GL_PACK_RESAMPLE_SGIX = GL_PACK_RESAMPLE_SGIX GL_PACK_ROW_LENGTH = GL_PACK_ROW_LENGTH GL_PACK_SKIP_IMAGES = GL_PACK_SKIP_IMAGES GL_PACK_SKIP_IMAGES_EXT = GL_PACK_SKIP_IMAGES_EXT GL_PACK_SKIP_PIXELS = GL_PACK_SKIP_PIXELS GL_PACK_SKIP_ROWS = GL_PACK_SKIP_ROWS GL_PACK_SKIP_VOLUMES_SGIS = GL_PACK_SKIP_VOLUMES_SGIS GL_PACK_SUBSAMPLE_RATE_SGIX = GL_PACK_SUBSAMPLE_RATE_SGIX GL_PACK_SWAP_BYTES = GL_PACK_SWAP_BYTES GL_PARALLEL_ARRAYS_INTEL = GL_PARALLEL_ARRAYS_INTEL GL_PASS_THROUGH_NV = GL_PASS_THROUGH_NV GL_PASS_THROUGH_TOKEN = GL_PASS_THROUGH_TOKEN GL_PERSPECTIVE_CORRECTION_HINT = GL_PERSPECTIVE_CORRECTION_HINT GL_PERTURB_EXT = GL_PERTURB_EXT GL_PER_STAGE_CONSTANTS_NV = GL_PER_STAGE_CONSTANTS_NV GL_PHONG_HINT_WIN = GL_PHONG_HINT_WIN GL_PHONG_WIN = GL_PHONG_WIN GL_PIXEL_COUNTER_BITS_NV = GL_PIXEL_COUNTER_BITS_NV GL_PIXEL_COUNT_AVAILABLE_NV = GL_PIXEL_COUNT_AVAILABLE_NV GL_PIXEL_COUNT_NV = GL_PIXEL_COUNT_NV GL_PIXEL_CUBIC_WEIGHT_EXT = GL_PIXEL_CUBIC_WEIGHT_EXT GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS GL_PIXEL_GROUP_COLOR_SGIS = GL_PIXEL_GROUP_COLOR_SGIS GL_PIXEL_MAG_FILTER_EXT = GL_PIXEL_MAG_FILTER_EXT GL_PIXEL_MAP_A_TO_A = GL_PIXEL_MAP_A_TO_A GL_PIXEL_MAP_A_TO_A_SIZE = GL_PIXEL_MAP_A_TO_A_SIZE GL_PIXEL_MAP_B_TO_B = GL_PIXEL_MAP_B_TO_B GL_PIXEL_MAP_B_TO_B_SIZE = GL_PIXEL_MAP_B_TO_B_SIZE GL_PIXEL_MAP_G_TO_G = GL_PIXEL_MAP_G_TO_G GL_PIXEL_MAP_G_TO_G_SIZE = GL_PIXEL_MAP_G_TO_G_SIZE GL_PIXEL_MAP_I_TO_A = GL_PIXEL_MAP_I_TO_A GL_PIXEL_MAP_I_TO_A_SIZE = GL_PIXEL_MAP_I_TO_A_SIZE GL_PIXEL_MAP_I_TO_B = GL_PIXEL_MAP_I_TO_B GL_PIXEL_MAP_I_TO_B_SIZE = GL_PIXEL_MAP_I_TO_B_SIZE GL_PIXEL_MAP_I_TO_G = GL_PIXEL_MAP_I_TO_G GL_PIXEL_MAP_I_TO_G_SIZE = GL_PIXEL_MAP_I_TO_G_SIZE GL_PIXEL_MAP_I_TO_I = GL_PIXEL_MAP_I_TO_I GL_PIXEL_MAP_I_TO_I_SIZE = GL_PIXEL_MAP_I_TO_I_SIZE GL_PIXEL_MAP_I_TO_R = GL_PIXEL_MAP_I_TO_R GL_PIXEL_MAP_I_TO_R_SIZE = GL_PIXEL_MAP_I_TO_R_SIZE GL_PIXEL_MAP_R_TO_R = GL_PIXEL_MAP_R_TO_R GL_PIXEL_MAP_R_TO_R_SIZE = GL_PIXEL_MAP_R_TO_R_SIZE GL_PIXEL_MAP_S_TO_S = GL_PIXEL_MAP_S_TO_S GL_PIXEL_MAP_S_TO_S_SIZE = GL_PIXEL_MAP_S_TO_S_SIZE GL_PIXEL_MIN_FILTER_EXT = GL_PIXEL_MIN_FILTER_EXT GL_PIXEL_MODE_BIT = GL_PIXEL_MODE_BIT GL_PIXEL_PACK_BUFFER_ARB = GL_PIXEL_PACK_BUFFER_ARB GL_PIXEL_PACK_BUFFER_BINDING_ARB = GL_PIXEL_PACK_BUFFER_BINDING_ARB GL_PIXEL_PACK_BUFFER_BINDING_EXT = GL_PIXEL_PACK_BUFFER_BINDING_EXT GL_PIXEL_PACK_BUFFER_EXT = GL_PIXEL_PACK_BUFFER_EXT GL_PIXEL_SUBSAMPLE_2424_SGIX = GL_PIXEL_SUBSAMPLE_2424_SGIX GL_PIXEL_SUBSAMPLE_4242_SGIX = GL_PIXEL_SUBSAMPLE_4242_SGIX GL_PIXEL_SUBSAMPLE_4444_SGIX = GL_PIXEL_SUBSAMPLE_4444_SGIX GL_PIXEL_TEXTURE_SGIS = GL_PIXEL_TEXTURE_SGIS GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX GL_PIXEL_TEX_GEN_MODE_SGIX = GL_PIXEL_TEX_GEN_MODE_SGIX GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = GL_PIXEL_TEX_GEN_Q_CEILING_SGIX GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = GL_PIXEL_TEX_GEN_Q_ROUND_SGIX GL_PIXEL_TEX_GEN_SGIX = GL_PIXEL_TEX_GEN_SGIX GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = GL_PIXEL_TILE_CACHE_INCREMENT_SGIX GL_PIXEL_TILE_CACHE_SIZE_SGIX = GL_PIXEL_TILE_CACHE_SIZE_SGIX GL_PIXEL_TILE_GRID_DEPTH_SGIX = GL_PIXEL_TILE_GRID_DEPTH_SGIX GL_PIXEL_TILE_GRID_HEIGHT_SGIX = GL_PIXEL_TILE_GRID_HEIGHT_SGIX GL_PIXEL_TILE_GRID_WIDTH_SGIX = GL_PIXEL_TILE_GRID_WIDTH_SGIX GL_PIXEL_TILE_HEIGHT_SGIX = GL_PIXEL_TILE_HEIGHT_SGIX GL_PIXEL_TILE_WIDTH_SGIX = GL_PIXEL_TILE_WIDTH_SGIX GL_PIXEL_TRANSFORM_2D_EXT = GL_PIXEL_TRANSFORM_2D_EXT GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = GL_PIXEL_TRANSFORM_2D_MATRIX_EXT GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT GL_PIXEL_UNPACK_BUFFER_ARB = GL_PIXEL_UNPACK_BUFFER_ARB GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = GL_PIXEL_UNPACK_BUFFER_BINDING_ARB GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = GL_PIXEL_UNPACK_BUFFER_BINDING_EXT GL_PIXEL_UNPACK_BUFFER_EXT = GL_PIXEL_UNPACK_BUFFER_EXT GL_PN_TRIANGLES_ATI = GL_PN_TRIANGLES_ATI GL_PN_TRIANGLES_NORMAL_MODE_ATI = GL_PN_TRIANGLES_NORMAL_MODE_ATI GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI GL_PN_TRIANGLES_POINT_MODE_ATI = GL_PN_TRIANGLES_POINT_MODE_ATI GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI GL_POINT = GL_POINT GL_POINTS = GL_POINTS GL_POINT_BIT = GL_POINT_BIT GL_POINT_DISTANCE_ATTENUATION = GL_POINT_DISTANCE_ATTENUATION GL_POINT_DISTANCE_ATTENUATION_ARB = GL_POINT_DISTANCE_ATTENUATION_ARB GL_POINT_FADE_THRESHOLD_SIZE = GL_POINT_FADE_THRESHOLD_SIZE GL_POINT_FADE_THRESHOLD_SIZE_ARB = GL_POINT_FADE_THRESHOLD_SIZE_ARB GL_POINT_FADE_THRESHOLD_SIZE_EXT = GL_POINT_FADE_THRESHOLD_SIZE_EXT GL_POINT_FADE_THRESHOLD_SIZE_SGIS = GL_POINT_FADE_THRESHOLD_SIZE_SGIS GL_POINT_SIZE = GL_POINT_SIZE GL_POINT_SIZE_GRANULARITY = GL_SMOOTH_POINT_SIZE_GRANULARITY GL_POINT_SIZE_MAX = GL_POINT_SIZE_MAX GL_POINT_SIZE_MAX_ARB = GL_POINT_SIZE_MAX_ARB GL_POINT_SIZE_MAX_EXT = GL_POINT_SIZE_MAX_EXT GL_POINT_SIZE_MAX_SGIS = GL_POINT_SIZE_MAX_SGIS GL_POINT_SIZE_MIN = GL_POINT_SIZE_MIN GL_POINT_SIZE_MIN_ARB = GL_POINT_SIZE_MIN_ARB GL_POINT_SIZE_MIN_EXT = GL_POINT_SIZE_MIN_EXT GL_POINT_SIZE_MIN_SGIS = GL_POINT_SIZE_MIN_SGIS GL_POINT_SIZE_RANGE = GL_SMOOTH_POINT_SIZE_RANGE GL_POINT_SMOOTH = GL_POINT_SMOOTH GL_POINT_SMOOTH_HINT = GL_POINT_SMOOTH_HINT GL_POINT_SPRITE = GL_POINT_SPRITE GL_POINT_SPRITE_ARB = GL_POINT_SPRITE_ARB GL_POINT_SPRITE_COORD_ORIGIN = GL_POINT_SPRITE_COORD_ORIGIN GL_POINT_SPRITE_NV = GL_POINT_SPRITE_NV GL_POINT_SPRITE_R_MODE_NV = GL_POINT_SPRITE_R_MODE_NV GL_POINT_TOKEN = GL_POINT_TOKEN GL_POLYGON = GL_POLYGON GL_POLYGON_BIT = GL_POLYGON_BIT GL_POLYGON_MODE = GL_POLYGON_MODE GL_POLYGON_OFFSET_BIAS_EXT = GL_POLYGON_OFFSET_BIAS_EXT GL_POLYGON_OFFSET_EXT = GL_POLYGON_OFFSET_EXT GL_POLYGON_OFFSET_FACTOR = GL_POLYGON_OFFSET_FACTOR GL_POLYGON_OFFSET_FACTOR_EXT = GL_POLYGON_OFFSET_FACTOR_EXT GL_POLYGON_OFFSET_FILL = GL_POLYGON_OFFSET_FILL GL_POLYGON_OFFSET_LINE = GL_POLYGON_OFFSET_LINE GL_POLYGON_OFFSET_POINT = GL_POLYGON_OFFSET_POINT GL_POLYGON_OFFSET_UNITS = GL_POLYGON_OFFSET_UNITS GL_POLYGON_SMOOTH = GL_POLYGON_SMOOTH GL_POLYGON_SMOOTH_HINT = GL_POLYGON_SMOOTH_HINT GL_POLYGON_STIPPLE = GL_POLYGON_STIPPLE GL_POLYGON_STIPPLE_BIT = GL_POLYGON_STIPPLE_BIT GL_POLYGON_TOKEN = GL_POLYGON_TOKEN GL_POSITION = GL_POSITION GL_POST_COLOR_MATRIX_ALPHA_BIAS = GL_POST_COLOR_MATRIX_ALPHA_BIAS GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI GL_POST_COLOR_MATRIX_ALPHA_SCALE = GL_POST_COLOR_MATRIX_ALPHA_SCALE GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI GL_POST_COLOR_MATRIX_BLUE_BIAS = GL_POST_COLOR_MATRIX_BLUE_BIAS GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI GL_POST_COLOR_MATRIX_BLUE_SCALE = GL_POST_COLOR_MATRIX_BLUE_SCALE GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI GL_POST_COLOR_MATRIX_COLOR_TABLE = GL_POST_COLOR_MATRIX_COLOR_TABLE GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI GL_POST_COLOR_MATRIX_GREEN_BIAS = GL_POST_COLOR_MATRIX_GREEN_BIAS GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI GL_POST_COLOR_MATRIX_GREEN_SCALE = GL_POST_COLOR_MATRIX_GREEN_SCALE GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI GL_POST_COLOR_MATRIX_RED_BIAS = GL_POST_COLOR_MATRIX_RED_BIAS GL_POST_COLOR_MATRIX_RED_BIAS_SGI = GL_POST_COLOR_MATRIX_RED_BIAS_SGI GL_POST_COLOR_MATRIX_RED_SCALE = GL_POST_COLOR_MATRIX_RED_SCALE GL_POST_COLOR_MATRIX_RED_SCALE_SGI = GL_POST_COLOR_MATRIX_RED_SCALE_SGI GL_POST_CONVOLUTION_ALPHA_BIAS = GL_POST_CONVOLUTION_ALPHA_BIAS GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = GL_POST_CONVOLUTION_ALPHA_BIAS_EXT GL_POST_CONVOLUTION_ALPHA_SCALE = GL_POST_CONVOLUTION_ALPHA_SCALE GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = GL_POST_CONVOLUTION_ALPHA_SCALE_EXT GL_POST_CONVOLUTION_BLUE_BIAS = GL_POST_CONVOLUTION_BLUE_BIAS GL_POST_CONVOLUTION_BLUE_BIAS_EXT = GL_POST_CONVOLUTION_BLUE_BIAS_EXT GL_POST_CONVOLUTION_BLUE_SCALE = GL_POST_CONVOLUTION_BLUE_SCALE GL_POST_CONVOLUTION_BLUE_SCALE_EXT = GL_POST_CONVOLUTION_BLUE_SCALE_EXT GL_POST_CONVOLUTION_COLOR_TABLE = GL_POST_CONVOLUTION_COLOR_TABLE GL_POST_CONVOLUTION_COLOR_TABLE_SGI = GL_POST_CONVOLUTION_COLOR_TABLE_SGI GL_POST_CONVOLUTION_GREEN_BIAS = GL_POST_CONVOLUTION_GREEN_BIAS GL_POST_CONVOLUTION_GREEN_BIAS_EXT = GL_POST_CONVOLUTION_GREEN_BIAS_EXT GL_POST_CONVOLUTION_GREEN_SCALE = GL_POST_CONVOLUTION_GREEN_SCALE GL_POST_CONVOLUTION_GREEN_SCALE_EXT = GL_POST_CONVOLUTION_GREEN_SCALE_EXT GL_POST_CONVOLUTION_RED_BIAS = GL_POST_CONVOLUTION_RED_BIAS GL_POST_CONVOLUTION_RED_BIAS_EXT = GL_POST_CONVOLUTION_RED_BIAS_EXT GL_POST_CONVOLUTION_RED_SCALE = GL_POST_CONVOLUTION_RED_SCALE GL_POST_CONVOLUTION_RED_SCALE_EXT = GL_POST_CONVOLUTION_RED_SCALE_EXT GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX GL_POST_TEXTURE_FILTER_BIAS_SGIX = GL_POST_TEXTURE_FILTER_BIAS_SGIX GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX GL_POST_TEXTURE_FILTER_SCALE_SGIX = GL_POST_TEXTURE_FILTER_SCALE_SGIX GL_PREFER_DOUBLEBUFFER_HINT_PGI = GL_PREFER_DOUBLEBUFFER_HINT_PGI GL_PRESERVE_ATI = GL_PRESERVE_ATI GL_PREVIOUS = GL_PREVIOUS GL_PREVIOUS_ARB = GL_PREVIOUS_ARB GL_PREVIOUS_EXT = GL_PREVIOUS_EXT GL_PREVIOUS_TEXTURE_INPUT_NV = GL_PREVIOUS_TEXTURE_INPUT_NV GL_PRIMARY_COLOR = GL_PRIMARY_COLOR GL_PRIMARY_COLOR_ARB = GL_PRIMARY_COLOR_ARB GL_PRIMARY_COLOR_EXT = GL_PRIMARY_COLOR_EXT GL_PRIMARY_COLOR_NV = GL_PRIMARY_COLOR_NV GL_PRIMITIVE_RESTART_INDEX_NV = GL_PRIMITIVE_RESTART_INDEX_NV GL_PRIMITIVE_RESTART_NV = GL_PRIMITIVE_RESTART_NV GL_PROGRAM_ADDRESS_REGISTERS_ARB = GL_PROGRAM_ADDRESS_REGISTERS_ARB GL_PROGRAM_ALU_INSTRUCTIONS_ARB = GL_PROGRAM_ALU_INSTRUCTIONS_ARB GL_PROGRAM_ATTRIBS_ARB = GL_PROGRAM_ATTRIBS_ARB GL_PROGRAM_BINDING_ARB = GL_PROGRAM_BINDING_ARB GL_PROGRAM_ERROR_POSITION_ARB = GL_PROGRAM_ERROR_POSITION_ARB GL_PROGRAM_ERROR_POSITION_NV = GL_PROGRAM_ERROR_POSITION_NV GL_PROGRAM_ERROR_STRING_ARB = GL_PROGRAM_ERROR_STRING_ARB GL_PROGRAM_ERROR_STRING_NV = GL_PROGRAM_ERROR_STRING_NV GL_PROGRAM_FORMAT_ARB = GL_PROGRAM_FORMAT_ARB GL_PROGRAM_FORMAT_ASCII_ARB = GL_PROGRAM_FORMAT_ASCII_ARB GL_PROGRAM_INSTRUCTIONS_ARB = GL_PROGRAM_INSTRUCTIONS_ARB GL_PROGRAM_LENGTH_ARB = GL_PROGRAM_LENGTH_ARB GL_PROGRAM_LENGTH_NV = GL_PROGRAM_LENGTH_NV GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB GL_PROGRAM_NATIVE_ATTRIBS_ARB = GL_PROGRAM_NATIVE_ATTRIBS_ARB GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB GL_PROGRAM_NATIVE_PARAMETERS_ARB = GL_PROGRAM_NATIVE_PARAMETERS_ARB GL_PROGRAM_NATIVE_TEMPORARIES_ARB = GL_PROGRAM_NATIVE_TEMPORARIES_ARB GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB GL_PROGRAM_OBJECT_ARB = GL_PROGRAM_OBJECT_ARB GL_PROGRAM_PARAMETERS_ARB = GL_PROGRAM_PARAMETERS_ARB GL_PROGRAM_PARAMETER_NV = GL_PROGRAM_PARAMETER_NV GL_PROGRAM_RESIDENT_NV = GL_PROGRAM_RESIDENT_NV GL_PROGRAM_STRING_ARB = GL_PROGRAM_STRING_ARB GL_PROGRAM_STRING_NV = GL_PROGRAM_STRING_NV GL_PROGRAM_TARGET_NV = GL_PROGRAM_TARGET_NV GL_PROGRAM_TEMPORARIES_ARB = GL_PROGRAM_TEMPORARIES_ARB GL_PROGRAM_TEX_INDIRECTIONS_ARB = GL_PROGRAM_TEX_INDIRECTIONS_ARB GL_PROGRAM_TEX_INSTRUCTIONS_ARB = GL_PROGRAM_TEX_INSTRUCTIONS_ARB GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB GL_PROJECTION = GL_PROJECTION GL_PROJECTION_MATRIX = GL_PROJECTION_MATRIX GL_PROJECTION_STACK_DEPTH = GL_PROJECTION_STACK_DEPTH GL_PROXY_COLOR_TABLE = GL_PROXY_COLOR_TABLE GL_PROXY_COLOR_TABLE_SGI = GL_PROXY_COLOR_TABLE_SGI GL_PROXY_HISTOGRAM = GL_PROXY_HISTOGRAM GL_PROXY_HISTOGRAM_EXT = GL_PROXY_HISTOGRAM_EXT GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = GL_PROXY_POST_CONVOLUTION_COLOR_TABLE GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP GL_PROXY_TEXTURE_1D = GL_PROXY_TEXTURE_1D GL_PROXY_TEXTURE_1D_EXT = GL_PROXY_TEXTURE_1D_EXT GL_PROXY_TEXTURE_2D = GL_PROXY_TEXTURE_2D GL_PROXY_TEXTURE_2D_EXT = GL_PROXY_TEXTURE_2D_EXT GL_PROXY_TEXTURE_3D = GL_PROXY_TEXTURE_3D GL_PROXY_TEXTURE_3D_EXT = GL_PROXY_TEXTURE_3D_EXT GL_PROXY_TEXTURE_4D_SGIS = GL_PROXY_TEXTURE_4D_SGIS GL_PROXY_TEXTURE_COLOR_TABLE_SGI = GL_PROXY_TEXTURE_COLOR_TABLE_SGI GL_PROXY_TEXTURE_CUBE_MAP = GL_PROXY_TEXTURE_CUBE_MAP GL_PROXY_TEXTURE_CUBE_MAP_ARB = GL_PROXY_TEXTURE_CUBE_MAP_ARB GL_PROXY_TEXTURE_CUBE_MAP_EXT = GL_PROXY_TEXTURE_CUBE_MAP_EXT GL_PROXY_TEXTURE_RECTANGLE_ARB = GL_PROXY_TEXTURE_RECTANGLE_ARB GL_PROXY_TEXTURE_RECTANGLE_NV = GL_PROXY_TEXTURE_RECTANGLE_NV GL_Q = GL_Q GL_QUADRATIC_ATTENUATION = GL_QUADRATIC_ATTENUATION GL_QUADS = GL_QUADS GL_QUAD_ALPHA4_SGIS = GL_QUAD_ALPHA4_SGIS GL_QUAD_ALPHA8_SGIS = GL_QUAD_ALPHA8_SGIS GL_QUAD_INTENSITY4_SGIS = GL_QUAD_INTENSITY4_SGIS GL_QUAD_INTENSITY8_SGIS = GL_QUAD_INTENSITY8_SGIS GL_QUAD_LUMINANCE4_SGIS = GL_QUAD_LUMINANCE4_SGIS GL_QUAD_LUMINANCE8_SGIS = GL_QUAD_LUMINANCE8_SGIS GL_QUAD_MESH_SUN = GL_QUAD_MESH_SUN GL_QUAD_STRIP = GL_QUAD_STRIP GL_QUAD_TEXTURE_SELECT_SGIS = GL_QUAD_TEXTURE_SELECT_SGIS GL_QUARTER_BIT_ATI = GL_QUARTER_BIT_ATI GL_QUERY_COUNTER_BITS = GL_QUERY_COUNTER_BITS GL_QUERY_COUNTER_BITS_ARB = GL_QUERY_COUNTER_BITS_ARB GL_QUERY_RESULT = GL_QUERY_RESULT GL_QUERY_RESULT_ARB = GL_QUERY_RESULT_ARB GL_QUERY_RESULT_AVAILABLE = GL_QUERY_RESULT_AVAILABLE GL_QUERY_RESULT_AVAILABLE_ARB = GL_QUERY_RESULT_AVAILABLE_ARB GL_R = GL_R GL_R1UI_C3F_V3F_SUN = GL_R1UI_C3F_V3F_SUN GL_R1UI_C4F_N3F_V3F_SUN = GL_R1UI_C4F_N3F_V3F_SUN GL_R1UI_C4UB_V3F_SUN = GL_R1UI_C4UB_V3F_SUN GL_R1UI_N3F_V3F_SUN = GL_R1UI_N3F_V3F_SUN GL_R1UI_T2F_C4F_N3F_V3F_SUN = GL_R1UI_T2F_C4F_N3F_V3F_SUN GL_R1UI_T2F_N3F_V3F_SUN = GL_R1UI_T2F_N3F_V3F_SUN GL_R1UI_T2F_V3F_SUN = GL_R1UI_T2F_V3F_SUN GL_R1UI_V3F_SUN = GL_R1UI_V3F_SUN GL_R3_G3_B2 = GL_R3_G3_B2 GL_RASTER_POSITION_UNCLIPPED_IBM = GL_RASTER_POSITION_UNCLIPPED_IBM GL_READ_BUFFER = GL_READ_BUFFER GL_READ_ONLY = GL_READ_ONLY GL_READ_ONLY_ARB = GL_READ_ONLY_ARB GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = GL_READ_PIXEL_DATA_RANGE_LENGTH_NV GL_READ_PIXEL_DATA_RANGE_NV = GL_READ_PIXEL_DATA_RANGE_NV GL_READ_PIXEL_DATA_RANGE_POINTER_NV = GL_READ_PIXEL_DATA_RANGE_POINTER_NV GL_READ_WRITE = GL_READ_WRITE GL_READ_WRITE_ARB = GL_READ_WRITE_ARB GL_RECLAIM_MEMORY_HINT_PGI = GL_RECLAIM_MEMORY_HINT_PGI GL_RED = GL_RED GL_REDUCE = GL_REDUCE GL_REDUCE_EXT = GL_REDUCE_EXT GL_RED_BIAS = GL_RED_BIAS GL_RED_BITS = GL_RED_BITS GL_RED_BIT_ATI = GL_RED_BIT_ATI GL_RED_MAX_CLAMP_INGR = GL_RED_MAX_CLAMP_INGR GL_RED_MIN_CLAMP_INGR = GL_RED_MIN_CLAMP_INGR GL_RED_SCALE = GL_RED_SCALE GL_REFERENCE_PLANE_EQUATION_SGIX = GL_REFERENCE_PLANE_EQUATION_SGIX GL_REFERENCE_PLANE_SGIX = GL_REFERENCE_PLANE_SGIX GL_REFLECTION_MAP = GL_REFLECTION_MAP GL_REFLECTION_MAP_ARB = GL_REFLECTION_MAP_ARB GL_REFLECTION_MAP_EXT = GL_REFLECTION_MAP_EXT GL_REFLECTION_MAP_NV = GL_REFLECTION_MAP_NV GL_REGISTER_COMBINERS_NV = GL_REGISTER_COMBINERS_NV GL_REG_0_ATI = GL_REG_0_ATI GL_REG_10_ATI = GL_REG_10_ATI GL_REG_11_ATI = GL_REG_11_ATI GL_REG_12_ATI = GL_REG_12_ATI GL_REG_13_ATI = GL_REG_13_ATI GL_REG_14_ATI = GL_REG_14_ATI GL_REG_15_ATI = GL_REG_15_ATI GL_REG_16_ATI = GL_REG_16_ATI GL_REG_17_ATI = GL_REG_17_ATI GL_REG_18_ATI = GL_REG_18_ATI GL_REG_19_ATI = GL_REG_19_ATI GL_REG_1_ATI = GL_REG_1_ATI GL_REG_20_ATI = GL_REG_20_ATI GL_REG_21_ATI = GL_REG_21_ATI GL_REG_22_ATI = GL_REG_22_ATI GL_REG_23_ATI = GL_REG_23_ATI GL_REG_24_ATI = GL_REG_24_ATI GL_REG_25_ATI = GL_REG_25_ATI GL_REG_26_ATI = GL_REG_26_ATI GL_REG_27_ATI = GL_REG_27_ATI GL_REG_28_ATI = GL_REG_28_ATI GL_REG_29_ATI = GL_REG_29_ATI GL_REG_2_ATI = GL_REG_2_ATI GL_REG_30_ATI = GL_REG_30_ATI GL_REG_31_ATI = GL_REG_31_ATI GL_REG_3_ATI = GL_REG_3_ATI GL_REG_4_ATI = GL_REG_4_ATI GL_REG_5_ATI = GL_REG_5_ATI GL_REG_6_ATI = GL_REG_6_ATI GL_REG_7_ATI = GL_REG_7_ATI GL_REG_8_ATI = GL_REG_8_ATI GL_REG_9_ATI = GL_REG_9_ATI GL_RENDER = GL_RENDER GL_RENDERBUFFER_ALPHA_SIZE_EXT = GL_RENDERBUFFER_ALPHA_SIZE_EXT GL_RENDERBUFFER_BINDING_EXT = GL_RENDERBUFFER_BINDING_EXT GL_RENDERBUFFER_BLUE_SIZE_EXT = GL_RENDERBUFFER_BLUE_SIZE_EXT GL_RENDERBUFFER_DEPTH_SIZE_EXT = GL_RENDERBUFFER_DEPTH_SIZE_EXT GL_RENDERBUFFER_EXT = GL_RENDERBUFFER_EXT GL_RENDERBUFFER_GREEN_SIZE_EXT = GL_RENDERBUFFER_GREEN_SIZE_EXT GL_RENDERBUFFER_HEIGHT_EXT = GL_RENDERBUFFER_HEIGHT_EXT GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = GL_RENDERBUFFER_INTERNAL_FORMAT_EXT GL_RENDERBUFFER_RED_SIZE_EXT = GL_RENDERBUFFER_RED_SIZE_EXT GL_RENDERBUFFER_STENCIL_SIZE_EXT = GL_RENDERBUFFER_STENCIL_SIZE_EXT GL_RENDERBUFFER_WIDTH_EXT = GL_RENDERBUFFER_WIDTH_EXT GL_RENDERER = GL_RENDERER GL_RENDER_MODE = GL_RENDER_MODE GL_REPEAT = GL_REPEAT GL_REPLACE = GL_REPLACE GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN GL_REPLACEMENT_CODE_ARRAY_SUN = GL_REPLACEMENT_CODE_ARRAY_SUN GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN GL_REPLACEMENT_CODE_SUN = GL_REPLACEMENT_CODE_SUN GL_REPLACE_EXT = GL_REPLACE_EXT GL_REPLACE_MIDDLE_SUN = GL_REPLACE_MIDDLE_SUN GL_REPLACE_OLDEST_SUN = GL_REPLACE_OLDEST_SUN GL_REPLICATE_BORDER = GL_REPLICATE_BORDER GL_REPLICATE_BORDER_HP = GL_REPLICATE_BORDER_HP GL_RESAMPLE_AVERAGE_OML = GL_RESAMPLE_AVERAGE_OML GL_RESAMPLE_DECIMATE_OML = GL_RESAMPLE_DECIMATE_OML GL_RESAMPLE_DECIMATE_SGIX = GL_RESAMPLE_DECIMATE_SGIX GL_RESAMPLE_REPLICATE_OML = GL_RESAMPLE_REPLICATE_OML GL_RESAMPLE_REPLICATE_SGIX = GL_RESAMPLE_REPLICATE_SGIX GL_RESAMPLE_ZERO_FILL_OML = GL_RESAMPLE_ZERO_FILL_OML GL_RESAMPLE_ZERO_FILL_SGIX = GL_RESAMPLE_ZERO_FILL_SGIX GL_RESCALE_NORMAL = GL_RESCALE_NORMAL GL_RESCALE_NORMAL_EXT = GL_RESCALE_NORMAL_EXT GL_RESTART_SUN = GL_RESTART_SUN GL_RETURN = GL_RETURN GL_RGB = GL_RGB GL_RGB10 = GL_RGB10 GL_RGB10_A2 = GL_RGB10_A2 GL_RGB10_A2_EXT = GL_RGB10_A2_EXT GL_RGB10_EXT = GL_RGB10_EXT GL_RGB12 = GL_RGB12 GL_RGB12_EXT = GL_RGB12_EXT GL_RGB16 = GL_RGB16 GL_RGB16F_ARB = GL_RGB16F_ARB GL_RGB16_EXT = GL_RGB16_EXT GL_RGB2_EXT = GL_RGB2_EXT GL_RGB32F_ARB = GL_RGB32F_ARB GL_RGB4 = GL_RGB4 GL_RGB4_EXT = GL_RGB4_EXT GL_RGB4_S3TC = GL_RGB4_S3TC GL_RGB5 = GL_RGB5 GL_RGB5_A1 = GL_RGB5_A1 GL_RGB5_A1_EXT = GL_RGB5_A1_EXT GL_RGB5_EXT = GL_RGB5_EXT GL_RGB8 = GL_RGB8 GL_RGB8_EXT = GL_RGB8_EXT GL_RGBA = GL_RGBA GL_RGBA12 = GL_RGBA12 GL_RGBA12_EXT = GL_RGBA12_EXT GL_RGBA16 = GL_RGBA16 GL_RGBA16F_ARB = GL_RGBA16F_ARB GL_RGBA16_EXT = GL_RGBA16_EXT GL_RGBA2 = GL_RGBA2 GL_RGBA2_EXT = GL_RGBA2_EXT GL_RGBA32F_ARB = GL_RGBA32F_ARB GL_RGBA4 = GL_RGBA4 GL_RGBA4_EXT = GL_RGBA4_EXT GL_RGBA4_S3TC = GL_RGBA4_S3TC GL_RGBA8 = GL_RGBA8 GL_RGBA8_EXT = GL_RGBA8_EXT GL_RGBA_FLOAT16_ATI = GL_RGBA_FLOAT16_ATI GL_RGBA_FLOAT32_ATI = GL_RGBA_FLOAT32_ATI GL_RGBA_FLOAT_MODE_ARB = GL_RGBA_FLOAT_MODE_ARB GL_RGBA_MODE = GL_RGBA_MODE GL_RGBA_S3TC = GL_RGBA_S3TC GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV GL_RGB_FLOAT16_ATI = GL_RGB_FLOAT16_ATI GL_RGB_FLOAT32_ATI = GL_RGB_FLOAT32_ATI GL_RGB_S3TC = GL_RGB_S3TC GL_RGB_SCALE = GL_RGB_SCALE GL_RGB_SCALE_ARB = GL_RGB_SCALE_ARB GL_RGB_SCALE_EXT = GL_RGB_SCALE_EXT GL_RIGHT = GL_RIGHT GL_S = GL_S GL_SAMPLER_1D = GL_SAMPLER_1D GL_SAMPLER_1D_ARB = GL_SAMPLER_1D_ARB GL_SAMPLER_1D_SHADOW = GL_SAMPLER_1D_SHADOW GL_SAMPLER_1D_SHADOW_ARB = GL_SAMPLER_1D_SHADOW_ARB GL_SAMPLER_2D = GL_SAMPLER_2D GL_SAMPLER_2D_ARB = GL_SAMPLER_2D_ARB GL_SAMPLER_2D_RECT_ARB = GL_SAMPLER_2D_RECT_ARB GL_SAMPLER_2D_RECT_SHADOW_ARB = GL_SAMPLER_2D_RECT_SHADOW_ARB GL_SAMPLER_2D_SHADOW = GL_SAMPLER_2D_SHADOW GL_SAMPLER_2D_SHADOW_ARB = GL_SAMPLER_2D_SHADOW_ARB GL_SAMPLER_3D = GL_SAMPLER_3D GL_SAMPLER_3D_ARB = GL_SAMPLER_3D_ARB GL_SAMPLER_CUBE = GL_SAMPLER_CUBE GL_SAMPLER_CUBE_ARB = GL_SAMPLER_CUBE_ARB GL_SAMPLES = GL_SAMPLES GL_SAMPLES_3DFX = GL_SAMPLES_3DFX GL_SAMPLES_ARB = GL_SAMPLES_ARB GL_SAMPLES_EXT = GL_SAMPLES_EXT GL_SAMPLES_PASSED = GL_SAMPLES_PASSED GL_SAMPLES_PASSED_ARB = GL_SAMPLES_PASSED_ARB GL_SAMPLES_SGIS = GL_SAMPLES_SGIS GL_SAMPLE_ALPHA_TO_COVERAGE = GL_SAMPLE_ALPHA_TO_COVERAGE GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = GL_SAMPLE_ALPHA_TO_COVERAGE_ARB GL_SAMPLE_ALPHA_TO_MASK_EXT = GL_SAMPLE_ALPHA_TO_MASK_EXT GL_SAMPLE_ALPHA_TO_MASK_SGIS = GL_SAMPLE_ALPHA_TO_MASK_SGIS GL_SAMPLE_ALPHA_TO_ONE = GL_SAMPLE_ALPHA_TO_ONE GL_SAMPLE_ALPHA_TO_ONE_ARB = GL_SAMPLE_ALPHA_TO_ONE_ARB GL_SAMPLE_ALPHA_TO_ONE_EXT = GL_SAMPLE_ALPHA_TO_ONE_EXT GL_SAMPLE_ALPHA_TO_ONE_SGIS = GL_SAMPLE_ALPHA_TO_ONE_SGIS GL_SAMPLE_BUFFERS = GL_SAMPLE_BUFFERS GL_SAMPLE_BUFFERS_3DFX = GL_SAMPLE_BUFFERS_3DFX GL_SAMPLE_BUFFERS_ARB = GL_SAMPLE_BUFFERS_ARB GL_SAMPLE_BUFFERS_EXT = GL_SAMPLE_BUFFERS_EXT GL_SAMPLE_BUFFERS_SGIS = GL_SAMPLE_BUFFERS_SGIS GL_SAMPLE_COVERAGE = GL_SAMPLE_COVERAGE GL_SAMPLE_COVERAGE_ARB = GL_SAMPLE_COVERAGE_ARB GL_SAMPLE_COVERAGE_INVERT = GL_SAMPLE_COVERAGE_INVERT GL_SAMPLE_COVERAGE_INVERT_ARB = GL_SAMPLE_COVERAGE_INVERT_ARB GL_SAMPLE_COVERAGE_VALUE = GL_SAMPLE_COVERAGE_VALUE GL_SAMPLE_COVERAGE_VALUE_ARB = GL_SAMPLE_COVERAGE_VALUE_ARB GL_SAMPLE_MASK_EXT = GL_SAMPLE_MASK_EXT GL_SAMPLE_MASK_INVERT_EXT = GL_SAMPLE_MASK_INVERT_EXT GL_SAMPLE_MASK_INVERT_SGIS = GL_SAMPLE_MASK_INVERT_SGIS GL_SAMPLE_MASK_SGIS = GL_SAMPLE_MASK_SGIS GL_SAMPLE_MASK_VALUE_EXT = GL_SAMPLE_MASK_VALUE_EXT GL_SAMPLE_MASK_VALUE_SGIS = GL_SAMPLE_MASK_VALUE_SGIS GL_SAMPLE_PATTERN_EXT = GL_SAMPLE_PATTERN_EXT GL_SAMPLE_PATTERN_SGIS = GL_SAMPLE_PATTERN_SGIS GL_SATURATE_BIT_ATI = GL_SATURATE_BIT_ATI GL_SCALAR_EXT = GL_SCALAR_EXT GL_SCALEBIAS_HINT_SGIX = GL_SCALEBIAS_HINT_SGIX GL_SCALE_BY_FOUR_NV = GL_SCALE_BY_FOUR_NV GL_SCALE_BY_ONE_HALF_NV = GL_SCALE_BY_ONE_HALF_NV GL_SCALE_BY_TWO_NV = GL_SCALE_BY_TWO_NV GL_SCISSOR_BIT = GL_SCISSOR_BIT GL_SCISSOR_BOX = GL_SCISSOR_BOX GL_SCISSOR_TEST = GL_SCISSOR_TEST GL_SCREEN_COORDINATES_REND = GL_SCREEN_COORDINATES_REND GL_SECONDARY_COLOR_ARRAY = GL_SECONDARY_COLOR_ARRAY GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB GL_SECONDARY_COLOR_ARRAY_EXT = GL_SECONDARY_COLOR_ARRAY_EXT GL_SECONDARY_COLOR_ARRAY_LIST_IBM = GL_SECONDARY_COLOR_ARRAY_LIST_IBM GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM GL_SECONDARY_COLOR_ARRAY_POINTER = GL_SECONDARY_COLOR_ARRAY_POINTER GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = GL_SECONDARY_COLOR_ARRAY_POINTER_EXT GL_SECONDARY_COLOR_ARRAY_SIZE = GL_SECONDARY_COLOR_ARRAY_SIZE GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = GL_SECONDARY_COLOR_ARRAY_SIZE_EXT GL_SECONDARY_COLOR_ARRAY_STRIDE = GL_SECONDARY_COLOR_ARRAY_STRIDE GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT GL_SECONDARY_COLOR_ARRAY_TYPE = GL_SECONDARY_COLOR_ARRAY_TYPE GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = GL_SECONDARY_COLOR_ARRAY_TYPE_EXT GL_SECONDARY_COLOR_NV = GL_SECONDARY_COLOR_NV GL_SECONDARY_INTERPOLATOR_ATI = GL_SECONDARY_INTERPOLATOR_ATI GL_SELECT = GL_SELECT GL_SELECTION_BUFFER_POINTER = GL_SELECTION_BUFFER_POINTER GL_SELECTION_BUFFER_SIZE = GL_SELECTION_BUFFER_SIZE GL_SEPARABLE_2D = GL_SEPARABLE_2D GL_SEPARABLE_2D_EXT = GL_SEPARABLE_2D_EXT GL_SEPARATE_SPECULAR_COLOR = GL_SEPARATE_SPECULAR_COLOR GL_SEPARATE_SPECULAR_COLOR_EXT = GL_SEPARATE_SPECULAR_COLOR_EXT GL_SET = GL_SET GL_SHADER_CONSISTENT_NV = GL_SHADER_CONSISTENT_NV GL_SHADER_OBJECT_ARB = GL_SHADER_OBJECT_ARB GL_SHADER_OPERATION_NV = GL_SHADER_OPERATION_NV GL_SHADER_SOURCE_LENGTH = GL_SHADER_SOURCE_LENGTH GL_SHADER_TYPE = GL_SHADER_TYPE GL_SHADE_MODEL = GL_SHADE_MODEL GL_SHADING_LANGUAGE_VERSION = GL_SHADING_LANGUAGE_VERSION GL_SHADING_LANGUAGE_VERSION_ARB = GL_SHADING_LANGUAGE_VERSION_ARB GL_SHADOW_AMBIENT_SGIX = GL_SHADOW_AMBIENT_SGIX GL_SHADOW_ATTENUATION_EXT = GL_SHADOW_ATTENUATION_EXT GL_SHARED_TEXTURE_PALETTE_EXT = GL_SHARED_TEXTURE_PALETTE_EXT GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS GL_SHININESS = GL_SHININESS GL_SHORT = GL_SHORT GL_SIGNED_ALPHA8_NV = GL_SIGNED_ALPHA8_NV GL_SIGNED_ALPHA_NV = GL_SIGNED_ALPHA_NV GL_SIGNED_HILO16_NV = GL_SIGNED_HILO16_NV GL_SIGNED_HILO8_NV = GL_SIGNED_HILO8_NV GL_SIGNED_HILO_NV = GL_SIGNED_HILO_NV GL_SIGNED_IDENTITY_NV = GL_SIGNED_IDENTITY_NV GL_SIGNED_INTENSITY8_NV = GL_SIGNED_INTENSITY8_NV GL_SIGNED_INTENSITY_NV = GL_SIGNED_INTENSITY_NV GL_SIGNED_LUMINANCE8_ALPHA8_NV = GL_SIGNED_LUMINANCE8_ALPHA8_NV GL_SIGNED_LUMINANCE8_NV = GL_SIGNED_LUMINANCE8_NV GL_SIGNED_LUMINANCE_ALPHA_NV = GL_SIGNED_LUMINANCE_ALPHA_NV GL_SIGNED_LUMINANCE_NV = GL_SIGNED_LUMINANCE_NV GL_SIGNED_NEGATE_NV = GL_SIGNED_NEGATE_NV GL_SIGNED_RGB8_NV = GL_SIGNED_RGB8_NV GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV GL_SIGNED_RGBA8_NV = GL_SIGNED_RGBA8_NV GL_SIGNED_RGBA_NV = GL_SIGNED_RGBA_NV GL_SIGNED_RGB_NV = GL_SIGNED_RGB_NV GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = GL_SIGNED_RGB_UNSIGNED_ALPHA_NV GL_SINGLE_COLOR = GL_SINGLE_COLOR GL_SINGLE_COLOR_EXT = GL_SINGLE_COLOR_EXT GL_SLICE_ACCUM_SUN = GL_SLICE_ACCUM_SUN GL_SMOOTH = GL_SMOOTH GL_SMOOTH_LINE_WIDTH_GRANULARITY = GL_SMOOTH_LINE_WIDTH_GRANULARITY GL_SMOOTH_LINE_WIDTH_RANGE = GL_SMOOTH_LINE_WIDTH_RANGE GL_SMOOTH_POINT_SIZE_GRANULARITY = GL_SMOOTH_POINT_SIZE_GRANULARITY GL_SMOOTH_POINT_SIZE_RANGE = GL_SMOOTH_POINT_SIZE_RANGE GL_SOURCE0_ALPHA = GL_SOURCE0_ALPHA GL_SOURCE0_ALPHA_ARB = GL_SOURCE0_ALPHA_ARB GL_SOURCE0_ALPHA_EXT = GL_SOURCE0_ALPHA_EXT GL_SOURCE0_RGB = GL_SOURCE0_RGB GL_SOURCE0_RGB_ARB = GL_SOURCE0_RGB_ARB GL_SOURCE0_RGB_EXT = GL_SOURCE0_RGB_EXT GL_SOURCE1_ALPHA = GL_SOURCE1_ALPHA GL_SOURCE1_ALPHA_ARB = GL_SOURCE1_ALPHA_ARB GL_SOURCE1_ALPHA_EXT = GL_SOURCE1_ALPHA_EXT GL_SOURCE1_RGB = GL_SOURCE1_RGB GL_SOURCE1_RGB_ARB = GL_SOURCE1_RGB_ARB GL_SOURCE1_RGB_EXT = GL_SOURCE1_RGB_EXT GL_SOURCE2_ALPHA = GL_SOURCE2_ALPHA GL_SOURCE2_ALPHA_ARB = GL_SOURCE2_ALPHA_ARB GL_SOURCE2_ALPHA_EXT = GL_SOURCE2_ALPHA_EXT GL_SOURCE2_RGB = GL_SOURCE2_RGB GL_SOURCE2_RGB_ARB = GL_SOURCE2_RGB_ARB GL_SOURCE2_RGB_EXT = GL_SOURCE2_RGB_EXT GL_SOURCE3_ALPHA_NV = GL_SOURCE3_ALPHA_NV GL_SOURCE3_RGB_NV = GL_SOURCE3_RGB_NV GL_SPARE0_NV = GL_SPARE0_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV = GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_SPARE1_NV = GL_SPARE1_NV GL_SPECULAR = GL_SPECULAR GL_SPHERE_MAP = GL_SPHERE_MAP GL_SPOT_CUTOFF = GL_SPOT_CUTOFF GL_SPOT_DIRECTION = GL_SPOT_DIRECTION GL_SPOT_EXPONENT = GL_SPOT_EXPONENT GL_SPRITE_AXIAL_SGIX = GL_SPRITE_AXIAL_SGIX GL_SPRITE_AXIS_SGIX = GL_SPRITE_AXIS_SGIX GL_SPRITE_EYE_ALIGNED_SGIX = GL_SPRITE_EYE_ALIGNED_SGIX GL_SPRITE_MODE_SGIX = GL_SPRITE_MODE_SGIX GL_SPRITE_OBJECT_ALIGNED_SGIX = GL_SPRITE_OBJECT_ALIGNED_SGIX GL_SPRITE_SGIX = GL_SPRITE_SGIX GL_SPRITE_TRANSLATION_SGIX = GL_SPRITE_TRANSLATION_SGIX GL_SRC0_ALPHA = GL_SOURCE0_ALPHA GL_SRC0_RGB = GL_SOURCE0_RGB GL_SRC1_ALPHA = GL_SOURCE1_ALPHA GL_SRC1_RGB = GL_SOURCE1_RGB GL_SRC2_ALPHA = GL_SOURCE2_ALPHA GL_SRC2_RGB = GL_SOURCE2_RGB GL_SRC_ALPHA = GL_SRC_ALPHA GL_SRC_ALPHA_SATURATE = GL_SRC_ALPHA_SATURATE GL_SRC_COLOR = GL_SRC_COLOR GL_STACK_OVERFLOW = GL_STACK_OVERFLOW GL_STACK_UNDERFLOW = GL_STACK_UNDERFLOW GL_STATIC_ATI = GL_STATIC_ATI GL_STATIC_COPY = GL_STATIC_COPY GL_STATIC_COPY_ARB = GL_STATIC_COPY_ARB GL_STATIC_DRAW = GL_STATIC_DRAW GL_STATIC_DRAW_ARB = GL_STATIC_DRAW_ARB GL_STATIC_READ = GL_STATIC_READ GL_STATIC_READ_ARB = GL_STATIC_READ_ARB GL_STENCIL = GL_STENCIL GL_STENCIL_ATTACHMENT_EXT = GL_STENCIL_ATTACHMENT_EXT GL_STENCIL_BACK_FAIL = GL_STENCIL_BACK_FAIL GL_STENCIL_BACK_FAIL_ATI = GL_STENCIL_BACK_FAIL_ATI GL_STENCIL_BACK_FUNC = GL_STENCIL_BACK_FUNC GL_STENCIL_BACK_FUNC_ATI = GL_STENCIL_BACK_FUNC_ATI GL_STENCIL_BACK_PASS_DEPTH_FAIL = GL_STENCIL_BACK_PASS_DEPTH_FAIL GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI GL_STENCIL_BACK_PASS_DEPTH_PASS = GL_STENCIL_BACK_PASS_DEPTH_PASS GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI GL_STENCIL_BACK_REF = GL_STENCIL_BACK_REF GL_STENCIL_BACK_VALUE_MASK = GL_STENCIL_BACK_VALUE_MASK GL_STENCIL_BACK_WRITEMASK = GL_STENCIL_BACK_WRITEMASK GL_STENCIL_BITS = GL_STENCIL_BITS GL_STENCIL_BUFFER_BIT = GL_STENCIL_BUFFER_BIT GL_STENCIL_CLEAR_VALUE = GL_STENCIL_CLEAR_VALUE GL_STENCIL_FAIL = GL_STENCIL_FAIL GL_STENCIL_FUNC = GL_STENCIL_FUNC GL_STENCIL_INDEX = GL_STENCIL_INDEX GL_STENCIL_INDEX16_EXT = GL_STENCIL_INDEX16_EXT GL_STENCIL_INDEX1_EXT = GL_STENCIL_INDEX1_EXT GL_STENCIL_INDEX4_EXT = GL_STENCIL_INDEX4_EXT GL_STENCIL_INDEX8_EXT = GL_STENCIL_INDEX8_EXT GL_STENCIL_PASS_DEPTH_FAIL = GL_STENCIL_PASS_DEPTH_FAIL GL_STENCIL_PASS_DEPTH_PASS = GL_STENCIL_PASS_DEPTH_PASS GL_STENCIL_REF = GL_STENCIL_REF GL_STENCIL_TEST = GL_STENCIL_TEST GL_STENCIL_TEST_TWO_SIDE_EXT = GL_STENCIL_TEST_TWO_SIDE_EXT GL_STENCIL_VALUE_MASK = GL_STENCIL_VALUE_MASK GL_STENCIL_WRITEMASK = GL_STENCIL_WRITEMASK GL_STEREO = GL_STEREO GL_STORAGE_CACHED_APPLE = GL_STORAGE_CACHED_APPLE GL_STORAGE_SHARED_APPLE = GL_STORAGE_SHARED_APPLE GL_STREAM_COPY = GL_STREAM_COPY GL_STREAM_COPY_ARB = GL_STREAM_COPY_ARB GL_STREAM_DRAW = GL_STREAM_DRAW GL_STREAM_DRAW_ARB = GL_STREAM_DRAW_ARB GL_STREAM_READ = GL_STREAM_READ GL_STREAM_READ_ARB = GL_STREAM_READ_ARB GL_STRICT_DEPTHFUNC_HINT_PGI = GL_STRICT_DEPTHFUNC_HINT_PGI GL_STRICT_LIGHTING_HINT_PGI = GL_STRICT_LIGHTING_HINT_PGI GL_STRICT_SCISSOR_HINT_PGI = GL_STRICT_SCISSOR_HINT_PGI GL_SUBPIXEL_BITS = GL_SUBPIXEL_BITS GL_SUBTRACT = GL_SUBTRACT GL_SUBTRACT_ARB = GL_SUBTRACT_ARB GL_SUB_ATI = GL_SUB_ATI GL_SWIZZLE_STQ_ATI = GL_SWIZZLE_STQ_ATI GL_SWIZZLE_STQ_DQ_ATI = GL_SWIZZLE_STQ_DQ_ATI GL_SWIZZLE_STRQ_ATI = GL_SWIZZLE_STRQ_ATI GL_SWIZZLE_STRQ_DQ_ATI = GL_SWIZZLE_STRQ_DQ_ATI GL_SWIZZLE_STR_ATI = GL_SWIZZLE_STR_ATI GL_SWIZZLE_STR_DR_ATI = GL_SWIZZLE_STR_DR_ATI GL_T = GL_T GL_T2F_C3F_V3F = GL_T2F_C3F_V3F GL_T2F_C4F_N3F_V3F = GL_T2F_C4F_N3F_V3F GL_T2F_C4UB_V3F = GL_T2F_C4UB_V3F GL_T2F_IUI_N3F_V2F_EXT = GL_T2F_IUI_N3F_V2F_EXT GL_T2F_IUI_N3F_V3F_EXT = GL_T2F_IUI_N3F_V3F_EXT GL_T2F_IUI_V2F_EXT = GL_T2F_IUI_V2F_EXT GL_T2F_IUI_V3F_EXT = GL_T2F_IUI_V3F_EXT GL_T2F_N3F_V3F = GL_T2F_N3F_V3F GL_T2F_V3F = GL_T2F_V3F GL_T4F_C4F_N3F_V4F = GL_T4F_C4F_N3F_V4F GL_T4F_V4F = GL_T4F_V4F GL_TABLE_TOO_LARGE = GL_TABLE_TOO_LARGE GL_TABLE_TOO_LARGE_EXT = GL_TABLE_TOO_LARGE_EXT GL_TANGENT_ARRAY_EXT = GL_TANGENT_ARRAY_EXT GL_TANGENT_ARRAY_POINTER_EXT = GL_TANGENT_ARRAY_POINTER_EXT GL_TANGENT_ARRAY_STRIDE_EXT = GL_TANGENT_ARRAY_STRIDE_EXT GL_TANGENT_ARRAY_TYPE_EXT = GL_TANGENT_ARRAY_TYPE_EXT GL_TEXCOORD1_BIT_PGI = GL_TEXCOORD1_BIT_PGI GL_TEXCOORD2_BIT_PGI = GL_TEXCOORD2_BIT_PGI GL_TEXCOORD3_BIT_PGI = GL_TEXCOORD3_BIT_PGI GL_TEXCOORD4_BIT_PGI = GL_TEXCOORD4_BIT_PGI GL_TEXTURE = GL_TEXTURE GL_TEXTURE0 = GL_TEXTURE0 GL_TEXTURE0_ARB = GL_TEXTURE0_ARB GL_TEXTURE1 = GL_TEXTURE1 GL_TEXTURE10 = GL_TEXTURE10 GL_TEXTURE10_ARB = GL_TEXTURE10_ARB GL_TEXTURE11 = GL_TEXTURE11 GL_TEXTURE11_ARB = GL_TEXTURE11_ARB GL_TEXTURE12 = GL_TEXTURE12 GL_TEXTURE12_ARB = GL_TEXTURE12_ARB GL_TEXTURE13 = GL_TEXTURE13 GL_TEXTURE13_ARB = GL_TEXTURE13_ARB GL_TEXTURE14 = GL_TEXTURE14 GL_TEXTURE14_ARB = GL_TEXTURE14_ARB GL_TEXTURE15 = GL_TEXTURE15 GL_TEXTURE15_ARB = GL_TEXTURE15_ARB GL_TEXTURE16 = GL_TEXTURE16 GL_TEXTURE16_ARB = GL_TEXTURE16_ARB GL_TEXTURE17 = GL_TEXTURE17 GL_TEXTURE17_ARB = GL_TEXTURE17_ARB GL_TEXTURE18 = GL_TEXTURE18 GL_TEXTURE18_ARB = GL_TEXTURE18_ARB GL_TEXTURE19 = GL_TEXTURE19 GL_TEXTURE19_ARB = GL_TEXTURE19_ARB GL_TEXTURE1_ARB = GL_TEXTURE1_ARB GL_TEXTURE2 = GL_TEXTURE2 GL_TEXTURE20 = GL_TEXTURE20 GL_TEXTURE20_ARB = GL_TEXTURE20_ARB GL_TEXTURE21 = GL_TEXTURE21 GL_TEXTURE21_ARB = GL_TEXTURE21_ARB GL_TEXTURE22 = GL_TEXTURE22 GL_TEXTURE22_ARB = GL_TEXTURE22_ARB GL_TEXTURE23 = GL_TEXTURE23 GL_TEXTURE23_ARB = GL_TEXTURE23_ARB GL_TEXTURE24 = GL_TEXTURE24 GL_TEXTURE24_ARB = GL_TEXTURE24_ARB GL_TEXTURE25 = GL_TEXTURE25 GL_TEXTURE25_ARB = GL_TEXTURE25_ARB GL_TEXTURE26 = GL_TEXTURE26 GL_TEXTURE26_ARB = GL_TEXTURE26_ARB GL_TEXTURE27 = GL_TEXTURE27 GL_TEXTURE27_ARB = GL_TEXTURE27_ARB GL_TEXTURE28 = GL_TEXTURE28 GL_TEXTURE28_ARB = GL_TEXTURE28_ARB GL_TEXTURE29 = GL_TEXTURE29 GL_TEXTURE29_ARB = GL_TEXTURE29_ARB GL_TEXTURE2_ARB = GL_TEXTURE2_ARB GL_TEXTURE3 = GL_TEXTURE3 GL_TEXTURE30 = GL_TEXTURE30 GL_TEXTURE30_ARB = GL_TEXTURE30_ARB GL_TEXTURE31 = GL_TEXTURE31 GL_TEXTURE31_ARB = GL_TEXTURE31_ARB GL_TEXTURE3_ARB = GL_TEXTURE3_ARB GL_TEXTURE4 = GL_TEXTURE4 GL_TEXTURE4_ARB = GL_TEXTURE4_ARB GL_TEXTURE5 = GL_TEXTURE5 GL_TEXTURE5_ARB = GL_TEXTURE5_ARB GL_TEXTURE6 = GL_TEXTURE6 GL_TEXTURE6_ARB = GL_TEXTURE6_ARB GL_TEXTURE7 = GL_TEXTURE7 GL_TEXTURE7_ARB = GL_TEXTURE7_ARB GL_TEXTURE8 = GL_TEXTURE8 GL_TEXTURE8_ARB = GL_TEXTURE8_ARB GL_TEXTURE9 = GL_TEXTURE9 GL_TEXTURE9_ARB = GL_TEXTURE9_ARB GL_TEXTURE_1D = GL_TEXTURE_1D GL_TEXTURE_1D_BINDING_EXT = GL_TEXTURE_1D_BINDING_EXT GL_TEXTURE_2D = GL_TEXTURE_2D GL_TEXTURE_2D_BINDING_EXT = GL_TEXTURE_2D_BINDING_EXT GL_TEXTURE_3D = GL_TEXTURE_3D GL_TEXTURE_3D_BINDING_EXT = GL_TEXTURE_3D_BINDING_EXT GL_TEXTURE_3D_EXT = GL_TEXTURE_3D_EXT GL_TEXTURE_4DSIZE_SGIS = GL_TEXTURE_4DSIZE_SGIS GL_TEXTURE_4D_BINDING_SGIS = GL_TEXTURE_4D_BINDING_SGIS GL_TEXTURE_4D_SGIS = GL_TEXTURE_4D_SGIS GL_TEXTURE_ALPHA_SIZE = GL_TEXTURE_ALPHA_SIZE GL_TEXTURE_ALPHA_SIZE_EXT = GL_TEXTURE_ALPHA_SIZE_EXT GL_TEXTURE_ALPHA_TYPE_ARB = GL_TEXTURE_ALPHA_TYPE_ARB GL_TEXTURE_APPLICATION_MODE_EXT = GL_TEXTURE_APPLICATION_MODE_EXT GL_TEXTURE_BASE_LEVEL = GL_TEXTURE_BASE_LEVEL GL_TEXTURE_BASE_LEVEL_SGIS = GL_TEXTURE_BASE_LEVEL_SGIS GL_TEXTURE_BINDING_1D = GL_TEXTURE_BINDING_1D GL_TEXTURE_BINDING_2D = GL_TEXTURE_BINDING_2D GL_TEXTURE_BINDING_3D = GL_TEXTURE_BINDING_3D GL_TEXTURE_BINDING_CUBE_MAP = GL_TEXTURE_BINDING_CUBE_MAP GL_TEXTURE_BINDING_CUBE_MAP_ARB = GL_TEXTURE_BINDING_CUBE_MAP_ARB GL_TEXTURE_BINDING_CUBE_MAP_EXT = GL_TEXTURE_BINDING_CUBE_MAP_EXT GL_TEXTURE_BINDING_RECTANGLE_ARB = GL_TEXTURE_BINDING_RECTANGLE_ARB GL_TEXTURE_BINDING_RECTANGLE_NV = GL_TEXTURE_BINDING_RECTANGLE_NV GL_TEXTURE_BIT = GL_TEXTURE_BIT GL_TEXTURE_BLUE_SIZE = GL_TEXTURE_BLUE_SIZE GL_TEXTURE_BLUE_SIZE_EXT = GL_TEXTURE_BLUE_SIZE_EXT GL_TEXTURE_BLUE_TYPE_ARB = GL_TEXTURE_BLUE_TYPE_ARB GL_TEXTURE_BORDER = GL_TEXTURE_BORDER GL_TEXTURE_BORDER_COLOR = GL_TEXTURE_BORDER_COLOR GL_TEXTURE_BORDER_VALUES_NV = GL_TEXTURE_BORDER_VALUES_NV GL_TEXTURE_CLIPMAP_CENTER_SGIX = GL_TEXTURE_CLIPMAP_CENTER_SGIX GL_TEXTURE_CLIPMAP_DEPTH_SGIX = GL_TEXTURE_CLIPMAP_DEPTH_SGIX GL_TEXTURE_CLIPMAP_FRAME_SGIX = GL_TEXTURE_CLIPMAP_FRAME_SGIX GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX GL_TEXTURE_CLIPMAP_OFFSET_SGIX = GL_TEXTURE_CLIPMAP_OFFSET_SGIX GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX GL_TEXTURE_COLOR_TABLE_SGI = GL_TEXTURE_COLOR_TABLE_SGI GL_TEXTURE_COLOR_WRITEMASK_SGIS = GL_TEXTURE_COLOR_WRITEMASK_SGIS GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = GL_TEXTURE_COMPARE_FAIL_VALUE_ARB GL_TEXTURE_COMPARE_FUNC = GL_TEXTURE_COMPARE_FUNC GL_TEXTURE_COMPARE_FUNC_ARB = GL_TEXTURE_COMPARE_FUNC_ARB GL_TEXTURE_COMPARE_MODE = GL_TEXTURE_COMPARE_MODE GL_TEXTURE_COMPARE_MODE_ARB = GL_TEXTURE_COMPARE_MODE_ARB GL_TEXTURE_COMPARE_OPERATOR_SGIX = GL_TEXTURE_COMPARE_OPERATOR_SGIX GL_TEXTURE_COMPARE_SGIX = GL_TEXTURE_COMPARE_SGIX GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT GL_TEXTURE_COMPRESSED = GL_TEXTURE_COMPRESSED GL_TEXTURE_COMPRESSED_ARB = GL_TEXTURE_COMPRESSED_ARB GL_TEXTURE_COMPRESSED_IMAGE_SIZE = GL_TEXTURE_COMPRESSED_IMAGE_SIZE GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB GL_TEXTURE_COMPRESSION_HINT = GL_TEXTURE_COMPRESSION_HINT GL_TEXTURE_COMPRESSION_HINT_ARB = GL_TEXTURE_COMPRESSION_HINT_ARB GL_TEXTURE_CONSTANT_DATA_SUNX = GL_TEXTURE_CONSTANT_DATA_SUNX GL_TEXTURE_COORD_ARRAY = GL_TEXTURE_COORD_ARRAY GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB GL_TEXTURE_COORD_ARRAY_COUNT_EXT = GL_TEXTURE_COORD_ARRAY_COUNT_EXT GL_TEXTURE_COORD_ARRAY_EXT = GL_TEXTURE_COORD_ARRAY_EXT GL_TEXTURE_COORD_ARRAY_LIST_IBM = GL_TEXTURE_COORD_ARRAY_LIST_IBM GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL GL_TEXTURE_COORD_ARRAY_POINTER = GL_TEXTURE_COORD_ARRAY_POINTER GL_TEXTURE_COORD_ARRAY_POINTER_EXT = GL_TEXTURE_COORD_ARRAY_POINTER_EXT GL_TEXTURE_COORD_ARRAY_SIZE = GL_TEXTURE_COORD_ARRAY_SIZE GL_TEXTURE_COORD_ARRAY_SIZE_EXT = GL_TEXTURE_COORD_ARRAY_SIZE_EXT GL_TEXTURE_COORD_ARRAY_STRIDE = GL_TEXTURE_COORD_ARRAY_STRIDE GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = GL_TEXTURE_COORD_ARRAY_STRIDE_EXT GL_TEXTURE_COORD_ARRAY_TYPE = GL_TEXTURE_COORD_ARRAY_TYPE GL_TEXTURE_COORD_ARRAY_TYPE_EXT = GL_TEXTURE_COORD_ARRAY_TYPE_EXT GL_TEXTURE_CUBE_MAP = GL_TEXTURE_CUBE_MAP GL_TEXTURE_CUBE_MAP_ARB = GL_TEXTURE_CUBE_MAP_ARB GL_TEXTURE_CUBE_MAP_EXT = GL_TEXTURE_CUBE_MAP_EXT GL_TEXTURE_CUBE_MAP_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT GL_TEXTURE_CUBE_MAP_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT GL_TEXTURE_CUBE_MAP_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT GL_TEXTURE_CUBE_MAP_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT GL_TEXTURE_DEFORMATION_BIT_SGIX = GL_TEXTURE_DEFORMATION_BIT_SGIX GL_TEXTURE_DEFORMATION_SGIX = GL_TEXTURE_DEFORMATION_SGIX GL_TEXTURE_DEPTH = GL_TEXTURE_DEPTH GL_TEXTURE_DEPTH_EXT = GL_TEXTURE_DEPTH_EXT GL_TEXTURE_DEPTH_SIZE = GL_TEXTURE_DEPTH_SIZE GL_TEXTURE_DEPTH_SIZE_ARB = GL_TEXTURE_DEPTH_SIZE_ARB GL_TEXTURE_DEPTH_TYPE_ARB = GL_TEXTURE_DEPTH_TYPE_ARB GL_TEXTURE_DS_SIZE_NV = GL_TEXTURE_DS_SIZE_NV GL_TEXTURE_DT_SIZE_NV = GL_TEXTURE_DT_SIZE_NV GL_TEXTURE_ENV = GL_TEXTURE_ENV GL_TEXTURE_ENV_BIAS_SGIX = GL_TEXTURE_ENV_BIAS_SGIX GL_TEXTURE_ENV_COLOR = GL_TEXTURE_ENV_COLOR GL_TEXTURE_ENV_MODE = GL_TEXTURE_ENV_MODE GL_TEXTURE_FILTER4_SIZE_SGIS = GL_TEXTURE_FILTER4_SIZE_SGIS GL_TEXTURE_FILTER_CONTROL = GL_TEXTURE_FILTER_CONTROL GL_TEXTURE_FILTER_CONTROL_EXT = GL_TEXTURE_FILTER_CONTROL_EXT GL_TEXTURE_FLOAT_COMPONENTS_NV = GL_TEXTURE_FLOAT_COMPONENTS_NV GL_TEXTURE_GEN_MODE = GL_TEXTURE_GEN_MODE GL_TEXTURE_GEN_Q = GL_TEXTURE_GEN_Q GL_TEXTURE_GEN_R = GL_TEXTURE_GEN_R GL_TEXTURE_GEN_S = GL_TEXTURE_GEN_S GL_TEXTURE_GEN_T = GL_TEXTURE_GEN_T GL_TEXTURE_GEQUAL_R_SGIX = GL_TEXTURE_GEQUAL_R_SGIX GL_TEXTURE_GREEN_SIZE = GL_TEXTURE_GREEN_SIZE GL_TEXTURE_GREEN_SIZE_EXT = GL_TEXTURE_GREEN_SIZE_EXT GL_TEXTURE_GREEN_TYPE_ARB = GL_TEXTURE_GREEN_TYPE_ARB GL_TEXTURE_HEIGHT = GL_TEXTURE_HEIGHT GL_TEXTURE_HI_SIZE_NV = GL_TEXTURE_HI_SIZE_NV GL_TEXTURE_INDEX_SIZE_EXT = GL_TEXTURE_INDEX_SIZE_EXT GL_TEXTURE_INTENSITY_SIZE = GL_TEXTURE_INTENSITY_SIZE GL_TEXTURE_INTENSITY_SIZE_EXT = GL_TEXTURE_INTENSITY_SIZE_EXT GL_TEXTURE_INTENSITY_TYPE_ARB = GL_TEXTURE_INTENSITY_TYPE_ARB GL_TEXTURE_INTERNAL_FORMAT = GL_TEXTURE_INTERNAL_FORMAT GL_TEXTURE_LEQUAL_R_SGIX = GL_TEXTURE_LEQUAL_R_SGIX GL_TEXTURE_LIGHTING_MODE_HP = GL_TEXTURE_LIGHTING_MODE_HP GL_TEXTURE_LIGHT_EXT = GL_TEXTURE_LIGHT_EXT GL_TEXTURE_LOD_BIAS = GL_TEXTURE_LOD_BIAS GL_TEXTURE_LOD_BIAS_EXT = GL_TEXTURE_LOD_BIAS_EXT GL_TEXTURE_LOD_BIAS_R_SGIX = GL_TEXTURE_LOD_BIAS_R_SGIX GL_TEXTURE_LOD_BIAS_S_SGIX = GL_TEXTURE_LOD_BIAS_S_SGIX GL_TEXTURE_LOD_BIAS_T_SGIX = GL_TEXTURE_LOD_BIAS_T_SGIX GL_TEXTURE_LO_SIZE_NV = GL_TEXTURE_LO_SIZE_NV GL_TEXTURE_LUMINANCE_SIZE = GL_TEXTURE_LUMINANCE_SIZE GL_TEXTURE_LUMINANCE_SIZE_EXT = GL_TEXTURE_LUMINANCE_SIZE_EXT GL_TEXTURE_LUMINANCE_TYPE_ARB = GL_TEXTURE_LUMINANCE_TYPE_ARB GL_TEXTURE_MAG_FILTER = GL_TEXTURE_MAG_FILTER GL_TEXTURE_MAG_SIZE_NV = GL_TEXTURE_MAG_SIZE_NV GL_TEXTURE_MATERIAL_FACE_EXT = GL_TEXTURE_MATERIAL_FACE_EXT GL_TEXTURE_MATERIAL_PARAMETER_EXT = GL_TEXTURE_MATERIAL_PARAMETER_EXT GL_TEXTURE_MATRIX = GL_TEXTURE_MATRIX GL_TEXTURE_MAX_ANISOTROPY_EXT = GL_TEXTURE_MAX_ANISOTROPY_EXT GL_TEXTURE_MAX_CLAMP_R_SGIX = GL_TEXTURE_MAX_CLAMP_R_SGIX GL_TEXTURE_MAX_CLAMP_S_SGIX = GL_TEXTURE_MAX_CLAMP_S_SGIX GL_TEXTURE_MAX_CLAMP_T_SGIX = GL_TEXTURE_MAX_CLAMP_T_SGIX GL_TEXTURE_MAX_LEVEL = GL_TEXTURE_MAX_LEVEL GL_TEXTURE_MAX_LEVEL_SGIS = GL_TEXTURE_MAX_LEVEL_SGIS GL_TEXTURE_MAX_LOD = GL_TEXTURE_MAX_LOD GL_TEXTURE_MAX_LOD_SGIS = GL_TEXTURE_MAX_LOD_SGIS GL_TEXTURE_MIN_FILTER = GL_TEXTURE_MIN_FILTER GL_TEXTURE_MIN_LOD = GL_TEXTURE_MIN_LOD GL_TEXTURE_MIN_LOD_SGIS = GL_TEXTURE_MIN_LOD_SGIS GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = GL_TEXTURE_MULTI_BUFFER_HINT_SGIX GL_TEXTURE_NORMAL_EXT = GL_TEXTURE_NORMAL_EXT GL_TEXTURE_POST_SPECULAR_HP = GL_TEXTURE_POST_SPECULAR_HP GL_TEXTURE_PRE_SPECULAR_HP = GL_TEXTURE_PRE_SPECULAR_HP GL_TEXTURE_PRIORITY = GL_TEXTURE_PRIORITY GL_TEXTURE_PRIORITY_EXT = GL_TEXTURE_PRIORITY_EXT GL_TEXTURE_RECTANGLE_ARB = GL_TEXTURE_RECTANGLE_ARB GL_TEXTURE_RECTANGLE_NV = GL_TEXTURE_RECTANGLE_NV GL_TEXTURE_RED_SIZE = GL_TEXTURE_RED_SIZE GL_TEXTURE_RED_SIZE_EXT = GL_TEXTURE_RED_SIZE_EXT GL_TEXTURE_RED_TYPE_ARB = GL_TEXTURE_RED_TYPE_ARB GL_TEXTURE_RESIDENT = GL_TEXTURE_RESIDENT GL_TEXTURE_RESIDENT_EXT = GL_TEXTURE_RESIDENT_EXT GL_TEXTURE_SHADER_NV = GL_TEXTURE_SHADER_NV GL_TEXTURE_STACK_DEPTH = GL_TEXTURE_STACK_DEPTH GL_TEXTURE_TOO_LARGE_EXT = GL_TEXTURE_TOO_LARGE_EXT GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = GL_TEXTURE_UNSIGNED_REMAP_MODE_NV GL_TEXTURE_WIDTH = GL_TEXTURE_WIDTH GL_TEXTURE_WRAP_Q_SGIS = GL_TEXTURE_WRAP_Q_SGIS GL_TEXTURE_WRAP_R = GL_TEXTURE_WRAP_R GL_TEXTURE_WRAP_R_EXT = GL_TEXTURE_WRAP_R_EXT GL_TEXTURE_WRAP_S = GL_TEXTURE_WRAP_S GL_TEXTURE_WRAP_T = GL_TEXTURE_WRAP_T GL_TEXT_FRAGMENT_SHADER_ATI = GL_TEXT_FRAGMENT_SHADER_ATI GL_TRACK_MATRIX_NV = GL_TRACK_MATRIX_NV GL_TRACK_MATRIX_TRANSFORM_NV = GL_TRACK_MATRIX_TRANSFORM_NV GL_TRANSFORM_BIT = GL_TRANSFORM_BIT GL_TRANSFORM_HINT_APPLE = GL_TRANSFORM_HINT_APPLE GL_TRANSPOSE_COLOR_MATRIX = GL_TRANSPOSE_COLOR_MATRIX GL_TRANSPOSE_COLOR_MATRIX_ARB = GL_TRANSPOSE_COLOR_MATRIX_ARB GL_TRANSPOSE_CURRENT_MATRIX_ARB = GL_TRANSPOSE_CURRENT_MATRIX_ARB GL_TRANSPOSE_MODELVIEW_MATRIX = GL_TRANSPOSE_MODELVIEW_MATRIX GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = GL_TRANSPOSE_MODELVIEW_MATRIX_ARB GL_TRANSPOSE_NV = GL_TRANSPOSE_NV GL_TRANSPOSE_PROJECTION_MATRIX = GL_TRANSPOSE_PROJECTION_MATRIX GL_TRANSPOSE_PROJECTION_MATRIX_ARB = GL_TRANSPOSE_PROJECTION_MATRIX_ARB GL_TRANSPOSE_TEXTURE_MATRIX = GL_TRANSPOSE_TEXTURE_MATRIX GL_TRANSPOSE_TEXTURE_MATRIX_ARB = GL_TRANSPOSE_TEXTURE_MATRIX_ARB GL_TRIANGLES = GL_TRIANGLES GL_TRIANGLE_FAN = GL_TRIANGLE_FAN GL_TRIANGLE_LIST_SUN = GL_TRIANGLE_LIST_SUN GL_TRIANGLE_MESH_SUN = GL_TRIANGLE_MESH_SUN GL_TRIANGLE_STRIP = GL_TRIANGLE_STRIP GL_TRUE = GL_TRUE GL_TYPE_RGBA_FLOAT_ATI = GL_TYPE_RGBA_FLOAT_ATI GL_UNPACK_ALIGNMENT = GL_UNPACK_ALIGNMENT GL_UNPACK_CLIENT_STORAGE_APPLE = GL_UNPACK_CLIENT_STORAGE_APPLE GL_UNPACK_CMYK_HINT_EXT = GL_UNPACK_CMYK_HINT_EXT GL_UNPACK_CONSTANT_DATA_SUNX = GL_UNPACK_CONSTANT_DATA_SUNX GL_UNPACK_IMAGE_DEPTH_SGIS = GL_UNPACK_IMAGE_DEPTH_SGIS GL_UNPACK_IMAGE_HEIGHT = GL_UNPACK_IMAGE_HEIGHT GL_UNPACK_IMAGE_HEIGHT_EXT = GL_UNPACK_IMAGE_HEIGHT_EXT GL_UNPACK_LSB_FIRST = GL_UNPACK_LSB_FIRST GL_UNPACK_RESAMPLE_OML = GL_UNPACK_RESAMPLE_OML GL_UNPACK_RESAMPLE_SGIX = GL_UNPACK_RESAMPLE_SGIX GL_UNPACK_ROW_LENGTH = GL_UNPACK_ROW_LENGTH GL_UNPACK_SKIP_IMAGES = GL_UNPACK_SKIP_IMAGES GL_UNPACK_SKIP_IMAGES_EXT = GL_UNPACK_SKIP_IMAGES_EXT GL_UNPACK_SKIP_PIXELS = GL_UNPACK_SKIP_PIXELS GL_UNPACK_SKIP_ROWS = GL_UNPACK_SKIP_ROWS GL_UNPACK_SKIP_VOLUMES_SGIS = GL_UNPACK_SKIP_VOLUMES_SGIS GL_UNPACK_SUBSAMPLE_RATE_SGIX = GL_UNPACK_SUBSAMPLE_RATE_SGIX GL_UNPACK_SWAP_BYTES = GL_UNPACK_SWAP_BYTES GL_UNSIGNED_BYTE = GL_UNSIGNED_BYTE GL_UNSIGNED_BYTE_2_3_3_REV = GL_UNSIGNED_BYTE_2_3_3_REV GL_UNSIGNED_BYTE_3_3_2 = GL_UNSIGNED_BYTE_3_3_2 GL_UNSIGNED_BYTE_3_3_2_EXT = GL_UNSIGNED_BYTE_3_3_2_EXT GL_UNSIGNED_IDENTITY_NV = GL_UNSIGNED_IDENTITY_NV GL_UNSIGNED_INT = GL_UNSIGNED_INT GL_UNSIGNED_INT_10_10_10_2 = GL_UNSIGNED_INT_10_10_10_2 GL_UNSIGNED_INT_10_10_10_2_EXT = GL_UNSIGNED_INT_10_10_10_2_EXT GL_UNSIGNED_INT_24_8_NV = GL_UNSIGNED_INT_24_8_NV GL_UNSIGNED_INT_2_10_10_10_REV = GL_UNSIGNED_INT_2_10_10_10_REV GL_UNSIGNED_INT_8_8_8_8 = GL_UNSIGNED_INT_8_8_8_8 GL_UNSIGNED_INT_8_8_8_8_EXT = GL_UNSIGNED_INT_8_8_8_8_EXT GL_UNSIGNED_INT_8_8_8_8_REV = GL_UNSIGNED_INT_8_8_8_8_REV GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = GL_UNSIGNED_INT_8_8_S8_S8_REV_NV GL_UNSIGNED_INT_S8_S8_8_8_NV = GL_UNSIGNED_INT_S8_S8_8_8_NV GL_UNSIGNED_INVERT_NV = GL_UNSIGNED_INVERT_NV GL_UNSIGNED_NORMALIZED_ARB = GL_UNSIGNED_NORMALIZED_ARB GL_UNSIGNED_SHORT = GL_UNSIGNED_SHORT GL_UNSIGNED_SHORT_1_5_5_5_REV = GL_UNSIGNED_SHORT_1_5_5_5_REV GL_UNSIGNED_SHORT_4_4_4_4 = GL_UNSIGNED_SHORT_4_4_4_4 GL_UNSIGNED_SHORT_4_4_4_4_EXT = GL_UNSIGNED_SHORT_4_4_4_4_EXT GL_UNSIGNED_SHORT_4_4_4_4_REV = GL_UNSIGNED_SHORT_4_4_4_4_REV GL_UNSIGNED_SHORT_5_5_5_1 = GL_UNSIGNED_SHORT_5_5_5_1 GL_UNSIGNED_SHORT_5_5_5_1_EXT = GL_UNSIGNED_SHORT_5_5_5_1_EXT GL_UNSIGNED_SHORT_5_6_5 = GL_UNSIGNED_SHORT_5_6_5 GL_UNSIGNED_SHORT_5_6_5_REV = GL_UNSIGNED_SHORT_5_6_5_REV GL_UNSIGNED_SHORT_8_8_APPLE = GL_UNSIGNED_SHORT_8_8_APPLE GL_UNSIGNED_SHORT_8_8_MESA = GL_UNSIGNED_SHORT_8_8_MESA GL_UNSIGNED_SHORT_8_8_REV_APPLE = GL_UNSIGNED_SHORT_8_8_REV_APPLE GL_UNSIGNED_SHORT_8_8_REV_MESA = GL_UNSIGNED_SHORT_8_8_REV_MESA GL_UPPER_LEFT = GL_UPPER_LEFT GL_V2F = GL_V2F GL_V3F = GL_V3F GL_VALIDATE_STATUS = GL_VALIDATE_STATUS GL_VARIABLE_A_NV = GL_VARIABLE_A_NV GL_VARIABLE_B_NV = GL_VARIABLE_B_NV GL_VARIABLE_C_NV = GL_VARIABLE_C_NV GL_VARIABLE_D_NV = GL_VARIABLE_D_NV GL_VARIABLE_E_NV = GL_VARIABLE_E_NV GL_VARIABLE_F_NV = GL_VARIABLE_F_NV GL_VARIABLE_G_NV = GL_VARIABLE_G_NV GL_VARIANT_ARRAY_EXT = GL_VARIANT_ARRAY_EXT GL_VARIANT_ARRAY_POINTER_EXT = GL_VARIANT_ARRAY_POINTER_EXT GL_VARIANT_ARRAY_STRIDE_EXT = GL_VARIANT_ARRAY_STRIDE_EXT GL_VARIANT_ARRAY_TYPE_EXT = GL_VARIANT_ARRAY_TYPE_EXT GL_VARIANT_DATATYPE_EXT = GL_VARIANT_DATATYPE_EXT GL_VARIANT_EXT = GL_VARIANT_EXT GL_VARIANT_VALUE_EXT = GL_VARIANT_VALUE_EXT GL_VECTOR_EXT = GL_VECTOR_EXT GL_VENDOR = GL_VENDOR GL_VERSION = GL_VERSION GL_VERSION_1_1 = GL_VERSION_1_1 GL_VERSION_1_2 = GL_VERSION_1_2 GL_VERSION_1_3 = GL_VERSION_1_3 GL_VERSION_1_4 = GL_VERSION_1_4 GL_VERSION_1_5 = GL_VERSION_1_5 GL_VERSION_2_0 = GL_VERSION_2_0 GL_VERTEX23_BIT_PGI = GL_VERTEX23_BIT_PGI GL_VERTEX4_BIT_PGI = GL_VERTEX4_BIT_PGI GL_VERTEX_ARRAY = GL_VERTEX_ARRAY GL_VERTEX_ARRAY_BINDING_APPLE = GL_VERTEX_ARRAY_BINDING_APPLE GL_VERTEX_ARRAY_BUFFER_BINDING = GL_VERTEX_ARRAY_BUFFER_BINDING GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = GL_VERTEX_ARRAY_BUFFER_BINDING_ARB GL_VERTEX_ARRAY_COUNT_EXT = GL_VERTEX_ARRAY_COUNT_EXT GL_VERTEX_ARRAY_EXT = GL_VERTEX_ARRAY_EXT GL_VERTEX_ARRAY_LIST_IBM = GL_VERTEX_ARRAY_LIST_IBM GL_VERTEX_ARRAY_LIST_STRIDE_IBM = GL_VERTEX_ARRAY_LIST_STRIDE_IBM GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL GL_VERTEX_ARRAY_POINTER = GL_VERTEX_ARRAY_POINTER GL_VERTEX_ARRAY_POINTER_EXT = GL_VERTEX_ARRAY_POINTER_EXT GL_VERTEX_ARRAY_RANGE_APPLE = GL_VERTEX_ARRAY_RANGE_APPLE GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE GL_VERTEX_ARRAY_RANGE_LENGTH_NV = GL_VERTEX_ARRAY_RANGE_LENGTH_NV GL_VERTEX_ARRAY_RANGE_NV = GL_VERTEX_ARRAY_RANGE_NV GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = GL_VERTEX_ARRAY_RANGE_POINTER_APPLE GL_VERTEX_ARRAY_RANGE_POINTER_NV = GL_VERTEX_ARRAY_RANGE_POINTER_NV GL_VERTEX_ARRAY_RANGE_VALID_NV = GL_VERTEX_ARRAY_RANGE_VALID_NV GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV GL_VERTEX_ARRAY_SIZE = GL_VERTEX_ARRAY_SIZE GL_VERTEX_ARRAY_SIZE_EXT = GL_VERTEX_ARRAY_SIZE_EXT GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = GL_VERTEX_ARRAY_STORAGE_HINT_APPLE GL_VERTEX_ARRAY_STRIDE = GL_VERTEX_ARRAY_STRIDE GL_VERTEX_ARRAY_STRIDE_EXT = GL_VERTEX_ARRAY_STRIDE_EXT GL_VERTEX_ARRAY_TYPE = GL_VERTEX_ARRAY_TYPE GL_VERTEX_ARRAY_TYPE_EXT = GL_VERTEX_ARRAY_TYPE_EXT GL_VERTEX_ATTRIB_ARRAY0_NV = GL_VERTEX_ATTRIB_ARRAY0_NV GL_VERTEX_ATTRIB_ARRAY10_NV = GL_VERTEX_ATTRIB_ARRAY10_NV GL_VERTEX_ATTRIB_ARRAY11_NV = GL_VERTEX_ATTRIB_ARRAY11_NV GL_VERTEX_ATTRIB_ARRAY12_NV = GL_VERTEX_ATTRIB_ARRAY12_NV GL_VERTEX_ATTRIB_ARRAY13_NV = GL_VERTEX_ATTRIB_ARRAY13_NV GL_VERTEX_ATTRIB_ARRAY14_NV = GL_VERTEX_ATTRIB_ARRAY14_NV GL_VERTEX_ATTRIB_ARRAY15_NV = GL_VERTEX_ATTRIB_ARRAY15_NV GL_VERTEX_ATTRIB_ARRAY1_NV = GL_VERTEX_ATTRIB_ARRAY1_NV GL_VERTEX_ATTRIB_ARRAY2_NV = GL_VERTEX_ATTRIB_ARRAY2_NV GL_VERTEX_ATTRIB_ARRAY3_NV = GL_VERTEX_ATTRIB_ARRAY3_NV GL_VERTEX_ATTRIB_ARRAY4_NV = GL_VERTEX_ATTRIB_ARRAY4_NV GL_VERTEX_ATTRIB_ARRAY5_NV = GL_VERTEX_ATTRIB_ARRAY5_NV GL_VERTEX_ATTRIB_ARRAY6_NV = GL_VERTEX_ATTRIB_ARRAY6_NV GL_VERTEX_ATTRIB_ARRAY7_NV = GL_VERTEX_ATTRIB_ARRAY7_NV GL_VERTEX_ATTRIB_ARRAY8_NV = GL_VERTEX_ATTRIB_ARRAY8_NV GL_VERTEX_ATTRIB_ARRAY9_NV = GL_VERTEX_ATTRIB_ARRAY9_NV GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB GL_VERTEX_ATTRIB_ARRAY_ENABLED = GL_VERTEX_ATTRIB_ARRAY_ENABLED GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = GL_VERTEX_ATTRIB_ARRAY_NORMALIZED GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB GL_VERTEX_ATTRIB_ARRAY_POINTER = GL_VERTEX_ATTRIB_ARRAY_POINTER GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB GL_VERTEX_ATTRIB_ARRAY_SIZE = GL_VERTEX_ATTRIB_ARRAY_SIZE GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB GL_VERTEX_ATTRIB_ARRAY_STRIDE = GL_VERTEX_ATTRIB_ARRAY_STRIDE GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB GL_VERTEX_ATTRIB_ARRAY_TYPE = GL_VERTEX_ATTRIB_ARRAY_TYPE GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB GL_VERTEX_BLEND_ARB = GL_VERTEX_BLEND_ARB GL_VERTEX_CONSISTENT_HINT_PGI = GL_VERTEX_CONSISTENT_HINT_PGI GL_VERTEX_DATA_HINT_PGI = GL_VERTEX_DATA_HINT_PGI GL_VERTEX_PRECLIP_HINT_SGIX = GL_VERTEX_PRECLIP_HINT_SGIX GL_VERTEX_PRECLIP_SGIX = GL_VERTEX_PRECLIP_SGIX GL_VERTEX_PROGRAM_ARB = GL_VERTEX_PROGRAM_ARB GL_VERTEX_PROGRAM_BINDING_NV = GL_VERTEX_PROGRAM_BINDING_NV GL_VERTEX_PROGRAM_NV = GL_VERTEX_PROGRAM_NV GL_VERTEX_PROGRAM_POINT_SIZE = GL_VERTEX_PROGRAM_POINT_SIZE GL_VERTEX_PROGRAM_POINT_SIZE_ARB = GL_VERTEX_PROGRAM_POINT_SIZE_ARB GL_VERTEX_PROGRAM_POINT_SIZE_NV = GL_VERTEX_PROGRAM_POINT_SIZE_NV GL_VERTEX_PROGRAM_TWO_SIDE = GL_VERTEX_PROGRAM_TWO_SIDE GL_VERTEX_PROGRAM_TWO_SIDE_ARB = GL_VERTEX_PROGRAM_TWO_SIDE_ARB GL_VERTEX_PROGRAM_TWO_SIDE_NV = GL_VERTEX_PROGRAM_TWO_SIDE_NV GL_VERTEX_SHADER = GL_VERTEX_SHADER GL_VERTEX_SHADER_ARB = GL_VERTEX_SHADER_ARB GL_VERTEX_SHADER_BINDING_EXT = GL_VERTEX_SHADER_BINDING_EXT GL_VERTEX_SHADER_EXT = GL_VERTEX_SHADER_EXT GL_VERTEX_SHADER_INSTRUCTIONS_EXT = GL_VERTEX_SHADER_INSTRUCTIONS_EXT GL_VERTEX_SHADER_INVARIANTS_EXT = GL_VERTEX_SHADER_INVARIANTS_EXT GL_VERTEX_SHADER_LOCALS_EXT = GL_VERTEX_SHADER_LOCALS_EXT GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT GL_VERTEX_SHADER_OPTIMIZED_EXT = GL_VERTEX_SHADER_OPTIMIZED_EXT GL_VERTEX_SHADER_VARIANTS_EXT = GL_VERTEX_SHADER_VARIANTS_EXT GL_VERTEX_SOURCE_ATI = GL_VERTEX_SOURCE_ATI GL_VERTEX_STATE_PROGRAM_NV = GL_VERTEX_STATE_PROGRAM_NV GL_VERTEX_STREAM0_ATI = GL_VERTEX_STREAM0_ATI GL_VERTEX_STREAM1_ATI = GL_VERTEX_STREAM1_ATI GL_VERTEX_STREAM2_ATI = GL_VERTEX_STREAM2_ATI GL_VERTEX_STREAM3_ATI = GL_VERTEX_STREAM3_ATI GL_VERTEX_STREAM4_ATI = GL_VERTEX_STREAM4_ATI GL_VERTEX_STREAM5_ATI = GL_VERTEX_STREAM5_ATI GL_VERTEX_STREAM6_ATI = GL_VERTEX_STREAM6_ATI GL_VERTEX_STREAM7_ATI = GL_VERTEX_STREAM7_ATI GL_VERTEX_WEIGHTING_EXT = GL_VERTEX_WEIGHTING_EXT GL_VERTEX_WEIGHT_ARRAY_EXT = GL_VERTEX_WEIGHT_ARRAY_EXT GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT GL_VIBRANCE_BIAS_NV = GL_VIBRANCE_BIAS_NV GL_VIBRANCE_SCALE_NV = GL_VIBRANCE_SCALE_NV GL_VIEWPORT = GL_VIEWPORT GL_VIEWPORT_BIT = GL_VIEWPORT_BIT GL_WEIGHT_ARRAY_ARB = GL_WEIGHT_ARRAY_ARB GL_WEIGHT_ARRAY_BUFFER_BINDING = GL_WEIGHT_ARRAY_BUFFER_BINDING GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB GL_WEIGHT_ARRAY_POINTER_ARB = GL_WEIGHT_ARRAY_POINTER_ARB GL_WEIGHT_ARRAY_SIZE_ARB = GL_WEIGHT_ARRAY_SIZE_ARB GL_WEIGHT_ARRAY_STRIDE_ARB = GL_WEIGHT_ARRAY_STRIDE_ARB GL_WEIGHT_ARRAY_TYPE_ARB = GL_WEIGHT_ARRAY_TYPE_ARB GL_WEIGHT_SUM_UNITY_ARB = GL_WEIGHT_SUM_UNITY_ARB GL_WIDE_LINE_HINT_PGI = GL_WIDE_LINE_HINT_PGI GL_WRAP_BORDER_SUN = GL_WRAP_BORDER_SUN GL_WRITE_ONLY = GL_WRITE_ONLY GL_WRITE_ONLY_ARB = GL_WRITE_ONLY_ARB GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV GL_WRITE_PIXEL_DATA_RANGE_NV = GL_WRITE_PIXEL_DATA_RANGE_NV GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV GL_W_EXT = GL_W_EXT GL_XOR = GL_XOR GL_X_EXT = GL_X_EXT GL_YCBCR_422_APPLE = GL_YCBCR_422_APPLE GL_YCBCR_MESA = GL_YCBCR_MESA GL_YCRCBA_SGIX = GL_YCRCBA_SGIX GL_YCRCB_422_SGIX = GL_YCRCB_422_SGIX GL_YCRCB_444_SGIX = GL_YCRCB_444_SGIX GL_YCRCB_SGIX = GL_YCRCB_SGIX GL_Y_EXT = GL_Y_EXT GL_ZERO = GL_ZERO GL_ZERO_EXT = GL_ZERO_EXT GL_ZOOM_X = GL_ZOOM_X GL_ZOOM_Y = GL_ZOOM_Y GL_Z_EXT = GL_Z_EXT GLvoid = None name = 'glUniform4iv' outline = array('', [array('', [0.0, 0.0, 0.0]), array('', [1.0, 1.0, 0.0]), array('', [-1.0, 1.0, 0.0])])