!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.8 GB of 142.11 GB (91.34%)
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


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

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

Overview (from the spec)
    
    This extension expands on the interface provided by the
    ARB_vertex_buffer_object extension (and later integrated into OpenGL
    1.5) in order to permit buffer objects to be used not only with vertex
    array data, but also with pixel data.  The intent is to provide more
    acceleration opportunities for OpenGL pixel commands.
    
    While a single buffer object can be bound for both vertex arrays and
    pixel commands, we use the designations vertex buffer object (VBO)
    and pixel buffer object (PBO) to indicate their particular usage in
    a given situation.
    
    Recall that buffer objects conceptually are nothing more than arrays
    of bytes, just like any chunk of memory.  ARB_vertex_buffer_object
    allows GL commands to source data from a buffer object by binding the
    buffer object to a given target and then overloading a certain set of
    GL commands' pointer arguments to refer to offsets inside the buffer,
    rather than pointers to user memory.  An offset is encoded in a
    pointer by adding the offset to a null pointer.
    
    This extension does not add any new functionality to buffer objects
    themselves.  It simply adds two new targets to which buffer objects
    can be bound: GL_PIXEL_PACK_BUFFER and GL_PIXEL_UNPACK_BUFFER.  When a
    buffer object is bound to the GL_PIXEL_PACK_BUFFER target, commands
    such as glReadPixels pack (write) their data into a buffer object.
    When a buffer object is bound to the GL_PIXEL_UNPACK_BUFFER target,
    commands such as glDrawPixels and glTexImage2D unpack (read) their
    data from a buffer object.
    
    There are a several approaches to improve graphics performance
    with PBOs.  Some of the most interesting approaches are:
    
    - Streaming texture updates:  If the application uses
      glMapBuffer/glUnmapBuffer to write its data for glTexSubImage into
      a buffer object, at least one of the data copies usually required
      to download a texture can be eliminated, significantly increasing
      texture download performance.
    
    - Streaming draw pixels: When glDrawPixels sources client memory,
      OpenGL says the client memory can be modified immediately after the
      glDrawPixels command returns without disturbing the drawn image.
      This typically necessitates unpacking and copying the image prior
      to glDrawPixels returning.  However, when using glDrawPixels with
      a pixel pack buffer object, glDrawPixels may return prior to image
      unpacking because future modification of the buffer data requires
      explicit commands (glMapBuffer, glBufferData, or glBufferSubData).
    
    - Asynchronous glReadPixels:  If an application needs to read back a
      number of images and process them with the CPU, the existing GL
      interface makes it nearly impossible to pipeline this operation.
      The driver will typically send the hardware a readback command
      when glReadPixels is called, and then wait for all of the data to
      be available before returning control to the application.  Then,
      the application can either process the data immediately or call
      glReadPixels again; in neither case will the readback overlap with
      the processing.  If the application issues several readbacks
      into several buffer objects, however, and then maps each one to
      process its data, then the readbacks can proceed in parallel with
      the data processing.
    
    - Render to vertex array:  The application can use a fragment
      program to render some image into one of its buffers, then read
      this image out into a buffer object via glReadPixels.  Then, it can
      use this buffer object as a source of vertex data.

The official definition of this extension is available here:
http://www.opengl.org/registry/specs/ARB/pixel_buffer_object.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.pixel_buffer_object 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.0086 ]--