コード例 #1
0
def paint():

    n = 100
    data = np.hstack(
        (.2 * np.random.randn(n, 2), np.random.rand(n, 4))).astype(np.float32)

    vs = compile_shader(VS, gl.GL_VERTEX_SHADER)
    fs = compile_shader(FS, gl.GL_FRAGMENT_SHADER)
    shaders_program = link_shader_program(vs, fs)

    buffer = gl.glGenBuffers(1)
    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer)
    gl.glBufferData(gl.GL_ARRAY_BUFFER, data, gl.GL_STATIC_DRAW)

    l = gl.glGetAttribLocation(shaders_program, "position")
    gl.glVertexAttribPointer(l, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
    gl.glEnableVertexAttribArray(l)

    lc = gl.glGetAttribLocation(shaders_program, "color")
    gl.glVertexAttribPointer(lc, 4, gl.GL_FLOAT, gl.GL_FALSE, 2 * 4, None)
    gl.glEnableVertexAttribArray(lc)

    gl.glUseProgram(shaders_program)

    gl.glViewport(0, 0, 500, 500)
    gl.glClearColor(0., 0., 0., 1.)
    gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)

    gl.glEnable(gl.GL_BLEND)
    gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)

    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer)

    gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, data.shape[0])
コード例 #2
0
ファイル: buffer.py プロジェクト: tobyhijzen/vispy
 def _update(self):
     """ Upload all pending data to GPU. """
     
     # Bind buffer now 
     gl.glBindBuffer(self._target, self._handle)
    
     # Allocate new size if necessary
     if self._need_resize:
         # This will only allocate the buffer on GPU
         # WARNING: we should check if this operation is ok
         gl.glBufferData(self._target, self._nbytes, None, self._usage)
         # debug
         #print("Creating a new buffer (%d) of %d bytes"
         #        % (self._handle, self._nbytes))
         self._need_resize = False
     
     # Upload data
     while self._pending_data:
         data, nbytes, offset = self._pending_data.pop(0)
         # debug
         # print("Uploading %d bytes at offset %d to buffer (%d)"
         #        % (nbytes, offset, self._handle))
         try:
             gl.glBufferSubData(self._target, offset, nbytes, data)
         except Exception as error:
             # This might be due to a driver error (seen on ATI), issue #64.
             # We try to detect this, and if we can use glBufferData instead
             if (    hasattr(error, 'err') and 
                     error.err == gl.GL_INVALID_VALUE and 
                     offset == 0 and nbytes == self._nbytes ):
                 gl.glBufferData(self._target, nbytes, data, self._usage)
             else:
                 raise
コード例 #3
0
ファイル: rawgl-fireworks.py プロジェクト: joe311/vispy
    def on_paint(self, event):

        # Technically, we would only need to set u_time on every draw,
        # because the program is enabled at the beginning and never disabled.
        # In vispy, the program is re-enabled at each draw though and we
        # want to keep the code similar.

        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)

        # Activate program  and texture
        gl.glUseProgram(self._prog_handle)
        gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)

        # Update VBO
        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._vbo_handle)
        gl.glBufferData(gl.GL_ARRAY_BUFFER, vertex_data.nbytes, vertex_data,
                        gl.GL_DYNAMIC_DRAW)

        # Set attributes (again, the loc can be cached)
        loc = gl.glGetAttribLocation(self._prog_handle,
                                     'a_lifetime'.encode('utf-8'))
        gl.glEnableVertexAttribArray(loc)
        gl.glVertexAttribPointer(loc, 1, gl.GL_FLOAT, False, 7 * 4,
                                 ctypes.c_voidp(0))
        #
        loc = gl.glGetAttribLocation(self._prog_handle,
                                     'a_startPosition'.encode('utf-8'))
        gl.glEnableVertexAttribArray(loc)
        gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 7 * 4,
                                 ctypes.c_voidp(1 * 4))
        #
        loc = gl.glGetAttribLocation(self._prog_handle,
                                     'a_endPosition'.encode('utf-8'))
        gl.glEnableVertexAttribArray(loc)
        gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 7 * 4,
                                 ctypes.c_voidp(4 * 4))
        #
        loc = gl.glGetUniformLocation(self._prog_handle,
                                      'u_color'.encode('utf-8'))
        gl.glUniform4f(loc, *self._color)

        # Set unforms
        loc = gl.glGetUniformLocation(self._prog_handle,
                                      'u_time'.encode('utf-8'))
        gl.glUniform1f(loc, time.time() - self._starttime)
        #
        loc = gl.glGetUniformLocation(self._prog_handle,
                                      'u_centerPosition'.encode('utf-8'))
        gl.glUniform3f(loc, *self._centerpos)

        # Draw
        gl.glDrawArrays(gl.GL_POINTS, 0, N)

        # New explosion?
        if time.time() - self._starttime > 1.5:
            self._new_explosion()

        # Redraw as fast as we can
        self.update()
コード例 #4
0
ファイル: rawgl-fireworks.py プロジェクト: joe311/vispy
 def on_paint(self, event):
     
     # Technically, we would only need to set u_time on every draw,
     # because the program is enabled at the beginning and never disabled.
     # In vispy, the program is re-enabled at each draw though and we
     # want to keep the code similar.
     
     gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
     
     # Activate program  and texture
     gl.glUseProgram(self._prog_handle)
     gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
     
     # Update VBO
     gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._vbo_handle)
     gl.glBufferData(gl.GL_ARRAY_BUFFER, vertex_data.nbytes, vertex_data, gl.GL_DYNAMIC_DRAW)
     
     # Set attributes (again, the loc can be cached)
     loc = gl.glGetAttribLocation(self._prog_handle, 'a_lifetime'.encode('utf-8'))
     gl.glEnableVertexAttribArray(loc)
     gl.glVertexAttribPointer(loc, 1, gl.GL_FLOAT, False, 7*4, ctypes.c_voidp(0))
     #
     loc = gl.glGetAttribLocation(self._prog_handle, 'a_startPosition'.encode('utf-8'))
     gl.glEnableVertexAttribArray(loc)
     gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 7*4, ctypes.c_voidp(1*4))
     #
     loc = gl.glGetAttribLocation(self._prog_handle, 'a_endPosition'.encode('utf-8'))
     gl.glEnableVertexAttribArray(loc)
     gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 7*4, ctypes.c_voidp(4*4))
     #
     loc = gl.glGetUniformLocation(self._prog_handle, 'u_color'.encode('utf-8'))
     gl.glUniform4f(loc, *self._color)
     
     # Set unforms
     loc = gl.glGetUniformLocation(self._prog_handle, 'u_time'.encode('utf-8'))
     gl.glUniform1f(loc, time.time()-self._starttime)
     #
     loc = gl.glGetUniformLocation(self._prog_handle, 'u_centerPosition'.encode('utf-8'))
     gl.glUniform3f(loc, *self._centerpos)
     
     # Draw
     gl.glDrawArrays(gl.GL_POINTS, 0, N)
     
     # New explosion?
     if time.time() - self._starttime > 1.5:
         self._new_explosion()
         
     # Redraw as fast as we can
     self.update()
コード例 #5
0
    def on_paint(self, event):

        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)

        # Activate program  and texture
        gl.glUseProgram(self._prog_handle)
        gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)

        # Set attributes (again, the loc can be cached)
        loc = gl.glGetAttribLocation(self._prog_handle,
                                     'a_position'.encode('utf-8'))
        gl.glEnableVertexAttribArray(loc)
        if use_buffers:
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle)
            gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 0, None)
        else:
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)  # 0 means do not use buffer
            gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 0, positions)
        #
        loc = gl.glGetAttribLocation(self._prog_handle,
                                     'a_texcoord'.encode('utf-8'))
        gl.glEnableVertexAttribArray(loc)
        if use_buffers:
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle)
            gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, 0, None)
        else:
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)  # 0 means do not use buffer
            gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, 0, texcoords)

        # Set uniforms (note that you could cache the locations)
        loc = gl.glGetUniformLocation(self._prog_handle,
                                      'u_view'.encode('utf-8'))
        gl.glUniformMatrix4fv(loc, 1, False, self.view)
        loc = gl.glGetUniformLocation(self._prog_handle,
                                      'u_model'.encode('utf-8'))
        gl.glUniformMatrix4fv(loc, 1, False, self.model)
        loc = gl.glGetUniformLocation(self._prog_handle,
                                      'u_projection'.encode('utf-8'))
        gl.glUniformMatrix4fv(loc, 1, False, self.projection)

        # Draw
        if use_buffers:
            gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle)
            gl.glDrawElements(gl.GL_TRIANGLES, faces.size, gl.GL_UNSIGNED_INT,
                              None)
        else:
            gl.glDrawElements(gl.GL_TRIANGLES, faces.size, gl.GL_UNSIGNED_INT,
                              faces)
コード例 #6
0
ファイル: rawgl-cube.py プロジェクト: joe311/vispy
 def on_paint(self, event):
     
     gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
     
     # Activate program  and texture
     gl.glUseProgram(self._prog_handle)
     gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
     
     # Set attributes (again, the loc can be cached)
     loc = gl.glGetAttribLocation(self._prog_handle, 'a_position'.encode('utf-8'))
     gl.glEnableVertexAttribArray(loc)
     if use_buffers:
         gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle)
         gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 0, None)
     else:
         gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)  # 0 means do not use buffer
         gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 0, positions)
     #
     loc = gl.glGetAttribLocation(self._prog_handle, 'a_texcoord'.encode('utf-8'))
     gl.glEnableVertexAttribArray(loc)
     if use_buffers:
         gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle)
         gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, 0, None)
     else:
         gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)  # 0 means do not use buffer
         gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, 0, texcoords)
     
     # Set uniforms (note that you could cache the locations)
     loc = gl.glGetUniformLocation(self._prog_handle, 'u_view'.encode('utf-8'))
     gl.glUniformMatrix4fv(loc, 1, False, self.view)
     loc = gl.glGetUniformLocation(self._prog_handle, 'u_model'.encode('utf-8'))
     gl.glUniformMatrix4fv(loc, 1, False, self.model)
     loc = gl.glGetUniformLocation(self._prog_handle, 'u_projection'.encode('utf-8'))
     gl.glUniformMatrix4fv(loc, 1, False, self.projection)
     
     # Draw
     if use_buffers:
         gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle)
         gl.glDrawElements(gl.GL_TRIANGLES, faces.size, gl.GL_UNSIGNED_INT, None)
     else:
         gl.glDrawElements(gl.GL_TRIANGLES, faces.size, gl.GL_UNSIGNED_INT, faces)
コード例 #7
0
ファイル: rawgl-cube.py プロジェクト: joe311/vispy
    def on_initialize(self, event):
        gl.glClearColor(1,1,1,1)
        gl.glEnable(gl.GL_DEPTH_TEST)
        
        # Create shader program
        self._prog_handle = gl.glCreateProgram()

        # Create vertex shader
        shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
        gl.glShaderSource(shader, VERT_CODE)
        gl.glCompileShader(shader)
        status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
        if not status:
            # We could show more useful info here, but that takes a few lines
            raise RuntimeError('Vertex shader did not compile.')
        else:
            gl.glAttachShader(self._prog_handle, shader)
        
        # Create fragment shader
        shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
        gl.glShaderSource(shader, FRAG_CODE)
        gl.glCompileShader(shader)
        status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
        if not status:
            # We could show more useful info here, but that takes a few lines
            raise RuntimeError('Fragment shader did not compile.')
        else:
            gl.glAttachShader(self._prog_handle, shader)
        
        # Link
        gl.glLinkProgram(self._prog_handle)
        status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS)
        if not status:
            # We could show more useful info here, but that takes a few lines
            raise RuntimeError('Program did not link.')
        
        # Create texture
        im = io.crate()
        self._tex_handle = gl.glGenTextures(1)
        gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
        gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
        gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, 
            im.shape[1], im.shape[0], 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im)
        gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
        gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
        
        if use_buffers:
            # Create vertex buffer
            self._positions_handle = gl.glGenBuffers(1)
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle)
            gl.glBufferData(gl.GL_ARRAY_BUFFER, positions.nbytes, positions, gl.GL_DYNAMIC_DRAW)
            #
            self._texcoords_handle = gl.glGenBuffers(1)
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle)
            gl.glBufferData(gl.GL_ARRAY_BUFFER, texcoords.nbytes, texcoords, gl.GL_DYNAMIC_DRAW)
            
            # Create buffer for faces
            self._faces_handle = gl.glGenBuffers(1)
            gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle)
            gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, faces.nbytes, faces, gl.GL_DYNAMIC_DRAW)
コード例 #8
0
ファイル: testgl.py プロジェクト: vispy/webgl-experiment
def paint():
    
    n = 100
    data = np.hstack((
        .2 * np.random.randn(n, 2),
        np.random.rand(n, 4)
    )).astype(np.float32)
    
    vs = compile_shader(VS, gl.GL_VERTEX_SHADER)
    fs = compile_shader(FS, gl.GL_FRAGMENT_SHADER)
    shaders_program = link_shader_program(vs, fs)
    
    buffer = gl.glGenBuffers(1)
    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer)
    gl.glBufferData(gl.GL_ARRAY_BUFFER, data, gl.GL_STATIC_DRAW)
    
    
    l = gl.glGetAttribLocation(shaders_program, "position")
    gl.glVertexAttribPointer(l, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
    gl.glEnableVertexAttribArray(l);
    
    lc = gl.glGetAttribLocation(shaders_program, "color")
    gl.glVertexAttribPointer(lc, 4, gl.GL_FLOAT, gl.GL_FALSE, 2 * 4, None)
    gl.glEnableVertexAttribArray(lc);
    
    gl.glUseProgram(shaders_program)
    
    gl.glViewport(0, 0, 500, 500)
    gl.glClearColor(0., 0., 0., 1.)
    gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
    
    gl.glEnable(gl.GL_BLEND)
    gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)

    
    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer)
    
    gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, data.shape[0])
コード例 #9
0
    def _update(self):
        """ Upload all pending data to GPU. """

        # Bind buffer now
        gl.glBindBuffer(self._target, self._handle)

        # Allocate new size if necessary
        if self._need_resize:
            # This will only allocate the buffer on GPU
            # WARNING: we should check if this operation is ok
            gl.glBufferData(self._target, self._nbytes, None, self._usage)
            # debug
            #print("Creating a new buffer (%d) of %d bytes"
            #        % (self._handle,self._nbytes))
            self._need_resize = False

        # Upload data
        while self._pending_data:
            data, nbytes, offset = self._pending_data.pop(0)
            # debug
            # print("Uploading %d bytes at offset %d to buffer (%d)"
            #        % (size, offset, self._handle))
            gl.glBufferSubData(self._target, offset, nbytes, data)
コード例 #10
0
ファイル: buffer.py プロジェクト: joe311/vispy
 def _update(self):
     """ Upload all pending data to GPU. """
     
     # Bind buffer now 
     gl.glBindBuffer(self._target, self._handle)
    
     # Allocate new size if necessary
     if self._need_resize:
         # This will only allocate the buffer on GPU
         # WARNING: we should check if this operation is ok
         gl.glBufferData(self._target, self._nbytes, None, self._usage)
         # debug
         #print("Creating a new buffer (%d) of %d bytes"
         #        % (self._handle,self._nbytes))
         self._need_resize = False
         
     # Upload data
     while self._pending_data:
         data, nbytes, offset = self._pending_data.pop(0)
         # debug
         # print("Uploading %d bytes at offset %d to buffer (%d)"
         #        % (size, offset, self._handle))
         gl.glBufferSubData(self._target, offset, nbytes, data)
コード例 #11
0
    def on_initialize(self, event):
        gl.glClearColor(1, 1, 1, 1)
        gl.glEnable(gl.GL_DEPTH_TEST)

        # Create shader program
        self._prog_handle = gl.glCreateProgram()

        # Create vertex shader
        shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
        gl.glShaderSource(shader, VERT_CODE)
        gl.glCompileShader(shader)
        status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
        if not status:
            # We could show more useful info here, but that takes a few lines
            raise RuntimeError('Vertex shader did not compile.')
        else:
            gl.glAttachShader(self._prog_handle, shader)

        # Create fragment shader
        shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
        gl.glShaderSource(shader, FRAG_CODE)
        gl.glCompileShader(shader)
        status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
        if not status:
            # We could show more useful info here, but that takes a few lines
            raise RuntimeError('Fragment shader did not compile.')
        else:
            gl.glAttachShader(self._prog_handle, shader)

        # Link
        gl.glLinkProgram(self._prog_handle)
        status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS)
        if not status:
            # We could show more useful info here, but that takes a few lines
            raise RuntimeError('Program did not link.')

        # Create texture
        im = io.crate()
        self._tex_handle = gl.glGenTextures(1)
        gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
        gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
        gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, im.shape[1],
                        im.shape[0], 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im)
        gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
                          gl.GL_LINEAR)
        gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
                          gl.GL_LINEAR)

        if use_buffers:
            # Create vertex buffer
            self._positions_handle = gl.glGenBuffers(1)
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle)
            gl.glBufferData(gl.GL_ARRAY_BUFFER, positions.nbytes, positions,
                            gl.GL_DYNAMIC_DRAW)
            #
            self._texcoords_handle = gl.glGenBuffers(1)
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle)
            gl.glBufferData(gl.GL_ARRAY_BUFFER, texcoords.nbytes, texcoords,
                            gl.GL_DYNAMIC_DRAW)

            # Create buffer for faces
            self._faces_handle = gl.glGenBuffers(1)
            gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle)
            gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, faces.nbytes, faces,
                            gl.GL_DYNAMIC_DRAW)
コード例 #12
0
    def upload(self, program):
        """ Actual upload of data to GPU memory  """

        # If there is not data, there is no point in uploading
        if self._data is None:
            if self._show_warning_notset:
                print("Value for attribute '%s' is not set." % self.name)
                self._show_warning_notset = False
            return

        # Check active status (mandatory)
        if self._loc is None:
            raise VariableError("Attribute is not active")

        # Generic vertex attribute (all vertices receive the same value)
        if self._generic:

            # Tell OpenGL to use the constant value
            gl.glDisableVertexAttribArray(self._loc)

            # Early exit
            if not self._dirty:
                return

            # Apply
            self._afunction(self._loc, *self._data)

        # Client side array
        elif isinstance(self._data, ClientVertexBuffer):

            # Tell OpenGL to use the array and not the glVertexAttrib* value
            gl.glEnableVertexAttribArray(self._loc)

            # Disable any VBO
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)

            # Early exit (pointer to CPU-data is still known by Program)
            if not self._dirty:
                return

            # Get numpy array from its container
            data = self._data.data

            # Check attribute format against data format
            size, gtype, _ = gl_typeinfo[self._gtype]
            #if self._gtype != self._data._gtype:
            #    raise ValueError("Data not compatible with attribute type")
            offset = 0
            stride = self._data.stride

            # Apply (first disable any previous VertexBuffer)
            gl.glVertexAttribPointer(self._loc, size, gtype, False, stride,
                                     data)

        # Regular vertex buffer or vertex buffer view
        else:

            data = self._data
            # todo: check offset = -1?

            # Tell OpenGL to use the array and not the glVertexAttrib* value
            gl.glEnableVertexAttribArray(self._loc)

            # Enable the VBO
            program.activate_object(data)

            # Early exit
            if not self._dirty:
                return

            # Check attribute format against data format
            size, gtype, _ = gl_typeinfo[self._gtype]
            #if self._gtype != self._data._gtype:
            #    raise ValueError("Data not compatible with attribute type")
            offset = self._data.offset
            stride = self._data.stride

            #size, gtype, dtype = gl_typeinfo[self._gtype]
            #offset, stride = data._offset, data._stride  # view_params not on VertexBuffer

            # Make offset a pointer, or it will be interpreted as a small array
            offset = ctypes.c_void_p(offset)

            # Apply
            gl.glVertexAttribPointer(self._loc, size, gtype, False, stride,
                                     offset)

        # Mark as uploaded
        self._dirty = False
コード例 #13
0
 def _activate(self):
     """ Bind the buffer to some target """
     gl.glBindBuffer(self._target, self._handle)
コード例 #14
0
ファイル: buffer.py プロジェクト: tobyhijzen/vispy
 def _deactivate(self):
     """ Unbind the current bound buffer """
     gl.glBindBuffer(self._target, 0)
コード例 #15
0
ファイル: buffer.py プロジェクト: tobyhijzen/vispy
 def _activate(self):
     """ Bind the buffer to some target """
     gl.glBindBuffer(self._target, self._handle)
コード例 #16
0
ファイル: variable.py プロジェクト: tobyhijzen/vispy
    def upload(self, program):
        """ Actual upload of data to GPU memory  """
        
        # If there is not data, there is no point in uploading
        if self._data is None:
            if self._show_warning_notset:
                print("Value for attribute '%s' is not set." % self.name)
                self._show_warning_notset = False
            return
        
        # Check active status (mandatory)
        if self._loc is None:
            raise VariableError("Attribute is not active")
        
        # Note: It has been seen (on my (AK) machine) that attributes
        # are *not* local to the program object; the splitscreen example
        # is broken if we use the early exits here.
        
        # todo: instead of setting dirty to true, remove early exits
        # (leaving for now for testing on other machines)
        self._dirty = True
        
        # Generic vertex attribute (all vertices receive the same value)
        if self._generic:
            
            # Tell OpenGL to use the constant value
            gl.glDisableVertexAttribArray(self._loc)
            
            # Early exit
            if not self._dirty:
                return
            
            # Apply
            self._afunction(self._loc, *self._data)

        # Client side array
        elif isinstance(self._data, ClientVertexBuffer):
            
            # Tell OpenGL to use the array and not the glVertexAttrib* value
            gl.glEnableVertexAttribArray(self._loc)
            
            # Disable any VBO
            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
            
            # Early exit (pointer to CPU-data is still known by Program)
            if not self._dirty:
                return
            
            # Get numpy array from its container
            data = self._data.data
            
            # Check attribute format against data format
            size, gtype, _ = gl_typeinfo[self._gtype]
            #if self._gtype != self._data._gtype: 
            #    raise ValueError("Data not compatible with attribute type")
            offset = 0
            stride = self._data.stride

            # Apply (first disable any previous VertexBuffer)
            gl.glVertexAttribPointer(self._loc, size, gtype, False, stride, data)
        
        # Regular vertex buffer or vertex buffer view
        else:
            
            data = self._data
            # todo: check offset = -1?
            
            # Tell OpenGL to use the array and not the glVertexAttrib* value
            gl.glEnableVertexAttribArray(self._loc)
            
            # Enable the VBO
            program.activate_object(data)
            
            # Early exit
            if not self._dirty:
                return
            
            # Check attribute format against data format
            size, gtype, _ = gl_typeinfo[self._gtype]
            #if self._gtype != self._data._gtype: 
            #    raise ValueError("Data not compatible with attribute type")
            offset = self._data.offset
            stride = self._data.stride

            #size, gtype, dtype = gl_typeinfo[self._gtype]
            #offset, stride = data._offset, data._stride  # view_params not on VertexBuffer

            # Make offset a pointer, or it will be interpreted as a small array
            offset = ctypes.c_void_p(offset)
                
            # Apply
            gl.glVertexAttribPointer(self._loc, size, gtype,  False, stride, offset)
        
        # Mark as uploaded
        self._dirty = False
コード例 #17
0
 def _deactivate(self):
     """ Unbind the current bound buffer """
     gl.glBindBuffer(self._target, 0)