OpenGL.GL.NV.fragment_program
index
/home/mcfletch/pylive/OpenGL/GL/NV/fragment_program.py

OpenGL extension NV.fragment_program
 
This module customises the behaviour of the 
OpenGL.raw.GL.NV.fragment_program to provide a more 
Python-friendly API
 
Overview (from the spec)
        
        OpenGL mandates a certain set of configurable per-fragment computations
        defining texture lookup, texture environment, color sum, and fog
        operations.  Each of these areas provide a useful but limited set of fixed
        operations.  For example, unextended OpenGL 1.2.1 provides only four
        texture environment modes, color sum, and three fog modes.  Many OpenGL
        extensions have either improved existing functionality or introduced new
        configurable fragment operations.  While these extensions have enabled new
        and interesting rendering effects, the set of effects is limited by the
        set of special modes introduced by the extension.  This lack of
        flexibility is in contrast to the high-level of programmability of
        general-purpose CPUs and other (frequently software-based) shading
        languages.  The purpose of this extension is to expose to the OpenGL
        application writer an unprecedented degree of programmability in the
        computation of final fragment colors and depth values.
        
        This extension provides a mechanism for defining fragment program
        instruction sequences for application-defined fragment programs.  When in
        fragment program mode, a program is executed each time a fragment is
        produced by rasterization.  The inputs for the program are the attributes
        (position, colors, texture coordinates) associated with the fragment and a
        set of constant registers.  A fragment program can perform mathematical
        computations and texture lookups using arbitrary texture coordinates.  The
        results of a fragment program are new color and depth values for the
        fragment.
        
        This extension defines a programming model including a 4-component vector
        instruction set, 16- and 32-bit floating-point data types, and a
        relatively large set of temporary registers.  The programming model also
        includes a condition code vector which can be used to mask register writes
        at run-time or kill fragments altogether.  The syntax, program
        instructions, and general semantics are similar to those in the
        NV_vertex_program and NV_vertex_program2 extensions, which provide for the
        execution of an arbitrary program each time the GL receives a vertex.
        
        The fragment program execution environment is designed for efficient
        hardware implementation and to support a wide variety of programs.  By
        design, the entire set of existing fragment programs defined by existing
        OpenGL per-fragment computation extensions can be implemented using the
        extension's programming model.
        
        The fragment program execution environment accesses textures via
        arbitrarily computed texture coordinates.  As such, there is no necessary
        correspondence between the texture coordinates and texture maps previously
        lumped into a single "texture unit".  This extension separates the notion
        of "texture coordinate sets" and "texture image units" (texture maps and
        associated parameters), allowing implementations with a different number
        of each.  The initial implementation of this extension will support 8
        texture coordinate sets and 16 texture image units.
 
The official definition of this extension is available here:
http://www.opengl.org/registry/specs/NV/fragment_program.txt

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

 
Data
        EXTENSION_NAME = 'GL_NV_fragment_program'
GL_FRAGMENT_PROGRAM_BINDING_NV = GL_FRAGMENT_PROGRAM_BINDING_NV
GL_FRAGMENT_PROGRAM_NV = GL_FRAGMENT_PROGRAM_NV
GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV
GL_MAX_TEXTURE_COORDS_NV = GL_MAX_TEXTURE_COORDS_NV
GL_MAX_TEXTURE_IMAGE_UNITS_NV = GL_MAX_TEXTURE_IMAGE_UNITS_NV
GL_PROGRAM_ERROR_STRING_NV = GL_PROGRAM_ERROR_STRING_NV
__file__ = '/home/mcfletch/pylive/OpenGL/GL/NV/fragment_program.pyc'
__name__ = 'OpenGL.GL.NV.fragment_program'
__package__ = 'OpenGL.GL.NV'
glGetProgramNamedParameterdvNV = <OpenGL.platform.baseplatform.glGetProgramNamedParameterdvNV object at 0x78e81d0>
glGetProgramNamedParameterfvNV = <OpenGL.platform.baseplatform.glGetProgramNamedParameterfvNV object at 0x78e8150>
glProgramNamedParameter4dNV = <OpenGL.platform.baseplatform.glProgramNamedParameter4dNV object at 0x78dff90>
glProgramNamedParameter4dvNV = <OpenGL.platform.baseplatform.glProgramNamedParameter4dvNV object at 0x78e80d0>
glProgramNamedParameter4fNV = <OpenGL.platform.baseplatform.glProgramNamedParameter4fNV object at 0x78df510>
glProgramNamedParameter4fvNV = <OpenGL.platform.baseplatform.glProgramNamedParameter4fvNV object at 0x78e8050>