!C99Shell v. 2.0 [PHP 7 Update] [25.02.2019]!

Software: Apache/2.2.16 (Debian). PHP/5.3.3-7+squeeze19 

uname -a: Linux mail.tri-specialutilitydistrict.com 2.6.32-5-amd64 #1 SMP Tue May 13 16:34:35 UTC
2014 x86_64
 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/usr/share/pyshared/OpenGL/GL/ARB/   drwxr-xr-x
Free 129.91 GB of 142.11 GB (91.41%)
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     vertex_program.py (5.9 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
'''OpenGL extension ARB.vertex_program

This module customises the behaviour of the 
OpenGL.raw.GL.ARB.vertex_program to provide a more 
Python-friendly API

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
    (ARB_vertex_blend, 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/ARB_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 result 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://www.opengl.org/registry/specs/ARB/vertex_program.txt
'''
from OpenGL import platform, constants, constant, arrays
from OpenGL import extensions, wrapper
from OpenGL.GL import glget
import ctypes
from OpenGL.raw.GL.ARB.vertex_program import *
### END AUTOGENERATED SECTION
from OpenGL.lazywrapper import lazy

from OpenGL import converters, error, contextdata
from OpenGL.arrays.arraydatatype import ArrayDatatype
# Note: sizes here are == the only documented sizes I could find,
# may need a lookup table some day...
glGetProgramivARB = wrapper.wrapper(glGetProgramivARB).setOutput(
    'params', (1,),
)
glGetProgramEnvParameterdvARB = wrapper.wrapper(glGetProgramEnvParameterdvARB).setOutput(
    'params',(4,),
)
glGetProgramEnvParameterfvARB = wrapper.wrapper(glGetProgramEnvParameterfvARB).setOutput(
    'params',(4,),
)
glGetProgramLocalParameterdvARB = wrapper.wrapper(glGetProgramLocalParameterdvARB).setOutput(
    'params',(4,),
)
glGetProgramLocalParameterfvARB = wrapper.wrapper(glGetProgramLocalParameterfvARB).setOutput(
    'params',(4,),
)
glGetVertexAttribdvARB = wrapper.wrapper(glGetVertexAttribdvARB).setOutput(
    'params',(1,),
)

##glGetVertexAttribPointervARB = wrapper.wrapper(glGetVertexAttribPointervARB).setOutput(
##    'pointer',(1,),
##)
##
##_base_glGetVertexAttribPointervARB
##def glGetVertexAttribPointervARB( index, pname=GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB ):
##    """Retrieve named attribute vector
##    
##    XXX Needs logic checking, I don't think I got the number of
##    levels of indirection correct... i.e. I believe it's just going
##    to rewrite the temporary void_p's value, rather than writing
##    into the numpy array.
##    
##    returns 4-element double array...
##    """
##    output = arrays.GLdoubleArray.zeros( (4,) )
##    pointer = arrays.GLdoubleArray.voidDataPointer( output )
##    _base_glGetVertexAttribPointervARB( index, pname, pointer )
##    return output

@lazy( glVertexAttribPointerARB )
def glVertexAttribPointerARB( 
    baseOperation, index, size, type,
    normalized, stride, pointer,
):
    """Set an attribute pointer for a given shader (index)
    
    index -- the index of the generic vertex to bind, see 
        glGetAttribLocation for retrieval of the value,
        note that index is a global variable, not per-shader
    size -- number of basic elements per record, 1,2,3, or 4
    type -- enum constant for data-type 
    normalized -- whether to perform int to float 
        normalization on integer-type values
    stride -- stride in machine units (bytes) between 
        consecutive records, normally used to create 
        "interleaved" arrays 
    pointer -- data-pointer which provides the data-values,
        normally a vertex-buffer-object or offset into the 
        same.
    
    This implementation stores a copy of the data-pointer 
    in the contextdata structure in order to prevent null-
    reference errors in the renderer.
    """
    array = ArrayDatatype.asArray( pointer )
    key = ('vertex-attrib',index)
    contextdata.setValue( key, array )
    return baseOperation(
        index, size, type,
        normalized, stride, 
        ArrayDatatype.voidDataPointer( array ) 
    )

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ Read-Only ]

:: Make Dir ::
 
[ Read-Only ]
:: Make File ::
 
[ Read-Only ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 2.0 [PHP 7 Update] [25.02.2019] maintained by KaizenLouie | C99Shell Github | Generation time: 0.0084 ]--