예제 #1
0
    def plot(self):

        # Specify shader to be used
        glUseProgram(self.gls_pgr.program_id)

        # Bind VAO - this will automatically
        # bind all the vbo's saving us a bunch
        # of calls
        #glBindVertexArray(self.vao_id)

        glUniform4fv(self.gls_id_xy_color, 1, self.plot_color)

        # Modern GL makes the draw call really simple
        # All the complexity has been pushed elsewhere

        glEnableVertexAttribArray(self.vertIndex)

        # set buffers
        glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer)
        glVertexAttribPointer(self.vertIndex, 2, GL_FLOAT, GL_FALSE, 0, None)

        glDrawArrays(GL_LINE_STRIP, 0, self.data_points - 1)

        # Lets unbind the shader and vertex array state
        glUseProgram(0)
        # disable arrays
        glDisableVertexAttribArray(self.vertIndex)

        glBindVertexArray(0)
예제 #2
0
def generate_vbo(chunk_data):
    """Generate VBO object.

    Args:
        chunk_data (Chunk): chunk data

    Return:
        VboData: VBO data object
    """

    positions = generate_vbo_blocks(chunk_data)

    chunk_vertexes = generate_vertexes(positions)

    gl_vertexes = generate_gl_vertexes(chunk_vertexes)

    chunk_vbo = graphics.VboData(chunk_data.chunk_id)
    chunk_vbo.vertexes_count = len(gl_vertexes)

    glBindBuffer(GL_ARRAY_BUFFER, chunk_vbo.name)
    glBufferData(
        GL_ARRAY_BUFFER,
        len(gl_vertexes) * 4,
        gl_vertexes,
        GL_STATIC_DRAW)
    glBindBuffer(GL_ARRAY_BUFFER, 0)

    return chunk_vbo
예제 #3
0
 def _disable_merged_chunk(self, chunk_coords: Tuple[int, int]):
     """Zero out the region of memory in the merged chunks related to a given chunk"""
     if chunk_coords in self._merged_chunk_locations:
         (
             offset,
             size,
             translucent_offset,
             translucent_size,
         ) = self._merged_chunk_locations.pop(chunk_coords)
         glBindVertexArray(self._vao)
         glBindBuffer(GL_ARRAY_BUFFER, self._vbo)
         glBufferSubData(
             GL_ARRAY_BUFFER,
             offset * 4,
             size * 4,
             numpy.zeros(size, dtype=numpy.float32),
         )
         glBufferSubData(
             GL_ARRAY_BUFFER,
             translucent_offset * 4,
             translucent_size * 4,
             numpy.zeros(translucent_size, dtype=numpy.float32),
         )
         glBindVertexArray(0)
         glBindBuffer(GL_ARRAY_BUFFER, 0)
예제 #4
0
파일: test.py 프로젝트: Chr0nos/PyFractoul
 def send_vertices(self, vertices):
     vertices = np.array(vertices, np.float32)
     glBindBuffer(GL_ARRAY_BUFFER, self.id)
     glBufferData(self.kind, len(vertices) * 4, vertices, GL_STATIC_DRAW)
     # glBindBuffer(GL_ARRAY_BUFFER, self.id)
     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
     return self
예제 #5
0
    def __init__(self, index, args):
        """
        setup two buffers : one for the element index,
        the other with the actual data
        """
        # assume all index are triangles or quads
        self.nElement = len(index)

        # interleave data
        data = hstack(args).flatten()

        self.indexBuffer = glGenBuffers(1)
        self.dataBuffer = glGenBuffers(1)

        indices_buffer = (c_uint * self.nElement)(*index)
        data_buffer = (c_float * len(data))(*data)

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.indexBuffer)
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices_buffer, GL_STATIC_DRAW)

        glBindBuffer(GL_ARRAY_BUFFER, self.dataBuffer)
        glBufferData(GL_ARRAY_BUFFER, data_buffer, GL_STATIC_DRAW)

        del indices_buffer
        del data_buffer
예제 #6
0
    def plot(self):

        # Specify shader to be used
        glUseProgram(self.gls_pgr.program_id)

        # Bind VAO - this will automatically
        # bind all the vbo's saving us a bunch
        # of calls
        #glBindVertexArray(self.vao_id)

        glUniform4fv(self.gls_id_xy_color,1, self.plot_color)

        # Modern GL makes the draw call really simple
        # All the complexity has been pushed elsewhere


        glEnableVertexAttribArray(self.vertIndex)


        # set buffers
        glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer)
        glVertexAttribPointer(self.vertIndex,2, GL_FLOAT, GL_FALSE, 0, None)

        glDrawArrays(GL_LINE_STRIP, 0, self.data_points-1)

        # Lets unbind the shader and vertex array state
        glUseProgram(0)
        # disable arrays
        glDisableVertexAttribArray(self.vertIndex)

        glBindVertexArray(0)
예제 #7
0
    def __init__(self, data):
        self.cull_face = data["cull_face"]

        indicesData, buffer = ObjLoader.load_model(
            "resources/objects/obj/{}.obj".format(data["name"]))
        self.__indicesLen = len(indicesData)

        self.VAO = glGenVertexArrays(1)
        self.VBO = glGenBuffers(1)

        glBindBuffer(GL_ARRAY_BUFFER, self.VBO)
        glBufferData(GL_ARRAY_BUFFER, buffer.nbytes, buffer, GL_STATIC_DRAW)

        glBindVertexArray(self.VAO)
        #  vertices
        glEnableVertexAttribArray(0)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, buffer.itemsize * 8,
                              ctypes.c_void_p(0))

        #  textures
        glEnableVertexAttribArray(2)
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, buffer.itemsize * 8,
                              ctypes.c_void_p(12))

        #  normals
        glEnableVertexAttribArray(1)
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, buffer.itemsize * 8,
                              ctypes.c_void_p(20))

        glBindBuffer(GL_ARRAY_BUFFER, 0)
        glBindVertexArray(0)

        self.texture = LoadTexture('resources/objects/texture/{}'.format(
            data["texture_name"]))
예제 #8
0
    def bind(self, attrib_index):
        if self._index == 0:
            return False

        glBindBuffer(self._array_type, self._vbo)

        if self._changed:
            data = self._arr
            size = data.itemsize * self._index
            glBufferData(self._array_type, size, data.ptr, GL_DYNAMIC_DRAW)
            self._changed = False

            if self._array_type == GL_ARRAY_BUFFER:
                glEnableVertexAttribArray(attrib_index)
                count = self.component_count
                stride = self.bytes_per_element
                dtype = self.dtype

                if dtype == 'float32':
                    gl_type = GL_FLOAT
                elif dtype == 'float64':
                    gl_type = GL_DOUBLE
                elif dtype == 'uint8':
                    gl_type = GL_UNSIGNED_BYTE
                elif dtype == 'uint16':
                    gl_type = GL_UNSIGNED_SHORT
                elif dtype == 'uint32':
                    gl_type = GL_UNSIGNED_INT
                else:
                    raise UserWarning(f'Unknown data type: {dtype}')

                glVertexAttribPointer(attrib_index, count, gl_type, False,
                                      stride, None)

        return True
예제 #9
0
파일: renderer.py 프로젝트: JIC-CSB/pyvol
    def make_volume_obj(self, stack, spacing):

        volume_object = VolumeObject(stack, spacing)

        glEnableVertexAttribArray(self.b_shader.get_attrib("position"))
        glVertexAttribPointer(self.b_shader.get_attrib("position"),
                              3,
                              GL_FLOAT,
                              False,
                              self.volume_stride,
                              volume_object.vtVBO)

        glEnableVertexAttribArray(self.b_shader.get_attrib("texcoord"))
        glVertexAttribPointer(
            self.b_shader.get_attrib("texcoord"),
            3, GL_FLOAT, False, self.volume_stride, volume_object.vtVBO+12
            )

        glBindVertexArray(0)
        glDisableVertexAttribArray(self.b_shader.get_attrib("position"))
        glDisableVertexAttribArray(self.b_shader.get_attrib("texcoord"))

        glBindBuffer(GL_ARRAY_BUFFER, 0)

        self.volume_objects.append(volume_object)
예제 #10
0
파일: grad.py 프로젝트: razorkam/ACG-1
def create_grad(rows, cols, size):
    # y = 5*x + z*z
    vertices_list = []

    def der_x(x):
        return math.sin(x)

    def der_z(z):
        return math.cos(z)

    for z in range(0, 50):
        for x in range(0, 50):
            d_x = der_x(x)
            d_z = der_z(z)

            vertices_list.append([x, 0.0, z])
            vertices_list.append([x + d_x, 0.0, z + d_z])

    vertices_vec = np.array(vertices_list, dtype=np.float32)

    vao = glGenVertexArrays(1)
    vbo_vertices = glGenBuffers(1)

    glBindVertexArray(vao)

    glBindBuffer(GL_ARRAY_BUFFER, vbo_vertices)
    glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(vertices_vec),
                 vertices_vec.flatten(), GL_STATIC_DRAW)  #
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(0)

    glBindVertexArray(0)

    return (vao, len(vertices_list))
예제 #11
0
    def initGL(self):
        self.vertexData = [-1, -1, 0,
                           1, -1, 0,
                           0, 1, 0]

        self.vertexArrayID = glGenVertexArrays(1)
        glBindVertexArray(self.vertexArrayID)

        self.attrID = 0
        self.vertexBuffer = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer)
        arrayType = GLfloat * len(self.vertexData)

        #initialize data for the buffer
        target = GL_ARRAY_BUFFER
        size = len(self.vertexData) * ctypes.sizeof(ctypes.c_float)
        data = arrayType(*self.vertexData)
        usage = GL_STATIC_DRAW
        glBufferData(target, size, data, usage)
                     
        glVertexAttribPointer(self.attrID, 3, GL_FLOAT, False, 0, None)
        glEnableVertexAttribArray(self.attrID)
        
        #access the code for the vertex and fragment shaders
        with open(self.vertPath, 'r') as vertProg:
            self.vertCode = vertProg.read()
        
        with open(self.fragPath, 'r') as fragProg:
            self.fragCode = fragProg.read()
        
        #compile those shaders
        self.vertShader = shaders.compileShader(self.vertCode, GL_VERTEX_SHADER)
        self.fragShader = shaders.compileShader(self.fragCode, GL_FRAGMENT_SHADER)
        self.shader = shaders.compileProgram(self.vertShader, self.fragShader)
        glUseProgram(self.shader)
예제 #12
0
 def __bind_indices_buffer(self, indices: np.ndarray) -> None:
     vbo_id = glGenBuffers(1)
     self.__vbos.append(vbo_id)
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_id)
     glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                  size=indices.nbytes,
                  data=indices,
                  usage=GL_STATIC_DRAW)
예제 #13
0
    def vao_update(self,data):
        if data.size:
           self.vao_data=data
        # Bind a buffer before we can use it
        glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer)

        # Now go ahead and fill this bound buffer with some data
        glBufferSubData(GL_ARRAY_BUFFER,0, ArrayDatatype.arrayByteCount(self.vao_data), self.vao_data)
예제 #14
0
    def draw(self):
        """Draw test object."""

        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
        glEnableVertexAttribArray(0)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
        glDrawArrays(GL_TRIANGLES, 0, 6)
        glDisableVertexAttribArray(0)
        glBindBuffer(GL_ARRAY_BUFFER, 0)
예제 #15
0
 def add_attribute(self, vid, data, name):
     """Add array vertex attribute for shaders."""
     if data.ndim > 1:
         data = data.flatten()
     glBindBuffer(GL_ARRAY_BUFFER, self.__vbo_id[vid])
     glBufferData(GL_ARRAY_BUFFER, data.nbytes, data, GL_STATIC_DRAW)
     glVertexAttribPointer(glGetAttribLocation(self.__program, name),
                           3, GL_FLOAT, GL_FALSE, 0, None)
     glEnableVertexAttribArray(vid)
     self.__attributes.append(data)
예제 #16
0
    def vao_update(self, data):
        if data.size:
            self.vao_data = data
        # Bind a buffer before we can use it
        glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer)

        # Now go ahead and fill this bound buffer with some data
        glBufferSubData(GL_ARRAY_BUFFER, 0,
                        ArrayDatatype.arrayByteCount(self.vao_data),
                        self.vao_data)
예제 #17
0
def bufferize(data: np.ndarray, vbo=None) -> int:
    """Generating Buffer to store this object's vertex data,
    necessary for drawing"""
    if vbo is None:
        vbo = glGenBuffers(1)

    glBindBuffer(GL_ARRAY_BUFFER, vbo)
    glBufferData(GL_ARRAY_BUFFER, data.nbytes, data, GL_STATIC_DRAW)

    return vbo
예제 #18
0
 def add_attribute(self, vid, data, name):
     """Add array vertex attribute for shaders."""
     if data.ndim > 1:
         data = data.flatten()
     glBindBuffer(GL_ARRAY_BUFFER, self.__vbo_id[vid])
     glBufferData(GL_ARRAY_BUFFER, data.nbytes, data, GL_STATIC_DRAW)
     glVertexAttribPointer(glGetAttribLocation(self.__program, name), 3,
                           GL_FLOAT, GL_FALSE, 0, None)
     glEnableVertexAttribArray(vid)
     self.__attributes.append(data)
예제 #19
0
    def init_vao_vbo(self,data=None):

        if data.size:
           self.vao_data=data

        # Lets create a VAO and bind it
        # Think of VAO's as object that encapsulate buffer state
        # Using a VAO enables you to cut down on calls in your draw
        # loop which generally makes things run faster

        self.vertexBuffer = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer)
        glBufferData(GL_ARRAY_BUFFER, 4*len(self.vao_data), self.vao_data,GL_DYNAMIC_DRAW)






        #self.vbo_id = glGenBuffers(1)
        #glBindBuffer(GL_ARRAY_BUFFER, self.vbo_id)
        #vertexData = numpy.array(quadV, numpy.float32)
        #glBufferData(GL_ARRAY_BUFFER, 4*len(self.vao_data), self.vao_data,GL_DYNAMIC_DRAW)
        # self.vao_id = \
        #vao_id=glGenVertexArrays(1,None)

        #self.vao_id=vao_id

        #print vao_id
        #glBindVertexArray(self.vao_id[0])

        # Lets create our Vertex Buffer objects - these are the buffers
        # that will contain our per vertex data
        #self.vbo_id = glGenBuffers(1)

        # Bind a buffer before we can use it
        #glBindBuffer(GL_ARRAY_BUFFER, self.vbo_id[0])

        # Now go ahead and fill this bound buffer with some data
        #glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(self.data), self.data, GL_DYNAMIC_DRAW)

        # Now specify how the shader program will be receiving this data
        # In this case the data from this buffer will be available in the shader as the vin_position vertex attribute


        # Now do the same for the other vertex buffer
        #glBindBuffer(GL_ARRAY_BUFFER, vbo_id[1])
        #glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(color_data), color_data, GL_STATIC_DRAW)
        #glVertexAttribPointer(program.attribute_location('vin_color'), 3, GL_FLOAT, GL_FALSE, 0, None)
        #glEnableVertexAttribArray(1)

        # Lets unbind our vbo and vao state
        # We will bind these again in the draw loop
        glBindBuffer(GL_ARRAY_BUFFER, 0)
        glBindVertexArray(0)
예제 #20
0
    def __init__(self, data, usage=GL_STATIC_DRAW):
        """
        Initiate the vertex buffer object on the CPU
        """
        self.buffer = GLuint(0)
        glGenBuffers(1, self.buffer)
        self.buffer = self.buffer.value

        glBindBuffer(GL_ARRAY_BUFFER, self.buffer)
        glBufferData(GL_ARRAY_BUFFER, ADT.arrayByteCount(data),
                     ADT.voidDataPointer(data), usage)
예제 #21
0
    def init_vao_vbo(self, data=None):

        if data.size:
            self.vao_data = data

        # Lets create a VAO and bind it
        # Think of VAO's as object that encapsulate buffer state
        # Using a VAO enables you to cut down on calls in your draw
        # loop which generally makes things run faster

        self.vertexBuffer = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer)
        glBufferData(GL_ARRAY_BUFFER, 4 * len(self.vao_data), self.vao_data,
                     GL_DYNAMIC_DRAW)

        #self.vbo_id = glGenBuffers(1)
        #glBindBuffer(GL_ARRAY_BUFFER, self.vbo_id)
        #vertexData = numpy.array(quadV, numpy.float32)
        #glBufferData(GL_ARRAY_BUFFER, 4*len(self.vao_data), self.vao_data,GL_DYNAMIC_DRAW)
        # self.vao_id = \
        #vao_id=glGenVertexArrays(1,None)

        #self.vao_id=vao_id

        #print vao_id
        #glBindVertexArray(self.vao_id[0])

        # Lets create our Vertex Buffer objects - these are the buffers
        # that will contain our per vertex data
        #self.vbo_id = glGenBuffers(1)

        # Bind a buffer before we can use it
        #glBindBuffer(GL_ARRAY_BUFFER, self.vbo_id[0])

        # Now go ahead and fill this bound buffer with some data
        #glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(self.data), self.data, GL_DYNAMIC_DRAW)

        # Now specify how the shader program will be receiving this data
        # In this case the data from this buffer will be available in the shader as the vin_position vertex attribute

        # Now do the same for the other vertex buffer
        #glBindBuffer(GL_ARRAY_BUFFER, vbo_id[1])
        #glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(color_data), color_data, GL_STATIC_DRAW)
        #glVertexAttribPointer(program.attribute_location('vin_color'), 3, GL_FLOAT, GL_FALSE, 0, None)
        #glEnableVertexAttribArray(1)

        # Lets unbind our vbo and vao state
        # We will bind these again in the draw loop
        glBindBuffer(GL_ARRAY_BUFFER, 0)
        glBindVertexArray(0)
예제 #22
0
def initialize_buffer(buffer_data_size,
                      buffer_data=None,
                      buffer_usage=GL_STATIC_DRAW):

    if buffer_data is None:
        buffer_data_size, buffer_data = buffer_data_size

    buffer = GLuint(0)
    glGenBuffers(1, buffer)
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer)
    glBufferData(GL_SHADER_STORAGE_BUFFER, buffer_data_size, buffer_data,
                 buffer_usage)
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
    return buffer
    def SetColors(self, colors):
        if not iterable(colors):
            return
        if len(colors) < self.dataNum:
            return
        self.colors = colors
        workingColors = self.colors
#         workingData, self.dataNum, workingColors = self.GetWorkingSet(self.data, self.dataNum, self.colors)
        self.colorsNum = len(workingColors)
        
        self.colors_vbo = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, self.colors_vbo)
        glBufferData(GL_ARRAY_BUFFER, workingColors.nbytes, workingColors, GL_STATIC_DRAW)
        glColorPointer(3, GL_FLOAT, 0, None)
        glBindBuffer(GL_ARRAY_BUFFER, 0)
        print "Color is ready"
예제 #24
0
    def create_vaos(self) -> None:
        """Bind VAOs to define vertex data."""
        self._vao_gridlines, self._vao_bounding_box = glGenVertexArrays(2)
        vbo = glGenBuffers(5)

        vertices, colors = self._get_gridlines()
        self._count_gridlines = vertices.size // 3
        glBindVertexArray(self._vao_gridlines)

        # gridlines
        glBindBuffer(GL_ARRAY_BUFFER, vbo[0])
        glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices,
                     GL_STATIC_DRAW)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0))
        glEnableVertexAttribArray(0)

        glBindBuffer(GL_ARRAY_BUFFER, vbo[1])
        glBufferData(GL_ARRAY_BUFFER, colors.nbytes, colors, GL_STATIC_DRAW)
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0))
        glEnableVertexAttribArray(1)

        # ---

        points, indices = self._get_bounding_box()
        self._count_bounding_box = indices.length
        glBindVertexArray(self._vao_bounding_box)

        # bounding box
        glBindBuffer(GL_ARRAY_BUFFER, vbo[2])
        glBufferData(GL_ARRAY_BUFFER, points.nbytes, points, GL_STATIC_DRAW)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 24, ctypes.c_void_p(0))
        glEnableVertexAttribArray(0)

        glBindBuffer(GL_ARRAY_BUFFER, vbo[3])
        glBufferData(GL_ARRAY_BUFFER, points.nbytes, points, GL_STATIC_DRAW)
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 24,
                              ctypes.c_void_p(12))
        glEnableVertexAttribArray(1)

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[4])
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices.ptr,
                     GL_STATIC_DRAW)

        self._axes.create_vaos()

        glBindVertexArray(0)
        glDeleteBuffers(5, vbo)
예제 #25
0
    def render(self):
        """Render game world."""

        for vbo in self.vbos:

            if vbo.render:

                glBindBuffer(GL_ARRAY_BUFFER, vbo.name)
                glEnableVertexAttribArray(0)
                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)

                glDrawArrays(
                    GL_TRIANGLES,
                    0,
                    vbo.vertexes_count)
                glDisableVertexAttribArray(0)
                glBindBuffer(GL_ARRAY_BUFFER, 0)
    def SetDisplayingItems(self, data, dataLen, colors):
        self.data = data
        self.colors = colors
        
        self.xcount = len(unique(data[:, 0]))
        self.ycount = len(unique(data[:, 1]))
        
        workingData = self.data
        workingColors = self.colors
        self.dataNum = dataLen
        self.colorsNum = self.dataNum
        
        maxVals = amax(workingData, axis=0)
        self.xMax = maxVals[0]
        self.yMax = maxVals[1]
        self.zMax = maxVals[2]
        minVals = amin(workingData, axis=0)
        self.xMin = minVals[0]
        self.yMin = minVals[1]
        self.zMin = minVals[2]
#         print "Max before offset:", self.xMax, self.yMax, self.zMax
#         print "Min before offset:", self.xMin, self.yMin, self.zMin
        self.diffX = (self.xMax + self.xMin) / 2
        self.diffY = (self.yMax + self.yMin) / 2
        self.diffZ = (self.zMax + self.zMin) / 2
#         print "Offset:", self.diffX, self.diffY, self.diffZ
        workingData = subtract(workingData, array([self.diffX, self.diffY, self.diffZ], float32))
        # recollect limitations
        maxVals = amax(workingData, axis=0)
        self.xMax = maxVals[0]
        self.yMax = maxVals[1]
        self.zMax = maxVals[2]
        minVals = amin(workingData, axis=0)
        self.xMin = minVals[0]
        self.yMin = minVals[1]
        self.zMin = minVals[2]
#         print "Max:", self.xMax, self.yMax, self.zMax
#         print "Min:", self.xMin, self.yMin, self.zMin
        self.eyeDistance = 100 * max(abs(self.xMax), abs(self.xMin),
                                     abs(self.yMax), abs(self.yMin),
                                     abs(self.zMax), abs(self.zMin))
#         print "eye distance:", self.eyeDistance
        self.vertices_vbo = glGenBuffers(1)
        glEnableClientState(GL_VERTEX_ARRAY)
        glBindBuffer(GL_ARRAY_BUFFER, self.vertices_vbo)
        glBufferData(GL_ARRAY_BUFFER, workingData.nbytes, workingData, GL_STATIC_DRAW)
        glVertexPointer(3, GL_FLOAT, 0, None)
        glBindBuffer(GL_ARRAY_BUFFER, 0)
                
        self.colors_vbo = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, self.colors_vbo)
        glBufferData(GL_ARRAY_BUFFER, workingColors.nbytes, workingColors, GL_STATIC_DRAW)
        glColorPointer(3, GL_FLOAT, 0, None)
        glBindBuffer(GL_ARRAY_BUFFER, 0)
        print "Points and color is ready"
예제 #27
0
    def start(self):
        self.__VBO = glGenBuffers(1)
        self.__EBO = glGenBuffers(1)
        self.__instanceVBO = glGenBuffers(1)

        glBindBuffer(GL_ARRAY_BUFFER, self.__VBO)
        glBufferData(GL_ARRAY_BUFFER, self.__vertices.nbytes, self.__vertices,
                     GL_STATIC_DRAW)

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.__EBO)

        self.__texture_buffer = Texture.get_default_texture()
        return
        self.__all_objects = [
            (key, val) for key, val in self.get_all_objects().items()
            if 'Material' in key.components and 'Mesh' in key.components
        ]

        vertices = []
        indices = []

        shaders = defaultdict(list)
        verts_len = 0
        for obj in self.__all_objects:
            material = obj[0].components['Material']
            mesh = obj[0].components['Mesh']
            vertices.extend(
                list(mesh.get_data_positioned_to_material(material)))
            object_data = {
                'pointer': len(vertices),
                'length': mesh.vertices.size,
                'matrix': obj[1],
                'object': obj[0],
                'indices': mesh.indices.flatten() + verts_len
            }
            # indices.extend(list(mesh.indices.flatten() + verts_len))
            verts_len += len(mesh.vertices)
            if 'Texture' in obj[0].components:
                object_data['texture'] = obj[0].components['Texture']
            shaders[material].append(object_data)

        self.__data_for_render = shaders

        self.__vertices = np.array(vertices, dtype=np.float32)
        self.__indices = np.array(indices, dtype=np.uint32)
예제 #28
0
    def create_vaos(self) -> None:
        """Bind VAOs to define vertex data."""
        vbo = glGenBuffers(1)

        # initialize camera box
        # TODO: update to obj file
        vertices = glm.array(
            vec3(-1.0, -0.5, -1.0),  # bottom
            vec3(-1.0, -0.5, 1.0),
            vec3(-1.0, 0.5, 1.0),
            vec3(-1.0, 0.5, -1.0),
            vec3(1.0, -0.5, -1.0),  # right
            vec3(-1.0, -0.5, -1.0),
            vec3(-1.0, 0.5, -1.0),
            vec3(1.0, 0.5, -1.0),
            vec3(1.0, -0.5, 1.0),  # top
            vec3(1.0, -0.5, -1.0),
            vec3(1.0, 0.5, -1.0),
            vec3(1.0, 0.5, 1.0),
            vec3(-1.0, -0.5, 1.0),  # left
            vec3(1.0, -0.5, 1.0),
            vec3(1.0, 0.5, 1.0),
            vec3(-1.0, 0.5, 1.0),
            vec3(1.0, 0.5, -1.0),  # back
            vec3(-1.0, 0.5, -1.0),
            vec3(-1.0, 0.5, 1.0),
            vec3(1.0, 0.5, 1.0),
            vec3(-1.0, -0.5, -1.0),  # front
            vec3(1.0, -0.5, -1.0),
            vec3(1.0, -0.5, 1.0),
            vec3(-1.0, -0.5, 1.0),
        )
        glBindBuffer(GL_ARRAY_BUFFER, vbo)
        glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices.ptr,
                     GL_STATIC_DRAW)

        self._vaos['box'] = glGenVertexArrays(1)
        glBindVertexArray(self._vaos['box'])
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0))
        glEnableVertexAttribArray(0)

        self._vaos['camera'] = glGenVertexArrays(1)
        glBindVertexArray(self._vaos['camera'])
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0))
        glEnableVertexAttribArray(0)
예제 #29
0
 def _setup(self):
     """Setup OpenGL attributes if required"""
     if self._vao is None:  # if the opengl state has not been set
         self._shader = get_shader(self.context_identifier, self.shader_name)
         glUseProgram(self._shader)
         self._transform_location = glGetUniformLocation(
             self._shader, "transformation_matrix"
         )
         self._texture_location = glGetUniformLocation(self._shader, "image")
         self._vao = glGenVertexArrays(1)  # create the array
         glBindVertexArray(self._vao)
         self._vbo = glGenBuffers(1)  # and the buffer
         glBindBuffer(GL_ARRAY_BUFFER, self._vbo)
         self._setup_opengl_attrs()
         self._change_verts()
         glBindVertexArray(0)
         glBindBuffer(GL_ARRAY_BUFFER, 0)
         glUseProgram(0)
예제 #30
0
    def build_vbo(self, uid, vertexes, gl_vertexes):

        chunk_vertexes = vertexes
        gl_vertexes = gl_vertexes

        vertexes_count = len(chunk_vertexes)

        chunk_vbo = graphics.VboData(uid)
        chunk_vbo.vertexes_count = vertexes_count

        glBindBuffer(GL_ARRAY_BUFFER, chunk_vbo.name)
        glBufferData(
            GL_ARRAY_BUFFER,
            vertexes_count * 4,
            gl_vertexes,
            GL_STATIC_DRAW)
        glBindBuffer(GL_ARRAY_BUFFER, 0)

        self.active_tasks.remove(uid)
        self.orig_list.append(chunk_vbo)
def getTriangleVAO1(program):
    # it is a container for buffers
    vao_id = glGenVertexArrays(1)
    glBindVertexArray(vao_id)
    vbo_id = glGenBuffers(2)
    # bind some GL_ARRAY_BUFFER to generated one id
    # it's a position buffer
    glBindBuffer(GL_ARRAY_BUFFER, vbo_id[0])
    # fill it with values
    glBufferData(GL_ARRAY_BUFFER, vertex_data1, GL_STATIC_DRAW)
    # tell, how to interpret it
    glVertexAttribPointer(program.attribLocation('vin_position'), 3, GL_FLOAT,
                          GL_FALSE, 0, None)
    # open the valve, let it to be used.
    glEnableVertexAttribArray(0)
    # repeat it for colors.
    glBindBuffer(GL_ARRAY_BUFFER, vbo_id[1])
    glBufferData(GL_ARRAY_BUFFER, color_data1, GL_STATIC_DRAW)
    glVertexAttribPointer(program.attribLocation('vin_color'), 3, GL_FLOAT,
                          GL_FALSE, 0, None)
    glEnableVertexAttribArray(1)
    # there we unbind current buffer and vertex array object
    glBindBuffer(GL_ARRAY_BUFFER, 0)
    glBindVertexArray(0)
    # will bind VAO's at every draw action.
    return vao_id
예제 #32
0
파일: grid.py 프로젝트: magandrez/payton
    def build(self) -> None:
        self._vao = glGenVertexArrays(1)
        vbos = glGenBuffers(2)
        glBindVertexArray(self._vao)

        self._material.build_shader()
        vertices = np.array(self._vertices, dtype=np.float32)
        indices = np.array(self._indices, dtype=np.int32)

        glBindBuffer(GL_ARRAY_BUFFER, vbos[0])
        glEnableVertexAttribArray(0)  # shader layout location
        glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, ctypes.c_void_p(0))
        glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices,
                     GL_STATIC_DRAW)

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[1])
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices,
                     GL_STATIC_DRAW)
        self._vertex_count = len(indices)

        glBindVertexArray(0)
        # glDisableVertexAttribArray(0)
        glBindBuffer(GL_ARRAY_BUFFER, 0)
        glDeleteBuffers(2, vbos)

        if self.static:
            # we can clear this data to free some more memory
            self._vertices = []
            self._indices = []
예제 #33
0
    def update_objects(self) -> None:
        """Update proxy objects when object list changes.

        Called from GLCanvas upon core_o_list_changed signal.
        """
        self._meshes.clear()

        for index, object3d in enumerate(self.core.objects):
            vao = glGenVertexArrays(1)
            glBindVertexArray(vao)

            vertices: glm.array = None
            normals: glm.array = None
            indices: glm.array = None

            if object3d.__class__ == CylinderObject3D:
                vertices, normals, indices = get_cylinder_vertices(
                    object3d, 24)

            elif object3d.__class__ == OBJObject3D:
                vertices = object3d.vertices
                normals = object3d.normals
                indices = object3d.indices

            elif object3d.__class__ == AABBObject3D:
                vertices, normals, indices = get_aabb_vertices(object3d)

            else:
                continue

            vbo = glGenBuffers(3)

            # vertices
            glBindBuffer(GL_ARRAY_BUFFER, vbo[0])
            glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices.ptr,
                         GL_STATIC_DRAW)
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0,
                                  ctypes.c_void_p(0))
            glEnableVertexAttribArray(0)

            # normals
            glBindBuffer(GL_ARRAY_BUFFER, vbo[1])
            glBufferData(GL_ARRAY_BUFFER, normals.nbytes, normals.ptr,
                         GL_STATIC_DRAW)
            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0,
                                  ctypes.c_void_p(0))
            glEnableVertexAttribArray(1)

            # indices
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[2])
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices.ptr,
                         GL_STATIC_DRAW)

            self._meshes.append(
                Mesh(color=vec4(0.8, 0.8, 0.8, 0.85),
                     count=indices.length * 3,
                     vao=vao,
                     object_id=index,
                     selected=False))
            glBindVertexArray(0)
예제 #34
0
    def on_realize(self, area):
        # We need to make the context current if we want to
        # call GL API
        area.make_current()
        context = area.get_context()
        if (area.get_error() != None):
            return

        fragment_shader = shaders.compileShader(FRAGMENT_SOURCE,
                                                GL_FRAGMENT_SHADER)
        vertex_shader = shaders.compileShader(VERTEX_SOURCE, GL_VERTEX_SHADER)
        self.shaderContent.shader_prog = shaders.compileProgram(
            fragment_shader, vertex_shader)
        glLinkProgram(self.shaderContent.shader_prog)
        self.vertex_array_object = glGenVertexArrays(1)
        glBindVertexArray(self.vertex_array_object)
        # Generate buffers to hold our vertices
        self.vertex_buffer = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, self.vertex_buffer)

        self.position = glGetAttribLocation(self.shaderContent.shader_prog,
                                            'position')
        self.time_l = glGetUniformLocation(self.shaderContent.shader_prog,
                                           'time')
        print(self.time_l)
        # glBindAttribLocation(self.shaderContent.shader_prog, self.time, 'time')
        glEnableVertexAttribArray(self.position)
        glVertexAttribPointer(index=self.position,
                              size=4,
                              type=GL_FLOAT,
                              normalized=False,
                              stride=0,
                              pointer=ctypes.c_void_p(0))
        glBufferData(GL_ARRAY_BUFFER, 192, self.vertices, GL_STATIC_DRAW)
        glBindVertexArray(0)
        glDisableVertexAttribArray(self.position)
        glBindBuffer(GL_ARRAY_BUFFER, 0)
        self.on_render(self.shaderContent)

        return True
예제 #35
0
 def setup_scene_geometry(self, vertex_data, index_data, faces):
     self.has_geometry = True
     from tremor.graphics.vbo import VertexBufferObject
     from OpenGL.GL import glGenVertexArrays, glBindVertexArray, glBindBuffer, GL_FALSE, GL_FLOAT, glGenBuffers, \
         GL_STATIC_DRAW, \
         GL_ELEMENT_ARRAY_BUFFER, glBufferData, glVertexAttribPointer, ctypes, glEnableVertexAttribArray
     self.faces = faces
     self.vao = glGenVertexArrays(1)
     glBindVertexArray(self.vao)
     self.faceVBO = VertexBufferObject()
     self.faceVBO.update_data(vertex_data, True)  # vertex information: vec3f pos, vec3f norm, vec2f tex
     self.faceVBO.bind()
     self.faceIBO = glGenBuffers(1)
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.faceIBO)
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, index_data, GL_STATIC_DRAW)
     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (3 + 3 + 2) * 4, ctypes.c_void_p(0))
     glEnableVertexAttribArray(0)
     glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (3 + 3 + 2) * 4, ctypes.c_void_p(3 * 4))
     glEnableVertexAttribArray(1)
     glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, (3 + 3 + 2) * 4, ctypes.c_void_p(6 * 4))
     glEnableVertexAttribArray(3)
     glBindVertexArray(0)
예제 #36
0
    def store_data_in_attribute_list(self,
                                     attribute_number: int,
                                     data: np.ndarray,
                                     dim: int = 3,
                                     datatype: int = GL_FLOAT) -> None:
        """
        Stores the position information of the vertices at attribute 0 of the Vertex Array Object.

        It handles the necessary VBO

        Args:
            (int) attribute_number: The attribute number of the VAO where we want the data to be stored
            (np.ndarray) data: Data to be stored
            (int) dim: The dimension number of the individual data point. E.g 3 for (x, y, z) coordinates
        """
        vbo_id = glGenBuffers(1)
        self.__vbos.append(vbo_id)
        glBindBuffer(GL_ARRAY_BUFFER, vbo_id)
        glBufferData(GL_ARRAY_BUFFER, data.nbytes, data, GL_STATIC_DRAW)
        glVertexAttribPointer(attribute_number, dim, datatype, GL_FALSE, 0,
                              None)

        # Unbind VBO
        glBindBuffer(GL_ARRAY_BUFFER, 0)
예제 #37
0
    def __init__(self):

        self.vbo = GLuint()

        self.vertexes = (
            0, 0, 0,
            1.0, 0, 0,
            1.0, 1.0, 0,
            0, 0, 0,
            1.0, 1.0, 0,
            0, 1.0, 0,
        )

        self.vertexes_GL = (GLfloat * len(
            self.vertexes))(*self.vertexes)

        glGenBuffers(1, self.vbo)
        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
        glBufferData(
            GL_ARRAY_BUFFER,
            len(self.vertexes_GL) * 4,
            self.vertexes_GL,
            GL_STATIC_DRAW)
        glBindBuffer(GL_ARRAY_BUFFER, 0)
예제 #38
0
    def __init__(__, args):

        # assume all elements have correct size

        __.nElement = len(args[0])
        print('new buffer : %i elements' % __.nElement)

        # interleave data
        data = hstack(args).flatten()

        __.indexBuffer = glGenBuffers(1)
        __.dataBuffer = glGenBuffers(1)

        indices_buffer = (c_uint * __.nElement)(*list(range(__.nElement)))
        data_buffer = (c_float * len(data))(*data)

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, __.indexBuffer)
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices_buffer, GL_STATIC_DRAW)

        glBindBuffer(GL_ARRAY_BUFFER, __.dataBuffer)
        glBufferData(GL_ARRAY_BUFFER, data_buffer, GL_STATIC_DRAW)

        del indices_buffer
        del data_buffer
예제 #39
0
def buff_vertices(verts: list, indes: list=None) -> int:
    """Given a list of vertex-like objects, an optional list of indices, returns a VAO handle.
    Format (all should be floats): [[pX, pY, pZ, nX, nY, nZ, cR, cR, cB, tU, tV]] * len."""
    vao = glGenVertexArrays(1)
    glBindVertexArray(vao)

    v = vbo.VBO(array(verts, 'f'))
    v.bind()
    glVertexAttribPointer(0, 3, GL_FLOAT, False, 44, v)
    glVertexAttribPointer(1, 3, GL_FLOAT, False, 44, v+12)
    glVertexAttribPointer(2, 3, GL_FLOAT, False, 44, v+24)
    glVertexAttribPointer(3, 2, GL_FLOAT, False, 44, v+36)
    glEnableVertexAttribArray(0)
    glEnableVertexAttribArray(1)
    glEnableVertexAttribArray(2)
    glEnableVertexAttribArray(3)
    # Maybe you want to include the vertices verbatim? Go for it.
    if indes is not None:
        ebo = glGenBuffers(1)
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo)
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, len(indes)*8, array(indes, 'i'), GL_STATIC_DRAW)

    glBindVertexArray(0)
    return vao
예제 #40
0
def bind_buffer(vbo_vertices, vertices_vec, vbo_normals, normals_vec, vbo_indices, indices_vec):
    glBindBuffer(GL_ARRAY_BUFFER, vbo_vertices)
    glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(vertices_vec), vertices_vec.flatten(), GL_STATIC_DRAW)  #
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(0)

    glBindBuffer(GL_ARRAY_BUFFER, vbo_normals)
    glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(normals_vec), normals_vec.flatten(), GL_STATIC_DRAW)  #
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(1)

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_indices)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(indices_vec), indices_vec.flatten(),
                 GL_STATIC_DRAW)
    pass
예제 #41
0
def read_ply():

    plydata = PlyData.read('cloud.ply')
    vertices_list = []
    normal_list = []
    color_list = []

    for data in plydata.elements[0].data:
        vertices_list.append([data[0],data[1],data[2]])
        normal_list.append([data[3],data[4],data[5]])
        color_list.append([data[6], data[7], data[8]])

    vector_vertices = np.array(vertices_list, dtype=np.float32)
    vector_normal = np.array(normal_list, dtype=np.float32)
    vector_color = np.array(color_list, dtype=np.float32)

    vector_color /= 255.0


    vao = glGenVertexArrays(1)
    vbo_vertices = glGenBuffers(1)
    vbo_normals = glGenBuffers(1)
    vbo_colors = glGenBuffers(1)

    glBindVertexArray(vao)

    glBindBuffer(GL_ARRAY_BUFFER, vbo_vertices)
    glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(vector_vertices), vector_vertices.flatten(), GL_STATIC_DRAW)  #
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(0)

    glBindBuffer(GL_ARRAY_BUFFER, vbo_normals)
    glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(vector_normal), vector_normal.flatten(), GL_STATIC_DRAW)  #
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(1)

    glBindBuffer(GL_ARRAY_BUFFER, vbo_colors)
    glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(vector_color), vector_color.flatten(),
                 GL_STATIC_DRAW)  #
    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(2)


    glBindVertexArray(0)

    return vao, len(vertices_list)
예제 #42
0
 def change_verts(self, verts=None):
     """Modify the vertices in OpenGL."""
     log.debug(f"change_verts {self}")
     try:
         glBindVertexArray(self._vao)
         glBindBuffer(GL_ARRAY_BUFFER, self._vbo)
     except GLError:  # There seems to be errors randomly when binding the VBO
         log.debug(
             f"Failed binding the OpenGL state for {self}. Trying to reload it."
         )
         self.unload()
         self._setup()
         if verts is None:
             return
         glBindVertexArray(self._vao)
         glBindBuffer(GL_ARRAY_BUFFER, self._vbo)
     self._change_verts(verts)
     glBindVertexArray(0)
     glBindBuffer(GL_ARRAY_BUFFER, 0)
예제 #43
0
    def _bind_vao_mat_col_id(self, vao, mat: glm.array, col: glm.array,
                             ids: glm.array) -> None:
        vbo = glGenBuffers(3)
        glBindBuffer(GL_ARRAY_BUFFER, vbo[0])
        glBufferData(GL_ARRAY_BUFFER, mat.nbytes, mat.ptr, GL_STATIC_DRAW)
        glBindVertexArray(vao)

        # modelmats
        glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, 64, ctypes.c_void_p(0))
        glEnableVertexAttribArray(3)
        glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, 64,
                              ctypes.c_void_p(16))  # sizeof(glm::vec4)
        glVertexAttribDivisor(3, 1)
        glEnableVertexAttribArray(4)
        glVertexAttribDivisor(4, 1)
        glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, 64,
                              ctypes.c_void_p(32))  # 2 * sizeof(glm::vec4)
        glEnableVertexAttribArray(5)
        glVertexAttribDivisor(5, 1)
        glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, 64,
                              ctypes.c_void_p(48))  # 3 * sizeof(glm::vec4)
        glEnableVertexAttribArray(6)
        glVertexAttribDivisor(6, 1)

        # colors
        glBindBuffer(GL_ARRAY_BUFFER, vbo[1])
        glBufferData(GL_ARRAY_BUFFER, col.nbytes, col.ptr, GL_STATIC_DRAW)
        glVertexAttribPointer(7, 4, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0))
        glEnableVertexAttribArray(7)
        glVertexAttribDivisor(7, 1)

        # ids for picking
        glBindBuffer(GL_ARRAY_BUFFER, vbo[2])
        glBufferData(GL_ARRAY_BUFFER, ids.nbytes, ids.ptr, GL_STATIC_DRAW)
        # it should be GL_INT here, yet only GL_FLOAT works. huh??
        glVertexAttribPointer(8, 1, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0))
        glEnableVertexAttribArray(8)
        glVertexAttribDivisor(8, 1)

        glEnableVertexAttribArray(0)
        glBindVertexArray(0)
예제 #44
0
 def bind(self):
     if self._BoundBufferObjects[self._kind] != self._hnd:
         glBindBuffer(self._kind, self._hnd)
         self._BoundBufferObjects[self._kind] = self._hnd
예제 #45
0
    # begore we can draw anything
    program = ShaderProgram(fragment=fragment, vertex=vertex)

    # Lets create a VAO and bind it
    # Think of VAO's as object that encapsulate buffer state
    # Using a VAO enables you to cut down on calls in your draw
    # loop which generally makes things run faster
    vao_id = glGenVertexArrays(1)
    glBindVertexArray(vao_id)

    # Lets create our Vertex Buffer objects - these are the buffers
    # that will contain our per vertex data
    vbo_id = glGenBuffers(2)

    # Bind a buffer before we can use it
    glBindBuffer(GL_ARRAY_BUFFER, vbo_id[0])

    # Now go ahead and fill this bound buffer with some data
    glBufferData(GL_ARRAY_BUFFER,
        ArrayDatatype.arrayByteCount(vertex_data),
        vertex_data, GL_STATIC_DRAW)

    # Now specify how the shader program will be receiving this data
    # In this case the data from this buffer will be
    # available in the shader as the vin_position vertex attribute
    glVertexAttribPointer(program.attribute_location('vin_position'),
        3, GL_FLOAT, GL_FALSE, 0, None)

    # Turn on this vertex attribute in the shader
    glEnableVertexAttribArray(0)
예제 #46
0
 def __exit__(self, type, value, tb):
     if self._is_binded:
         glBindBuffer(GL_ARRAY_BUFFER, 0)
         self._is_binded = False
예제 #47
0
    def __init__(self, vertices, indices, normals=None, uvs=None):
        """Constructor.

        Creates and initializes corresponding OpenGL objects with given data.

        :param vertices: Vertex data, specified as a contiguous list of X,Y,Z
            floating point values.
        :type vertices: list

        :param indices: Indices which identify model faces. The only supported
            geometry primitive is the triangle, thus, the size of indices list must
            be a multiple of 3.
        :type indices: list

        :param normals: Normals data, specified as a contiguos list of Xn,Yn,Zn
            floating point values. List length must be a multiple of 3.
        :type normals: list

        :param uvs: List of texture coordinates, specified as a contigous array
            of U,V floating pont values.. List length must be a multiple of 2.
        :type uvs: list
        """
        if len(vertices) < 3 or len(vertices) % 3:
            raise ValueError(
                'Vertex data must be an array of floats, which length is a '
                'positive multiple of 3')

        if len(indices) < 3 or len(indices) % 3:
            raise ValueError('Indices count must be a positive multiple of 3')

        if normals and (len(normals) < 3 or len(normals) % 3):
            raise ValueError(
                'Normals data must be an array of floats, which length is a '
                'positive multiple of 3')

        if uvs is not None and len(uvs) % 2:
            raise ValueError('UVs count must be a positive multiple of 2')

        self.num_elements = len(indices)

        # generate vertex array object and make it active
        self.vao = glGenVertexArrays(1)
        glBindVertexArray(self.vao)

        # generate buffers
        self.buffers = glGenBuffers(2)
        vbo, ibo = self.buffers

        # initialize vertex buffer
        vertex_data = np.array(vertices, np.float32)

        # append normals data, if provided
        normals_offset = 0
        if normals:
            normals_offset = vertex_data.nbytes
            vertex_data = np.append(vertex_data, np.array(normals, np.float32))

        # append UVs data, if provided
        uvs_offset = 0
        if uvs:
            uvs_offset = vertex_data.nbytes
            vertex_data = np.append(vertex_data, np.array(uvs, np.float32))

        glBindBuffer(GL_ARRAY_BUFFER, vbo)
        glBufferData(GL_ARRAY_BUFFER, vertex_data.nbytes,
                     vertex_data, GL_STATIC_DRAW)

        # initialize index buffer
        index_data = np.array(indices, np.uint32)
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo)
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, index_data.nbytes,
                     index_data, GL_STATIC_DRAW)

        # specify first attribute as vertex data
        glEnableVertexAttribArray(0)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)

        # if provided, specify normals as second attribute
        if normals is not None:
            glEnableVertexAttribArray(1)
            glVertexAttribPointer(
                1,
                3,
                GL_FLOAT,
                GL_FALSE,
                0,
                ctypes.c_void_p(normals_offset))

        # if provided, specify UVs as third attribute
        if uvs is not None:
            glEnableVertexAttribArray(2)
            glVertexAttribPointer(
                2,
                2,
                GL_FLOAT,
                GL_FALSE,
                0,
                ctypes.c_void_p(uvs_offset))

        # unbind the vertex array object
        glBindVertexArray(0)
예제 #48
0
        if not self.vbo_isinit:
           self.vbo_init()

        #--- vertices
        glBindBuffer(GL_ARRAY_BUFFER, self.vbo_id_data)
        #--- TODO ck if only y/signal value can be copied step 2
        glBufferSubData(GL_ARRAY_BUFFER,0,4*len(self.vbo_data_signal), self.vbo_data_signal)




"""
index buffer
GLuint elementbuffer;
 glGenBuffers(1, &elementbuffer);
 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer);
 glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);



// Index buffer
 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer);

 // Draw the triangles !
 glDrawElements(
     GL_TRIANGLES,      // mode
     indices.size(),    // count
     GL_UNSIGNED_INT,   // type   -> GL_UNSIGNED_SHORT
     (void*)0           // element array buffer offset
 );
예제 #49
0
def make_buffer(target, buffer_data, size):
    buf = glGenBuffers(1)
    glBindBuffer(target, buf)
    glBufferData(target, size, buffer_data, GL_STATIC_DRAW)
    return buf
예제 #50
0
 def __enter__(self):
     if not self._is_binded:
         glBindBuffer(GL_ARRAY_BUFFER, self.id)
         self._is_binded = True