Add half finished code.

Author: adamlwgriffiths

pygly/attic/fbo.py

@@ -0,0 +1,58 @@
+
+class FBO( object ):
+
+    def __init__( self ):
+        super( FBO, self ).__init__()
+
+        self.fbo = (GLuint)()
+        glGenFramebuffers( 1, self.fbo )
+
+        self.textures = {}
+
+    def __del__( self ):
+        fbo = getattr( self, 'fbo', None )
+        if fbo:
+            glDeleteFramebuffers( 1, fbo )
+
+    def bind( self ):
+        glBindFramebuffer( GL_RENDERBUFFER, self.fbo )
+
+    def unbind( self ):
+        glBindFramebuffer( GL_RENDERBUFFER, 0 )
+
+    def set_active( self, targets = None ):
+        """Prepares the FBO for drawing.
+        Calls glDrawFramebuffer.
+
+        If targets is None, the entire set of
+        currently set texture targets will be used.
+        """
+        if not targets:
+            targets = self.textures.keys()
+
+        enums = numpy.array([targets])
+        data = (GLuint * enums.size)(*enums.flat)
+
+        glDrawFramebuffer( enums.size, data )
+
+    def attach_texture_2d(
+        self,
+        texture,
+        texture_target = GL_TEXTURE_2D,
+        fb_target = GL_COLOR_ATTACHMENT0,
+        level = 0,
+        ):
+        glFramebufferTexture2d(
+            GL_FRAMEBUFFER,
+            fb_target,
+            texture_target,
+            texture,
+            level
+            )
+        self.textures[ fb_target ] = texture
+
+class ManagedFBO( FBO ):
+    def create_texture_2d( self ):
+        pass
+    pass
+

pygly/attic/vertex_array.py

@@ -0,0 +1,74 @@
+from pygly.vertex_buffer import VertexBuffer
+
+
+class VertexArray( object ):
+
+    attrib_pointer_function = {
+        GL_BYTE:            glVertexAttribPointerI,
+        GL_UNSIGNED_BYTE:   glVertexAttribPointerI,
+        GL_SHORT:           glVertexAttribPointerI,
+        GL_UNSIGNED_SHORT:  glVertexAttribPointerI,
+        GL_INT:             glVertexAttribPointerI,
+        GL_UNSIGNED_INT:    glVertexAttribPointerI,
+        GL_HALF_FLOAT:      glVertexAttribPointer,
+        GL_FLOAT:           glVertexAttribPointer,
+        GL_DOUBLE:          glVertexAttribPointerL,
+        }
+
+    def __init__( self ):
+        super( VertexArray, self ).__init__()
+
+        self.id = (GLuint)()
+        glGenVertexArrays( 1, self.id )
+
+    def __del__( self ):
+        id = getattr( self, 'id', None )
+        if id and id.value != 0:
+            glDeleteVertexArrays( 1, id )
+
+    def bind( self ):
+        glBindVertexArray( self.id )
+
+    def unbind( self ):
+        glBindVertexArray( 0 )
+
+    def set_vertex_buffer( self, size, type, stride, offset ):
+        pointer = (GLvoid)( sizeof(gl_type) * offset )
+        glVertexPointer( size, type, stride, pointer )
+
+    def set_normal_buffer( self, size, stride, offset ):
+        pointer = (GLvoid)( sizeof(gl_type) * offset )
+        glNormalPointer( size, stride, pointer )
+
+    def set_colour_buffer( self, size, type, stride, offset ):
+        pointer = (GLvoid)( sizeof(gl_type) * offset )
+        glColourPointer( size, type, stride, pointer )
+
+    def set_texture_coordinate_buffer( self, size, type, stride, offset ):
+        pointer = (GLvoid)( sizeof(gl_type) * offset )
+        glTexCoordPointer( size, type, stride, pointer )
+
+    def set_buffer( self, index, buffer, normalise = False, stride = 0, offset = 0 ):
+        type_tuple, element_size, usage = VertexBuffer.parse_format( format )
+
+        # extract the gl type enum and data type
+        gl_enum, gl_type = type_tuple
+
+        gl_normalise = GL_TRUE if normalise else GL_FALSE
+
+        # convert our offset to a pointer
+        # because it's a pointer, it needs to be converted from
+        # element offset to memory offset
+        pointer = (GLvoid)( sizeof(gl_type) * offset )
+
+        func = VertexArray.attrib_pointer_function[ gl_enum ]
+
+        func(
+            index,
+            element_size,
+            gl_enum,
+            gl_normalise,
+            stride,
+            pointer
+            )
+

pygly/attic/vertex_buffer.py

@@ -0,0 +1,90 @@
+from ctypes import *
+
+from pyglet.gl import *
+
+import pygly.utils
+
+
+class VertexBuffer( object ):
+
+    # http://www.khronos.org/files/opengl-quick-reference-card.pdf
+    types = {
+        'i8':       (GL_BYTE, GLbyte),
+        'u8':       (GL_UNSIGNED_BYTE, GLubyte),
+        'i16':      (GL_SHORT, GLshort),
+        'u16':      (GL_UNSIGNED_SHORT, GLushort),
+        'i32':      (GL_INT, GLint),
+        'u32':      (GL_UNSIGNED_INT, GLuint),
+        # no native half-float
+        'f16':      (GL_HALF_FLOAT, GLfloat),
+        'f32':      (GL_FLOAT, GLfloat),
+        'f64':      (GL_DOUBLE, GLdouble),
+        }
+
+    uses = {
+        'stream_draw':  GL_STREAM_DRAW,
+        'stream_read':  GL_STREAM_READ,
+        'stream_copy':  GL_STREAM_COPY,
+        'static_draw':  GL_STATIC_DRAW,
+        'static_read':  GL_STATIC_READ,
+        'static_copy':  GL_STATIC_COPY,
+        'dynamic_draw': GL_DYNAMIC_DRAW,
+        'dynamic_read': GL_DYNAMIC_READ,
+        'dynamic_copy': GL_DYNAMIC_COPY,
+        }
+
+    @staticmethod
+    def parse_format( format ):
+        values = format.split('/')
+        type, element_size, usage = pygly.utils.extract_tuple( values, 3 )
+
+        return(
+            VertexBuffer.types[ type ],
+            int( element_size ),
+            VertexBuffer.uses[ usage ]
+            )
+
+    def __init__( self, target = GL_ARRAY_BUFFER ):
+        super( VertexBuffer, self ).__init__()
+
+        self.id = (GLuint)()
+        glGenBuffers( 1, self.id )
+
+        self.target = target
+
+        self.format = ''
+
+    def __del__( self ):
+        id = getattr( self, 'id', None )
+        if id and id.value != 0:
+            glDeleteBuffers( 1, id )
+
+    def bind( self ):
+        glBindBuffer( self.target, self.id )
+
+    def unbind( self ):
+        glBindBuffer( self.target, 0 )
+
+    def set_data( self, format, num_elements, data ):
+        """
+        Format is as follows:
+        data type / values per element / usage
+
+        For example:
+        f32/3/static_draw
+        """
+        # store our format for later
+        self.format = format
+
+        type_tuple, element_size, usage = VertexBuffer.parse_format( format )
+
+        # extract the gl type enum and data type
+        gl_enum, gl_type = type_tuple
+
+        glBufferData(
+            self.target,
+            len(data) * sizeof( gl_type ),
+            (gl_type * len(data))(*data),
+            usage
+            )
+