!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/NV/   drwxr-xr-x
Free 129.82 GB of 142.11 GB (91.35%)
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     vertex_array_range.py (4.41 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
'''OpenGL extension NV.vertex_array_range

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

Overview (from the spec)
    
    The goal of this extension is to permit extremely high vertex
    processing rates via OpenGL vertex arrays even when the CPU lacks
    the necessary data movement bandwidth to keep up with the rate
    at which the vertex engine can consume vertices.  CPUs can keep
    up if they can just pass vertex indices to the hardware and
    let the hardware "pull" the actual vertex data via Direct Memory
    Access (DMA).  Unfortunately, the current OpenGL 1.1 vertex array
    functionality has semantic constraints that make such an approach
    hard.  Hence, the vertex array range extension.
    
    This extension provides a mechanism for deferring the pulling of
    vertex array elements to facilitate DMAed pulling of vertices for
    fast, efficient vertex array transfers.  The OpenGL client need only
    pass vertex indices to the hardware which can DMA the actual index's
    vertex data directly out of the client address space.
    
    The OpenGL 1.1 vertex array functionality specifies a fairly strict
    coherency model for when OpenGL extracts vertex data from a vertex
    array and when the application can update the in memory
    vertex array data.  The OpenGL 1.1 specification says "Changes
    made to array data between the execution of Begin and the
    corresponding execution of End may affect calls to ArrayElement
    that are made within the same Begin/End period in non-sequential
    ways.  That is, a call to ArrayElement that precedes a change to
    array data may access the changed data, and a call that follows
    a change to array data may access the original data."
    
    This means that by the time End returns (and DrawArrays and
    DrawElements return since they have implicit Ends), the actual vertex
    array data must be transferred to OpenGL.  This strict coherency model
    prevents us from simply passing vertex element indices to the hardware
    and having the hardware "pull" the vertex data out (which is often
    long after the End for the primitive has returned to the application).
    
    Relaxing this coherency model and bounding the range from which
    vertex array data can be pulled is key to making OpenGL vertex
    array transfers faster and more efficient.
    
    The first task of the vertex array range extension is to relax
    the coherency model so that hardware can indeed "pull" vertex
    data from the OpenGL client's address space long after the application
    has completed sending the geometry primitives requiring the vertex
    data.
    
    The second problem with the OpenGL 1.1 vertex array functionality is
    the lack of any guidance from the API about what region of memory
    vertices can be pulled from.  There is no size limit for OpenGL 1.1
    vertex arrays.  Any vertex index that points to valid data in all
    enabled arrays is fair game.  This makes it hard for a vertex DMA
    engine to pull vertices since they can be potentially pulled from
    anywhere in the OpenGL client address space.
    
    The vertex array range extension specifies a range of the OpenGL
    client's address space where vertices can be pulled.  Vertex indices
    that access any array elements outside the vertex array range
    are specified to be undefined.  This permits hardware to DMA from
    finite regions of OpenGL client address space, making DMA engine
    implementation tractable.
    
    The extension is specified such that an (error free) OpenGL client
    using the vertex array range functionality could no-op its vertex
    array range commands and operate equivalently to using (if slower
    than) the vertex array range functionality.
    
    Because different memory types (local graphics memory, AGP memory)
    have different DMA bandwidths and caching behavior, this extension
    includes a window system dependent memory allocator to allocate
    cleanly the most appropriate memory for constructing a vertex array
    range.  The memory allocator provided allows the application to
    tradeoff the desired CPU read frequency, CPU write frequency, and
    memory priority while still leaving it up to OpenGL implementation
    the exact memory type to be allocated.

The official definition of this extension is available here:
http://www.opengl.org/registry/specs/NV/vertex_array_range.txt
'''
from OpenGL import platform, constants, constant, arrays
from OpenGL import extensions, wrapper
from OpenGL.GL import glget
import ctypes
from OpenGL.raw.GL.NV.vertex_array_range import *
### END AUTOGENERATED SECTION

:: 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 ]--