OpenGL.raw.GL.NV.vertex_program
index
/build/buildd/pyopengl-3.0.0~b3/OpenGL/raw/GL/NV/vertex_program.py

OpenGL extension NV.vertex_program
 
Overview (from the spec)
        
        Unextended OpenGL mandates a certain set of configurable per-vertex
        computations defining vertex transformation, texture coordinate
        generation and transformation, and lighting.  Several extensions
        have added further per-vertex computations to OpenGL.  For example,
        extensions have defined new texture coordinate generation modes
        (ARB_texture_cube_map, NV_texgen_reflection, NV_texgen_emboss), new
        vertex transformation modes (EXT_vertex_weighting), new lighting modes
        (OpenGL 1.2's separate specular and rescale normal functionality),
        several modes for fog distance generation (NV_fog_distance), and
        eye-distance point size attenuation (EXT_point_parameters).
        
        Each such extension adds a small set of relatively inflexible
        per-vertex computations.
        
        This inflexibility is in contrast to the typical flexibility provided
        by the underlying programmable floating point engines (whether
        micro-coded vertex engines, DSPs, or CPUs) that are traditionally used
        to implement OpenGL's per-vertex computations.  The purpose of this
        extension is to expose to the OpenGL application writer a significant
        degree of per-vertex programmability for computing vertex parameters.
        
        For the purposes of discussing this extension, a vertex program is
        a sequence of floating-point 4-component vector operations that
        determines how a set of program parameters (defined outside of
        OpenGL's begin/end pair) and an input set of per-vertex parameters
        are transformed to a set of per-vertex output parameters.
        
        The per-vertex computations for standard OpenGL given a particular
        set of lighting and texture coordinate generation modes (along with
        any state for extensions defining per-vertex computations) is, in
        essence, a vertex program.  However, the sequence of operations is
        defined implicitly by the current OpenGL state settings rather than
        defined explicitly as a sequence of instructions.
        
        This extension provides an explicit mechanism for defining vertex
        program instruction sequences for application-defined vertex programs.
        In order to define such vertex programs, this extension defines
        a vertex programming model including a floating-point 4-component
        vector instruction set and a relatively large set of floating-point
        4-component registers.
        
        The extension's vertex programming model is designed for efficient
        hardware implementation and to support a wide variety of vertex
        programs.  By design, the entire set of existing vertex programs
        defined by existing OpenGL per-vertex computation extensions can be
        implemented using the extension's vertex programming model.
 
The official definition of this extension is available here:
        http://oss.sgi.com/projects/ogl-sample/registry/NV/vertex_program.txt
 
Automatically generated by the get_gl_extensions script, do not edit!

 
Modules
       
OpenGL.arrays
OpenGL.constant
OpenGL.constants
ctypes
OpenGL.extensions
OpenGL.GL.glget
OpenGL.platform

 
Functions
       
glAreProgramsResidentNV(...)
glAreProgramsResidentNV( GLsizei(n), GLuintArray(programs), POINTER(constants.GLboolean)(residences) ) -> constants.GLboolean
glBindProgramNV(...)
glBindProgramNV( GLenum(target), GLuint(id) ) -> None
glDeleteProgramsNV(...)
glDeleteProgramsNV( GLsizei(n), GLuintArray(programs) ) -> None
glExecuteProgramNV(...)
glExecuteProgramNV( GLenum(target), GLuint(id), GLfloatArray(params) ) -> None
glGenProgramsNV(...)
glGenProgramsNV( GLsizei(n), GLuintArray(programs) ) -> None
glGetProgramParameterdvNV(...)
glGetProgramParameterdvNV( GLenum(target), GLuint(index), GLenum(pname), GLdoubleArray(params) ) -> None
glGetProgramParameterfvNV(...)
glGetProgramParameterfvNV( GLenum(target), GLuint(index), GLenum(pname), GLfloatArray(params) ) -> None
glGetProgramStringNV(...)
glGetProgramStringNV( GLuint(id), GLenum(pname), GLubyteArray(program) ) -> None
glGetProgramivNV(...)
glGetProgramivNV( GLuint(id), GLenum(pname), GLintArray(params) ) -> None
glGetTrackMatrixivNV(...)
glGetTrackMatrixivNV( GLenum(target), GLuint(address), GLenum(pname), GLintArray(params) ) -> None
glGetVertexAttribPointervNV(...)
glGetVertexAttribPointervNV( GLuint(index), GLenum(pname), POINTER(ctypes.c_void_p)(pointer) ) -> None
glGetVertexAttribdvNV(...)
glGetVertexAttribdvNV( GLuint(index), GLenum(pname), GLdoubleArray(params) ) -> None
glGetVertexAttribfvNV(...)
glGetVertexAttribfvNV( GLuint(index), GLenum(pname), GLfloatArray(params) ) -> None
glGetVertexAttribivNV(...)
glGetVertexAttribivNV( GLuint(index), GLenum(pname), GLintArray(params) ) -> None
glInitVertexProgramNV()
Return boolean indicating whether this extension is available
glIsProgramNV(...)
glIsProgramNV( GLuint(id) ) -> constants.GLboolean
glLoadProgramNV(...)
glLoadProgramNV( GLenum(target), GLuint(id), GLsizei(len), GLubyteArray(program) ) -> None
glProgramParameter4dNV(...)
glProgramParameter4dNV( GLenum(target), GLuint(index), GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None
glProgramParameter4dvNV(...)
glProgramParameter4dvNV( GLenum(target), GLuint(index), GLdoubleArray(v) ) -> None
glProgramParameter4fNV(...)
glProgramParameter4fNV( GLenum(target), GLuint(index), GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None
glProgramParameter4fvNV(...)
glProgramParameter4fvNV( GLenum(target), GLuint(index), GLfloatArray(v) ) -> None
glProgramParameters4dvNV(...)
glProgramParameters4dvNV( GLenum(target), GLuint(index), GLuint(count), GLdoubleArray(v) ) -> None
glProgramParameters4fvNV(...)
glProgramParameters4fvNV( GLenum(target), GLuint(index), GLuint(count), GLfloatArray(v) ) -> None
glRequestResidentProgramsNV(...)
glRequestResidentProgramsNV( GLsizei(n), GLuintArray(programs) ) -> None
glTrackMatrixNV(...)
glTrackMatrixNV( GLenum(target), GLuint(address), GLenum(matrix), GLenum(transform) ) -> None
glVertexAttrib1dNV(...)
glVertexAttrib1dNV( GLuint(index), GLdouble(x) ) -> None
glVertexAttrib1dvNV(...)
glVertexAttrib1dvNV( GLuint(index), GLdoubleArray(v) ) -> None
glVertexAttrib1fNV(...)
glVertexAttrib1fNV( GLuint(index), GLfloat(x) ) -> None
glVertexAttrib1fvNV(...)
glVertexAttrib1fvNV( GLuint(index), GLfloatArray(v) ) -> None
glVertexAttrib1sNV(...)
glVertexAttrib1sNV( GLuint(index), GLshort(x) ) -> None
glVertexAttrib1svNV(...)
glVertexAttrib1svNV( GLuint(index), GLshortArray(v) ) -> None
glVertexAttrib2dNV(...)
glVertexAttrib2dNV( GLuint(index), GLdouble(x), GLdouble(y) ) -> None
glVertexAttrib2dvNV(...)
glVertexAttrib2dvNV( GLuint(index), GLdoubleArray(v) ) -> None
glVertexAttrib2fNV(...)
glVertexAttrib2fNV( GLuint(index), GLfloat(x), GLfloat(y) ) -> None
glVertexAttrib2fvNV(...)
glVertexAttrib2fvNV( GLuint(index), GLfloatArray(v) ) -> None
glVertexAttrib2sNV(...)
glVertexAttrib2sNV( GLuint(index), GLshort(x), GLshort(y) ) -> None
glVertexAttrib2svNV(...)
glVertexAttrib2svNV( GLuint(index), GLshortArray(v) ) -> None
glVertexAttrib3dNV(...)
glVertexAttrib3dNV( GLuint(index), GLdouble(x), GLdouble(y), GLdouble(z) ) -> None
glVertexAttrib3dvNV(...)
glVertexAttrib3dvNV( GLuint(index), GLdoubleArray(v) ) -> None
glVertexAttrib3fNV(...)
glVertexAttrib3fNV( GLuint(index), GLfloat(x), GLfloat(y), GLfloat(z) ) -> None
glVertexAttrib3fvNV(...)
glVertexAttrib3fvNV( GLuint(index), GLfloatArray(v) ) -> None
glVertexAttrib3sNV(...)
glVertexAttrib3sNV( GLuint(index), GLshort(x), GLshort(y), GLshort(z) ) -> None
glVertexAttrib3svNV(...)
glVertexAttrib3svNV( GLuint(index), GLshortArray(v) ) -> None
glVertexAttrib4dNV(...)
glVertexAttrib4dNV( GLuint(index), GLdouble(x), GLdouble(y), GLdouble(z), GLdouble(w) ) -> None
glVertexAttrib4dvNV(...)
glVertexAttrib4dvNV( GLuint(index), GLdoubleArray(v) ) -> None
glVertexAttrib4fNV(...)
glVertexAttrib4fNV( GLuint(index), GLfloat(x), GLfloat(y), GLfloat(z), GLfloat(w) ) -> None
glVertexAttrib4fvNV(...)
glVertexAttrib4fvNV( GLuint(index), GLfloatArray(v) ) -> None
glVertexAttrib4sNV(...)
glVertexAttrib4sNV( GLuint(index), GLshort(x), GLshort(y), GLshort(z), GLshort(w) ) -> None
glVertexAttrib4svNV(...)
glVertexAttrib4svNV( GLuint(index), GLshortArray(v) ) -> None
glVertexAttrib4ubNV(...)
glVertexAttrib4ubNV( GLuint(index), GLubyte(x), GLubyte(y), GLubyte(z), GLubyte(w) ) -> None
glVertexAttrib4ubvNV(...)
glVertexAttrib4ubvNV( GLuint(index), GLubyteArray(v) ) -> None
glVertexAttribPointerNV(...)
glVertexAttribPointerNV( GLuint(index), GLint(fsize), GLenum(type), GLsizei(stride), c_void_p(pointer) ) -> None
glVertexAttribs1dvNV(...)
glVertexAttribs1dvNV( GLuint(index), GLsizei(count), GLdoubleArray(v) ) -> None
glVertexAttribs1fvNV(...)
glVertexAttribs1fvNV( GLuint(index), GLsizei(count), GLfloatArray(v) ) -> None
glVertexAttribs1svNV(...)
glVertexAttribs1svNV( GLuint(index), GLsizei(count), GLshortArray(v) ) -> None
glVertexAttribs2dvNV(...)
glVertexAttribs2dvNV( GLuint(index), GLsizei(count), GLdoubleArray(v) ) -> None
glVertexAttribs2fvNV(...)
glVertexAttribs2fvNV( GLuint(index), GLsizei(count), GLfloatArray(v) ) -> None
glVertexAttribs2svNV(...)
glVertexAttribs2svNV( GLuint(index), GLsizei(count), GLshortArray(v) ) -> None
glVertexAttribs3dvNV(...)
glVertexAttribs3dvNV( GLuint(index), GLsizei(count), GLdoubleArray(v) ) -> None
glVertexAttribs3fvNV(...)
glVertexAttribs3fvNV( GLuint(index), GLsizei(count), GLfloatArray(v) ) -> None
glVertexAttribs3svNV(...)
glVertexAttribs3svNV( GLuint(index), GLsizei(count), GLshortArray(v) ) -> None
glVertexAttribs4dvNV(...)
glVertexAttribs4dvNV( GLuint(index), GLsizei(count), GLdoubleArray(v) ) -> None
glVertexAttribs4fvNV(...)
glVertexAttribs4fvNV( GLuint(index), GLsizei(count), GLfloatArray(v) ) -> None
glVertexAttribs4svNV(...)
glVertexAttribs4svNV( GLuint(index), GLsizei(count), GLshortArray(v) ) -> None
glVertexAttribs4ubvNV(...)
glVertexAttribs4ubvNV( GLuint(index), GLsizei(count), GLubyteArray(v) ) -> None

 
Data
        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_CURRENT_ATTRIB_NV = GL_CURRENT_ATTRIB_NV
GL_CURRENT_MATRIX_NV = GL_CURRENT_MATRIX_NV
GL_CURRENT_MATRIX_STACK_DEPTH_NV = GL_CURRENT_MATRIX_STACK_DEPTH_NV
GL_IDENTITY_NV = GL_IDENTITY_NV
GL_INVERSE_NV = GL_INVERSE_NV
GL_INVERSE_TRANSPOSE_NV = GL_INVERSE_TRANSPOSE_NV
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_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_MATRIX0_NV = GL_MATRIX0_NV
GL_MATRIX1_NV = GL_MATRIX1_NV
GL_MATRIX2_NV = GL_MATRIX2_NV
GL_MATRIX3_NV = GL_MATRIX3_NV
GL_MATRIX4_NV = GL_MATRIX4_NV
GL_MATRIX5_NV = GL_MATRIX5_NV
GL_MATRIX6_NV = GL_MATRIX6_NV
GL_MATRIX7_NV = GL_MATRIX7_NV
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_MODELVIEW_PROJECTION_NV = GL_MODELVIEW_PROJECTION_NV
GL_PROGRAM_ERROR_POSITION_NV = GL_PROGRAM_ERROR_POSITION_NV
GL_PROGRAM_LENGTH_NV = GL_PROGRAM_LENGTH_NV
GL_PROGRAM_PARAMETER_NV = GL_PROGRAM_PARAMETER_NV
GL_PROGRAM_RESIDENT_NV = GL_PROGRAM_RESIDENT_NV
GL_PROGRAM_STRING_NV = GL_PROGRAM_STRING_NV
GL_PROGRAM_TARGET_NV = GL_PROGRAM_TARGET_NV
GL_TRACK_MATRIX_NV = GL_TRACK_MATRIX_NV
GL_TRACK_MATRIX_TRANSFORM_NV = GL_TRACK_MATRIX_TRANSFORM_NV
GL_TRANSPOSE_NV = GL_TRANSPOSE_NV
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_PROGRAM_BINDING_NV = GL_VERTEX_PROGRAM_BINDING_NV
GL_VERTEX_PROGRAM_NV = GL_VERTEX_PROGRAM_NV
GL_VERTEX_PROGRAM_POINT_SIZE_NV = GL_VERTEX_PROGRAM_POINT_SIZE_NV
GL_VERTEX_PROGRAM_TWO_SIDE_NV = GL_VERTEX_PROGRAM_TWO_SIDE_NV
GL_VERTEX_STATE_PROGRAM_NV = GL_VERTEX_STATE_PROGRAM_NV
__file__ = '/build/buildd/pyopengl-3.0.0~b3/OpenGL/raw/GL/NV/vertex_program.py'
__name__ = 'OpenGL.raw.GL.NV.vertex_program'